Add Gradio interfaces for Operations Research solvers and implement parsing functions

- Introduced `operations_research_interface.py` with Gradio interfaces for Branch and Bound, Simplex, and Dual Simplex solvers.
- Implemented parsing functions for vectors, matrices, relations, and bounds to handle user input.
- Enhanced `simplex_solver_with_steps.py` to log detailed steps during the Simplex method execution.
- Created comprehensive tests for the new interfaces and parsing functions, ensuring robust error handling and validation.

app.py

@@ -26,6 +26,9 @@ from maths.university.linear_algebra_interface import (
 from maths.university.differential_equations_interface import (
     first_order_ode_interface, second_order_ode_interface
 )
+from maths.university.operations_research.operations_research_interface import (
+    branch_and_bound_interface, dual_simplex_interface, simplex_solver_interface
+)
 
 # Group interfaces by education level
 # Note: I'm assuming previous subtasks correctly added GCD, LCM, Polynomial, Quadratic, etc. interfaces to their respective files.
@@ -68,6 +71,7 @@ university_interfaces_list = [
     vector_add_interface, vector_subtract_interface, vector_dot_product_interface,
     vector_cross_product_interface, solve_linear_system_interface,
     first_order_ode_interface, second_order_ode_interface
+    # OR Tab will be added below
 ]
 university_tab_names = [
     "Poly Derivatives", "Poly Integrals",
@@ -78,8 +82,19 @@ university_tab_names = [
     "Vector Add", "Vector Subtract", "Vector Dot Product",
     "Vector Cross Product", "Solve Linear System",
     "1st Order ODE", "2nd Order ODE"
+    # "Operations Research" will be added below
 ]
 
+# Operations Research Tab
+or_interfaces_list = [branch_and_bound_interface, dual_simplex_interface, simplex_solver_interface]
+or_tab_names = ["Branch & Bound", "Dual Simplex", "Simplex (Steps)"]
+or_tab = gr.TabbedInterface(or_interfaces_list, or_tab_names, title="Operations Research Solvers")
+
+# Add OR tab to University interfaces
+university_interfaces_list.append(or_tab)
+university_tab_names.append("Operations Research")
+
+
 elementary_tab = gr.TabbedInterface(elementary_interfaces_list, elementary_tab_names, title="Elementary School Math")
 middleschool_tab = gr.TabbedInterface(middleschool_interfaces_list, middleschool_tab_names, title="Middle School Math")
 highschool_tab = gr.TabbedInterface(highschool_interfaces_list, highschool_tab_names, title="High School Math")

maths/university/linear_algebra_interface.py

@@ -4,7 +4,6 @@ Gradio Interface for Linear Algebra operations.
 import gradio as gr
 import numpy as np
 import json # For parsing matrices and vectors easily
-from typing import Union
 
 from maths.university.linear_algebra import (
     matrix_add, matrix_subtract, matrix_multiply,

maths/university/operations_research/BranchAndBoundSolver.py

@@ -56,6 +56,9 @@ class BranchAndBoundSolver:
         
         # Set of active nodes
         self.active_nodes = set()
+
+        # For logging messages
+        self.log_messages = []
     
     def is_integer_feasible(self, x):
         """Check if the solution satisfies integer constraints"""
@@ -156,10 +159,11 @@ class BranchAndBoundSolver:
     def display_steps_table(self):
         """Display the steps in tabular format"""
         headers = ["Node", "z", "x", "z*", "x*", "UB", "LB", "Z at end of stage"]
-        print(tabulate(self.steps_table, headers=headers, tablefmt="grid"))
+        return tabulate(self.steps_table, headers=headers, tablefmt="grid")
     
     def solve(self, verbose=True):
         """Solve the problem using branch and bound"""
+        self.log_messages = [] # Initialize log for this run
         # Initialize bounds
         lower_bounds = [0] * self.n
         upper_bounds = [None] * self.n  # None means unbounded
@@ -173,26 +177,27 @@ class BranchAndBoundSolver:
         node_queue = PriorityQueue()
         
         # Solve the root relaxation
-        print("Step 1: Solving root relaxation (continuous problem)")
+        self.log_messages.append("Step 1: Solving root relaxation (continuous problem)")
         x_root, obj_root = self.solve_relaxation(lower_bounds, upper_bounds)
         
         if x_root is None:
-            print("Root problem infeasible")
-            return None, float('-inf') if self.maximize else float('inf')
+            self.log_messages.append("Root problem infeasible")
+            fig = self.visualize_graph() # Still generate graph even if infeasible at root
+            return None, float('-inf') if self.maximize else float('inf'), self.log_messages, fig
         
         # Add root node to the graph
         root_node = "S0"
         self.add_node_to_graph(root_node, obj_root, x_root)
         
-        print(f"Root relaxation objective: {obj_root:.6f}")
-        print(f"Root solution: {x_root}")
+        self.log_messages.append(f"Root relaxation objective: {obj_root:.6f}")
+        self.log_messages.append(f"Root solution: {x_root}")
         
         # Initial upper bound is the root objective
         upper_bound = obj_root
         
         # Check if the root solution is already integer-feasible
         if self.is_integer_feasible(x_root):
-            print("Root solution is integer-feasible! No need for branching.")
+            self.log_messages.append("Root solution is integer-feasible! No need for branching.")
             self.best_solution = x_root
             self.best_objective = obj_root
             
@@ -204,9 +209,10 @@ class BranchAndBoundSolver:
                 f"{upper_bound:.2f}", f"{self.best_objective:.2f}", active_nodes_str
             ])
             
-            self.display_steps_table()
-            self.visualize_graph()
-            return x_root, obj_root
+            steps_table_string = self.display_steps_table()
+            self.log_messages.append(steps_table_string)
+            fig = self.visualize_graph()
+            return self.best_solution, self.best_objective, self.log_messages, fig
         
         # Add root node to the queue and active nodes set
         priority = -obj_root if self.maximize else obj_root
@@ -219,11 +225,11 @@ class BranchAndBoundSolver:
         x_star_str = "-" if self.best_solution is None else f"({', '.join([f'{x:.2f}' for x in self.best_solution])})"
         
         self.steps_table.append([
-            root_node, f"{obj_root:.2f}", f"({', '.join([f'{x:.2f}' for x in x_root])})", 
+            root_node, f"{obj_root:.2f}", f"({', '.join([f'{x:.2f}' for x in x_root])})",
             lb_str, x_star_str, f"{upper_bound:.2f}", lb_str, active_nodes_str
         ])
         
-        print("\nStarting branch and bound process:")
+        self.log_messages.append("\nStarting branch and bound process:")
         node_counter = 1
         
         while not node_queue.empty():
@@ -231,7 +237,7 @@ class BranchAndBoundSolver:
             priority, _, node_name, node_lower_bounds, node_upper_bounds = node_queue.get()
             self.nodes_explored += 1
             
-            print(f"\nStep {self.nodes_explored + 1}: Exploring node {node_name}")
+            self.log_messages.append(f"\nStep {self.nodes_explored + 1}: Exploring node {node_name}")
             
             # Remove from active nodes
             self.active_nodes.remove(node_name)
@@ -244,13 +250,13 @@ class BranchAndBoundSolver:
             if branch_var in self.binary_vars:
                 floor_val = 0
                 ceil_val = 1
-                print(f"  Branching on binary variable x_{branch_var + 1} with value {branch_val:.6f}")
-                print(f"  Creating two branches: x_{branch_var + 1} = 0 and x_{branch_var + 1} = 1")
+                self.log_messages.append(f"  Branching on binary variable x_{branch_var + 1} with value {branch_val:.6f}")
+                self.log_messages.append(f"  Creating two branches: x_{branch_var + 1} = 0 and x_{branch_var + 1} = 1")
             else:
                 floor_val = math.floor(branch_val)
                 ceil_val = math.ceil(branch_val)
-                print(f"  Branching on variable x_{branch_var + 1} with value {branch_val:.6f}")
-                print(f"  Creating two branches: x_{branch_var + 1} ≤ {floor_val} and x_{branch_var + 1} ≥ {ceil_val}")
+                self.log_messages.append(f"  Branching on variable x_{branch_var + 1} with value {branch_val:.6f}")
+                self.log_messages.append(f"  Creating two branches: x_{branch_var + 1} ≤ {floor_val} and x_{branch_var + 1} ≥ {ceil_val}")
             
             # Process left branch (floor)
             left_node = f"S{node_counter}"
@@ -278,17 +284,17 @@ class BranchAndBoundSolver:
             
             # Process the floor branch
             if x_floor is None:
-                print(f"  {left_node} is infeasible")
+                self.log_messages.append(f"  {left_node} is infeasible")
             else:
-                print(f"  {left_node} relaxation objective: {obj_floor:.6f}")
-                print(f"  {left_node} solution: {x_floor}")
+                self.log_messages.append(f"  {left_node} relaxation objective: {obj_floor:.6f}")
+                self.log_messages.append(f"  {left_node} solution: {x_floor}")
                 
                 # Check if integer feasible and update best solution if needed
                 if self.is_integer_feasible(x_floor) and ((self.maximize and obj_floor > self.best_objective) or 
                                                         (not self.maximize and obj_floor < self.best_objective)):
                     self.best_solution = x_floor.copy()
                     self.best_objective = obj_floor
-                    print(f"  Found new best integer solution with objective {self.best_objective:.6f}")
+                    self.log_messages.append(f"  Found new best integer solution with objective {self.best_objective:.6f}")
                 
                 # Add to queue if not fathomed
                 if ((self.maximize and obj_floor > self.best_objective) or 
@@ -325,17 +331,17 @@ class BranchAndBoundSolver:
             
             # Process the ceil branch
             if x_ceil is None:
-                print(f"  {right_node} is infeasible")
+                self.log_messages.append(f"  {right_node} is infeasible")
             else:
-                print(f"  {right_node} relaxation objective: {obj_ceil:.6f}")
-                print(f"  {right_node} solution: {x_ceil}")
+                self.log_messages.append(f"  {right_node} relaxation objective: {obj_ceil:.6f}")
+                self.log_messages.append(f"  {right_node} solution: {x_ceil}")
                 
                 # Check if integer feasible and update best solution if needed
                 if self.is_integer_feasible(x_ceil) and ((self.maximize and obj_ceil > self.best_objective) or 
                                                        (not self.maximize and obj_ceil < self.best_objective)):
                     self.best_solution = x_ceil.copy()
                     self.best_objective = obj_ceil
-                    print(f"  Found new best integer solution with objective {self.best_objective:.6f}")
+                    self.log_messages.append(f"  Found new best integer solution with objective {self.best_objective:.6f}")
                 
                 # Add to queue if not fathomed
                 if ((self.maximize and obj_ceil > self.best_objective) or 
@@ -361,24 +367,25 @@ class BranchAndBoundSolver:
             
             self.steps_table.append([
                 node_name, 
-                f"{self.graph.nodes[node_name]['obj']:.2f}", 
+                f"{self.graph.nodes[node_name]['obj']:.2f}",
                 f"({', '.join([f'{x:.2f}' for x in self.graph.nodes[node_name]['x']])})",
                 lb_str, x_star_str, f"{upper_bound:.2f}", lb_str, active_nodes_str
             ])
         
-        print("\nBranch and bound completed!")
-        print(f"Nodes explored: {self.nodes_explored}")
+        self.log_messages.append("\nBranch and bound completed!")
+        self.log_messages.append(f"Nodes explored: {self.nodes_explored}")
         
         if self.best_solution is not None:
-            print(f"Optimal objective: {self.best_objective:.6f}")
-            print(f"Optimal solution: {self.best_solution}")
+            self.log_messages.append(f"Optimal objective: {self.best_objective:.6f}")
+            self.log_messages.append(f"Optimal solution: {self.best_solution}")
         else:
-            print("No feasible integer solution found")
+            self.log_messages.append("No feasible integer solution found")
         
-        # Display steps table
-        self.display_steps_table()
+        # Append steps table string to log
+        steps_table_string = self.display_steps_table()
+        self.log_messages.append(steps_table_string)
         
         # Visualize the graph
-        self.visualize_graph()
+        fig = self.visualize_graph()
         
-        return self.best_solution, self.best_objective
+        return self.best_solution, self.best_objective, self.log_messages, fig

maths/university/operations_research/DualSimplexSolver.py

@@ -44,6 +44,7 @@ class DualSimplexSolver:
         self.basic_vars = [] # Indices of basic variables (column index)
         self.var_names = []  # Names like 'x1', 's1', etc.
         self.is_minimized_problem = False # Flag to adjust final Z
+        self.log_messages = []
 
         self._preprocess()
 
@@ -134,26 +135,28 @@ class DualSimplexSolver:
         # Ensure the initial objective row is dual feasible (non-negative coeffs for Max)
         # We rely on the user providing a problem where this holds after conversion.
         if np.any(self.tableau[0, 1:-1] < -TOLERANCE):
-             print("\nWarning: Initial tableau is not dual feasible (objective row has negative coefficients).")
-             print("The standard Dual Simplex method might not apply directly or may require Phase I.")
+             self.log_messages.append("\nWarning: Initial tableau is not dual feasible (objective row has negative coefficients).")
+             self.log_messages.append("The standard Dual Simplex method might not apply directly or may require Phase I.")
              # For this implementation, we'll proceed, but it might fail if assumption is violated.
 
 
     def _print_tableau(self, iteration):
-        """Prints the current state of the tableau."""
-        print(f"\n--- Iteration {iteration} ---")
+        """Formats the current state of the tableau into a string."""
+        tableau_str_lines = []
+        tableau_str_lines.append(f"\n--- Iteration {iteration} ---")
         header = ["BV"] + ["Z"] + self.var_names + ["RHS"]
-        print(" ".join(f"{h:>8}" for h in header))
-        print("-" * (len(header) * 9))
+        tableau_str_lines.append(" ".join(f"{h:>8}" for h in header))
+        tableau_str_lines.append("-" * (len(header) * 9))
 
         basic_var_map = {idx: name for idx, name in enumerate(self.var_names)}
         row_basic_vars = ["Z"] + [basic_var_map.get(bv_idx, f'col{bv_idx}') for bv_idx in self.basic_vars]
 
         for i, row_bv_name in enumerate(row_basic_vars):
-             row_str = [f"{row_bv_name:>8}"]
-             row_str.extend([f"{val: >8.3f}" for val in self.tableau[i]])
-             print(" ".join(row_str))
-        print("-" * (len(header) * 9))
+             row_str_parts = [f"{row_bv_name:>8}"]
+             row_str_parts.extend([f"{val: >8.3f}" for val in self.tableau[i]])
+             tableau_str_lines.append(" ".join(row_str_parts))
+        tableau_str_lines.append("-" * (len(header) * 9))
+        return "\n".join(tableau_str_lines)
 
 
     def _find_pivot_row(self):
@@ -168,12 +171,12 @@ class DualSimplexSolver:
         if self.tableau[pivot_row_index, -1] >= -TOLERANCE:
              return -1 # Should not happen if np.all check passed, but safety check
 
-        print(f"\nStep: Select Pivot Row (Leaving Variable)")
-        print(f"   RHS values (b): {rhs_values}")
+        self.log_messages.append(f"\nStep: Select Pivot Row (Leaving Variable)")
+        self.log_messages.append(f"   RHS values (b): {rhs_values}")
         leaving_var_idx = self.basic_vars[pivot_row_index - 1]
         leaving_var_name = self.var_names[leaving_var_idx]
-        print(f"   Most negative RHS is {self.tableau[pivot_row_index, -1]:.3f} in Row {pivot_row_index} (Basic Var: {leaving_var_name}).")
-        print(f"   Leaving Variable: {leaving_var_name} (Row {pivot_row_index})")
+        self.log_messages.append(f"   Most negative RHS is {self.tableau[pivot_row_index, -1]:.3f} in Row {pivot_row_index} (Basic Var: {leaving_var_name}).")
+        self.log_messages.append(f"   Leaving Variable: {leaving_var_name} (Row {pivot_row_index})")
         return pivot_row_index
 
     def _find_pivot_col(self, pivot_row_index):
@@ -185,10 +188,10 @@ class DualSimplexSolver:
         min_ratio = float('inf')
         pivot_col_index = -1
 
-        print(f"\nStep: Select Pivot Column (Entering Variable) using Ratio Test")
-        print(f"   Pivot Row (Row {pivot_row_index}) coefficients (excluding Z, RHS): {pivot_row}")
-        print(f"   Objective Row coefficients (excluding Z, RHS): {objective_row}")
-        print(f"   Calculating ratios = ObjCoeff / abs(PivotRowCoeff) for PivotRowCoeff < 0:")
+        self.log_messages.append(f"\nStep: Select Pivot Column (Entering Variable) using Ratio Test")
+        self.log_messages.append(f"   Pivot Row (Row {pivot_row_index}) coefficients (excluding Z, RHS): {pivot_row}")
+        self.log_messages.append(f"   Objective Row coefficients (excluding Z, RHS): {objective_row}")
+        self.log_messages.append(f"   Calculating ratios = ObjCoeff / abs(PivotRowCoeff) for PivotRowCoeff < 0:")
 
         found_negative_coeff = False
         for j, coeff in enumerate(pivot_row):
@@ -198,35 +201,30 @@ class DualSimplexSolver:
             if coeff < -TOLERANCE: # Must be strictly negative
                 found_negative_coeff = True
                 obj_coeff = objective_row[j]
-                # Ratio calculation: obj_coeff / abs(coeff) or obj_coeff / -coeff
                 ratio = obj_coeff / (-coeff)
                 ratios[col_var_index] = ratio
-                print(f"      Var {self.var_names[col_var_index]} (Col {col_tableau_index}): Coeff={coeff:.3f}, ObjCoeff={obj_coeff:.3f}, Ratio = {obj_coeff:.3f} / {-coeff:.3f} = {ratio:.3f}")
+                self.log_messages.append(f"      Var {self.var_names[col_var_index]} (Col {col_tableau_index}): Coeff={coeff:.3f}, ObjCoeff={obj_coeff:.3f}, Ratio = {obj_coeff:.3f} / {-coeff:.3f} = {ratio:.3f}")
 
-                # Update minimum ratio
                 if ratio < min_ratio:
                     min_ratio = ratio
-                    pivot_col_index = col_tableau_index # Store the tableau column index
+                    pivot_col_index = col_tableau_index
 
         if not found_negative_coeff:
-            print("   No negative coefficients found in the pivot row.")
-            return -1 # Indicates primal infeasibility (dual unboundedness)
+            self.log_messages.append("   No negative coefficients found in the pivot row.")
+            return -1
 
-        # Handle potential ties in minimum ratio (choose smallest column index - Bland's rule simplified)
         min_ratio_vars = [idx for idx, r in ratios.items() if abs(r - min_ratio) < TOLERANCE]
         if len(min_ratio_vars) > 1:
-            print(f"   Tie detected for minimum ratio ({min_ratio:.3f}) among variables: {[self.var_names[idx] for idx in min_ratio_vars]}.")
-            # Apply Bland's rule: choose the variable with the smallest index
-            pivot_col_index = min(min_ratio_vars) + 1 # +1 for tableau index
-            print(f"   Applying Bland's rule: Choosing variable with smallest index: {self.var_names[pivot_col_index - 1]}.")
+            self.log_messages.append(f"   Tie detected for minimum ratio ({min_ratio:.3f}) among variables: {[self.var_names[idx] for idx in min_ratio_vars]}.")
+            pivot_col_index = min(min_ratio_vars) + 1
+            self.log_messages.append(f"   Applying Bland's rule: Choosing variable with smallest index: {self.var_names[pivot_col_index - 1]}.")
         elif pivot_col_index != -1:
-             entering_var_name = self.var_names[pivot_col_index - 1] # -1 to get var_name index
-             print(f"   Minimum ratio is {min_ratio:.3f} for variable {entering_var_name} (Column {pivot_col_index}).")
-             print(f"   Entering Variable: {entering_var_name} (Column {pivot_col_index})")
+             entering_var_name = self.var_names[pivot_col_index - 1]
+             self.log_messages.append(f"   Minimum ratio is {min_ratio:.3f} for variable {entering_var_name} (Column {pivot_col_index}).")
+             self.log_messages.append(f"   Entering Variable: {entering_var_name} (Column {pivot_col_index})")
         else:
-             # This case should technically not be reached if found_negative_coeff was true
-             print("Error in ratio calculation or tie-breaking.")
-             return -2 # Error indicator
+             self.log_messages.append("Error in ratio calculation or tie-breaking.")
+             return -2
 
         return pivot_col_index
 
@@ -235,209 +233,210 @@ class DualSimplexSolver:
         """Performs the pivot operation."""
         pivot_element = self.tableau[pivot_row_index, pivot_col_index]
 
-        print(f"\nStep: Pivot Operation")
-        print(f"   Pivot Element: {pivot_element:.3f} at (Row {pivot_row_index}, Col {pivot_col_index})")
+        self.log_messages.append(f"\nStep: Pivot Operation")
+        self.log_messages.append(f"   Pivot Element: {pivot_element:.3f} at (Row {pivot_row_index}, Col {pivot_col_index})")
 
         if abs(pivot_element) < TOLERANCE:
-            print("Error: Pivot element is zero. Cannot proceed.")
-            # This might indicate an issue with the problem formulation or numerical instability.
+            self.log_messages.append("Error: Pivot element is zero. Cannot proceed.")
             raise ZeroDivisionError("Pivot element is too close to zero.")
 
-        # 1. Normalize the pivot row
-        print(f"   Normalizing Pivot Row {pivot_row_index} by dividing by {pivot_element:.3f}")
+        self.log_messages.append(f"   Normalizing Pivot Row {pivot_row_index} by dividing by {pivot_element:.3f}")
         self.tableau[pivot_row_index, :] /= pivot_element
 
-        # 2. Eliminate other entries in the pivot column
-        print(f"   Eliminating other entries in Pivot Column {pivot_col_index}:")
+        self.log_messages.append(f"   Eliminating other entries in Pivot Column {pivot_col_index}:")
         for i in range(self.tableau.shape[0]):
             if i != pivot_row_index:
                 factor = self.tableau[i, pivot_col_index]
-                if abs(factor) > TOLERANCE: # Only perform if factor is non-zero
-                    print(f"      Row {i} = Row {i} - ({factor:.3f}) * (New Row {pivot_row_index})")
+                if abs(factor) > TOLERANCE:
+                    self.log_messages.append(f"      Row {i} = Row {i} - ({factor:.3f}) * (New Row {pivot_row_index})")
                     self.tableau[i, :] -= factor * self.tableau[pivot_row_index, :]
 
-        # 3. Update basic variables list
-        # The variable corresponding to pivot_col_index becomes basic for pivot_row_index
         old_basic_var_index = self.basic_vars[pivot_row_index - 1]
-        new_basic_var_index = pivot_col_index - 1 # Convert tableau col index to var_names index
+        new_basic_var_index = pivot_col_index - 1
         self.basic_vars[pivot_row_index - 1] = new_basic_var_index
-        print(f"   Updating Basic Variables: {self.var_names[new_basic_var_index]} replaces {self.var_names[old_basic_var_index]} in the basis for Row {pivot_row_index}.")
+        self.log_messages.append(f"   Updating Basic Variables: {self.var_names[new_basic_var_index]} replaces {self.var_names[old_basic_var_index]} in the basis for Row {pivot_row_index}.")
 
 
     def solve(self, use_fallbacks=True):
         """
         Executes the Dual Simplex algorithm.
-        
-        Args:
-            use_fallbacks (bool): If True, will attempt to use alternative solvers
-                                  when the dual simplex method encounters issues
-                                  
         Returns:
-            tuple: (tableau, basic_vars) if successful using dual simplex,
-                   or a dictionary of results if fallback solvers were used
+            tuple: (final_solution_str, final_objective_str, log_messages, is_fallback_used_str)
         """
-        print("--- Starting Dual Simplex Method ---")
+        self.log_messages = [] # Clear log for this run
+        self.log_messages.append("--- Starting Dual Simplex Method ---")
+        is_fallback_used_str = "No"
+
         if self.tableau is None:
-            print("Error: Tableau not initialized.")
-            return None
+            self.log_messages.append("Error: Tableau not initialized.")
+            return "Error", "Tableau not initialized", self.log_messages, is_fallback_used_str
 
         iteration = 0
-        self._print_tableau(iteration)
+        tableau_str = self._print_tableau(iteration)
+        self.log_messages.append(tableau_str)
 
-        while iteration < 100: # Safety break for too many iterations
+        while iteration < 100:
             iteration += 1
 
-            # 1. Check for Optimality (Primal Feasibility)
             pivot_row_index = self._find_pivot_row()
             if pivot_row_index == -1:
-                print("\n--- Optimal Solution Found ---")
-                print("   All RHS values are non-negative.")
-                self._print_results()
-                return self.tableau, self.basic_vars
+                self.log_messages.append("\n--- Optimal Solution Found ---")
+                self.log_messages.append("   All RHS values are non-negative.")
+                objective_str, solution_details_str = self._print_results()
+                # _print_results already appends to log, so just return them
+                return solution_details_str, objective_str, self.log_messages, is_fallback_used_str
 
-            # 2. Select Entering Variable (Pivot Column)
             pivot_col_index = self._find_pivot_col(pivot_row_index)
 
-            # 3. Check for Primal Infeasibility (Dual Unboundedness)
             if pivot_col_index == -1:
-                print("\n--- Primal Problem Infeasible ---")
-                print(f"   All coefficients in Pivot Row {pivot_row_index} are non-negative, but RHS is negative.")
-                print("   The dual problem is unbounded, implying the primal problem has no feasible solution.")
-                
+                self.log_messages.append("\n--- Primal Problem Infeasible ---")
+                self.log_messages.append(f"   All coefficients in Pivot Row {pivot_row_index} are non-negative, but RHS is negative.")
+                self.log_messages.append("   The dual problem is unbounded, implying the primal problem has no feasible solution.")
                 if use_fallbacks:
-                    return self._try_fallback_solvers("primal_infeasible")
-                return None, None # Indicate infeasibility
-                
+                    is_fallback_used_str = "Yes"
+                    return self._handle_fallback_results("primal_infeasible")
+                return "Infeasible", "N/A", self.log_messages, is_fallback_used_str
+
             elif pivot_col_index == -2:
-                 # Error during pivot column selection
-                 print("\n--- Error during pivot column selection ---")
-                 
+                 self.log_messages.append("\n--- Error during pivot column selection ---")
                  if use_fallbacks:
-                    return self._try_fallback_solvers("pivot_error")
-                 return None, None
+                    is_fallback_used_str = "Yes"
+                    return self._handle_fallback_results("pivot_error")
+                 return "Error", "Pivot selection error", self.log_messages, is_fallback_used_str
 
-            # 4. Perform Pivot Operation
             try:
                 self._pivot(pivot_row_index, pivot_col_index)
             except ZeroDivisionError as e:
-                print(f"\n--- Error during pivot operation: {e} ---")
-                
+                self.log_messages.append(f"\n--- Error during pivot operation: {e} ---")
                 if use_fallbacks:
-                    return self._try_fallback_solvers("numerical_instability")
-                return None, None
+                    is_fallback_used_str = "Yes"
+                    return self._handle_fallback_results("numerical_instability")
+                return "Error", "Numerical instability", self.log_messages, is_fallback_used_str
 
-            # Print the tableau after pivoting
-            self._print_tableau(iteration)
+            tableau_str = self._print_tableau(iteration)
+            self.log_messages.append(tableau_str)
 
-        print("\n--- Maximum Iterations Reached ---")
-        print("   The algorithm did not converge within the iteration limit.")
-        print("   This might indicate cycling or a very large problem.")
-        
+        self.log_messages.append("\n--- Maximum Iterations Reached ---")
+        self.log_messages.append("   The algorithm did not converge within the iteration limit.")
+        self.log_messages.append("   This might indicate cycling or a very large problem.")
         if use_fallbacks:
-            return self._try_fallback_solvers("iteration_limit")
-        return None, None # Indicate non-convergence
+            is_fallback_used_str = "Yes"
+            return self._handle_fallback_results("iteration_limit")
+        return "Error", "Max iterations reached", self.log_messages, is_fallback_used_str
+
+    def _handle_fallback_results(self, error_type_for_primary_solver):
+        """ Helper to process results from _try_fallback_solvers and structure return for solve() """
+        fallback_results = self._try_fallback_solvers(error_type_for_primary_solver)
+
+        final_solution_str = "Fallback attempted."
+        final_objective_str = "N/A"
+        is_fallback_used_str = f"Yes, due to {error_type_for_primary_solver}."
+
+        # Check dual_approach_result first
+        if fallback_results.get("dual_approach_result"):
+            res = fallback_results["dual_approach_result"]
+            is_fallback_used_str += f" Dual Approach: {res['message']}."
+            if res["status"] == 0 and res["primal_solution"] is not None:
+                final_objective_str = f"{res['objective_value']:.6f} (via Dual Approach)"
+                final_solution_str = ", ".join([f"x{i+1}={v:.3f}" for i, v in enumerate(res["primal_solution"])])
+                return final_solution_str, final_objective_str, self.log_messages, is_fallback_used_str
+
+        # Then check direct_solver_result
+        if fallback_results.get("direct_solver_result"):
+            res = fallback_results["direct_solver_result"]
+            is_fallback_used_str += f" Direct Solver: {res['message']}."
+            if res["status"] == 0 and res["primal_solution"] is not None:
+                final_objective_str = f"{res['objective_value']:.6f} (via Direct Solver)"
+                final_solution_str = ", ".join([f"x{i+1}={v:.3f}" for i, v in enumerate(res["primal_solution"])])
+                return final_solution_str, final_objective_str, self.log_messages, is_fallback_used_str
+
+        # If both fallbacks failed or didn't yield a solution
+        final_solution_str = "All solvers failed or problem is infeasible/unbounded."
+        self.log_messages.append(final_solution_str)
+        return final_solution_str, final_objective_str, self.log_messages, is_fallback_used_str
+
 
     def _try_fallback_solvers(self, error_type):
         """
-        Tries alternative solvers when the dual simplex method fails.
-        
-        Args:
-            error_type (str): Type of error encountered in the dual simplex method
-            
-        Returns:
-            dict: Results from fallback solvers
+        Tries alternative solvers. Appends to self.log_messages.
+        Returns dict of results.
         """
-        print(f"\n--- Using Fallback Solvers due to '{error_type}' ---")
+        self.log_messages.append(f"\n--- Using Fallback Solvers due to '{error_type}' ---")
         
         results = {
             "error_type": error_type,
-            "dual_simplex_result": None,
+            "dual_simplex_result": None, # This would be the state if Dual Simplex had a result
             "dual_approach_result": None,
             "direct_solver_result": None
         }
         
-        # First try using solve_lp_via_dual (which uses complementary slackness)
-        print("\n=== Attempting to solve via Dual Approach with Complementary Slackness ===")
+        self.log_messages.append("\n=== Attempting to solve via Dual Approach with Complementary Slackness ===")
         status, message, primal_sol, dual_sol, obj_val = solve_lp_via_dual(
-            self.objective_type, 
-            self.original_c, 
-            self.original_A, 
-            self.original_relations, 
-            self.original_b
+            self.objective_type, self.original_c, self.original_A,
+            self.original_relations, self.original_b
         )
         
         results["dual_approach_result"] = {
-            "status": status,
-            "message": message,
-            "primal_solution": primal_sol,
-            "dual_solution": dual_sol,
-            "objective_value": obj_val
+            "status": status, "message": message, "primal_solution": primal_sol,
+            "dual_solution": dual_sol, "objective_value": obj_val
         }
+        self.log_messages.append(f"Dual Approach Result: {message}")
+        if status == 0 and primal_sol is not None:
+            self.log_messages.append(f"Objective Value (Dual Approach): {obj_val}")
+            # No early return, let solve() decide based on this dict
         
-        print(f"Dual Approach Result: {message}")
-        if status == 0 and primal_sol:
-            print(f"Objective Value: {obj_val}")
-            return results
-        
-        # If that fails, try direct method (most robust)
-        print("\n=== Attempting direct solution using SciPy's linprog solver ===")
-        status, message, primal_sol, _, obj_val = solve_primal_directly(
-            self.objective_type, 
-            self.original_c, 
-            self.original_A, 
-            self.original_relations, 
-            self.original_b
+        self.log_messages.append("\n=== Attempting direct solution using SciPy's linprog solver ===")
+        status_direct, message_direct, primal_sol_direct, _, obj_val_direct = solve_primal_directly(
+            self.objective_type, self.original_c, self.original_A,
+            self.original_relations, self.original_b
         )
         
         results["direct_solver_result"] = {
-            "status": status,
-            "message": message,
-            "primal_solution": primal_sol,
-            "objective_value": obj_val
+            "status": status_direct, "message": message_direct,
+            "primal_solution": primal_sol_direct, "objective_value": obj_val_direct
         }
-        
-        print(f"Direct Solver Result: {message}")
-        if status == 0 and primal_sol:
-            print(f"Objective Value: {obj_val}")
-        
+        self.log_messages.append(f"Direct Solver Result: {message_direct}")
+        if status_direct == 0 and primal_sol_direct is not None:
+            self.log_messages.append(f"Objective Value (Direct Solver): {obj_val_direct}")
+
         return results
 
     def _print_results(self):
-        """Prints the final solution."""
-        print("\n--- Final Solution ---")
-        self._print_tableau("Final")
+        """Formats the final solution into strings and appends to log_messages."""
+        self.log_messages.append("\n--- Final Solution (from Dual Simplex Tableau) ---")
+
+        tableau_str = self._print_tableau("Final") # This method now returns a string
+        self.log_messages.append(tableau_str)
 
-        # Objective Value
         final_obj_value = self.tableau[0, -1]
+        obj_type_str = "Min Z" if self.is_minimized_problem else "Max Z"
         if self.is_minimized_problem:
-            final_obj_value = -final_obj_value # Correct for Min Z = -Max(-Z)
-            print(f"Optimal Objective Value (Min Z): {final_obj_value:.6f}")
-        else:
-            print(f"Optimal Objective Value (Max Z): {final_obj_value:.6f}")
+            final_obj_value = -final_obj_value
+
+        objective_str = f"Optimal Objective Value ({obj_type_str}): {final_obj_value:.6f}"
+        self.log_messages.append(objective_str)
 
-        # Variable Values
-        solution = {}
+        solution_details_parts = ["Optimal Variable Values:"]
         num_total_vars = len(self.var_names)
         final_solution_vector = np.zeros(num_total_vars)
 
         for i, basis_col_idx in enumerate(self.basic_vars):
-            # basis_col_idx is the index in the var_names list
-            # The corresponding tableau row is i + 1
             final_solution_vector[basis_col_idx] = self.tableau[i + 1, -1]
 
-        print("Optimal Variable Values:")
         for i in range(self.num_original_vars):
              var_name = self.var_names[i]
              value = final_solution_vector[i]
-             print(f"   {var_name}: {value:.6f}")
-             solution[var_name] = value
+             solution_details_parts.append(f"   {var_name}: {value:.6f}")
 
-        # Optionally print slack variable values
-        print("Slack/Surplus Variable Values:")
+        solution_details_parts.append("Slack/Surplus Variable Values:")
         for i in range(self.num_original_vars, num_total_vars):
              var_name = self.var_names[i]
              value = final_solution_vector[i]
-             # Only print non-zero slacks for brevity, or all if needed
              if abs(value) > TOLERANCE:
-                 print(f"   {var_name}: {value:.6f}")
+                 solution_details_parts.append(f"   {var_name}: {value:.6f}")
+
+        solution_details_str = "\n".join(solution_details_parts)
+        self.log_messages.append(solution_details_str)
+
+        return objective_str, solution_details_str
 

maths/university/operations_research/operations_research_interface.py

@@ -0,0 +1,481 @@
+"""Gradio interfaces for Operations Research solvers."""
+import gradio as gr
+import numpy as np
+
+def parse_vector(input_str: str, dtype=float) -> list:
+    """Parses a comma-separated string into a list of numbers."""
+    if not input_str:
+        return []
+    try:
+        return [dtype(x.strip()) for x in input_str.split(',')]
+    except ValueError:
+        gr.Warning(f"Could not parse vector: '{input_str}'. Please use comma-separated numbers (e.g., '1,2,3.5').")
+        return []
+
+def parse_matrix(input_str: str) -> np.ndarray:
+    """Parses a string (rows separated by semicolons, elements by commas) into a NumPy array."""
+    if not input_str:
+        return np.array([])
+    try:
+        rows = input_str.split(';')
+        matrix = []
+        num_cols = -1
+        for i, row_str in enumerate(rows):
+            if not row_str.strip(): continue # Allow empty rows if they result from trailing semicolons
+
+            row = [float(x.strip()) for x in row_str.split(',')]
+            if num_cols == -1:
+                num_cols = len(row)
+            elif len(row) != num_cols:
+                raise ValueError(f"Row {i+1} has {len(row)} elements, expected {num_cols}.")
+            matrix.append(row)
+
+        if not matrix: # If all rows were empty or input_str was just ';'
+            return np.array([])
+
+        return np.array(matrix)
+    except ValueError as e:
+        gr.Warning(f"Could not parse matrix: '{input_str}'. Error: {e}. Expected format: '1,2;3,4'. Ensure all rows have the same number of columns.")
+        return np.array([])
+
+def parse_relations(input_str: str) -> list[str]:
+    """Parses a comma-separated string of relations into a list of strings."""
+    if not input_str:
+        return []
+    try:
+        relations = [r.strip() for r in input_str.split(',')]
+        valid_relations = {"<=", ">=", "="}
+        if not all(r in valid_relations for r in relations):
+            invalid_rels = [r for r in relations if r not in valid_relations]
+            gr.Warning(f"Invalid relation(s) found: {', '.join(invalid_rels)}. Allowed relations are: '<=', '>=', '='.")
+            return []
+        return relations
+    except Exception as e: # Catch any other unexpected errors during parsing
+        gr.Warning(f"Error parsing relations: '{input_str}'. Error: {e}")
+        return []
+
+def parse_bounds(input_str: str) -> list[tuple]:
+    """
+    Parses a string representing variable bounds into a list of tuples.
+    Format: "lower1,upper1; lower2,upper2; ..." (e.g., "0,None; 0,10; None,None")
+    'None' (case-insensitive) is used for no bound.
+    """
+    if not input_str:
+        return []
+    bounds_list = []
+    try:
+        pairs = input_str.split(';')
+        for i, pair_str in enumerate(pairs):
+            if not pair_str.strip(): continue # Allow for trailing semicolons or empty entries
+
+            parts = pair_str.split(',')
+            if len(parts) != 2:
+                raise ValueError(f"Bound pair '{pair_str}' (entry {i+1}) does not have two elements. Expected format 'lower,upper'.")
+
+            lower_str, upper_str = parts[0].strip().lower(), parts[1].strip().lower()
+
+            lower = None if lower_str == 'none' else float(lower_str)
+            upper = None if upper_str == 'none' else float(upper_str)
+
+            if lower is not None and upper is not None and lower > upper:
+                raise ValueError(f"Lower bound {lower} cannot be greater than upper bound {upper} for pair '{pair_str}' (entry {i+1}).")
+
+            bounds_list.append((lower, upper))
+        return bounds_list
+    except ValueError as e:
+        gr.Warning(f"Could not parse bounds: '{input_str}'. Error: {e}. Expected format: 'lower1,upper1; lower2,upper2; ...' e.g., '0,None; 0,10'. Use 'None' for no bound.")
+        return []
+    except Exception as e: # Catch any other unexpected parsing errors
+        gr.Warning(f"Unexpected error parsing bounds: '{input_str}'. Error: {e}")
+        return []
+
+# --- Branch and Bound Interface ---
+from .BranchAndBoundSolver import BranchAndBoundSolver
+
+def solve_branch_and_bound_interface(c_str, A_str, b_str, integer_vars_str, binary_vars_str, maximize_bool):
+    """
+    Wrapper function to connect BranchAndBoundSolver with Gradio interface.
+    """
+    log_messages = []
+
+    c = parse_vector(c_str)
+    if not c:
+        log_messages.append("Error: Objective coefficients (c) could not be parsed or are empty.")
+        return "Error parsing c", "Error parsing c", "\n".join(log_messages), None
+
+    A = parse_matrix(A_str)
+    if A.size == 0: # Check if array is empty
+        log_messages.append("Error: Constraint matrix (A) could not be parsed or is empty.")
+        return "Error parsing A", "Error parsing A", "\n".join(log_messages), None
+
+    b = parse_vector(b_str)
+    if not b:
+        log_messages.append("Error: Constraint bounds (b) could not be parsed or are empty.")
+        return "Error parsing b", "Error parsing b", "\n".join(log_messages), None
+
+    # Validate dimensions
+    if A.shape[0] != len(b):
+        log_messages.append(f"Error: Number of rows in A ({A.shape[0]}) does not match number of elements in b ({len(b)}).")
+        return "Dimension mismatch A vs b", "Dimension mismatch A vs b", "\n".join(log_messages), None
+    if A.shape[1] != len(c):
+        log_messages.append(f"Error: Number of columns in A ({A.shape[1]}) does not match number of elements in c ({len(c)}).")
+        return "Dimension mismatch A vs c", "Dimension mismatch A vs c", "\n".join(log_messages), None
+
+    integer_vars = []
+    if integer_vars_str:
+        try:
+            integer_vars = [int(x.strip()) for x in integer_vars_str.split(',')]
+            if not all(0 <= i < len(c) for i in integer_vars):
+                raise ValueError("Integer variable indices out of bounds.")
+        except ValueError as e:
+            log_messages.append(f"Error parsing integer variable indices: {e}. Please use comma-separated 0-indexed integers (e.g., '0,1').")
+            return "Error parsing integer_vars", "Error parsing integer_vars", "\n".join(log_messages), None
+
+    binary_vars = []
+    if binary_vars_str:
+        try:
+            binary_vars = [int(x.strip()) for x in binary_vars_str.split(',')]
+            if not all(0 <= i < len(c) for i in binary_vars):
+                raise ValueError("Binary variable indices out of bounds.")
+        except ValueError as e:
+            log_messages.append(f"Error parsing binary variable indices: {e}. Please use comma-separated 0-indexed integers (e.g., '0,1').")
+            return "Error parsing binary_vars", "Error parsing binary_vars", "\n".join(log_messages), None
+
+    # Solver expects None if no specific integer_vars are given (meaning all are integer)
+    # However, our current B&B implementation defaults integer_vars to all if None.
+    # For clarity with user input (where empty means "no specific integer vars beyond binary"),
+    # we'll pass the list. If it's empty, and binary_vars is also empty, it implies a continuous LP for B&B,
+    # or if binary_vars is not empty, those will be treated as integer.
+    # The B&B solver correctly adds binary_vars to its internal integer_vars list.
+
+    log_messages.append("Inputs parsed successfully. Starting solver...")
+
+    try:
+        solver = BranchAndBoundSolver(c=np.array(c), A=A, b=np.array(b),
+                                      integer_vars=integer_vars if integer_vars else None, # Pass None if list is empty for solver's default logic
+                                      binary_vars=binary_vars if binary_vars else None, # Pass None if list is empty
+                                      maximize=maximize_bool)
+
+        best_solution, best_objective, solver_log, fig = solver.solve()
+
+        log_messages.extend(solver_log) # Add solver's internal log
+
+        if best_solution is not None:
+            solution_str = ", ".join([f"{val:.3f}" for val in best_solution])
+            objective_str = f"{best_objective:.3f}"
+        else:
+            solution_str = "No feasible integer solution found."
+            objective_str = "N/A"
+            if best_objective == float('-inf') or best_objective == float('inf'): # Check if it was due to infeasibility
+                 objective_str = "Infeasible or unbounded"
+
+
+        return solution_str, objective_str, "\n".join(log_messages), fig
+
+    except Exception as e:
+        gr.Error(f"An error occurred during solving: {e}")
+        log_messages.append(f"Runtime error: {e}")
+        return "Solver error", "Solver error", "\n".join(log_messages), None
+
+
+branch_and_bound_interface = gr.Interface(
+    fn=solve_branch_and_bound_interface,
+    inputs=[
+        gr.Textbox(label="Objective Coefficients (c)", info="Comma-separated, e.g., 3,2"),
+        gr.Textbox(label="Constraint Matrix (A)", info="Rows separated by ';', elements by ',', e.g., 2,1; 1,1; 1,0"),
+        gr.Textbox(label="Constraint RHS (b)", info="Comma-separated, e.g., 10,8,3. Must be Ax <= b form."),
+        gr.Textbox(label="Integer Variable Indices (optional)", info="Comma-separated, 0-indexed. If empty and no binary vars, all vars are continuous for B&B (effectively LP). If empty but binary vars exist, only binary are integer. If 'all', all vars are integer."), # Adjusted info
+        gr.Textbox(label="Binary Variable Indices (optional)", info="Comma-separated, 0-indexed, e.g., 0,1"),
+        gr.Checkbox(label="Maximize?", value=True)
+    ],
+    outputs=[
+        gr.Textbox(label="Optimal Solution (x)"),
+        gr.Textbox(label="Optimal Objective Value (z)"),
+        gr.Textbox(label="Solver Log and Steps", lines=15, interactive=False),
+        gr.Plot(label="Branch and Bound Tree")
+    ],
+    title="Branch and Bound Solver for Mixed Integer Linear Programs (MILP)",
+    description="Solves MILPs (Ax <= b) using the Branch and Bound method. Specify integer/binary variables or leave empty if not applicable (for pure LP).",
+    examples=[
+        [ # Example 1: Knapsack-like problem (from a common example)
+            "8,11,6,4", # c: Objective (maximize)
+            "5,7,4,3; 1,1,1,1", # A: Constraints matrix
+            "14; 4", # b: Constraints RHS
+            "", # integer_vars: all variables are effectively integer due to binary constraint if specified, or by default if integer_vars=None
+            "0,1,2,3", # binary_vars: All variables are binary
+            True # Maximize
+        ],
+        [ # Example 2: Simple MILP
+            "3,2,4", # c
+            "1,1,1; 2,1,0", # A
+            "10; 5", # b
+            "0,2", # integer_vars: x0 and x2 are integer
+            "", # binary_vars
+            True # Maximize
+        ],
+        [ # Example 3: Minimization problem (from a common example)
+            "3,5", # c (minimize)
+            "-1,0; 0,-1; 3,2", # A (original constraints might be >=, converted to <= by multiplying by -1)
+            "0;0;18", # b (original might be >=0, >=0, <=18. For >=0, we write -x <= 0)
+            "0,1", # integer_vars
+            "", # binary_vars
+            False # Minimize
+        ],
+         [ # Example 4: Provided in task description
+            "5,4", #c
+            "1,1;2,0;0,1", #A
+            "5,6,3", #b
+            "0,1", #integer
+            "", #binary
+            True #maximize
+        ]
+    ],
+    allow_flagging="never"
+)
+
+# --- Simplex Solver (with Steps) Interface ---
+from .simplex_solver_with_steps import simplex_solver_with_steps
+
+def run_simplex_solver_interface(c_str, A_str, b_str, bounds_str):
+    """
+    Wrapper function to connect simplex_solver_with_steps with Gradio interface.
+    """
+    current_log_list = ["Initializing Simplex Solver (with Steps) Interface..."]
+
+    c = parse_vector(c_str)
+    if not c:
+        current_log_list.append("Error: Objective coefficients (c) could not be parsed or are empty.")
+        return "Error parsing c", "Error parsing c", "\n".join(current_log_list)
+
+    A = parse_matrix(A_str)
+    if A.size == 0:
+        current_log_list.append("Error: Constraint matrix (A) could not be parsed or is empty.")
+        return "Error parsing A", "Error parsing A", "\n".join(current_log_list)
+
+    b = parse_vector(b_str)
+    if not b:
+        current_log_list.append("Error: Constraint bounds (b) could not be parsed or are empty.")
+        return "Error parsing b", "Error parsing b", "\n".join(current_log_list)
+
+    variable_bounds = parse_bounds(bounds_str) # This returns a list of tuples or []
+    # parse_bounds includes gr.Warning on failure and returns []
+    if bounds_str and not variable_bounds: # If input was given but parsing failed
+        current_log_list.append("Error: Variable bounds string could not be parsed. Please check format.")
+        # parse_bounds already issues a gr.Warning
+        return "Error parsing var_bounds", "Error parsing var_bounds", "\n".join(current_log_list)
+
+
+    # Dimensional validation
+    if A.shape[0] != len(b):
+        current_log_list.append(f"Dimension mismatch: Number of rows in A ({A.shape[0]}) must equal length of b ({len(b)}).")
+        return "Dimension Error", "Dimension Error", "\n".join(current_log_list)
+    if A.shape[1] != len(c):
+        current_log_list.append(f"Dimension mismatch: Number of columns in A ({A.shape[1]}) must equal length of c ({len(c)}).")
+        return "Dimension Error", "Dimension Error", "\n".join(current_log_list)
+    if variable_bounds and len(variable_bounds) != len(c):
+        current_log_list.append(f"Dimension mismatch: Number of variable bounds pairs ({len(variable_bounds)}) must equal number of objective coefficients ({len(c)}).")
+        return "Dimension Error", "Dimension Error", "\n".join(current_log_list)
+
+    # If bounds_str is empty, parse_bounds returns [], which is fine for the solver if it expects default non-negativity or specific handling.
+    # The simplex_solver_with_steps expects a list of tuples, and an empty list if no specific bounds beyond non-negativity are implied by problem setup.
+    # For this solver, bounds are crucial. If not provided, we should create default non-negative bounds.
+    if not variable_bounds:
+        variable_bounds = [(0, None) for _ in range(len(c))]
+        current_log_list.append("Defaulting to non-negative bounds for all variables as no specific bounds were provided.")
+
+
+    current_log_list.append("Inputs parsed and validated successfully.")
+
+    try:
+        # Ensure inputs are NumPy arrays as expected by some solvers (though this one might be flexible)
+        np_c = np.array(c)
+        np_b = np.array(b)
+
+        # Call the solver
+        # simplex_solver_with_steps returns: steps_log, x, optimal_value
+        steps_log, x_solution, opt_val = simplex_solver_with_steps(np_c, A, np_b, variable_bounds)
+
+        current_log_list.extend(steps_log) # steps_log is already a list of strings
+
+        solution_str = "N/A"
+        objective_str = "N/A"
+
+        if x_solution is not None:
+            solution_str = ", ".join([f"{val:.3f}" for val in x_solution])
+        else: # Check specific messages in log if solution is None
+            if any("Unbounded solution" in msg for msg in steps_log):
+                solution_str = "Unbounded solution"
+            elif any("infeasible" in msg.lower() for msg in steps_log): # More general infeasibility check
+                solution_str = "Infeasible solution"
+
+
+        if opt_val is not None:
+            if opt_val == float('inf') or opt_val == float('-inf'):
+                 objective_str = str(opt_val)
+            else:
+                objective_str = f"{opt_val:.3f}"
+
+        return solution_str, objective_str, "\n".join(current_log_list)
+
+    except Exception as e:
+        gr.Error(f"An error occurred during solving with Simplex Method: {e}")
+        current_log_list.append(f"Runtime error in Simplex Method: {e}")
+        return "Solver error", "Solver error", "\n".join(current_log_list)
+
+simplex_solver_interface = gr.Interface(
+    fn=run_simplex_solver_interface,
+    inputs=[
+        gr.Textbox(label="Objective Coefficients (c)", info="Comma-separated for maximization problem, e.g., 3,5"),
+        gr.Textbox(label="Constraint Matrix (A)", info="Rows separated by ';', elements by ',', e.g., 1,0;0,2;3,2. Assumes Ax <= b."),
+        gr.Textbox(label="Constraint RHS (b)", info="Comma-separated, e.g., 4,12,18"),
+        gr.Textbox(label="Variable Bounds (L,U) per variable", info="Pairs like L1,U1; L2,U2;... Use 'None' for no bound. E.g., '0,None;0,10'. If empty, defaults to non-negative for all variables (0,None).")
+    ],
+    outputs=[
+        gr.Textbox(label="Optimal Solution (x)"),
+        gr.Textbox(label="Optimal Objective Value"),
+        gr.Textbox(label="Solver Steps and Tableaus", lines=20, interactive=False)
+    ],
+    title="Simplex Method Solver (with Tableau Steps)",
+    description="Solves Linear Programs (maximization, Ax <= b) using the Simplex method and displays detailed tableau iterations. Assumes variables are non-negative if bounds not specified.",
+    examples=[
+        [ # Classic example from many textbooks (e.g., Taha, Operations Research)
+            "3,5", # c (Max Z = 3x1 + 5x2)
+            "1,0;0,2;3,2", # A
+            "4,12,18", # b
+            "0,None;0,None" # x1 >=0, x2 >=0 (explicitly stating non-negativity)
+        ],
+        [ # Another common example
+            "5,4", # c (Max Z = 5x1 + 4x2)
+            "6,4;1,2; -1,1;0,1", # A
+            "24,6,1,2", #b
+            "0,None;0,None" # x1,x2 >=0
+        ],
+        [ # Example that might be unbounded if not careful or show interesting steps
+            "1,1",
+            "1,-1;-1,1",
+            "1,1",
+            "0,None;0,None" # x1-x2 <=1, -x1+x2 <=1
+        ]
+    ],
+    allow_flagging="never"
+)
+
+# --- Dual Simplex Interface ---
+from .DualSimplexSolver import DualSimplexSolver
+
+def solve_dual_simplex_interface(objective_type_str, c_str, A_str, relations_str, b_str):
+    """
+    Wrapper function to connect DualSimplexSolver with Gradio interface.
+    """
+    current_log = ["Initializing Dual Simplex Solver Interface..."]
+
+    c = parse_vector(c_str)
+    if not c:
+        current_log.append("Error: Objective coefficients (c) could not be parsed or are empty.")
+        return "Error parsing c", "Error parsing c", "\n".join(current_log)
+
+    A = parse_matrix(A_str)
+    if A.size == 0:
+        current_log.append("Error: Constraint matrix (A) could not be parsed or is empty.")
+        return "Error parsing A", "Error parsing A", "\n".join(current_log)
+
+    b = parse_vector(b_str)
+    if not b:
+        current_log.append("Error: Constraint bounds (b) could not be parsed or are empty.")
+        return "Error parsing b", "Error parsing b", "\n".join(current_log)
+
+    relations = parse_relations(relations_str)
+    if not relations:
+        current_log.append("Error: Constraint relations could not be parsed, are empty, or contain invalid symbols.")
+        return "Error parsing relations", "Error parsing relations", "\n".join(current_log)
+
+    # Basic dimensional validation
+    if A.shape[0] != len(b):
+        current_log.append(f"Dimension mismatch: Number of rows in A ({A.shape[0]}) must equal length of b ({len(b)}).")
+        return "Dimension Error", "Dimension Error", "\n".join(current_log)
+    if A.shape[1] != len(c):
+        current_log.append(f"Dimension mismatch: Number of columns in A ({A.shape[1]}) must equal length of c ({len(c)}).")
+        return "Dimension Error", "Dimension Error", "\n".join(current_log)
+    if A.shape[0] != len(relations):
+        current_log.append(f"Dimension mismatch: Number of rows in A ({A.shape[0]}) must equal length of relations ({len(relations)}).")
+        return "Dimension Error", "Dimension Error", "\n".join(current_log)
+
+    current_log.append("Inputs parsed and validated successfully.")
+
+    try:
+        solver = DualSimplexSolver(objective_type_str, c, A, relations, b)
+        current_log.append("DualSimplexSolver instantiated.")
+
+        # The solve method now returns: final_solution_str, final_objective_str, log_messages, is_fallback_used_str
+        solution_str, objective_str, solver_log_messages, fallback_info = solver.solve()
+
+        current_log.extend(solver_log_messages)
+        current_log.append(f"Fallback Status: {fallback_info}")
+
+        return solution_str, objective_str, "\n".join(current_log)
+
+    except Exception as e:
+        gr.Error(f"An error occurred during solving with Dual Simplex: {e}")
+        current_log.append(f"Runtime error in Dual Simplex: {e}")
+        return "Solver error", "Solver error", "\n".join(current_log)
+
+dual_simplex_interface = gr.Interface(
+    fn=solve_dual_simplex_interface,
+    inputs=[
+        gr.Radio(label="Objective Type", choices=["max", "min"], value="max"),
+        gr.Textbox(label="Objective Coefficients (c)", info="Comma-separated, e.g., 4,1"),
+        gr.Textbox(label="Constraint Matrix (A)", info="Rows separated by ';', elements by ',', e.g., 3,1; 4,3; 1,2"),
+        gr.Textbox(label="Constraint Relations", info="Comma-separated, e.g., >=,>=,>="), # Dual simplex typically starts from Ax >= b for max problems if to be converted to <=
+        gr.Textbox(label="Constraint RHS (b)", info="Comma-separated, e.g., 3,6,4")
+    ],
+    outputs=[
+        gr.Textbox(label="Optimal Solution (Variables)"),
+        gr.Textbox(label="Optimal Objective Value"),
+        gr.Textbox(label="Solver Log, Tableau Steps, and Fallback Info", lines=15, interactive=False)
+    ],
+    title="Dual Simplex Solver for Linear Programs (LP)",
+    description="Solves LPs using the Dual Simplex method. This method is often efficient when an initial basic solution is dual feasible but primal infeasible (e.g. after adding cuts). Input Ax R b where R can be '>=', '<=', or '='.",
+    examples=[
+        [ # Example 1: Max problem, standard form for dual simplex often has >= constraints initially
+          # Maximize Z = 4x1 + x2
+          # Subject to:
+          #   3x1 + x2 >= 3  --> -3x1 - x2 <= -3
+          #   4x1 + 3x2 >= 6 --> -4x1 - 3x2 <= -6
+          #   x1 + 2x2 >= 4  --> -x1 - 2x2 <= -4  (Mistake in common example, should be <= to be interesting for dual or needs specific setup)
+          # Let's use a more typical dual simplex starting point:
+          # Min C = 2x1 + x2  (so Max -2x1 -x2)
+          # s.t. x1 + x2 >= 5
+          #      2x1 + x2 >= 6
+          #      x1, x2 >=0
+          # Becomes: Max Z' = -2x1 -x2
+          #      -x1 -x2 <= -5
+          #      -2x1 -x2 <= -6
+            "max", "-2,-1", "-1,-1;-2,-1", "<=,<=", "-5,-6" # This is already in <= form, good for dual if RHS is neg.
+        ],
+        [ # Example 2: (Taken from a standard textbook example for Dual Simplex)
+          # Minimize Z = 3x1 + 2x2 + x3
+          # Subject to:
+          #   3x1 + x2 + x3 >= 3
+          #   -3x1 + 3x2 + x3 >= 6
+          #   x1 + x2 + x3 <= 3  (This constraint makes it interesting)
+          #   x1,x2,x3 >=0
+          # For Gradio: obj_type='min', c="3,2,1", A="3,1,1;-3,3,1;1,1,1", relations=">=,>=,<=", b="3,6,3"
+            "min", "3,2,1", "3,1,1;-3,3,1;1,1,1", ">=,>=,<=", "3,6,3"
+        ],
+        [ # Example from problem description (slightly modified for typical dual simplex)
+          # Maximize Z = 3x1 + 2x2
+          # Subject to:
+          #   2x1 + x2 <= 18 (Original)
+          #   x1 + x2 <= 12  (Original)
+          #   x1       <= 5  (Original)
+          # To make it a dual simplex start, we might have transformed it from something else,
+          # or expect some RHS to be negative after initial setup.
+          # For a direct input that might be dual feasible but primal infeasible:
+          # Max Z = x1 + x2
+          # s.t. -2x1 - x2 <= -10  (i.e. 2x1 + x2 >= 10)
+          #      -x1 - 2x2 <= -10  (i.e. x1 + 2x2 >= 10)
+            "max", "1,1", "-2,-1;-1,-2", "<=,<=", "-10,-10"
+        ]
+    ],
+    allow_flagging="never"
+)

maths/university/operations_research/simplex_solver_with_steps.py

@@ -16,13 +16,15 @@ def simplex_solver_with_steps(c, A, b, bounds):
     Returns:
     - x: Optimal solution
     - optimal_value: Optimal objective value
+    - steps_log: List of strings detailing each step
     """
-    st.markdown("\n--- Starting Simplex Method ---")
-    st.text(f"Objective: Maximize {' + '.join([f'{c[i]}x_{i}' for i in range(len(c))])}")
-    st.text(f"Constraints:")
+    steps_log = []
+    steps_log.append("\n--- Starting Simplex Method ---")
+    steps_log.append(f"Objective: Maximize {' + '.join([f'{c[i]}x_{i}' for i in range(len(c))])}")
+    steps_log.append(f"Constraints:")
     for i in range(len(b)):
         constraint_str = ' + '.join([f"{A[i,j]}x_{j}" for j in range(A.shape[1])])
-        st.text(f"  {constraint_str} <= {b[i]}")
+        steps_log.append(f"  {constraint_str} <= {b[i]}")
     
     # Convert problem to standard form (for tableau method)
     # First handle bounds by adding necessary constraints
@@ -67,7 +69,7 @@ def simplex_solver_with_steps(c, A, b, bounds):
     base_vars = list(range(n_vars, n_vars + n_constraints))  # Slack variables are initially basic
     
     # Function to print current tableau
-    def print_tableau(tableau, base_vars):
+    def print_tableau(tableau, base_vars, steps_log_func):
         headers = [f"x_{j}" for j in range(n_vars)] + [f"s_{j}" for j in range(n_constraints)] + ["RHS"]
         rows = []
         row_labels = ["z"] + [f"eq_{i}" for i in range(n_constraints)]
@@ -75,13 +77,13 @@ def simplex_solver_with_steps(c, A, b, bounds):
         for i, row in enumerate(tableau):
             rows.append([row_labels[i]] + [f"{val:.3f}" for val in row])
         
-        st.text("\nCurrent Tableau:")
-        st.text(tabulate(rows, headers=headers, tablefmt="grid"))
-        st.text(f"Basic variables: {[f'x_{v}' if v < n_vars else f's_{v-n_vars}' for v in base_vars]}")
+        steps_log_func.append("\nCurrent Tableau:")
+        steps_log_func.append(tabulate(rows, headers=headers, tablefmt="grid"))
+        steps_log_func.append(f"Basic variables: {[f'x_{v}' if v < n_vars else f's_{v-n_vars}' for v in base_vars]}")
     
     # Print initial tableau
-    st.text("\nInitial tableau:")
-    print_tableau(tableau, base_vars)
+    steps_log.append("\nInitial tableau:")
+    print_tableau(tableau, base_vars, steps_log)
     
     # Main simplex loop
     iteration = 0
@@ -89,15 +91,15 @@ def simplex_solver_with_steps(c, A, b, bounds):
     
     while iteration < max_iterations:
         iteration += 1
-        st.text(f"\n--- Iteration {iteration} ---")
+        steps_log.append(f"\n--- Iteration {iteration} ---")
         
         # Find the entering variable (most negative coefficient in objective row for maximization)
         entering_col = np.argmin(tableau[0, :-1])
         if tableau[0, entering_col] >= -1e-10:  # Small negative numbers due to floating-point errors
-            st.text("Optimal solution reached - no negative coefficients in objective row")
+            steps_log.append("Optimal solution reached - no negative coefficients in objective row")
             break
         
-        st.text(f"Entering variable: {'x_' + str(entering_col) if entering_col < n_vars else 's_' + str(entering_col - n_vars)}")
+        steps_log.append(f"Entering variable: {'x_' + str(entering_col) if entering_col < n_vars else 's_' + str(entering_col - n_vars)}")
         
         # Find the leaving variable using min ratio test
         ratios = []
@@ -108,15 +110,15 @@ def simplex_solver_with_steps(c, A, b, bounds):
                 ratios.append(tableau[i, -1] / tableau[i, entering_col])
         
         if all(r == np.inf for r in ratios):
-            st.text("Unbounded solution - no leaving variable found")
-            return None, float('inf')  # Problem is unbounded
+            steps_log.append("Unbounded solution - no leaving variable found")
+            return steps_log, None, float('inf')  # Problem is unbounded
         
         # Find the row with minimum ratio
         leaving_row = np.argmin(ratios) + 1  # +1 because we skip the objective row
         leaving_var = base_vars[leaving_row - 1]
         
-        st.text(f"Leaving variable: {'x_' + str(leaving_var) if leaving_var < n_vars else 's_' + str(leaving_var - n_vars)}")
-        st.text(f"Pivot element: {tableau[leaving_row, entering_col]:.3f} at row {leaving_row}, column {entering_col}")
+        steps_log.append(f"Leaving variable: {'x_' + str(leaving_var) if leaving_var < n_vars else 's_' + str(leaving_var - n_vars)}")
+        steps_log.append(f"Pivot element: {tableau[leaving_row, entering_col]:.3f} at row {leaving_row}, column {entering_col}")
         
         # Perform pivot operation
         # First, normalize the pivot row
@@ -133,12 +135,12 @@ def simplex_solver_with_steps(c, A, b, bounds):
         base_vars[leaving_row - 1] = entering_col
         
         # Print updated tableau
-        st.text("\nAfter pivot:")
-        print_tableau(tableau, base_vars)
+        steps_log.append("\nAfter pivot:")
+        print_tableau(tableau, base_vars, steps_log)
     
     if iteration == max_iterations:
-        st.text("Max iterations reached without convergence")
-        return None, None
+        steps_log.append("Max iterations reached without convergence")
+        return steps_log, None, None
     
     # Extract solution
     x = np.zeros(n_vars)
@@ -154,9 +156,9 @@ def simplex_solver_with_steps(c, A, b, bounds):
     # Calculate objective value
     optimal_value = np.dot(c, x)
     
-    st.markdown("\n--- Simplex Method Complete ---")
-    st.text(f"Optimal solution found: {x}")
-    st.text(f"Optimal objective value: {optimal_value}")
+    steps_log.append("\n--- Simplex Method Complete ---")
+    steps_log.append(f"Optimal solution found: {x}")
+    steps_log.append(f"Optimal objective value: {optimal_value}")
     
-    return x, optimal_value
+    return steps_log, x, optimal_value
 

maths/university/tests/test_operations_research_interface.py

@@ -0,0 +1,134 @@
+import pytest
+import numpy as np
+import gradio as gr # Import for gr.Error if used in parsing
+
+# Assuming parsing functions and interface wrappers are in the following module
+from maths.university.operations_research.operations_research_interface import (
+    parse_vector, parse_matrix, parse_relations, parse_bounds, # Import parsing functions if you want to test them directly too
+    solve_branch_and_bound_interface,
+    solve_dual_simplex_interface,
+    run_simplex_solver_interface
+)
+
+# Test for Branch and Bound Interface
+def test_bnb_interface_valid_input():
+    # Example from its own interface definition
+    c_str = "5,4"
+    A_str = "1,1;2,0;0,1"
+    b_str = "5,6,3"
+    integer_vars_str = "0,1" # Both vars are integer
+    binary_vars_str = ""    # No specific binary vars beyond integer_vars
+    maximize_bool = True
+
+    solution_str, objective_str, log_str, fig = solve_branch_and_bound_interface(
+        c_str, A_str, b_str, integer_vars_str, binary_vars_str, maximize_bool
+    )
+
+    # Expected solution for this problem is x0=2, x1=3, objective=22
+    assert "2.000, 3.000" in solution_str or "2, 3" in solution_str # Allow for formatting variations
+    assert "22.000" in objective_str or "22.0" in objective_str
+    assert fig is not None # Check that a figure object is returned
+    assert "Branch and bound completed!" in log_str
+    assert "Optimal objective: 22.0" in log_str # More specific check
+
+def test_bnb_interface_parsing_error():
+    # Invalid matrix string (row length mismatch)
+    solution_str, objective_str, log_str, fig = solve_branch_and_bound_interface(
+        "1,2", "1,2;3", "10,12", "", "", True # b_str needs two elements if A has two rows
+    )
+    # The error message comes from parse_matrix via gr.Warning, which is then caught by the wrapper.
+    # The wrapper appends to its own log_messages.
+    assert "Error parsing matrix" in log_str or "Could not parse matrix" in log_str
+    assert fig is None
+
+# Test for Dual Simplex Interface
+def test_dual_simplex_interface_valid_input():
+    # Example from its own interface definition, but made consistent for Dual Simplex properties
+    # Max Z = -2x1 -x2  (originally Min 2x1+x2)
+    # s.t. -x1 -x2 <= -5 (originally x1+x2 >= 5)
+    #      -2x1 -x2 <= -6 (originally 2x1+x2 >= 6)
+    obj_type = "max"
+    c_str = "-2,-1"
+    A_str = "-1,-1;-2,-1"
+    relations_str = "<=,<=" # Correct for typical dual simplex tableau setup
+    b_str = "-5,-6"
+
+    solution_str, objective_str, log_str = solve_dual_simplex_interface(
+        obj_type, c_str, A_str, relations_str, b_str
+    )
+
+    # For Z' = -2x1 -x2 s.t. -x1-x2<=-5, -2x1-x2<=-6. Optimal is x1=1, x2=4, Z'=-6. (Min Z = 6)
+    # The solution string format depends on the solver's _print_results
+    assert "x1: 1.000" in solution_str or "x1=1.000" in solution_str
+    assert "x2: 4.000" in solution_str or "x2=4.000" in solution_str
+    assert "-6.000" in objective_str # Max -Z
+    assert "Optimal Solution Found" in log_str or "Final Solution" in log_str
+
+def test_dual_simplex_interface_dim_mismatch():
+    solution_str, objective_str, log_str = solve_dual_simplex_interface(
+        "max", "1,2", "1,1;2,2", "<=", "10,12" # relations_str has 1 relation, A has 2 rows
+    )
+    assert "Dimension mismatch" in log_str # Check for error message
+
+# Test for Simplex Solver Interface
+def test_simplex_solver_interface_valid_input():
+    # Example from its own interface definition
+    c_str = "3,5"
+    A_str = "1,0;0,2;3,2"
+    b_str = "4,12,18"
+    bounds_str = "0,None;0,None" # Non-negative
+
+    solution_str, objective_str, steps_str = run_simplex_solver_interface(
+        c_str, A_str, b_str, bounds_str
+    )
+
+    # Expected: x1=2, x2=6, Z=36
+    assert "2.000, 6.000" in solution_str or "2, 6" in solution_str
+    assert "36.000" in objective_str or "36.0" in objective_str
+    assert "Simplex Method Complete" in steps_str
+    assert "Initial tableau" in steps_str
+
+def test_simplex_solver_interface_invalid_bounds():
+    solution_str, objective_str, steps_str = run_simplex_solver_interface(
+        "1,2", "1,1;2,1", "10,12", "0,None;0" # Malformed bounds pair
+    )
+    assert "Error parsing var_bounds" in steps_str or "Could not parse bounds" in steps_str
+
+
+# Test parsing functions directly
+def test_parse_matrix_valid():
+    assert np.array_equal(parse_matrix("1,2;3,4"), np.array([[1.0,2.0],[3.0,4.0]]))
+
+def test_parse_matrix_invalid_char():
+    # parse_matrix issues a gr.Warning and returns an empty np.array([])
+    # The test checks if the returned array is empty.
+    # We cannot directly test gr.Warning without a more complex setup.
+    result = parse_matrix("1,2;3,a")
+    assert isinstance(result, np.ndarray)
+    assert result.size == 0
+
+def test_parse_matrix_invalid_row_length():
+    result = parse_matrix("1,2;3,4,5")
+    assert isinstance(result, np.ndarray)
+    assert result.size == 0
+
+def test_parse_vector_valid():
+    assert parse_vector("1,2,3.5") == [1.0, 2.0, 3.5]
+
+def test_parse_vector_invalid():
+    assert parse_vector("1,a,3") == []
+
+def test_parse_relations_valid():
+    assert parse_relations("<=,>=,=") == ["<=", ">=", "="]
+
+def test_parse_relations_invalid():
+    assert parse_relations("<=,>,=") == [] # '>' is invalid
+
+def test_parse_bounds_valid():
+    assert parse_bounds("0,None;10,20.5;None,5") == [(0.0, None), (10.0, 20.5), (None, 5.0)]
+
+def test_parse_bounds_invalid_format():
+    assert parse_bounds("0,None;10,20,30") == [] # middle pair has 3 parts
+
+def test_parse_bounds_invalid_order():
+    assert parse_bounds("10,0") == [] # lower > upper