added more math tools

README.md

@@ -13,7 +13,7 @@ short_description: Mathematics tools for different educational levels
 
 # Math Education Tools
 
-This web application provides various mathematical tools organized by educational level, from elementary school to university. The application is built using Gradio and provides interactive interfaces for different mathematical operations.
+This web application provides a comprehensive suite of mathematical tools and interactive calculators, categorized by educational levels from elementary school through university. Built with Python and featuring user-friendly Gradio interfaces, it aims to assist with learning and performing a wide array of mathematical operations.
 
 ## Features
 
@@ -27,50 +27,94 @@ This web application provides various mathematical tools organized by educationa
 - Subtraction: Subtract one number from another
 - Multiplication: Multiply two numbers
 - Division: Divide one number by another
+- Greatest Common Divisor (GCD): Find the GCD of two integers.
+- Least Common Multiple (LCM): Find the LCM of two integers.
+- Prime Number Checker: Check if a number is prime.
+- Array Calculation: Perform basic operations on a list of numbers.
+- Array Calculation with Visualization: Array calculation with a number line plot.
 
 ### Middle School Math
 
-- Linear Equation Solver: Solve equations of the form ax = b
-- Quadratic Expression Evaluator: Calculate the value of ax² + bx + c for a given x
+- Linear Equation Solver: Solve equations of the form ax = b.
+- Quadratic Expression Evaluator: Calculate the value of ax² + bx + c for a given x.
+- Quadratic Equation Solver: Find roots of ax² + bx + c = 0.
+- Radical Simplifier: Simplify square roots (e.g., √12 to 2√3).
+- Polynomial Operations: Add, subtract, and multiply polynomials.
 
 ### High School Math
 
-- Trigonometry Calculator: Calculate sine, cosine, and tangent values for angles in degrees
+- Trigonometry Calculator: Calculate sine, cosine, and tangent values for angles in degrees.
+- Inverse Trigonometric Functions: Calculate asin, acos, atan in degrees.
+- Trigonometric Equation Solver: Solve basic trigonometric equations.
+- Trigonometric Identities: Demonstrate common identities like sin²(x) + cos²(x) = 1.
 
 ### University Math
 
-- Polynomial Derivative: Find the derivative of a polynomial function
-- Polynomial Integration: Find the indefinite integral of a polynomial function
+#### Calculus
+
+- Polynomial Derivative: Find the derivative of a polynomial function.
+- Polynomial Integration: Find the indefinite integral of a polynomial function.
+- Limits: Calculate the limit of an expression as a variable approaches a point.
+- Series Expansion: Compute Taylor series for functions. Includes examples for Fourier series.
+- Partial Derivatives: Compute partial derivatives of multi-variable expressions.
+- Multiple Integrals: Evaluate definite multiple integrals.
+
+#### Linear Algebra
+
+- Matrix Operations: Addition, subtraction, multiplication.
+- Matrix Analysis: Determinant and inverse of matrices.
+- Vector Operations: Addition, subtraction, dot product, and cross product (for 3D vectors).
+- System Solver: Solve systems of linear equations (Ax = B).
+
+#### Differential Equations
+
+- First-Order ODEs: Solve single or systems of first-order ordinary differential equations with initial conditions.
+- Second-Order ODEs: Solve second-order ordinary differential equations by converting to a system.
+- Solution Plotting: Visualize solutions for ODEs.
 
 ## Project Structure
 
 ```
-├── app.py                    # Main application file
-├── maths/                    # Mathematics modules
+├── app.py                    # Main Gradio application file
+├── requirements.txt          # Python package dependencies
+├── maths/                    # Core mathematics modules
 │   ├── __init__.py
-│   ├── elementary/           # Elementary school level
+│   ├── elementary/           # Elementary school level functions and interfaces
 │   │   ├── __init__.py
-│   │   └── arithmetic.py     # Basic operations (add, subtract, multiply, divide)
-│   ├── middleschool/         # Middle school level
+│   │   ├── arithmetic.py     # Logic for basic arithmetic, GCD, LCM, primes
+│   │   └── arithmetic_interface.py # Gradio interfaces for arithmetic
+│   ├── middleschool/         # Middle school level functions and interfaces
 │   │   ├── __init__.py
-│   │   └── algebra.py        # Algebra operations
-│   ├── highschool/           # High school level
+│   │   ├── algebra.py        # Logic for linear/quadratic equations, polynomials
+│   │   └── algebra_interface.py # Gradio interfaces for algebra
+│   ├── highschool/           # High school level functions and interfaces
 │   │   ├── __init__.py
-│   │   └── trigonometry.py   # Trigonometric functions
-│   └── university/           # University level
+│   │   ├── trigonometry.py   # Logic for trigonometric functions and equations
+│   │   └── trigonometry_interface.py # Gradio interfaces for trigonometry
+│   └── university/           # University level functions and interfaces
 │       ├── __init__.py
-│       └── calculus.py       # Calculus operations
-└── utils/                    # Utility functions
+│       ├── calculus.py       # Logic for calculus (limits, derivatives, integrals, series)
+│       ├── calculus_interface.py # Gradio interfaces for calculus
+│       ├── linear_algebra.py # Logic for matrix/vector operations, linear systems
+│       ├── linear_algebra_interface.py # Gradio interfaces for linear algebra
+│       ├── differential_equations.py # Logic for solving ODEs
+│       ├── differential_equations_interface.py # Gradio interfaces for ODEs
+│       └── tests/              # Unit tests for university level modules
+│           ├── __init__.py
+│           ├── test_linear_algebra.py
+│           └── test_differential_equations.py
+└── utils/                    # Utility functions and interfaces
     ├── __init__.py
-    └── text_utils.py         # Text processing utilities
+    ├── text_utils.py         # Logic for text processing utilities
+    └── text_utils_interface.py # Gradio interface for text utils
 ```
 
 ## Getting Started
 
 1. Install the required packages:
 
-   ```
-   pip install gradio
+   ```bash
+   pip install -r requirements.txt
    ```
 
 2. Run the application:
@@ -83,12 +127,15 @@ This web application provides various mathematical tools organized by educationa
 
 ## Extending the Project
 
-To add new mathematical functions:
+To add new mathematical functions or tools:
 
-1. Choose the appropriate educational level folder
-2. Add your function to an existing file or create a new module
-3. Import the function in app.py
-4. Create a new Gradio interface for the function
+1. **Create Logic**: Add your mathematical function/logic to an existing Python file in the appropriate `maths/<level>/` directory or create a new `.py` file for it. Ensure your functions have clear inputs, outputs, and docstrings.
+2. **Create Interface**: In the corresponding `maths/<level>/` directory (or a subdirectory like `interfaces` if preferred), create a `_interface.py` file (e.g., `newfeature_interface.py`) or add to an existing one. In this file, import your function(s) and create a Gradio interface for each. Define clear input and output components (e.g., `gr.Textbox()`, `gr.Number()`, `gr.Plot()`, `gr.Image()`).
+3. **Add Tests**: For more complex logic, especially at the university level, add unit tests in a corresponding `maths/<level>/tests/` directory (e.g., `test_newfeature.py`). Use the `unittest` module or `pytest`.
+4. **Update Main App**: Import your new Gradio interface object(s) in the main `app.py` file. Add the interface object(s) to the list of interfaces for the relevant educational level tab (e.g., `university_interfaces_list`) and provide a corresponding name in the tab names list (e.g., `university_tab_names`).
+5. **Update `__init__.py` Files**: Ensure your new modules and interface modules are importable by updating the `__init__.py` files in their respective directories if necessary (e.g., `from . import newfeature`, `from . import newfeature_interface`).
+6. **Update `requirements.txt`**: If your new feature introduces new external dependencies, add them to `requirements.txt`. It's good practice to pin versions (e.g., `new_package==1.2.3`).
+7. **Update README**: Document your new feature in the "Features" section and update the "Project Structure" if you added new files/directories.
 
 ## License
 

app.py

@@ -2,36 +2,88 @@ import gradio as gr
 from utils.text_utils_interface import letter_counter_interface
 from maths.elementary.arithmetic_interface import (
     add_interface, subtract_interface, multiply_interface, divide_interface,
-    array_calc_interface, array_calc_vis_interface
+    array_calc_interface, array_calc_vis_interface,
+    gcd_interface, lcm_interface, is_prime_interface # Assuming these were added earlier from a subtask
+)
+from maths.middleschool.algebra_interface import (
+    solve_linear_equation_interface, evaluate_expression_interface,
+    solve_quadratic_interface, simplify_radical_interface, polynomial_interface # Assuming these
+)
+from maths.highschool.trigonometry_interface import (
+    trig_interface, inverse_trig_interface, solve_trig_equations_interface, trig_identities_interface # Assuming these
+)
+from maths.university.calculus_interface import (
+    derivative_interface, integral_interface,
+    limit_interface, taylor_series_interface, fourier_series_interface, # Assuming these
+    partial_derivative_interface, multiple_integral_interface # Assuming these
+)
+from maths.university.linear_algebra_interface import (
+    matrix_add_interface, matrix_subtract_interface, matrix_multiply_interface,
+    matrix_determinant_interface, matrix_inverse_interface,
+    vector_add_interface, vector_subtract_interface, vector_dot_product_interface,
+    vector_cross_product_interface, solve_linear_system_interface
+)
+from maths.university.differential_equations_interface import (
+    first_order_ode_interface, second_order_ode_interface
 )
-from maths.middleschool.algebra_interface import solve_linear_equation_interface, evaluate_expression_interface
-from maths.highschool.trigonometry_interface import trig_interface
-from maths.university.calculus_interface import derivative_interface, integral_interface
 
 # Group interfaces by education level
-elementary_tab = gr.TabbedInterface(
-    [add_interface, subtract_interface, multiply_interface, divide_interface, array_calc_interface, array_calc_vis_interface],
-    ["Addition", "Subtraction", "Multiplication", "Division", "Array Calculation", "Array Calculation with Visualization"],
-    title="Elementary School Math"
-)
+# Note: I'm assuming previous subtasks correctly added GCD, LCM, Polynomial, Quadratic, etc. interfaces to their respective files.
+# If not, this app.py will have import errors for those. I'm focusing on the current task's imports.
+elementary_interfaces_list = [
+    add_interface, subtract_interface, multiply_interface, divide_interface,
+    gcd_interface, lcm_interface, is_prime_interface, # Added from subtask 1
+    array_calc_interface, array_calc_vis_interface
+]
+elementary_tab_names = [
+    "Addition", "Subtraction", "Multiplication", "Division",
+    "GCD", "LCM", "Prime Check", # Added from subtask 1
+    "Array Calculation", "Array Calc Viz"
+]
 
-middleschool_tab = gr.TabbedInterface(
-    [solve_linear_equation_interface, evaluate_expression_interface],
-    ["Linear Equations", "Evaluate Expressions"],
-    title="Middle School Math"
-)
+middleschool_interfaces_list = [
+    solve_linear_equation_interface, evaluate_expression_interface,
+    solve_quadratic_interface, simplify_radical_interface, polynomial_interface # Added from subtask 2
+]
+middleschool_tab_names = [
+    "Linear Equations", "Evaluate Expressions",
+    "Quadratic Solver", "Radical Simplifier", "Polynomial Ops" # Added from subtask 2
+]
 
-highschool_tab = gr.TabbedInterface(
-    [trig_interface],
-    ["Trigonometry"],
-    title="High School Math"
-)
+highschool_interfaces_list = [
+    trig_interface, inverse_trig_interface,
+    solve_trig_equations_interface, trig_identities_interface # Added from subtask 3
+]
+highschool_tab_names = [
+    "Trig Functions", "Inverse Trig",
+    "Solve Trig Eqs", "Trig Identities" # Added from subtask 3
+]
 
-university_tab = gr.TabbedInterface(
-    [derivative_interface, integral_interface],
-    ["Derivatives", "Integrals"],
-    title="University Math"
-)
+university_interfaces_list = [
+    derivative_interface, integral_interface,
+    limit_interface, taylor_series_interface, fourier_series_interface, # Added from subtask 4
+    partial_derivative_interface, multiple_integral_interface, # Added from subtask 4
+    matrix_add_interface, matrix_subtract_interface, matrix_multiply_interface,
+    matrix_determinant_interface, matrix_inverse_interface,
+    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
+]
+university_tab_names = [
+    "Poly Derivatives", "Poly Integrals",
+    "Limits", "Taylor Series", "Fourier Series", # Added from subtask 4
+    "Partial Derivatives", "Multiple Integrals", # Added from subtask 4
+    "Matrix Add", "Matrix Subtract", "Matrix Multiply",
+    "Matrix Determinant", "Matrix Inverse",
+    "Vector Add", "Vector Subtract", "Vector Dot Product",
+    "Vector Cross Product", "Solve Linear System",
+    "1st Order ODE", "2nd Order ODE"
+]
+
+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")
+university_tab = gr.TabbedInterface(university_interfaces_list, university_tab_names, title="University Math")
 
 # Main demo with tabs for each education level
 demo = gr.TabbedInterface(

maths/elementary/arithmetic.py

@@ -189,3 +189,56 @@ def calculate_array_with_visualization(numbers: list, operations: list) -> tuple
     # Visualization: show all intermediate results on the number line
     fig = create_number_line_visualization(numbers, ' -> '.join(operations), result)
     return result, fig
+
+
+def gcd(a: int, b: int) -> int:
+    """Compute the greatest common divisor of two integers.
+
+    Args:
+        a: The first integer.
+        b: The second integer.
+
+    Returns:
+        The greatest common divisor of a and b.
+    """
+    while b:
+        a, b = b, a % b
+    return abs(a)
+
+
+def lcm(a: int, b: int) -> int:
+    """Compute the least common multiple of two integers.
+
+    Args:
+        a: The first integer.
+        b: The second integer.
+
+    Returns:
+        The least common multiple of a and b.
+    """
+    if a == 0 or b == 0:
+        return 0
+    return abs(a * b) // gcd(a, b)
+
+
+def is_prime(n: int) -> bool:
+    """Check if a number is a prime number.
+
+    Args:
+        n: The number to check.
+
+    Returns:
+        True if n is prime, False otherwise.
+    """
+    if n <= 1:
+        return False
+    if n <= 3:
+        return True
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    return True

maths/elementary/arithmetic_interface.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from maths.elementary.arithmetic import add, subtract, multiply, divide, calculate_array, calculate_array_with_visualization
+from maths.elementary.arithmetic import add, subtract, multiply, divide, calculate_array, calculate_array_with_visualization, gcd, lcm, is_prime
 
 # Elementary Math Tab
 add_interface = gr.Interface(
@@ -71,3 +71,27 @@ array_calc_vis_interface = gr.Interface(
     title="Array Calculation with Visualization",
     description="Calculate a sequence of numbers with specified operations and see a number line visualization."
 )
+
+gcd_interface = gr.Interface(
+    fn=gcd,
+    inputs=[gr.Number(label="A", precision=0), gr.Number(label="B", precision=0)],
+    outputs="number",
+    title="Greatest Common Divisor (GCD)",
+    description="Compute the greatest common divisor of two integers."
+)
+
+lcm_interface = gr.Interface(
+    fn=lcm,
+    inputs=[gr.Number(label="A", precision=0), gr.Number(label="B", precision=0)],
+    outputs="number",
+    title="Least Common Multiple (LCM)",
+    description="Compute the least common multiple of two integers."
+)
+
+is_prime_interface = gr.Interface(
+    fn=is_prime,
+    inputs=[gr.Number(label="Number", precision=0)],
+    outputs="text", # Outputting as text to give a clear True/False message
+    title="Prime Number Check",
+    description="Check if a number is a prime number."
+)

maths/highschool/trigonometry.py

@@ -14,3 +14,183 @@ def cos_degrees(angle):
 def tan_degrees(angle):
     """Calculate the tangent of an angle in degrees."""
     return math.tan(math.radians(angle))
+
+
+def inverse_trig_functions(value: float, function_name: str) -> str:
+    """
+    Calculates inverse trigonometric functions (asin, acos, atan) in degrees.
+
+    Args:
+        value: The value to calculate the inverse trigonometric function for.
+               For asin and acos, must be between -1 and 1.
+        function_name: "asin", "acos", or "atan".
+
+    Returns:
+        A string representing the result in degrees, or an error message.
+    """
+    if not isinstance(value, (int, float)):
+        return "Error: Input value must be a number."
+
+    func_name = function_name.lower()
+    result_rad = 0.0
+
+    if func_name == "asin":
+        if -1 <= value <= 1:
+            result_rad = math.asin(value)
+        else:
+            return "Error: Input for asin must be between -1 and 1."
+    elif func_name == "acos":
+        if -1 <= value <= 1:
+            result_rad = math.acos(value)
+        else:
+            return "Error: Input for acos must be between -1 and 1."
+    elif func_name == "atan":
+        result_rad = math.atan(value)
+    else:
+        return "Error: Invalid function name. Choose 'asin', 'acos', or 'atan'."
+
+    return f"{math.degrees(result_rad):.4f} degrees"
+
+
+def solve_trig_equations(a: float, b: float, c: float, trig_func: str, interval_degrees: tuple[float, float] = (0, 360)) -> str:
+    """
+    Solves basic trigonometric equations of the form a * func(x) + b = c.
+    Finds solutions for x within a given interval (in degrees).
+
+    Args:
+        a: Coefficient of the trigonometric function.
+        b: Constant term added to the function part.
+        c: Constant term on the other side of the equation.
+        trig_func: The trigonometric function ("sin", "cos", "tan").
+        interval_degrees: Tuple (min_angle, max_angle) for solutions in degrees.
+
+    Returns:
+        A string describing the solutions in degrees.
+    """
+    if a == 0:
+        return "Error: Coefficient 'a' cannot be zero."
+
+    # Rearrange to func(x) = (c - b) / a
+    val = (c - b) / a
+    func = trig_func.lower()
+    solutions_deg = []
+
+    if func == "sin":
+        if not (-1 <= val <= 1):
+            return f"No solution: sin(x) cannot be {val:.4f}."
+        angle_rad_principal = math.asin(val)
+    elif func == "cos":
+        if not (-1 <= val <= 1):
+            return f"No solution: cos(x) cannot be {val:.4f}."
+        angle_rad_principal = math.acos(val)
+    elif func == "tan":
+        angle_rad_principal = math.atan(val)
+    else:
+        return "Error: Invalid trigonometric function. Choose 'sin', 'cos', or 'tan'."
+
+    # Convert principal solution to degrees
+    angle_deg_principal = math.degrees(angle_rad_principal)
+
+    min_interval_deg, max_interval_deg = interval_degrees
+
+    # Find solutions within the interval
+    # General solutions:
+    # sin(x) = sin(alpha) => x = n*360 + alpha OR x = n*360 + (180 - alpha)
+    # cos(x) = cos(alpha) => x = n*360 + alpha OR x = n*360 - alpha
+    # tan(x) = tan(alpha) => x = n*180 + alpha
+
+    for n in range(int(min_interval_deg / 360) - 2, int(max_interval_deg / 360) + 3): # Check a few cycles around the interval
+        if func == "sin":
+            sol1_deg = n * 360 + angle_deg_principal
+            sol2_deg = n * 360 + (180 - angle_deg_principal)
+            if min_interval_deg <= sol1_deg <= max_interval_deg:
+                solutions_deg.append(sol1_deg)
+            if min_interval_deg <= sol2_deg <= max_interval_deg:
+                solutions_deg.append(sol2_deg)
+        elif func == "cos":
+            sol1_deg = n * 360 + angle_deg_principal
+            sol2_deg = n * 360 - angle_deg_principal
+            if min_interval_deg <= sol1_deg <= max_interval_deg:
+                solutions_deg.append(sol1_deg)
+            if min_interval_deg <= sol2_deg <= max_interval_deg:
+                solutions_deg.append(sol2_deg)
+        elif func == "tan":
+            # For tan, general solution is n*180 + alpha
+             for n_tan in range(int(min_interval_deg / 180) - 2, int(max_interval_deg / 180) + 3):
+                sol_deg = n_tan * 180 + angle_deg_principal
+                if min_interval_deg <= sol_deg <= max_interval_deg:
+                    solutions_deg.append(sol_deg)
+
+    # Remove duplicates and sort
+    unique_solutions = sorted(list(set(f"{s:.2f}" for s in solutions_deg))) # Format to avoid floating point issues
+
+    if not unique_solutions:
+        return f"No solutions found for {a}*{func}(x) + {b} = {c} in the interval [{min_interval_deg}, {max_interval_deg}] degrees."
+
+    return f"Solutions for x in [{min_interval_deg}, {max_interval_deg}] degrees: {', '.join(unique_solutions)}"
+
+
+def trig_identities(angle_degrees: float, identity_name: str = "pythagorean1") -> str:
+    """
+    Demonstrates common trigonometric identities for a given angle (in degrees).
+
+    Args:
+        angle_degrees: The angle in degrees to evaluate the identities for.
+        identity_name: Name of the identity to demonstrate.
+                       "pythagorean1": sin^2(x) + cos^2(x) = 1
+                       "pythagorean2": 1 + tan^2(x) = sec^2(x)
+                       "pythagorean3": 1 + cot^2(x) = csc^2(x)
+                       "all": Show all Pythagorean identities.
+                       More can be added.
+
+    Returns:
+        A string demonstrating the identity.
+    """
+    x_rad = math.radians(angle_degrees)
+    sinx = math.sin(x_rad)
+    cosx = math.cos(x_rad)
+
+    # Avoid division by zero for tan, sec, cot, csc
+    # Check if cosx is very close to zero
+    if abs(cosx) < 1e-9: # cos(90), cos(270) etc.
+        tanx = float('inf') if sinx > 0 else float('-inf') if sinx < 0 else 0 # tan is undefined or 0 if sinx is also 0
+        secx = float('inf') if cosx >= 0 else float('-inf') # sec is undefined
+    else:
+        tanx = sinx / cosx
+        secx = 1 / cosx
+
+    # Check if sinx is very close to zero
+    if abs(sinx) < 1e-9: # sin(0), sin(180) etc.
+        cotx = float('inf') if cosx > 0 else float('-inf') if cosx < 0 else 0 # cot is undefined or 0 if cosx is also 0
+        cscx = float('inf') if sinx >= 0 else float('-inf') # csc is undefined
+    else:
+        cotx = cosx / sinx
+        cscx = 1 / sinx
+
+    results = []
+    name = identity_name.lower()
+
+    if name == "pythagorean1" or name == "all":
+        lhs = sinx**2 + cosx**2
+        results.append(f"Pythagorean Identity 1: sin^2({angle_degrees}) + cos^2({angle_degrees}) = {sinx**2:.4f} + {cosx**2:.4f} = {lhs:.4f} (Expected: 1)")
+
+    if name == "pythagorean2" or name == "all":
+        if abs(cosx) < 1e-9:
+             results.append(f"Pythagorean Identity 2 (1 + tan^2(x) = sec^2(x)): Not well-defined for x={angle_degrees} degrees as cos(x) is near zero (tan(x) and sec(x) are undefined or infinite).")
+        else:
+            lhs = 1 + tanx**2
+            rhs = secx**2
+            results.append(f"Pythagorean Identity 2: 1 + tan^2({angle_degrees}) = 1 + {tanx**2:.4f} = {lhs:.4f}. sec^2({angle_degrees}) = {secx**2:.4f}. (Expected LHS = RHS)")
+
+    if name == "pythagorean3" or name == "all":
+        if abs(sinx) < 1e-9:
+            results.append(f"Pythagorean Identity 3 (1 + cot^2(x) = csc^2(x)): Not well-defined for x={angle_degrees} degrees as sin(x) is near zero (cot(x) and csc(x) are undefined or infinite).")
+        else:
+            lhs = 1 + cotx**2
+            rhs = cscx**2
+            results.append(f"Pythagorean Identity 3: 1 + cot^2({angle_degrees}) = 1 + {cotx**2:.4f} = {lhs:.4f}. csc^2({angle_degrees}) = {cscx**2:.4f}. (Expected LHS = RHS)")
+
+    if not results:
+        return f"Unknown identity: {identity_name}. Available: pythagorean1, pythagorean2, pythagorean3, all."
+
+    return "\n".join(results)

maths/highschool/trigonometry_interface.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from maths.highschool.trigonometry import sin_degrees, cos_degrees, tan_degrees
+from maths.highschool.trigonometry import sin_degrees, cos_degrees, tan_degrees, inverse_trig_functions, solve_trig_equations, trig_identities
 
 # High School Math Tab
 trig_interface = gr.Interface(
@@ -16,3 +16,59 @@ trig_interface = gr.Interface(
     title="Trigonometry Calculator",
     description="Calculate trigonometric functions for angles in degrees"
 )
+
+inverse_trig_interface = gr.Interface(
+    fn=inverse_trig_functions,
+    inputs=[
+        gr.Number(label="Value"),
+        gr.Radio(["asin", "acos", "atan"], label="Inverse Function")
+    ],
+    outputs="text",
+    title="Inverse Trigonometry Calculator",
+    description="Calculate inverse trigonometric functions. Output in degrees."
+)
+
+def parse_interval(interval_str: str) -> tuple[float, float]:
+    """Helper to parse comma-separated interval string (e.g., "0,360") into a tuple."""
+    try:
+        parts = [float(x.strip()) for x in interval_str.split(',')]
+        if len(parts) == 2 and parts[0] <= parts[1]:
+            return parts[0], parts[1]
+        raise ValueError("Interval must be two numbers, min,max.")
+    except Exception:
+        # Return a default or raise specific error for Gradio
+        raise gr.Error("Invalid interval format. Use 'min,max' (e.g., '0,360').")
+
+
+solve_trig_equations_interface = gr.Interface(
+    fn=lambda a, b, c, func, interval_str: solve_trig_equations(a,b,c,func, parse_interval(interval_str)),
+    inputs=[
+        gr.Number(label="a (coefficient of function)"),
+        gr.Number(label="b (constant added to function part)"),
+        gr.Number(label="c (constant on other side of equation)"),
+        gr.Radio(["sin", "cos", "tan"], label="Trigonometric Function"),
+        gr.Textbox(label="Interval for x (degrees, comma-separated, e.g., 0,360)", value="0,360")
+    ],
+    outputs="text",
+    title="Trigonometric Equation Solver",
+    description="Solves equations like a * func(x) + b = c for x in a given interval (degrees)."
+)
+
+trig_identities_interface = gr.Interface(
+    fn=trig_identities,
+    inputs=[
+        gr.Number(label="Angle (degrees)"),
+        gr.Radio(
+            choices=[
+                ("sin²(x) + cos²(x) = 1", "pythagorean1"),
+                ("1 + tan²(x) = sec²(x)", "pythagorean2"),
+                ("1 + cot²(x) = csc²(x)", "pythagorean3"),
+                ("All Pythagorean", "all")
+            ],
+            label="Trigonometric Identity to Demonstrate"
+        )
+    ],
+    outputs="text",
+    title="Trigonometric Identities Demonstrator",
+    description="Show common trigonometric identities for a given angle."
+)

maths/middleschool/algebra.py

@@ -18,3 +18,157 @@ def evaluate_expression(a, b, c, x):
     Evaluate the expression ax² + bx + c for a given value of x.
     """
     return a * (x ** 2) + b * x + c
+
+
+def solve_quadratic(a: float, b: float, c: float) -> str:
+    """
+    Solve the quadratic equation ax^2 + bx + c = 0.
+
+    Args:
+        a: Coefficient of x^2.
+        b: Coefficient of x.
+        c: Constant term.
+
+    Returns:
+        A string representing the solutions.
+    """
+    if a == 0:
+        if b == 0:
+            return "Not a valid equation (a and b cannot both be zero)." if c != 0 else "Infinite solutions (0 = 0)"
+        # Linear equation: bx + c = 0 -> x = -c/b
+        return f"Linear equation: x = {-c/b}"
+
+    delta = b**2 - 4*a*c
+
+    if delta > 0:
+        x1 = (-b + delta**0.5) / (2*a)
+        x2 = (-b - delta**0.5) / (2*a)
+        return f"Two distinct real roots: x1 = {x1}, x2 = {x2}"
+    elif delta == 0:
+        x1 = -b / (2*a)
+        return f"One real root (repeated): x = {x1}"
+    else: # delta < 0
+        real_part = -b / (2*a)
+        imag_part = (-delta)**0.5 / (2*a)
+        return f"Two complex roots: x1 = {real_part} + {imag_part}i, x2 = {real_part} - {imag_part}i"
+
+
+def simplify_radical(number: int) -> str:
+    """
+    Simplifies a radical (square root) to its simplest form (e.g., sqrt(12) -> 2*sqrt(3)).
+
+    Args:
+        number: The number under the radical.
+
+    Returns:
+        A string representing the simplified radical.
+    """
+    if not isinstance(number, int):
+        return "Input must be an integer."
+    if number < 0:
+        return "Cannot simplify the square root of a negative number with this function."
+    if number == 0:
+        return "0"
+
+    i = 2
+    factor = 1
+    remaining = number
+    while i * i <= remaining:
+        if remaining % (i * i) == 0:
+            factor *= i
+            remaining //= (i*i)
+            # Restart checking with the same i in case of factors like i^4, i^6 etc.
+            continue
+        i += 1
+
+    if factor == 1:
+        return f"sqrt({remaining})"
+    if remaining == 1:
+        return str(factor)
+    return f"{factor}*sqrt({remaining})"
+
+
+def polynomial_operations(poly1_coeffs: list[float], poly2_coeffs: list[float], operation: str) -> str:
+    """
+    Performs addition, subtraction, or multiplication of two polynomials.
+    Polynomials are represented by lists of coefficients in descending order of power.
+    Example: [1, -2, 3] represents x^2 - 2x + 3.
+
+    Args:
+        poly1_coeffs: Coefficients of the first polynomial.
+        poly2_coeffs: Coefficients of the second polynomial.
+        operation: "add", "subtract", or "multiply".
+
+    Returns:
+        A string representing the resulting polynomial or an error message.
+    """
+    if not all(isinstance(c, (int, float)) for c in poly1_coeffs) or \
+       not all(isinstance(c, (int, float)) for c in poly2_coeffs):
+        return "Error: All coefficients must be numbers."
+
+    if not poly1_coeffs:
+        poly1_coeffs = [0]
+    if not poly2_coeffs:
+        poly2_coeffs = [0]
+
+    op = operation.lower()
+
+    if op == "add":
+        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
+        max_len = max(len1, len2)
+        p1 = [0]*(max_len - len1) + poly1_coeffs
+        p2 = [0]*(max_len - len2) + poly2_coeffs
+        result_coeffs = [p1[i] + p2[i] for i in range(max_len)]
+    elif op == "subtract":
+        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
+        max_len = max(len1, len2)
+        p1 = [0]*(max_len - len1) + poly1_coeffs
+        p2 = [0]*(max_len - len2) + poly2_coeffs
+        result_coeffs = [p1[i] - p2[i] for i in range(max_len)]
+    elif op == "multiply":
+        len1, len2 = len(poly1_coeffs), len(poly2_coeffs)
+        result_coeffs = [0] * (len1 + len2 - 1)
+        for i in range(len1):
+            for j in range(len2):
+                result_coeffs[i+j] += poly1_coeffs[i] * poly2_coeffs[j]
+    else:
+        return "Error: Invalid operation. Choose 'add', 'subtract', or 'multiply'."
+
+    # Format the result string
+    if not result_coeffs or all(c == 0 for c in result_coeffs):
+        return "0"
+
+    terms = []
+    degree = len(result_coeffs) - 1
+    for i, coeff in enumerate(result_coeffs):
+        power = degree - i
+        if coeff == 0:
+            continue
+
+        term_coeff = ""
+        if coeff == 1 and power != 0:
+            term_coeff = ""
+        elif coeff == -1 and power != 0:
+            term_coeff = "-"
+        else:
+            term_coeff = str(coeff)
+            if isinstance(coeff, float) and coeff.is_integer():
+                term_coeff = str(int(coeff))
+
+
+        if power == 0:
+            terms.append(term_coeff)
+        elif power == 1:
+            terms.append(f"{term_coeff}x")
+        else:
+            terms.append(f"{term_coeff}x^{power}")
+
+    # Join terms, handling signs
+    result_str = terms[0]
+    for term in terms[1:]:
+        if term.startswith("-"):
+            result_str += f" - {term[1:]}"
+        else:
+            result_str += f" + {term}"
+
+    return result_str

maths/middleschool/algebra_interface.py

@@ -1,5 +1,5 @@
 import gradio as gr
-from maths.middleschool.algebra import solve_linear_equation, evaluate_expression
+from maths.middleschool.algebra import solve_linear_equation, evaluate_expression, solve_quadratic, simplify_radical, polynomial_operations
 
 # Middle School Math Tab
 solve_linear_equation_interface = gr.Interface(
@@ -25,3 +25,45 @@ evaluate_expression_interface = gr.Interface(
     title="Quadratic Expression Evaluator",
     description="Evaluate ax² + bx + c for a given value of x"
 )
+
+solve_quadratic_interface = gr.Interface(
+    fn=solve_quadratic,
+    inputs=[
+        gr.Number(label="a (coefficient of x²)"),
+        gr.Number(label="b (coefficient of x)"),
+        gr.Number(label="c (constant)")
+    ],
+    outputs="text",
+    title="Quadratic Equation Solver",
+    description="Solve ax² + bx + c = 0"
+)
+
+simplify_radical_interface = gr.Interface(
+    fn=simplify_radical,
+    inputs=gr.Number(label="Number under radical", precision=0),
+    outputs="text",
+    title="Radical Simplifier",
+    description="Simplify a square root (e.g., √12 → 2√3)"
+)
+
+def parse_coeffs(coeff_str: str) -> list[float]:
+    """Helper to parse comma-separated coefficients from string input."""
+    if not coeff_str.strip():
+        return [0.0]
+    try:
+        return [float(x.strip()) for x in coeff_str.split(',') if x.strip() != '']
+    except ValueError:
+        # Return a value that indicates error, Gradio will show the function's error message
+        raise gr.Error("Invalid coefficient input. Ensure all coefficients are numbers.")
+
+polynomial_interface = gr.Interface(
+    fn=lambda p1_str, p2_str, op: polynomial_operations(parse_coeffs(p1_str), parse_coeffs(p2_str), op),
+    inputs=[
+        gr.Textbox(label="Polynomial 1 Coefficients (comma-separated, highest power first, e.g., 1,-2,3 for x²-2x+3)"),
+        gr.Textbox(label="Polynomial 2 Coefficients (comma-separated, e.g., 2,5 for 2x+5)"),
+        gr.Radio(choices=["add", "subtract", "multiply"], label="Operation")
+    ],
+    outputs="text",
+    title="Polynomial Operations",
+    description="Add, subtract, or multiply two polynomials. Enter coefficients in descending order of power."
+)

maths/university/__init__.py

@@ -1,3 +1,9 @@
 """
 University level mathematics tools.
 """
+
+from . import calculus
+from . import linear_algebra
+from . import linear_algebra_interface
+from . import differential_equations
+from . import differential_equations_interface

maths/university/calculus.py

@@ -1,6 +1,13 @@
 """
 Calculus operations for university level.
 """
+import sympy
+from sympy.parsing.mathematica import parse_mathematica # For robust expression parsing
+import numpy as np # For numerical integration if needed
+from typing import Callable, Union, List, Tuple
+
+# Define common symbols for Sympy expressions
+x, y, z, n = sympy.symbols('x y z n')
 
 def derivative_polynomial(coefficients):
     """
@@ -40,3 +47,219 @@ def integral_polynomial(coefficients, c=0):
     
     result.append(c)  # Add integration constant
     return result
+
+
+def calculate_limit(expression_str: str, variable_str: str, point_str: str, direction: str = '+-') -> str:
+    """
+    Calculates the limit of an expression as a variable approaches a point.
+
+    Args:
+        expression_str: The mathematical expression as a string (e.g., "sin(x)/x").
+        variable_str: The variable in the expression (e.g., "x").
+        point_str: The point the variable is approaching (e.g., "0", "oo" for infinity).
+        direction: The direction of the limit ('+', '-', or '+-' for both sides).
+
+    Returns:
+        A string representing the limit or an error message.
+    """
+    try:
+        var = sympy.Symbol(variable_str)
+        # Using parse_mathematica for more robust parsing than sympify alone
+        # It handles expressions like "x^2" or "sin(x)" more reliably.
+        # We need to ensure the variable is available in the parsing context.
+        local_dict = {variable_str: var}
+        expr = sympy.parse_expr(expression_str, local_dict=local_dict, transformations='all')
+
+
+        if point_str.lower() == 'oo':
+            point = sympy.oo
+        elif point_str.lower() == '-oo':
+            point = -sympy.oo
+        else:
+            point = sympy.sympify(point_str) # Can handle numbers or symbolic constants like pi
+
+        if direction == '+':
+            limit_val = sympy.limit(expr, var, point, dir='+')
+        elif direction == '-':
+            limit_val = sympy.limit(expr, var, point, dir='-')
+        else: # '+-' default
+            limit_val = sympy.limit(expr, var, point)
+
+        return str(limit_val)
+    except (sympy.SympifyError, TypeError, SyntaxError) as e:
+        return f"Error parsing expression or point: {e}. Ensure valid Sympy syntax (e.g. use 'oo' for infinity, ensure variables match)."
+    except Exception as e:
+        return f"An unexpected error occurred: {e}"
+
+
+def taylor_series_expansion(expression_str: str, variable_str: str = 'x', point: float = 0, order: int = 5) -> str:
+    """
+    Computes the Taylor series expansion of an expression around a point.
+
+    Args:
+        expression_str: The mathematical expression (e.g., "exp(x)").
+        variable_str: The variable (default 'x').
+        point: The point around which to expand (default 0).
+        order: The order of the Taylor polynomial (default 5).
+
+    Returns:
+        String representation of the Taylor series or an error message.
+    """
+    try:
+        var = sympy.Symbol(variable_str)
+        expr = sympy.parse_expr(expression_str, local_dict={variable_str: var}, transformations='all')
+
+        series = expr.series(var, x0=point, n=order).removeO() # removeO() removes the O(x^n) term
+        return str(series)
+    except Exception as e:
+        return f"Error calculating Taylor series: {e}"
+
+
+def fourier_series_example(function_type: str = "sawtooth", n_terms: int = 5) -> str:
+    """
+    Provides an example of a Fourier series for a predefined function.
+
+    Args:
+        function_type: "sawtooth" or "square" wave.
+        n_terms: Number of terms to compute in the series.
+
+    Returns:
+        String representation of the Fourier series.
+    """
+    try:
+        L = sympy.pi  # Periodicity, assuming 2L = 2*pi for standard examples
+        x = sympy.Symbol('x')
+
+        if function_type == "sawtooth":
+            # Sawtooth wave: f(x) = x for -pi < x < pi
+            # a0 = 0
+            # an = 0
+            # bn = 2/L * integral(x*sin(n*pi*x/L), (x, 0, L))
+            #    = 2/pi * integral(x*sin(nx), (x, 0, pi))
+            #    = 2/pi * [-x*cos(nx)/n + sin(nx)/n^2]_0^pi
+            #    = 2/pi * [-pi*cos(n*pi)/n] = -2*(-1)^n / n
+            series = sympy.S(0) # Start with zero, as a0 is 0
+            for i in range(1, n_terms + 1):
+                bn_coeff = -2 * ((-1)**i) / i
+                series += bn_coeff * sympy.sin(i * x)
+            return f"Fourier series for sawtooth wave (f(x)=x on [-pi,pi]): {str(series)}"
+
+        elif function_type == "square":
+            # Square wave: f(x) = -1 for -pi < x < 0, f(x) = 1 for 0 < x < pi
+            # a0 = 0
+            # an = 0
+            # bn = 2/L * integral(f(x)*sin(n*pi*x/L), (x, 0, L)) where f(x)=1 for (0,L)
+            #    = 2/pi * integral(sin(nx), (x, 0, pi))
+            #    = 2/pi * [-cos(nx)/n]_0^pi
+            #    = 2/(n*pi) * (1 - cos(n*pi)) = 2/(n*pi) * (1 - (-1)^n)
+            # This means bn is 4/(n*pi) if n is odd, and 0 if n is even.
+            series = sympy.S(0)
+            for i in range(1, n_terms + 1):
+                if i % 2 != 0: # n is odd
+                    bn_coeff = 4 / (i * sympy.pi)
+                    series += bn_coeff * sympy.sin(i * x)
+            return f"Fourier series for square wave (f(x)=1 on [0,pi], -1 on [-pi,0]): {str(series)}"
+        else:
+            return "Error: Unknown function type for Fourier series. Choose 'sawtooth' or 'square'."
+    except Exception as e:
+        return f"Error generating Fourier series: {e}"
+
+
+def partial_derivative(expression_str: str, variables_str: List[str]) -> str:
+    """
+    Computes partial derivatives of an expression with respect to specified variables.
+    Example: expression_str="x**2*y**3", variables_str=["x", "y"] will compute d/dx then d/dy.
+    If you want d^2f/dx^2, use variables_str=["x", "x"].
+
+    Args:
+        expression_str: The mathematical expression (e.g., "x**2*y + y*z**2").
+        variables_str: A list of variable names (strings) to differentiate by, in order.
+                       (e.g., ["x", "y"] for d/dy(d/dx(expr)) ).
+
+    Returns:
+        String representation of the partial derivative or an error message.
+    """
+    try:
+        # Create symbols for all variables that might appear in the expression
+        # For simplicity, we'll assume 'x', 'y', 'z' are common, but user must specify which to derive by.
+        # A more robust way would be to parse expression_str to find all symbols.
+        symbols_in_expr = {s.name: s for s in sympy.parse_expr(expression_str, transformations='all').free_symbols}
+
+        # Ensure variables to differentiate by are symbols
+        diff_vars_symbols = []
+        for var_name in variables_str:
+            if var_name in symbols_in_expr:
+                diff_vars_symbols.append(symbols_in_expr[var_name])
+            else:
+                # If a variable to differentiate by is not in free_symbols, it might be an error
+                # or the expression doesn't depend on it. Sympy handles differentiation by non-present vars as 0.
+                # We'll create the symbol anyway to pass to diff.
+                diff_vars_symbols.append(sympy.Symbol(var_name))
+
+        if not diff_vars_symbols:
+             return "Error: No variables specified for differentiation."
+
+        expr = sympy.parse_expr(expression_str, local_dict=symbols_in_expr, transformations='all')
+
+        # Compute partial derivatives iteratively
+        current_expr = expr
+        for var_sym in diff_vars_symbols:
+            current_expr = sympy.diff(current_expr, var_sym)
+
+        return str(current_expr)
+    except (sympy.SympifyError, TypeError, SyntaxError) as e:
+        return f"Error parsing expression or variables: {e}"
+    except Exception as e:
+        return f"An unexpected error occurred: {e}"
+
+
+def multiple_integral(expression_str: str, integration_vars: List[Tuple[str, Union[str, float], Union[str, float]]]) -> str:
+    """
+    Computes definite multiple integrals.
+
+    Args:
+        expression_str: The mathematical expression (e.g., "x*y**2").
+        integration_vars: A list of tuples, where each tuple contains:
+                          (variable_name_str, lower_bound_str_or_float, upper_bound_str_or_float).
+                          Example: [("x", "0", "1"), ("y", "0", "x")] for integral from 0 to 1 dx of integral from 0 to x dy of (x*y**2).
+                          The order in the list is the order of integration (inner to outer).
+
+    Returns:
+        String representation of the integral result or an error message.
+    """
+    try:
+        # Create symbols for all variables that might appear in the expression
+        # and in integration bounds.
+        # A more robust approach might involve parsing the expression and bounds to identify all symbols.
+        # For now, we'll default to x, y, z if not explicitly mentioned.
+        present_symbols = {sym.name: sym for sym in sympy.parse_expr(expression_str, transformations='all').free_symbols}
+
+        integration_params_sympy = []
+        for var_name, lower_bound, upper_bound in integration_vars:
+            var_sym = present_symbols.get(var_name, sympy.Symbol(var_name))
+            if var_sym.name not in present_symbols: # Add if it wasn't in expression but is an integration var
+                present_symbols[var_sym.name] = var_sym
+
+            # Bounds can be numbers or expressions involving other variables
+            # We need to ensure these other variables are available in the context for sympify
+            lower_s = sympy.sympify(lower_bound, locals=present_symbols)
+            upper_s = sympy.sympify(upper_bound, locals=present_symbols)
+            integration_params_sympy.append((var_sym, lower_s, upper_s))
+
+        if not integration_params_sympy:
+            return "Error: No integration variables specified."
+
+        expr = sympy.parse_expr(expression_str, local_dict=present_symbols, transformations='all')
+
+        # Compute integral iteratively (from inner to outer)
+        # Sympy's integrate function takes tuples like (x, 0, 1)
+        # The order of integration_params_sympy should be from inner-most integral to outer-most.
+        # For sympy.integrate, the order of variables in the list is outer to inner. So we reverse.
+
+        integral_val = sympy.integrate(expr, *integration_params_sympy)
+
+        return str(integral_val)
+    except (sympy.SympifyError, TypeError, SyntaxError) as e:
+        return f"Error parsing expression, bounds, or variables: {e}. Ensure bounds are numbers or valid expressions."
+    except Exception as e:
+        return f"An unexpected error occurred during integration: {e}"

maths/university/calculus_interface.py

@@ -1,5 +1,10 @@
 import gradio as gr
-from maths.university.calculus import derivative_polynomial, integral_polynomial
+from maths.university.calculus import (
+    derivative_polynomial, integral_polynomial,
+    calculate_limit, taylor_series_expansion, fourier_series_example,
+    partial_derivative, multiple_integral
+)
+import json # For parsing list of tuples for multiple integrals
 
 # University Math Tab
 derivative_interface = gr.Interface(
@@ -20,3 +25,101 @@ integral_interface = gr.Interface(
     title="Polynomial Integration",
     description="Find the indefinite integral of a polynomial function"
 )
+
+limit_interface = gr.Interface(
+    fn=calculate_limit,
+    inputs=[
+        gr.Textbox(label="Expression (e.g., sin(x)/x, x**2, exp(-x))", value="sin(x)/x"),
+        gr.Textbox(label="Variable (e.g., x)", value="x"),
+        gr.Textbox(label="Point (e.g., 0, 1, oo, -oo, pi)", value="0"),
+        gr.Radio(choices=["+-", "+", "-"], label="Direction", value="+-")
+    ],
+    outputs="text",
+    title="Limit Calculator",
+    description="Calculate the limit of an expression. Use 'oo' for infinity. Ensure variable in expression matches variable input."
+)
+
+taylor_series_interface = gr.Interface(
+    fn=taylor_series_expansion,
+    inputs=[
+        gr.Textbox(label="Expression (e.g., exp(x), cos(x))", value="exp(x)"),
+        gr.Textbox(label="Variable (e.g., x)", value="x"),
+        gr.Number(label="Point of Expansion (x0)", value=0),
+        gr.Number(label="Order of Taylor Polynomial", value=5, precision=0)
+    ],
+    outputs="text",
+    title="Taylor Series Expansion",
+    description="Compute the Taylor series of a function around a point."
+)
+
+fourier_series_interface = gr.Interface(
+    fn=fourier_series_example,
+    inputs=[
+        gr.Radio(choices=["sawtooth", "square"], label="Function Type", value="sawtooth"),
+        gr.Number(label="Number of Terms (n)", value=5, precision=0)
+    ],
+    outputs="text",
+    title="Fourier Series Examples",
+    description="Generate Fourier series for predefined periodic functions (e.g., sawtooth wave, square wave)."
+)
+
+partial_derivative_interface = gr.Interface(
+    fn=lambda expr_str, vars_str: partial_derivative(expr_str, [v.strip() for v in vars_str.split(',') if v.strip()]),
+    inputs=[
+        gr.Textbox(label="Expression (e.g., x**2*y + z*sin(x))", value="x**2*y**3 + y*sin(z)"),
+        gr.Textbox(label="Variables to differentiate by (comma-separated, in order, e.g., x,y or x,x for d²f/dx²)", value="x,y")
+    ],
+    outputs="text",
+    title="Partial Derivative Calculator",
+    description="Compute partial derivatives. For d/dy(d/dx(f)), enter 'x,y'. For d²f/dx², enter 'x,x'."
+)
+
+
+def parse_integration_variables(vars_json_str: str):
+    """
+    Parses a JSON string representing a list of integration variables and their bounds.
+    Expected format: '[["var1", "lower1", "upper1"], ["var2", "lower2", "upper2"]]'
+    """
+    try:
+        parsed_list = json.loads(vars_json_str)
+        if not isinstance(parsed_list, list):
+            raise ValueError("Input must be a JSON list.")
+
+        integration_vars = []
+        for item in parsed_list:
+            if not (isinstance(item, list) and len(item) == 3):
+                raise ValueError("Each item in the list must be a sub-list of three elements: [variable_name, lower_bound, upper_bound].")
+
+            var, low, upp = item
+            if not isinstance(var, str):
+                raise ValueError(f"Variable name '{var}' must be a string.")
+
+            # Bounds can be numbers or strings (for symbolic bounds like 'x')
+            if not (isinstance(low, (str, int, float))) or not (isinstance(upp, (str, int, float))):
+                 raise ValueError(f"Bounds for variable '{var}' must be numbers or strings. Got '{low}' and '{upp}'.")
+
+            integration_vars.append((str(var), str(low), str(upp))) # Ensure all elements are strings for sympy processing later if needed
+
+        return integration_vars
+    except json.JSONDecodeError:
+        raise gr.Error("Invalid JSON format for integration variables.")
+    except ValueError as ve:
+        raise gr.Error(str(ve))
+    except Exception as e:
+        raise gr.Error(f"Unexpected error parsing integration variables: {str(e)}")
+
+
+multiple_integral_interface = gr.Interface(
+    fn=lambda expr_str, vars_json_str: multiple_integral(expr_str, parse_integration_variables(vars_json_str)),
+    inputs=[
+        gr.Textbox(label="Expression (e.g., x*y**2, 1)", value="x*y"),
+        gr.Textbox(
+            label="Integration Variables and Bounds (JSON list of [var, low, upp] tuples, inner to outer)",
+            value='[["y", "0", "x"], ["x", "0", "1"]]' ,
+            info="Example: integral_0^1 dx integral_0^x dy (x*y) is [['y', '0', 'x'], ['x', '0', '1']]"
+        )
+    ],
+    outputs="text",
+    title="Definite Multiple Integral Calculator",
+    description="Compute multiple integrals. Order of variables in list: inner-most integral first."
+)

maths/university/differential_equations.py

@@ -0,0 +1,236 @@
+"""
+Differential Equations solvers for university level, using SciPy.
+"""
+import numpy as np
+from scipy.integrate import solve_ivp
+from typing import Callable, List, Tuple, Dict, Any, Union
+import matplotlib.pyplot as plt
+
+# Type hint for the function defining the ODE system
+ODEFunc = Callable[[float, Union[np.ndarray, List[float]]], Union[np.ndarray, List[float]]]
+
+def solve_first_order_ode(
+    ode_func: ODEFunc,
+    t_span: Tuple[float, float],
+    y0: List[float],
+    t_eval_count: int = 100,
+    method: str = 'RK45',
+    **kwargs: Any
+) -> Dict[str, Union[np.ndarray, str, bool]]:
+    """
+    Solves a first-order ordinary differential equation (or system of first-order ODEs)
+    dy/dt = f(t, y) with initial condition y(t0) = y0.
+
+    Args:
+        ode_func: Callable f(t, y). `t` is a scalar, `y` is an ndarray of shape (n,).
+                  It should return an array-like object of shape (n,).
+                  Example for dy/dt = -2*y: lambda t, y: -2 * y
+                  Example for system dy1/dt = y2, dy2/dt = -y1: lambda t, y: [y[1], -y[0]]
+        t_span: Tuple (t_start, t_end) for the integration interval.
+        y0: List or NumPy array of initial conditions y(t_start).
+        t_eval_count: Number of points at which to store the computed solution.
+        method: Integration method to use (e.g., 'RK45', 'LSODA', 'BDF').
+        **kwargs: Additional keyword arguments to pass to `solve_ivp` (e.g., `rtol`, `atol`).
+
+    Returns:
+        A dictionary containing:
+            't': NumPy array of time points.
+            'y': NumPy array of solution values at each time point. (y[i] corresponds to t[i])
+                 For systems, y is an array with n_equations rows and n_timepoints columns.
+            'message': Solver message.
+            'success': Boolean indicating if the solver was successful.
+            'plot_path': Path to a saved plot of the solution (if successful), else None.
+    """
+    try:
+        y0_np = np.array(y0, dtype=float)
+        t_eval = np.linspace(t_span[0], t_span[1], t_eval_count)
+
+        sol = solve_ivp(ode_func, t_span, y0_np, method=method, t_eval=t_eval, **kwargs)
+
+        plot_path = None
+        if sol.success:
+            try:
+                plt.figure(figsize=(10, 6))
+                if y0_np.ndim == 0 or len(y0_np) == 1 : # Single equation
+                    plt.plot(sol.t, sol.y[0], label=f'y(t), y0={y0_np[0] if y0_np.ndim > 0 else y0_np}')
+                else: # System of equations
+                    for i in range(sol.y.shape[0]):
+                        plt.plot(sol.t, sol.y[i], label=f'y_{i+1}(t), y0_{i+1}={y0_np[i]}')
+                plt.xlabel("Time (t)")
+                plt.ylabel("Solution y(t)")
+                plt.title(f"Solution of First-Order ODE ({method})")
+                plt.legend()
+                plt.grid(True)
+                plot_path = "ode_solution_plot.png"
+                plt.savefig(plot_path)
+                plt.close() # Close the plot to free memory
+            except Exception as e_plot:
+                print(f"Warning: Could not generate plot: {e_plot}")
+                plot_path = None
+
+
+        return {
+            't': sol.t,
+            'y': sol.y,
+            'message': sol.message,
+            'success': sol.success,
+            'plot_path': plot_path
+        }
+    except Exception as e:
+        return {
+            't': np.array([]),
+            'y': np.array([]),
+            'message': f"Error during ODE solving: {str(e)}",
+            'success': False,
+            'plot_path': None
+        }
+
+def solve_second_order_ode(
+    ode_func_second_order: Callable[[float, float, float], float],
+    t_span: Tuple[float, float],
+    y0: float,
+    dy0_dt: float,
+    t_eval_count: int = 100,
+    method: str = 'RK45',
+    **kwargs: Any
+) -> Dict[str, Union[np.ndarray, str, bool]]:
+    """
+    Solves a single second-order ordinary differential equation of the form
+    d²y/dt² = f(t, y, dy/dt) with initial conditions y(t0)=y0 and dy/dt(t0)=dy0_dt.
+
+    This is done by converting the second-order ODE into a system of two first-order ODEs:
+    Let z1 = y and z2 = dy/dt.
+    Then dz1/dt = z2
+    And dz2/dt = d²y/dt² = f(t, z1, z2)
+
+    Args:
+        ode_func_second_order: Callable f(t, y, dy_dt). `t` is scalar, `y` is scalar, `dy_dt` is scalar.
+                               It should return the value of d²y/dt².
+                               Example for d²y/dt² = -0.1*(dy/dt) - y: lambda t, y, dy_dt: -0.1 * dy_dt - y
+        t_span: Tuple (t_start, t_end) for the integration interval.
+        y0: Initial value of y at t_start.
+        dy0_dt: Initial value of dy/dt at t_start.
+        t_eval_count: Number of points at which to store the computed solution.
+        method: Integration method to use.
+        **kwargs: Additional keyword arguments for `solve_ivp`.
+
+    Returns:
+        A dictionary containing:
+            't': NumPy array of time points.
+            'y': NumPy array of solution values y(t) at each time point.
+            'dy_dt': NumPy array of solution values dy/dt(t) at each time point.
+            'message': Solver message.
+            'success': Boolean indicating if the solver was successful.
+            'plot_path': Path to a saved plot of y(t) and dy/dt(t) (if successful), else None.
+    """
+    # Define the system of first-order ODEs
+    def system_func(t: float, z: np.ndarray) -> List[float]:
+        y_val, dy_dt_val = z[0], z[1]
+        d2y_dt2_val = ode_func_second_order(t, y_val, dy_dt_val)
+        return [dy_dt_val, d2y_dt2_val]
+
+    initial_conditions_system = [y0, dy0_dt]
+
+    try:
+        t_eval = np.linspace(t_span[0], t_span[1], t_eval_count)
+        sol = solve_ivp(system_func, t_span, initial_conditions_system, method=method, t_eval=t_eval, **kwargs)
+
+        plot_path = None
+        if sol.success:
+            try:
+                plt.figure(figsize=(12, 7))
+
+                plt.subplot(2,1,1)
+                plt.plot(sol.t, sol.y[0], label=f'y(t), y0={y0}')
+                plt.xlabel("Time (t)")
+                plt.ylabel("y(t)")
+                plt.title(f"Solution of Second-Order ODE: y(t) ({method})")
+                plt.legend()
+                plt.grid(True)
+
+                plt.subplot(2,1,2)
+                plt.plot(sol.t, sol.y[1], label=f'dy/dt(t), dy0/dt={dy0_dt}', color='orange')
+                plt.xlabel("Time (t)")
+                plt.ylabel("dy/dt(t)")
+                plt.title(f"Solution of Second-Order ODE: dy/dt(t) ({method})")
+                plt.legend()
+                plt.grid(True)
+
+                plt.tight_layout()
+                plot_path = "ode_second_order_solution_plot.png"
+                plt.savefig(plot_path)
+                plt.close()
+            except Exception as e_plot:
+                print(f"Warning: Could not generate plot: {e_plot}")
+                plot_path = None
+
+        return {
+            't': sol.t,
+            'y': sol.y[0],      # First component of the system's solution
+            'dy_dt': sol.y[1],  # Second component of the system's solution
+            'message': sol.message,
+            'success': sol.success,
+            'plot_path': plot_path
+        }
+    except Exception as e:
+        return {
+            't': np.array([]),
+            'y': np.array([]),
+            'dy_dt': np.array([]),
+            'message': f"Error during ODE solving: {str(e)}",
+            'success': False,
+            'plot_path': None
+        }
+
+# Example Usage (can be removed or commented out)
+if __name__ == '__main__':
+    # --- First-order ODE example: dy/dt = -y*t with y(0)=1 ---
+    def first_order_example(t, y):
+        return -y * t
+
+    print("Solving dy/dt = -y*t, y(0)=1 from t=0 to t=5")
+    solution1 = solve_first_order_ode(first_order_example, (0, 5), [1], t_eval_count=50)
+    if solution1['success']:
+        print(f"First-order ODE solved. Message: {solution1['message']}")
+        # print("t:", solution1['t'])
+        # print("y:", solution1['y'])
+        if solution1['plot_path']:
+            print(f"Plot saved to {solution1['plot_path']}")
+    else:
+        print(f"First-order ODE failed. Message: {solution1['message']}")
+
+    # --- First-order system example: Lotka-Volterra ---
+    # dy1/dt = a*y1 - b*y1*y2 (prey)
+    # dy2/dt = c*y1*y2 - d*y2 (predator)
+    a, b, c, d = 1.5, 0.8, 0.5, 0.9
+    def lotka_volterra(t, y):
+        prey, predator = y[0], y[1]
+        d_prey_dt = a * prey - b * prey * predator
+        d_predator_dt = c * prey * predator - d * predator
+        return [d_prey_dt, d_predator_dt]
+
+    print("\nSolving Lotka-Volterra system from t=0 to t=20 with y0=[10, 5]")
+    solution_lv = solve_first_order_ode(lotka_volterra, (0, 20), [10, 5], t_eval_count=200)
+    if solution_lv['success']:
+        print(f"Lotka-Volterra solved. Plot saved to {solution_lv['plot_path']}")
+    else:
+        print(f"Lotka-Volterra failed. Message: {solution_lv['message']}")
+
+
+    # --- Second-order ODE example: d²y/dt² = -sin(y) (simple pendulum) ---
+    # y is theta, dy/dt is omega. d²y/dt² = -g/L * sin(y)
+    g_L = 9.81 / 1.0 # Example: g/L = 9.81
+    def pendulum_ode(t, y_angle, dy_dt_angular_velocity):
+        return -g_L * np.sin(y_angle)
+
+    print("\nSolving d²y/dt² = -g/L*sin(y), y(0)=pi/4, dy/dt(0)=0 from t=0 to t=10")
+    solution2 = solve_second_order_ode(pendulum_ode, (0, 10), y0=np.pi/4, dy0_dt=0, t_eval_count=100)
+    if solution2['success']:
+        print(f"Second-order ODE solved. Message: {solution2['message']}")
+        # print("t:", solution2['t'])
+        # print("y:", solution2['y'])
+        # print("dy/dt:", solution2['dy_dt'])
+        if solution2['plot_path']:
+            print(f"Plot saved to {solution2['plot_path']}")
+    else:
+        print(f"Second-order ODE failed. Message: {solution2['message']}")

maths/university/differential_equations_interface.py

@@ -0,0 +1,172 @@
+"""
+Gradio Interface for Differential Equations solvers.
+
+SECURITY WARNING: These interfaces use eval() to parse user-provided Python lambda strings
+for defining ODE functions. This is a potential security risk if arbitrary code is entered.
+Use with caution and only with trusted inputs, especially if deploying this application
+outside a controlled environment.
+"""
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt # For displaying plots if not returned directly by solver
+from typing import Callable, Tuple, List, Dict, Any, Union
+import ast # For safer string literal evaluation if needed for parameters
+import math # To make math functions available in eval scope for ODEs
+
+# Import the solver functions
+from maths.university.differential_equations import solve_first_order_ode, solve_second_order_ode
+
+# --- Helper Functions ---
+
+def parse_float_list(input_str: str, expected_len: int = 0) -> List[float]:
+    """Parses a comma-separated string of floats into a list."""
+    try:
+        if not input_str.strip():
+            if expected_len > 0: # If expecting specific number, empty is error
+                 raise ValueError("Input string is empty.")
+            return [] # Allow empty list if not expecting specific length
+
+        parts = [float(p.strip()) for p in input_str.split(',') if p.strip()]
+        if expected_len > 0 and len(parts) != expected_len:
+            raise ValueError(f"Expected {expected_len} values, but got {len(parts)}.")
+        return parts
+    except ValueError as e:
+        raise gr.Error(f"Invalid format for list of numbers. Use comma-separated floats. Error: {e}")
+
+def parse_time_span(time_span_str: str) -> Tuple[float, float]:
+    """Parses a comma-separated string for time span (t_start, t_end)."""
+    parts = parse_float_list(time_span_str, expected_len=2)
+    if parts[0] >= parts[1]:
+        raise gr.Error("t_start must be less than t_end for the time span.")
+    return (parts[0], parts[1])
+
+def string_to_ode_func(lambda_str: str, expected_args: Tuple[str, ...]) -> Callable:
+    """
+    Converts a string representation of a Python lambda function into a callable.
+    Includes a basic check for 'lambda' keyword and argument count.
+
+    Args:
+        lambda_str: The string, e.g., "lambda t, y: -2*y" or "lambda t, y, dy_dt: -0.1*dy_dt -y".
+        expected_args: A tuple of expected argument names, e.g., ('t', 'y') or ('t', 'y', 'dy_dt').
+
+    Returns:
+        A callable function.
+    Raises:
+        gr.Error: If the string is not a valid lambda or has wrong argument structure.
+    """
+    lambda_str = lambda_str.strip()
+    if not lambda_str.startswith("lambda"):
+        raise gr.Error("ODE function must be a Python lambda string (e.g., 'lambda t, y: -y').")
+
+    try:
+        # Basic check for argument names within the lambda definition part (before ':')
+        # This is a heuristic and not a full AST parse for safety here, as eval is the main concern.
+        lambda_def_part = lambda_str.split(":")[0]
+        for arg_name in expected_args:
+            if arg_name not in lambda_def_part:
+                raise gr.Error(f"Lambda function string does not seem to contain expected argument: '{arg_name}'. Expected args: {expected_args}")
+
+        # The eval environment will have access to common math functions and numpy (np)
+        # This is where the security risk lies.
+        safe_eval_globals = {
+            "np": np,
+            "math": math,
+            "sin": math.sin, "cos": math.cos, "tan": math.tan,
+            "exp": math.exp, "log": math.log, "log10": math.log10,
+            "sqrt": math.sqrt, "fabs": math.fabs, "pow": math.pow,
+            "pi": math.pi, "e": math.e
+        }
+        # User must use 'math.func' or 'np.func' for most things not listed above.
+
+        func = eval(lambda_str, safe_eval_globals, {})
+        if not callable(func):
+            raise gr.Error("The provided string did not evaluate to a callable function.")
+        return func
+    except SyntaxError as se:
+        raise gr.Error(f"Syntax error in lambda function: {se}. Ensure it's valid Python syntax.")
+    except Exception as e:
+        raise gr.Error(f"Error evaluating lambda function string: {e}. Ensure it's a valid lambda returning the derivative(s).")
+
+
+# --- Gradio Interface for First-Order ODEs ---
+first_order_ode_interface = gr.Interface(
+    fn=lambda ode_str, t_span_str, y0_str, t_eval_count, method: solve_first_order_ode(
+        string_to_ode_func(ode_str, ('t', 'y')),
+        parse_time_span(t_span_str),
+        parse_float_list(y0_str), # y0 can be a list for systems
+        int(t_eval_count),
+        method
+    ),
+    inputs=[
+        gr.Textbox(label="ODE Function (lambda t, y: ...)",
+                   placeholder="e.g., lambda t, y: -y*t  OR for system lambda t, y: [y[1], -0.1*y[1] - y[0]]",
+                   info="Define dy/dt or a system [dy1/dt, dy2/dt,...]. `y` is a list/array for systems."),
+        gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,10"),
+        gr.Textbox(label="Initial Condition(s) y(t_start)", placeholder="e.g., 1 OR for system 1,0"),
+        gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
+        gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
+    ],
+    outputs=[
+        gr.Image(label="Solution Plot", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
+        gr.Textbox(label="Solver Message"),
+        gr.Textbox(label="Success Status"),
+        gr.JSON(label="Raw Data (t, y values)", visible=lambda res: res['success']) # For users to copy if needed
+    ],
+    title="First-Order ODE Solver",
+    description="Solves dy/dt = f(t,y) or a system of first-order ODEs. " \
+                "WARNING: Uses eval() for the ODE function string - potential security risk. " \
+                "For systems, `y` in lambda is `[y1, y2, ...]`, return `[dy1/dt, dy2/dt, ...]`. " \
+                "Example (Damped Oscillator): ODE: lambda t, y: [y[1], -0.5*y[1] - y[0]], y0: 1,0, Timespan: 0,20",
+    allow_flagging="never"
+)
+
+# --- Gradio Interface for Second-Order ODEs ---
+second_order_ode_interface = gr.Interface(
+    fn=lambda ode_str, t_span_str, y0_val_str, dy0_dt_val_str, t_eval_count, method: solve_second_order_ode(
+        string_to_ode_func(ode_str, ('t', 'y', 'dy_dt')), # Note: dy_dt is one variable name here
+        parse_time_span(t_span_str),
+        parse_float_list(y0_val_str, expected_len=1)[0], # y0 is a single float
+        parse_float_list(dy0_dt_val_str, expected_len=1)[0], # dy0_dt is a single float
+        int(t_eval_count),
+        method
+    ),
+    inputs=[
+        gr.Textbox(label="ODE Function (lambda t, y, dy_dt: ...)",
+                   placeholder="e.g., lambda t, y, dy_dt: -0.1*dy_dt - math.sin(y)",
+                   info="Define d²y/dt². `y` is current value, `dy_dt` is current first derivative."),
+        gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,20"),
+        gr.Textbox(label="Initial y(t_start)", placeholder="e.g., 1.0"),
+        gr.Textbox(label="Initial dy/dt(t_start)", placeholder="e.g., 0.0"),
+        gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
+        gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
+    ],
+    outputs=[
+        gr.Image(label="Solution Plot (y(t) and dy/dt(t))", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
+        gr.Textbox(label="Solver Message"),
+        gr.Textbox(label="Success Status"),
+        gr.JSON(label="Raw Data (t, y, dy_dt values)", visible=lambda res: res['success'])
+    ],
+    title="Second-Order ODE Solver",
+    description="Solves d²y/dt² = f(t, y, dy/dt). " \
+                "WARNING: Uses eval() for the ODE function string - potential security risk. " \
+                "Example (Pendulum): ODE: lambda t, y, dy_dt: -9.81/1.0 * math.sin(y), y0: math.pi/4, dy0/dt: 0, Timespan: 0,10",
+    allow_flagging="never"
+)
+
+# Example usage for testing (can be removed)
+if __name__ == '__main__':
+    # Test first order
+    # result1 = solve_first_order_ode(lambda t,y: -y*t, (0,5), [1])
+    # print(result1['success'], result1['message'])
+    # if result1['plot_path']: import os; os.system(f"open {result1['plot_path']}")
+
+
+    # Test second order
+    # result2 = solve_second_order_ode(lambda t,y,dydt: -0.1*dydt - y, (0,20), 1, 0)
+    # print(result2['success'], result2['message'])
+    # if result2['plot_path']: import os; os.system(f"open {result2['plot_path']}")
+
+    # To run one of these interfaces for testing:
+    # first_order_ode_interface.launch()
+    # second_order_ode_interface.launch()
+    pass

maths/university/linear_algebra.py

@@ -0,0 +1,249 @@
+"""
+Linear Algebra operations for university level, using NumPy.
+"""
+import numpy as np
+from typing import List, Union, Tuple
+
+Matrix = Union[List[List[float]], np.ndarray]
+Vector = Union[List[float], np.ndarray]
+
+def matrix_add(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
+    """
+    Adds two matrices.
+
+    Args:
+        matrix1: The first matrix.
+        matrix2: The second matrix.
+
+    Returns:
+        The resulting matrix as a NumPy array.
+    Raises:
+        ValueError: If matrices have incompatible shapes.
+    """
+    m1 = np.array(matrix1)
+    m2 = np.array(matrix2)
+    if m1.shape != m2.shape:
+        raise ValueError("Matrices must have the same dimensions for addition.")
+    return np.add(m1, m2)
+
+def matrix_subtract(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
+    """
+    Subtracts the second matrix from the first.
+
+    Args:
+        matrix1: The first matrix.
+        matrix2: The second matrix.
+
+    Returns:
+        The resulting matrix as a NumPy array.
+    Raises:
+        ValueError: If matrices have incompatible shapes.
+    """
+    m1 = np.array(matrix1)
+    m2 = np.array(matrix2)
+    if m1.shape != m2.shape:
+        raise ValueError("Matrices must have the same dimensions for subtraction.")
+    return np.subtract(m1, m2)
+
+def matrix_multiply(matrix1: Matrix, matrix2: Matrix) -> np.ndarray:
+    """
+    Multiplies two matrices.
+
+    Args:
+        matrix1: The first matrix.
+        matrix2: The second matrix.
+
+    Returns:
+        The resulting matrix as a NumPy array.
+    Raises:
+        ValueError: If matrices have incompatible shapes for multiplication.
+    """
+    m1 = np.array(matrix1)
+    m2 = np.array(matrix2)
+    if m1.shape[1] != m2.shape[0]:
+        raise ValueError("Number of columns in the first matrix must equal number of rows in the second for multiplication.")
+    return np.dot(m1, m2)
+
+def matrix_determinant(matrix: Matrix) -> float:
+    """
+    Calculates the determinant of a square matrix.
+
+    Args:
+        matrix: The matrix (must be square).
+
+    Returns:
+        The determinant of the matrix.
+    Raises:
+        ValueError: If the matrix is not square.
+    """
+    m = np.array(matrix)
+    if m.shape[0] != m.shape[1]:
+        raise ValueError("Matrix must be square to calculate its determinant.")
+    return np.linalg.det(m)
+
+def matrix_inverse(matrix: Matrix) -> np.ndarray:
+    """
+    Calculates the inverse of a square matrix.
+
+    Args:
+        matrix: The matrix (must be square and invertible).
+
+    Returns:
+        The inverse of the matrix as a NumPy array.
+    Raises:
+        ValueError: If the matrix is not square.
+        np.linalg.LinAlgError: If the matrix is singular (not invertible).
+    """
+    m = np.array(matrix)
+    if m.shape[0] != m.shape[1]:
+        raise ValueError("Matrix must be square to calculate its inverse.")
+    return np.linalg.inv(m)
+
+def vector_add(vector1: Vector, vector2: Vector) -> np.ndarray:
+    """
+    Adds two vectors.
+
+    Args:
+        vector1: The first vector.
+        vector2: The second vector.
+
+    Returns:
+        The resulting vector as a NumPy array.
+    Raises:
+        ValueError: If vectors have incompatible shapes.
+    """
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != v2.shape:
+        raise ValueError("Vectors must have the same dimensions for addition.")
+    return np.add(v1, v2)
+
+def vector_subtract(vector1: Vector, vector2: Vector) -> np.ndarray:
+    """
+    Subtracts the second vector from the first.
+
+    Args:
+        vector1: The first vector.
+        vector2: The second vector.
+
+    Returns:
+        The resulting vector as a NumPy array.
+    Raises:
+        ValueError: If vectors have incompatible shapes.
+    """
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != v2.shape:
+        raise ValueError("Vectors must have the same dimensions for subtraction.")
+    return np.subtract(v1, v2)
+
+def vector_dot_product(vector1: Vector, vector2: Vector) -> float:
+    """
+    Calculates the dot product of two vectors.
+
+    Args:
+        vector1: The first vector.
+        vector2: The second vector.
+
+    Returns:
+        The dot product of the vectors.
+    Raises:
+        ValueError: If vectors have incompatible shapes.
+    """
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != v2.shape:
+        raise ValueError("Vectors must have the same dimensions for dot product.")
+    return np.dot(v1, v2)
+
+def vector_cross_product(vector1: Vector, vector2: Vector) -> np.ndarray:
+    """
+    Calculates the cross product of two 3D vectors.
+
+    Args:
+        vector1: The first 3D vector.
+        vector2: The second 3D vector.
+
+    Returns:
+        The resulting 3D vector as a NumPy array.
+    Raises:
+        ValueError: If vectors are not 3-dimensional.
+    """
+    v1 = np.array(vector1)
+    v2 = np.array(vector2)
+    if v1.shape != (3,) or v2.shape != (3,):
+        raise ValueError("Cross product is only defined for 3-dimensional vectors.")
+    return np.cross(v1, v2)
+
+def solve_linear_system(coefficients_matrix: Matrix, constants_vector: Vector) -> np.ndarray:
+    """
+    Solves a system of linear equations Ax = B.
+
+    Args:
+        coefficients_matrix (A): The matrix of coefficients.
+        constants_vector (B): The vector of constants.
+
+    Returns:
+        The solution vector (x) as a NumPy array.
+    Raises:
+        ValueError: If the coefficient matrix is not square or dimensions are incompatible.
+        np.linalg.LinAlgError: If the system has no unique solution (e.g., singular matrix).
+    """
+    A = np.array(coefficients_matrix)
+    B = np.array(constants_vector)
+
+    if A.shape[0] != A.shape[1]:
+        raise ValueError("Coefficient matrix must be square.")
+    if A.shape[0] != B.shape[0]:
+        raise ValueError("Number of rows in coefficient matrix must match number of elements in constants vector.")
+
+    return np.linalg.solve(A, B)
+
+# Example Usage (can be removed or commented out for production)
+if __name__ == '__main__':
+    # Matrix examples
+    m_a = [[1, 2], [3, 4]]
+    m_b = [[5, 6], [7, 8]]
+    print("Matrix A+B:", matrix_add(m_a, m_b))
+    print("Matrix A*B:", matrix_multiply(m_a, m_b))
+    m_c = [[1,2,3],[4,5,6],[7,8,9]] # Singular
+    m_d = [[1,2,3],[0,1,4],[5,6,0]]
+    print("Determinant of D:", matrix_determinant(m_d))
+    try:
+        print("Inverse of D:", matrix_inverse(m_d))
+    except np.linalg.LinAlgError as e:
+        print("Error inverting D:", e)
+    try:
+        print("Inverse of C (singular):", matrix_inverse(m_c)) # Should raise error
+    except np.linalg.LinAlgError as e:
+        print("Error inverting C:", e)
+
+
+    # Vector examples
+    v_a = [1, 2, 3]
+    v_b = [4, 5, 6]
+    print("Vector A+B:", vector_add(v_a, v_b))
+    print("Vector A.B (dot):", vector_dot_product(v_a, v_b))
+    print("Vector AxB (cross):", vector_cross_product(v_a, v_b))
+
+    v_c = [1,2]
+    v_d = [3,4]
+    try:
+        print(vector_cross_product(v_c,v_d)) # Should error
+    except ValueError as e:
+        print("Error cross product:", e)
+
+    # Solve linear system example
+    # 2x + y = 1
+    # x + y = 1
+    coeffs = [[2, 1], [1, 1]]
+    consts = [1, 1]
+    print("Solution to 2x+y=1, x+y=1 is:", solve_linear_system(coeffs, consts)) # Expected: [0, 1]
+
+    # Singular system
+    coeffs_singular = [[1, 1], [1, 1]]
+    consts_singular = [1, 2] # No solution
+    try:
+        print("Solution to singular system:", solve_linear_system(coeffs_singular, consts_singular))
+    except np.linalg.LinAlgError as e:
+        print("Error solving singular system:", e)

maths/university/linear_algebra_interface.py

@@ -0,0 +1,197 @@
+"""
+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,
+    matrix_determinant, matrix_inverse,
+    vector_add, vector_subtract, vector_dot_product,
+    vector_cross_product, solve_linear_system
+)
+
+# Helper functions to parse inputs
+def parse_matrix(matrix_str: str, allow_empty_rows_cols=False) -> np.ndarray:
+    """Parses a string representation of a matrix (JSON format or comma/semicolon separated) into a NumPy array."""
+    try:
+        # Try JSON parsing first for structure like [[1,2],[3,4]]
+        m = json.loads(matrix_str)
+        arr = np.array(m, dtype=float)
+        if not allow_empty_rows_cols and (arr.shape[0] == 0 or (arr.ndim > 1 and arr.shape[1] == 0)):
+            raise ValueError("Matrix cannot have zero rows or columns.")
+        if arr.ndim == 1 and arr.shape[0] > 0: # Handles single row matrix like "[1,2,3]"
+             arr = arr.reshape(1, -1)
+        elif arr.ndim == 0 and not allow_empty_rows_cols : # Handles scalar input like "5" if not allowed
+            raise ValueError("Input is a scalar, not a matrix.")
+        return arr
+    except (json.JSONDecodeError, TypeError, ValueError) as e_json:
+        # Fallback for simpler comma/semicolon separated format, e.g. "1,2;3,4"
+        try:
+            rows = [list(map(float, row.split(','))) for row in matrix_str.split(';') if row.strip()]
+            if not rows and not allow_empty_rows_cols:
+                raise ValueError("Matrix input is empty.")
+            if not rows and allow_empty_rows_cols: # e.g. for an empty matrix if needed
+                return np.array([])
+
+            # Check for consistent row lengths
+            if len(rows) > 1:
+                first_row_len = len(rows[0])
+                if not all(len(r) == first_row_len for r in rows):
+                    raise ValueError("All rows must have the same number of columns.")
+
+            arr = np.array(rows, dtype=float)
+            if not allow_empty_rows_cols and (arr.shape[0] == 0 or (arr.ndim > 1 and arr.shape[1] == 0)):
+                 raise ValueError("Matrix cannot have zero rows or columns after parsing.")
+            return arr
+
+        except ValueError as e_csv:
+            raise gr.Error(f"Invalid matrix format. Use JSON (e.g., [[1,2],[3,4]]) or comma/semicolon (e.g., 1,2;3,4). Error: {e_csv} (Original JSON error: {e_json})")
+        except Exception as e_gen: # Catch any other parsing errors
+            raise gr.Error(f"General error parsing matrix: {e_gen}")
+
+
+def parse_vector(vector_str: str) -> np.ndarray:
+    """Parses a string representation of a vector (JSON or comma-separated) into a NumPy array."""
+    try:
+        # Try JSON parsing for lists like [1,2,3]
+        v = json.loads(vector_str)
+        arr = np.array(v, dtype=float)
+        if arr.ndim != 1:
+            raise ValueError("Vector must be 1-dimensional.")
+        if arr.shape[0] == 0:
+            raise ValueError("Vector cannot be empty.")
+        return arr
+    except (json.JSONDecodeError, TypeError, ValueError) as e_json:
+        # Fallback for simpler comma-separated format e.g. "1,2,3"
+        try:
+            if not vector_str.strip():
+                 raise ValueError("Vector input is empty.")
+            arr = np.array([float(x.strip()) for x in vector_str.split(',') if x.strip()], dtype=float)
+            if arr.shape[0] == 0: # case like "," or " , "
+                 raise ValueError("Vector cannot be empty after parsing.")
+            return arr
+        except ValueError as e_csv:
+            raise gr.Error(f"Invalid vector format. Use JSON (e.g., [1,2,3]) or comma-separated (e.g., 1,2,3). Error: {e_csv} (Original JSON error: {e_json})")
+        except Exception as e_gen:
+            raise gr.Error(f"General error parsing vector: {e_gen}")
+
+def format_output(data: Union[np.ndarray, float, str]) -> str:
+    """Formats NumPy array or float for display, handling errors."""
+    if isinstance(data, np.ndarray):
+        return str(data.tolist()) # Convert to list for cleaner display
+    elif isinstance(data, (float, int, str)):
+        return str(data)
+    return "Output type not recognized."
+
+# --- Matrix Interfaces ---
+matrix_add_interface = gr.Interface(
+    fn=lambda m1_str, m2_str: format_output(matrix_add(parse_matrix(m1_str), parse_matrix(m2_str))),
+    inputs=[
+        gr.Textbox(label="Matrix 1 (JSON or CSV format)", placeholder="e.g., [[1,2],[3,4]] or 1,2;3,4"),
+        gr.Textbox(label="Matrix 2 (JSON or CSV format)", placeholder="e.g., [[5,6],[7,8]] or 5,6;7,8")
+    ],
+    outputs=gr.Textbox(label="Resulting Matrix"),
+    title="Matrix Addition",
+    description="Adds two matrices. Ensure they have the same dimensions."
+)
+
+matrix_subtract_interface = gr.Interface(
+    fn=lambda m1_str, m2_str: format_output(matrix_subtract(parse_matrix(m1_str), parse_matrix(m2_str))),
+    inputs=[
+        gr.Textbox(label="Matrix 1 (Minuend)", placeholder="e.g., [[5,6],[7,8]]"),
+        gr.Textbox(label="Matrix 2 (Subtrahend)", placeholder="e.g., [[1,2],[3,4]]")
+    ],
+    outputs=gr.Textbox(label="Resulting Matrix"),
+    title="Matrix Subtraction",
+    description="Subtracts the second matrix from the first. Ensure they have the same dimensions."
+)
+
+matrix_multiply_interface = gr.Interface(
+    fn=lambda m1_str, m2_str: format_output(matrix_multiply(parse_matrix(m1_str), parse_matrix(m2_str))),
+    inputs=[
+        gr.Textbox(label="Matrix 1", placeholder="e.g., [[1,2],[3,4]]"),
+        gr.Textbox(label="Matrix 2", placeholder="e.g., [[5,6],[7,8]]")
+    ],
+    outputs=gr.Textbox(label="Resulting Matrix"),
+    title="Matrix Multiplication",
+    description="Multiplies two matrices. Columns of Matrix 1 must equal rows of Matrix 2."
+)
+
+matrix_determinant_interface = gr.Interface(
+    fn=lambda m_str: format_output(matrix_determinant(parse_matrix(m_str))),
+    inputs=gr.Textbox(label="Matrix (must be square)", placeholder="e.g., [[1,2],[3,4]]"),
+    outputs=gr.Textbox(label="Determinant"),
+    title="Matrix Determinant",
+    description="Calculates the determinant of a square matrix."
+)
+
+matrix_inverse_interface = gr.Interface(
+    fn=lambda m_str: format_output(matrix_inverse(parse_matrix(m_str))),
+    inputs=gr.Textbox(label="Matrix (must be square and invertible)", placeholder="e.g., [[1,2],[3,7]]"),
+    outputs=gr.Textbox(label="Inverse Matrix"),
+    title="Matrix Inverse",
+    description="Calculates the inverse of a square matrix. Matrix must be invertible (non-singular)."
+)
+
+# --- Vector Interfaces ---
+vector_add_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_add(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1 (JSON or CSV format)", placeholder="e.g., [1,2,3] or 1,2,3"),
+        gr.Textbox(label="Vector 2 (JSON or CSV format)", placeholder="e.g., [4,5,6] or 4,5,6")
+    ],
+    outputs=gr.Textbox(label="Resulting Vector"),
+    title="Vector Addition",
+    description="Adds two vectors. Ensure they have the same dimensions."
+)
+
+vector_subtract_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_subtract(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1 (Minuend)", placeholder="e.g., [4,5,6]"),
+        gr.Textbox(label="Vector 2 (Subtrahend)", placeholder="e.g., [1,2,3]")
+    ],
+    outputs=gr.Textbox(label="Resulting Vector"),
+    title="Vector Subtraction",
+    description="Subtracts the second vector from the first. Ensure they have the same dimensions."
+)
+
+vector_dot_product_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_dot_product(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1", placeholder="e.g., [1,2,3]"),
+        gr.Textbox(label="Vector 2", placeholder="e.g., [4,5,6]")
+    ],
+    outputs=gr.Textbox(label="Dot Product (Scalar)"),
+    title="Vector Dot Product",
+    description="Calculates the dot product of two vectors. Ensure they have the same dimensions."
+)
+
+vector_cross_product_interface = gr.Interface(
+    fn=lambda v1_str, v2_str: format_output(vector_cross_product(parse_vector(v1_str), parse_vector(v2_str))),
+    inputs=[
+        gr.Textbox(label="Vector 1 (3D)", placeholder="e.g., [1,2,3]"),
+        gr.Textbox(label="Vector 2 (3D)", placeholder="e.g., [4,5,6]")
+    ],
+    outputs=gr.Textbox(label="Resulting Vector (3D)"),
+    title="Vector Cross Product",
+    description="Calculates the cross product of two 3D vectors."
+)
+
+# --- Solve Linear System Interface ---
+solve_linear_system_interface = gr.Interface(
+    fn=lambda A_str, B_str: format_output(solve_linear_system(parse_matrix(A_str), parse_vector(B_str))),
+    inputs=[
+        gr.Textbox(label="Coefficients Matrix (A)", placeholder="For Ax=B. e.g., [[2,1],[1,1]] for 2x+y, x+y"),
+        gr.Textbox(label="Constants Vector (B)", placeholder="For Ax=B. e.g., [1,1] for =1, =1")
+    ],
+    outputs=gr.Textbox(label="Solution Vector (x)"),
+    title="Linear System Solver (Ax = B)",
+    description="Solves a system of linear equations Ax = B. Matrix A must be square and invertible."
+)
+
+# It might be useful to group these interfaces in a Gradio TabbedInterface or Blocks layout in a main app file.
+# For now, this file just defines the individual interfaces.

maths/university/operations_research/BranchAndBoundSolver.py

@@ -0,0 +1,384 @@
+import cvxpy as cp
+import numpy as np
+import math
+from queue import PriorityQueue
+import networkx as nx
+import matplotlib.pyplot as plt
+from tabulate import tabulate
+from scipy.optimize import linprog
+
+
+class BranchAndBoundSolver:
+    def __init__(self, c, A, b, integer_vars=None, binary_vars=None, maximize=True):
+        """
+        Initialize the Branch and Bound solver
+        
+        Parameters:
+        - c: Objective coefficients (for max c'x)
+        - A, b: Constraints Ax <= b
+        - integer_vars: Indices of variables that must be integers
+        - binary_vars: Indices of variables that must be binary (0 or 1)
+        - maximize: True for maximization, False for minimization
+        """
+        self.c = c
+        self.A = A
+        self.b = b
+        self.n = len(c)
+        
+        # Process binary and integer variables
+        self.binary_vars = [] if binary_vars is None else binary_vars
+        
+        # If integer_vars not specified, assume all non-binary variables are integers
+        if integer_vars is None:
+            self.integer_vars = list(range(self.n))
+        else:
+            self.integer_vars = integer_vars.copy()
+        
+        # Add binary variables to integer variables list if they're not already there
+        for idx in self.binary_vars:
+            if idx not in self.integer_vars:
+                self.integer_vars.append(idx)
+        
+        # Best solution found so far
+        self.best_solution = None
+        self.best_objective = float('-inf') if maximize else float('inf')
+        self.maximize = maximize
+        
+        # Track nodes explored
+        self.nodes_explored = 0
+        
+        # Graph for visualization
+        self.graph = nx.DiGraph()
+        self.node_id = 0
+        
+        # For tabular display of steps
+        self.steps_table = []
+        
+        # Set of active nodes
+        self.active_nodes = set()
+    
+    def is_integer_feasible(self, x):
+        """Check if the solution satisfies integer constraints"""
+        if x is None:
+            return False
+        
+        for idx in self.integer_vars:
+            if abs(round(x[idx]) - x[idx]) > 1e-6:
+                return False
+        return True
+    
+    def get_branching_variable(self, x):
+        """Select most fractional variable to branch on"""
+        max_fractional = -1
+        branching_var = -1
+        
+        for idx in self.integer_vars:
+            fractional_part = abs(x[idx] - round(x[idx]))
+            if fractional_part > max_fractional and fractional_part > 1e-6:
+                max_fractional = fractional_part
+                branching_var = idx
+        
+        return branching_var
+    
+    def solve_relaxation(self, lower_bounds, upper_bounds):
+        """Solve the continuous relaxation with given bounds"""
+        x = cp.Variable(self.n)
+        
+        # Set the objective - maximize c'x or minimize -c'x
+        if self.maximize:
+            objective = cp.Maximize(self.c @ x)
+        else:
+            objective = cp.Minimize(self.c @ x)
+        
+        # Basic constraints Ax <= b
+        constraints = [self.A @ x <= self.b]
+        
+        # Add bounds
+        for i in range(self.n):
+            if lower_bounds[i] is not None:
+                constraints.append(x[i] >= lower_bounds[i])
+            if upper_bounds[i] is not None:
+                constraints.append(x[i] <= upper_bounds[i])
+        
+        prob = cp.Problem(objective, constraints)
+        
+        try:
+            objective_value = prob.solve()
+            return x.value, objective_value
+        except:
+            return None, float('-inf') if self.maximize else float('inf')
+    
+    def add_node_to_graph(self, node_name, objective_value, x_value, parent=None, branch_var=None, branch_cond=None):
+        """Add a node to the branch and bound graph"""
+        self.graph.add_node(node_name, obj=objective_value, x=x_value, 
+                        branch_var=branch_var, branch_cond=branch_cond)
+        
+        if parent is not None:
+            # Use branch_var + 1 to show 1-indexed variables in the display
+            label = f"x_{branch_var + 1} {branch_cond}"
+            self.graph.add_edge(parent, node_name, label=label)
+        
+        return node_name
+    
+    def visualize_graph(self):
+        """Visualize the branch and bound graph"""
+        fig = plt.figure(figsize=(20, 8))
+        pos = nx.spring_layout(self.graph)  # Use spring layout instead of graphviz
+
+        # Node labels: Node name, Objective value and solution
+        labels = {}
+        for node, data in self.graph.nodes(data=True):
+            if data.get('x') is not None:
+                x_str = ', '.join([f"{x:.2f}" for x in data['x']])
+                labels[node] = f"{node}\n({data['obj']:.2f}, ({x_str}))"
+            else:
+                labels[node] = f"{node}\nInfeasible"
+        
+        # Edge labels: Branching conditions
+        edge_labels = nx.get_edge_attributes(self.graph, 'label')
+        
+        # Draw nodes
+        nx.draw_networkx_nodes(self.graph, pos, node_size=2000, node_color='skyblue')
+        
+        # Draw edges
+        nx.draw_networkx_edges(self.graph, pos, width=1.5, arrowsize=20, edge_color='gray')
+        
+        # Draw labels
+        nx.draw_networkx_labels(self.graph, pos, labels, font_size=10, font_family='sans-serif')
+        nx.draw_networkx_edge_labels(self.graph, pos, edge_labels=edge_labels, font_size=10, font_family='sans-serif')
+        
+        plt.title("Branch and Bound Tree", fontsize=14)
+        plt.axis('off')
+        plt.tight_layout()
+        return fig  # Return the figure instead of showing it
+
+    
+    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"))
+    
+    def solve(self, verbose=True):
+        """Solve the problem using branch and bound"""
+        # Initialize bounds
+        lower_bounds = [0] * self.n
+        upper_bounds = [None] * self.n  # None means unbounded
+        
+        # Set upper bounds for binary variables
+        for idx in self.binary_vars:
+            upper_bounds[idx] = 1
+        
+        # Create a priority queue for nodes (max heap for maximization, min heap for minimization)
+        # We use negative values for maximization to simulate max heap with Python's min heap
+        node_queue = PriorityQueue()
+        
+        # Solve the root relaxation
+        print("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')
+        
+        # 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}")
+        
+        # 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.best_solution = x_root
+            self.best_objective = obj_root
+            
+            # Add to steps table
+            active_nodes_str = "∅" if not self.active_nodes else "{" + ", ".join(self.active_nodes) + "}"
+            self.steps_table.append([
+                root_node, f"{obj_root:.2f}", f"({', '.join([f'{x:.2f}' for x in x_root])})", 
+                f"{self.best_objective:.2f}", f"({', '.join([f'{x:.2f}' for x in self.best_solution])})",
+                f"{upper_bound:.2f}", f"{self.best_objective:.2f}", active_nodes_str
+            ])
+            
+            self.display_steps_table()
+            self.visualize_graph()
+            return x_root, obj_root
+        
+        # Add root node to the queue and active nodes set
+        priority = -obj_root if self.maximize else obj_root
+        node_queue.put((priority, self.nodes_explored, root_node, lower_bounds.copy(), upper_bounds.copy()))
+        self.active_nodes.add(root_node)
+        
+        # Add entry to steps table for root node
+        active_nodes_str = "{" + ", ".join(self.active_nodes) + "}"
+        lb_str = "-" if self.best_objective == float('-inf') else f"{self.best_objective:.2f}"
+        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])})", 
+            lb_str, x_star_str, f"{upper_bound:.2f}", lb_str, active_nodes_str
+        ])
+        
+        print("\nStarting branch and bound process:")
+        node_counter = 1
+        
+        while not node_queue.empty():
+            # Get the node with the highest objective (for maximization)
+            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}")
+            
+            # Remove from active nodes
+            self.active_nodes.remove(node_name)
+            
+            # Branch on most fractional variable
+            branch_var = self.get_branching_variable(self.graph.nodes[node_name]['x'])
+            branch_val = self.graph.nodes[node_name]['x'][branch_var]
+            
+            # For binary variables, always branch with x=0 and x=1
+            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")
+            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}")
+            
+            # Process left branch (floor)
+            left_node = f"S{node_counter}"
+            node_counter += 1
+            
+            # Create the "floor" branch
+            floor_lower_bounds = node_lower_bounds.copy()
+            floor_upper_bounds = node_upper_bounds.copy()
+            
+            # For binary variables, set both bounds to 0 (x=0)
+            if branch_var in self.binary_vars:
+                floor_lower_bounds[branch_var] = 0
+                floor_upper_bounds[branch_var] = 0
+                branch_cond = f"= 0"
+            else:
+                floor_upper_bounds[branch_var] = floor_val
+                branch_cond = f"≤ {floor_val}"
+            
+            # Solve the relaxation for this node
+            x_floor, obj_floor = self.solve_relaxation(floor_lower_bounds, floor_upper_bounds)
+            
+            # Add node to graph
+            self.add_node_to_graph(left_node, obj_floor if x_floor is not None else float('-inf'), 
+                                x_floor, node_name, branch_var, branch_cond)
+            
+            # Process the floor branch
+            if x_floor is None:
+                print(f"  {left_node} is infeasible")
+            else:
+                print(f"  {left_node} relaxation objective: {obj_floor:.6f}")
+                print(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}")
+                
+                # Add to queue if not fathomed
+                if ((self.maximize and obj_floor > self.best_objective) or 
+                    (not self.maximize and obj_floor < self.best_objective)):
+                    if not self.is_integer_feasible(x_floor):  # Only branch if not integer feasible
+                        priority = -obj_floor if self.maximize else obj_floor
+                        node_queue.put((priority, self.nodes_explored, left_node, 
+                                       floor_lower_bounds.copy(), floor_upper_bounds.copy()))
+                        self.active_nodes.add(left_node)
+            
+            # Process right branch (ceil)
+            right_node = f"S{node_counter}"
+            node_counter += 1
+            
+            # Create the "ceil" branch
+            ceil_lower_bounds = node_lower_bounds.copy()
+            ceil_upper_bounds = node_upper_bounds.copy()
+            
+            # For binary variables, set both bounds to 1 (x=1)
+            if branch_var in self.binary_vars:
+                ceil_lower_bounds[branch_var] = 1
+                ceil_upper_bounds[branch_var] = 1
+                branch_cond = f"= 1"
+            else:
+                ceil_lower_bounds[branch_var] = ceil_val
+                branch_cond = f"≥ {ceil_val}"
+            
+            # Solve the relaxation for this node
+            x_ceil, obj_ceil = self.solve_relaxation(ceil_lower_bounds, ceil_upper_bounds)
+            
+            # Add node to graph
+            self.add_node_to_graph(right_node, obj_ceil if x_ceil is not None else float('-inf'), 
+                                x_ceil, node_name, branch_var, branch_cond)
+            
+            # Process the ceil branch
+            if x_ceil is None:
+                print(f"  {right_node} is infeasible")
+            else:
+                print(f"  {right_node} relaxation objective: {obj_ceil:.6f}")
+                print(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}")
+                
+                # Add to queue if not fathomed
+                if ((self.maximize and obj_ceil > self.best_objective) or 
+                    (not self.maximize and obj_ceil < self.best_objective)):
+                    if not self.is_integer_feasible(x_ceil):  # Only branch if not integer feasible
+                        priority = -obj_ceil if self.maximize else obj_ceil
+                        node_queue.put((priority, self.nodes_explored, right_node, 
+                                      ceil_lower_bounds.copy(), ceil_upper_bounds.copy()))
+                        self.active_nodes.add(right_node)
+            
+            # Update upper bound as the best objective in the remaining nodes
+            if not node_queue.empty():
+                # Upper bound is the best possible objective in the remaining nodes
+                next_priority = node_queue.queue[0][0]
+                upper_bound = -next_priority if self.maximize else next_priority
+            else:
+                upper_bound = self.best_objective
+            
+            # Add to steps table
+            active_nodes_str = "∅" if not self.active_nodes else "{" + ", ".join(self.active_nodes) + "}"
+            lb_str = f"{self.best_objective:.2f}" if self.best_objective != float('-inf') else "-"
+            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([
+                node_name, 
+                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}")
+        
+        if self.best_solution is not None:
+            print(f"Optimal objective: {self.best_objective:.6f}")
+            print(f"Optimal solution: {self.best_solution}")
+        else:
+            print("No feasible integer solution found")
+        
+        # Display steps table
+        self.display_steps_table()
+        
+        # Visualize the graph
+        self.visualize_graph()
+        
+        return self.best_solution, self.best_objective

maths/university/operations_research/DualSimplexSolver.py

@@ -0,0 +1,443 @@
+import numpy as np
+import sys
+from .solve_lp_via_dual import solve_lp_via_dual
+from .solve_primal_directly import solve_primal_directly
+
+TOLERANCE = 1e-9
+
+class DualSimplexSolver:
+    """
+    Solves a Linear Programming problem using the Dual Simplex Method.
+
+    Assumes the problem is provided in the form:
+    Maximize/Minimize c^T * x
+    Subject to:
+        A * x <= / >= / = b
+        x >= 0
+
+    The algorithm works best when the initial tableau (after converting all
+    constraints to <=) is dual feasible (objective row coefficients >= 0 for Max)
+    but primal infeasible (some RHS values are negative).
+    """
+
+    def __init__(self, objective_type, c, A, relations, b):
+        """
+        Initializes the solver.
+
+        Args:
+            objective_type (str): 'max' or 'min'.
+            c (list or np.array): Coefficients of the objective function.
+            A (list of lists or np.array): Coefficients of the constraints LHS.
+            relations (list): List of strings ('<=', '>=', '=') for each constraint.
+            b (list or np.array): RHS values of the constraints.
+        """
+        self.objective_type = objective_type.lower()
+        self.original_c = np.array(c, dtype=float)
+        self.original_A = np.array(A, dtype=float)
+        self.original_relations = relations
+        self.original_b = np.array(b, dtype=float)
+
+        self.num_original_vars = len(c)
+        self.num_constraints = len(b)
+
+        self.tableau = None
+        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._preprocess()
+
+    def _preprocess(self):
+        """
+        Converts the problem to the standard form for Dual Simplex:
+        - Maximization objective
+        - All constraints are <=
+        - Adds slack variables
+        - Builds the initial tableau
+        """
+        # --- 1. Handle Objective Function ---
+        if self.objective_type == 'min':
+            self.is_minimized_problem = True
+            current_c = -self.original_c
+        else:
+            current_c = self.original_c
+
+        # --- 2. Handle Constraints and Slack Variables ---
+        num_slacks_added = 0
+        processed_A = []
+        processed_b = []
+        self.basic_vars = [] # Will store column indices of basic vars
+
+        # Create variable names
+        self.var_names = [f'x{i+1}' for i in range(self.num_original_vars)]
+        slack_var_names = []
+
+        for i in range(self.num_constraints):
+            A_row = self.original_A[i]
+            b_val = self.original_b[i]
+            relation = self.original_relations[i]
+
+            if relation == '>=':
+                # Multiply by -1 to convert to <=
+                processed_A.append(-A_row)
+                processed_b.append(-b_val)
+            elif relation == '=':
+                # Convert Ax = b into Ax <= b and Ax >= b
+                # First: Ax <= b
+                processed_A.append(A_row)
+                processed_b.append(b_val)
+                # Second: Ax >= b --> -Ax <= -b
+                processed_A.append(-A_row)
+                processed_b.append(-b_val)
+            elif relation == '<=':
+                processed_A.append(A_row)
+                processed_b.append(b_val)
+            else:
+                raise ValueError(f"Invalid relation symbol: {relation}")
+
+        # Update number of effective constraints after handling '='
+        effective_num_constraints = len(processed_b)
+
+        # Add slack variables for all processed constraints (which are now all <=)
+        num_slack_vars = effective_num_constraints
+        final_A = np.zeros((effective_num_constraints, self.num_original_vars + num_slack_vars))
+        final_b = np.array(processed_b, dtype=float)
+
+        # Populate original variable coefficients
+        final_A[:, :self.num_original_vars] = np.array(processed_A, dtype=float)
+
+        # Add slack variable identity matrix part and names
+        for i in range(effective_num_constraints):
+            slack_col_index = self.num_original_vars + i
+            final_A[i, slack_col_index] = 1
+            slack_var_names.append(f's{i+1}')
+            self.basic_vars.append(slack_col_index) # Initially, slacks are basic
+
+        self.var_names.extend(slack_var_names)
+
+        # --- 3. Build the Tableau ---
+        num_total_vars = self.num_original_vars + num_slack_vars
+        # Rows: 1 for objective + number of constraints
+        # Cols: 1 for Z + number of total vars + 1 for RHS
+        self.tableau = np.zeros((effective_num_constraints + 1, num_total_vars + 2))
+
+        # Row 0 (Objective Z): [1, -c, 0_slacks, 0_rhs]
+        self.tableau[0, 0] = 1 # Z coefficient
+        self.tableau[0, 1:self.num_original_vars + 1] = -current_c
+        # Slack coefficients in objective are 0 initially
+        # RHS of objective row is 0 initially
+
+        # Rows 1 to m (Constraints): [0, A_final, b_final]
+        self.tableau[1:, 1:num_total_vars + 1] = final_A
+        self.tableau[1:, -1] = final_b
+
+        # 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.")
+             # 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} ---")
+        header = ["BV"] + ["Z"] + self.var_names + ["RHS"]
+        print(" ".join(f"{h:>8}" for h in header))
+        print("-" * (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))
+
+
+    def _find_pivot_row(self):
+        """Finds the index of the leaving variable (pivot row)."""
+        rhs_values = self.tableau[1:, -1]
+        # Find the index of the most negative RHS value (among constraints)
+        if np.all(rhs_values >= -TOLERANCE):
+            return -1 # All RHS non-negative, current solution is feasible (and optimal)
+
+        pivot_row_index = np.argmin(rhs_values) + 1 # +1 because we skip obj row 0
+        # Check if the minimum value is actually negative
+        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}")
+        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})")
+        return pivot_row_index
+
+    def _find_pivot_col(self, pivot_row_index):
+        """Finds the index of the entering variable (pivot column)."""
+        pivot_row = self.tableau[pivot_row_index, 1:-1] # Exclude Z and RHS cols
+        objective_row = self.tableau[0, 1:-1]           # Exclude Z and RHS cols
+
+        ratios = {}
+        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:")
+
+        found_negative_coeff = False
+        for j, coeff in enumerate(pivot_row):
+            col_var_index = j # This is the index within the var_names list
+            col_tableau_index = j + 1 # This is the index in the full tableau row
+
+            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}")
+
+                # Update minimum ratio
+                if ratio < min_ratio:
+                    min_ratio = ratio
+                    pivot_col_index = col_tableau_index # Store the tableau column index
+
+        if not found_negative_coeff:
+            print("   No negative coefficients found in the pivot row.")
+            return -1 # Indicates primal infeasibility (dual unboundedness)
+
+        # 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]}.")
+        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})")
+        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
+
+        return pivot_col_index
+
+
+    def _pivot(self, pivot_row_index, pivot_col_index):
+        """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})")
+
+        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.
+            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.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}:")
+        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})")
+                    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
+        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}.")
+
+
+    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
+        """
+        print("--- Starting Dual Simplex Method ---")
+        if self.tableau is None:
+            print("Error: Tableau not initialized.")
+            return None
+
+        iteration = 0
+        self._print_tableau(iteration)
+
+        while iteration < 100: # Safety break for too many iterations
+            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
+
+            # 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.")
+                
+                if use_fallbacks:
+                    return self._try_fallback_solvers("primal_infeasible")
+                return None, None # Indicate infeasibility
+                
+            elif pivot_col_index == -2:
+                 # Error during pivot column selection
+                 print("\n--- Error during pivot column selection ---")
+                 
+                 if use_fallbacks:
+                    return self._try_fallback_solvers("pivot_error")
+                 return None, None
+
+            # 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} ---")
+                
+                if use_fallbacks:
+                    return self._try_fallback_solvers("numerical_instability")
+                return None, None
+
+            # Print the tableau after pivoting
+            self._print_tableau(iteration)
+
+        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.")
+        
+        if use_fallbacks:
+            return self._try_fallback_solvers("iteration_limit")
+        return None, None # Indicate non-convergence
+
+    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
+        """
+        print(f"\n--- Using Fallback Solvers due to '{error_type}' ---")
+        
+        results = {
+            "error_type": error_type,
+            "dual_simplex_result": None,
+            "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 ===")
+        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
+        )
+        
+        results["dual_approach_result"] = {
+            "status": status,
+            "message": message,
+            "primal_solution": primal_sol,
+            "dual_solution": dual_sol,
+            "objective_value": obj_val
+        }
+        
+        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
+        )
+        
+        results["direct_solver_result"] = {
+            "status": status,
+            "message": message,
+            "primal_solution": primal_sol,
+            "objective_value": obj_val
+        }
+        
+        print(f"Direct Solver Result: {message}")
+        if status == 0 and primal_sol:
+            print(f"Objective Value: {obj_val}")
+        
+        return results
+
+    def _print_results(self):
+        """Prints the final solution."""
+        print("\n--- Final Solution ---")
+        self._print_tableau("Final")
+
+        # Objective Value
+        final_obj_value = self.tableau[0, -1]
+        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}")
+
+        # Variable Values
+        solution = {}
+        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
+
+        # Optionally print slack variable values
+        print("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}")
+

maths/university/operations_research/dual.ipynb

@@ -0,0 +1,153 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Warning: Initial tableau is not dual feasible (objective row has negative coefficients).\n",
+      "The standard Dual Simplex method might not apply directly or may require Phase I.\n",
+      "--- Starting Dual Simplex Method ---\n",
+      "\n",
+      "--- Iteration 0 ---\n",
+      "      BV        Z       x1       x2       s1       s2       s3      RHS\n",
+      "------------------------------------------------------------------------\n",
+      "       Z    1.000    1.000   -2.000    0.000    0.000    0.000    0.000\n",
+      "      s1    0.000   -5.000   -4.000    1.000    0.000    0.000  -20.000\n",
+      "      s2    0.000    1.000    5.000    0.000    1.000    0.000   10.000\n",
+      "      s3    0.000   -1.000   -5.000    0.000    0.000    1.000  -10.000\n",
+      "------------------------------------------------------------------------\n",
+      "\n",
+      "Step: Select Pivot Row (Leaving Variable)\n",
+      "   RHS values (b): [-20.  10. -10.]\n",
+      "   Most negative RHS is -20.000 in Row 1 (Basic Var: s1).\n",
+      "   Leaving Variable: s1 (Row 1)\n",
+      "\n",
+      "Step: Select Pivot Column (Entering Variable) using Ratio Test\n",
+      "   Pivot Row (Row 1) coefficients (excluding Z, RHS): [-5. -4.  1.  0.  0.]\n",
+      "   Objective Row coefficients (excluding Z, RHS): [ 1. -2.  0.  0.  0.]\n",
+      "   Calculating ratios = ObjCoeff / abs(PivotRowCoeff) for PivotRowCoeff < 0:\n",
+      "      Var x1 (Col 1): Coeff=-5.000, ObjCoeff=1.000, Ratio = 1.000 / 5.000 = 0.200\n",
+      "      Var x2 (Col 2): Coeff=-4.000, ObjCoeff=-2.000, Ratio = -2.000 / 4.000 = -0.500\n",
+      "   Minimum ratio is -0.500 for variable x2 (Column 2).\n",
+      "   Entering Variable: x2 (Column 2)\n",
+      "\n",
+      "Step: Pivot Operation\n",
+      "   Pivot Element: -4.000 at (Row 1, Col 2)\n",
+      "   Normalizing Pivot Row 1 by dividing by -4.000\n",
+      "   Eliminating other entries in Pivot Column 2:\n",
+      "      Row 0 = Row 0 - (-2.000) * (New Row 1)\n",
+      "      Row 2 = Row 2 - (5.000) * (New Row 1)\n",
+      "      Row 3 = Row 3 - (-5.000) * (New Row 1)\n",
+      "   Updating Basic Variables: x2 replaces s1 in the basis for Row 1.\n",
+      "\n",
+      "--- Iteration 1 ---\n",
+      "      BV        Z       x1       x2       s1       s2       s3      RHS\n",
+      "------------------------------------------------------------------------\n",
+      "       Z    1.000    3.500    0.000   -0.500    0.000    0.000   10.000\n",
+      "      x2   -0.000    1.250    1.000   -0.250   -0.000   -0.000    5.000\n",
+      "      s2    0.000   -5.250    0.000    1.250    1.000    0.000  -15.000\n",
+      "      s3    0.000    5.250    0.000   -1.250    0.000    1.000   15.000\n",
+      "------------------------------------------------------------------------\n",
+      "\n",
+      "Step: Select Pivot Row (Leaving Variable)\n",
+      "   RHS values (b): [  5. -15.  15.]\n",
+      "   Most negative RHS is -15.000 in Row 2 (Basic Var: s2).\n",
+      "   Leaving Variable: s2 (Row 2)\n",
+      "\n",
+      "Step: Select Pivot Column (Entering Variable) using Ratio Test\n",
+      "   Pivot Row (Row 2) coefficients (excluding Z, RHS): [-5.25  0.    1.25  1.    0.  ]\n",
+      "   Objective Row coefficients (excluding Z, RHS): [ 3.5  0.  -0.5  0.   0. ]\n",
+      "   Calculating ratios = ObjCoeff / abs(PivotRowCoeff) for PivotRowCoeff < 0:\n",
+      "      Var x1 (Col 1): Coeff=-5.250, ObjCoeff=3.500, Ratio = 3.500 / 5.250 = 0.667\n",
+      "   Minimum ratio is 0.667 for variable x1 (Column 1).\n",
+      "   Entering Variable: x1 (Column 1)\n",
+      "\n",
+      "Step: Pivot Operation\n",
+      "   Pivot Element: -5.250 at (Row 2, Col 1)\n",
+      "   Normalizing Pivot Row 2 by dividing by -5.250\n",
+      "   Eliminating other entries in Pivot Column 1:\n",
+      "      Row 0 = Row 0 - (3.500) * (New Row 2)\n",
+      "      Row 1 = Row 1 - (1.250) * (New Row 2)\n",
+      "      Row 3 = Row 3 - (5.250) * (New Row 2)\n",
+      "   Updating Basic Variables: x1 replaces s2 in the basis for Row 2.\n",
+      "\n",
+      "--- Iteration 2 ---\n",
+      "      BV        Z       x1       x2       s1       s2       s3      RHS\n",
+      "------------------------------------------------------------------------\n",
+      "       Z    1.000    0.000    0.000    0.333    0.667    0.000    0.000\n",
+      "      x2    0.000    0.000    1.000    0.048    0.238    0.000    1.429\n",
+      "      x1   -0.000    1.000   -0.000   -0.238   -0.190   -0.000    2.857\n",
+      "      s3    0.000    0.000    0.000    0.000    1.000    1.000    0.000\n",
+      "------------------------------------------------------------------------\n",
+      "\n",
+      "--- Optimal Solution Found ---\n",
+      "   All RHS values are non-negative.\n",
+      "\n",
+      "--- Final Solution ---\n",
+      "\n",
+      "--- Iteration Final ---\n",
+      "      BV        Z       x1       x2       s1       s2       s3      RHS\n",
+      "------------------------------------------------------------------------\n",
+      "       Z    1.000    0.000    0.000    0.333    0.667    0.000    0.000\n",
+      "      x2    0.000    0.000    1.000    0.048    0.238    0.000    1.429\n",
+      "      x1   -0.000    1.000   -0.000   -0.238   -0.190   -0.000    2.857\n",
+      "      s3    0.000    0.000    0.000    0.000    1.000    1.000    0.000\n",
+      "------------------------------------------------------------------------\n",
+      "Optimal Objective Value (Max Z): 0.000000\n",
+      "Optimal Variable Values:\n",
+      "   x1: 2.857143\n",
+      "   x2: 1.428571\n",
+      "Slack/Surplus Variable Values:\n"
+     ]
+    }
+   ],
+   "source": [
+    "from functions.DualSimplexSolver import DualSimplexSolver\n",
+    "if __name__ == \"__main__\":\n",
+    "    try:\n",
+    "        example_obj_type = 'max'\n",
+    "        example_c = [-1,2]\n",
+    "        example_A = [\n",
+    "            [5,4],\n",
+    "            [1,5],\n",
+    "        ]\n",
+    "        example_relations = ['>=', '=']\n",
+    "        example_b = [20,10]\n",
+    "\n",
+    "        solver = DualSimplexSolver(example_obj_type, example_c, example_A, example_relations, example_b)\n",
+    "        solver.solve()\n",
+    "    except Exception as e:\n",
+    "        print(f\"\\nAn error occurred: {e}\")\n",
+    "        import traceback\n",
+    "        traceback.print_exc()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv (3.13.2)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

maths/university/operations_research/get_user_input.py

@@ -0,0 +1,46 @@
+def get_user_input():
+    """Gets the LP problem details from the user."""
+    # (Identical to the input function in the previous Dual Simplex example)
+    print("Enter the Linear Programming Problem:")
+    while True:
+        obj_type = input("Is it a 'max' or 'min' problem? ").strip().lower()
+        if obj_type in ['max', 'min']:
+            break
+        print("Invalid input. Please enter 'max' or 'min'.")
+    c_str = input("Enter objective function coefficients (space-separated): ").strip()
+    c = list(map(float, c_str.split()))
+    num_vars = len(c)
+    A = []
+    relations = []
+    b = []
+    i = 1
+    print(f"Enter constraints (one per line). There are {num_vars} variables (x1, x2,...).")
+    print("Format: coeff1 coeff2 ... relation rhs (e.g., '3 1 >= 3')")
+    print("Type 'done' when finished.")
+    while True:
+        line = input(f"Constraint {i}: ").strip()
+        if line.lower() == 'done':
+            if i == 1:
+                print("Error: At least one constraint is required.")
+                continue
+            break
+        parts = line.split()
+        if len(parts) != num_vars + 2:
+            print(f"Error: Expected {num_vars} coefficients, 1 relation, and 1 RHS value.")
+            continue
+        try:
+            coeffs = list(map(float, parts[:num_vars]))
+            relation = parts[num_vars]
+            rhs = float(parts[num_vars + 1])
+            if relation not in ['<=', '>=', '=']:
+                print("Error: Invalid relation symbol. Use '<=', '>=', or '='.")
+                continue
+            A.append(coeffs)
+            relations.append(relation)
+            b.append(rhs)
+            i += 1
+        except ValueError:
+            print("Error: Invalid number format for coefficients or RHS.")
+            continue
+    return obj_type, c, A, relations, b
+

maths/university/operations_research/simplex_solver_with_steps.py

@@ -0,0 +1,162 @@
+import numpy as np
+import streamlit as st
+from tabulate import tabulate
+
+
+def simplex_solver_with_steps(c, A, b, bounds):
+    """
+    Solve LP using simplex method and display full tableau at each step
+    
+    Parameters:
+    - c: Objective coefficients (for maximizing c'x)
+    - A: Constraint coefficients matrix
+    - b: Right-hand side of constraints
+    - bounds: Variable bounds as [(lower_1, upper_1), (lower_2, upper_2), ...]
+    
+    Returns:
+    - x: Optimal solution
+    - optimal_value: Optimal objective value
+    """
+    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:")
+    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]}")
+    
+    # Convert problem to standard form (for tableau method)
+    # First handle bounds by adding necessary constraints
+    A_with_bounds = A.copy()
+    b_with_bounds = b.copy()
+    
+    for i, (lb, ub) in enumerate(bounds):
+        if lb is not None and lb > 0:
+            # For variables with lower bounds > 0, we'll substitute x_i = x_i' + lb
+            # This affects all constraints where x_i appears
+            for j in range(A.shape[0]):
+                b_with_bounds[j] -= A[j, i] * lb
+    
+    # Number of variables and constraints
+    n_vars = len(c)
+    n_constraints = A.shape[0]
+    
+    # Add slack variables to create standard form
+    # The tableau will have: [objective row | RHS]
+    #                        [-------------|----]
+    #                        [constraints  | RHS]
+    
+    # Initial tableau: 
+    # First row is -c (negative of objective coefficients) and 0s for slack variables, then 0 (for max)
+    # The rest are constraint coefficients, then identity matrix for slack variables, then RHS
+    tableau = np.zeros((n_constraints + 1, n_vars + n_constraints + 1))
+    
+    # Set the objective row (negated for maximization)
+    tableau[0, :n_vars] = -c
+    
+    # Set the constraint coefficients
+    tableau[1:, :n_vars] = A_with_bounds
+    
+    # Set the slack variable coefficients (identity matrix)
+    for i in range(n_constraints):
+        tableau[i + 1, n_vars + i] = 1
+    
+    # Set the RHS
+    tableau[1:, -1] = b_with_bounds
+    
+    # Base and non-base variables
+    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):
+        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)]
+        
+        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]}")
+    
+    # Print initial tableau
+    st.text("\nInitial tableau:")
+    print_tableau(tableau, base_vars)
+    
+    # Main simplex loop
+    iteration = 0
+    max_iterations = 100  # Prevent infinite loops
+    
+    while iteration < max_iterations:
+        iteration += 1
+        st.text(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")
+            break
+        
+        st.text(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 = []
+        for i in range(1, n_constraints + 1):
+            if tableau[i, entering_col] <= 0:
+                ratios.append(np.inf)  # Avoid division by zero or negative
+            else:
+                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
+        
+        # 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}")
+        
+        # Perform pivot operation
+        # First, normalize the pivot row
+        pivot = tableau[leaving_row, entering_col]
+        tableau[leaving_row] = tableau[leaving_row] / pivot
+        
+        # Update other rows
+        for i in range(tableau.shape[0]):
+            if i != leaving_row:
+                factor = tableau[i, entering_col]
+                tableau[i] = tableau[i] - factor * tableau[leaving_row]
+        
+        # Update basic variables
+        base_vars[leaving_row - 1] = entering_col
+        
+        # Print updated tableau
+        st.text("\nAfter pivot:")
+        print_tableau(tableau, base_vars)
+    
+    if iteration == max_iterations:
+        st.text("Max iterations reached without convergence")
+        return None, None
+    
+    # Extract solution
+    x = np.zeros(n_vars)
+    for i, var in enumerate(base_vars):
+        if var < n_vars:  # If it's an original variable and not a slack
+            x[var] = tableau[i + 1, -1]
+    
+    # Account for variable substitutions (if lower bounds were applied)
+    for i, (lb, _) in enumerate(bounds):
+        if lb is not None and lb > 0:
+            x[i] += lb
+    
+    # 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}")
+    
+    return x, optimal_value
+

maths/university/operations_research/solve_lp_via_dual.py

@@ -0,0 +1,317 @@
+
+import numpy as np
+from scipy.optimize import linprog # Using SciPy for robust LP solving
+import warnings
+from .solve_primal_directly import solve_primal_directly
+
+def solve_lp_via_dual(objective_type, c, A, relations, b, TOLERANCE=1e-6):
+    """
+    Solves an LP problem by formulating and solving the dual, then using
+    complementary slackness.
+
+    Args:
+        objective_type (str): 'max' or 'min'.
+        c (list or np.array): Primal objective coefficients.
+        A (list of lists or np.array): Primal constraint matrix LHS.
+        relations (list): Primal constraint relations ('<=', '>=', '=').
+        b (list or np.array): Primal constraint RHS.
+
+    Returns:
+        A tuple: (status, message, primal_solution, dual_solution, objective_value)
+        status: 0 for success, non-zero for failure.
+        message: Description of the outcome.
+        primal_solution: Dictionary of primal variable values (x).
+        dual_solution: Dictionary of dual variable values (p).
+        objective_value: Optimal objective value of the primal.
+    """
+    primal_c = np.array(c, dtype=float)
+    primal_A = np.array(A, dtype=float)
+    primal_b = np.array(b, dtype=float)
+    primal_relations = relations
+    num_primal_vars = len(primal_c)
+    num_primal_constraints = len(primal_b)
+
+    print("--- Step 1: Formulate the Dual Problem ---")
+
+    # Standardize Primal for consistent dual formulation: Convert to Min problem
+    original_obj_type = objective_type.lower()
+    if original_obj_type == 'max':
+        print("   Primal is Max. Converting to Min by negating objective coefficients.")
+        primal_c_std = -primal_c
+        objective_sign_flip = -1.0
+    else:
+        print("   Primal is Min. Using original objective coefficients.")
+        primal_c_std = primal_c
+        objective_sign_flip = 1.0
+
+    # Handle constraint relations for dual formulation
+    # We'll formulate the dual based on a standard primal form:
+    # Min c'x s.t. Ax >= b, x >= 0
+    # Dual: Max p'b s.t. p'A <= c', p >= 0
+    # Let's adjust the input primal constraints to fit the Ax >= b form needed for this dual pair.
+
+    A_geq = []
+    b_geq = []
+    print("   Adjusting primal constraints to >= form for dual formulation:")
+    for i in range(num_primal_constraints):
+        rel = primal_relations[i]
+        a_row = primal_A[i]
+        b_val = primal_b[i]
+
+        if rel == '<=':
+            print(f"      Constraint {i+1}: Multiplying by -1 ( {a_row} <= {b_val} -> {-a_row} >= {-b_val} )")
+            A_geq.append(-a_row)
+            b_geq.append(-b_val)
+        elif rel == '>=':
+            print(f"      Constraint {i+1}: Keeping as >= ( {a_row} >= {b_val} )")
+            A_geq.append(a_row)
+            b_geq.append(b_val)
+        elif rel == '=':
+            # Represent equality as two inequalities: >= and <=
+            print(f"      Constraint {i+1}: Splitting '=' into >= and <= ")
+            # >= part
+            print(f"         Part 1: {a_row} >= {b_val}")
+            A_geq.append(a_row)
+            b_geq.append(b_val)
+            # <= part -> multiply by -1 to get >=
+            print(f"         Part 2: {-a_row} >= {-b_val} (from {a_row} <= {b_val})")
+            A_geq.append(-a_row)
+            b_geq.append(-b_val)
+        else:
+            return 1, f"Invalid relation '{rel}' in constraint {i+1}", None, None, None
+
+    primal_A_std = np.array(A_geq, dtype=float)
+    primal_b_std = np.array(b_geq, dtype=float)
+    num_dual_vars = primal_A_std.shape[0] # One dual var per standardized constraint
+
+    # Now formulate the dual: Max p' * primal_b_std s.t. p' * primal_A_std <= primal_c_std, p >= 0
+    dual_c = primal_b_std  # Coefficients for Maximize objective
+    dual_A = primal_A_std.T # Transpose A
+    dual_b = primal_c_std  # RHS for dual constraints (<= type)
+
+    print("\n   Dual Problem Formulation:")
+    print(f"      Objective: Maximize p * [{', '.join(f'{bi:.2f}' for bi in dual_c)}]")
+    print(f"      Subject to:")
+    for j in range(dual_A.shape[0]): # Iterate through dual constraints
+         print(f"         {' + '.join(f'{dual_A[j, i]:.2f}*p{i+1}' for i in range(num_dual_vars))} <= {dual_b[j]:.2f}")
+    print(f"      p_i >= 0 for i=1..{num_dual_vars}")
+
+    print("\n--- Step 2: Solve the Dual Problem using SciPy linprog ---")
+    # linprog solves Min problems, so we Max p*b by Min -p*b
+    # Constraints for linprog: A_ub @ x <= b_ub, A_eq @ x == b_eq
+    # Our dual is Max p*b s.t. p*A <= c. Let p be x for linprog.
+    # Maximize dual_c @ p => Minimize -dual_c @ p
+    # Subject to: dual_A @ p <= dual_b
+    #             p >= 0 (default bounds)
+
+    c_linprog = -dual_c
+    A_ub_linprog = dual_A
+    b_ub_linprog = dual_b
+
+    # Use method='highs' which is the default and generally robust
+    # Options can be added for more control if needed
+    try:
+        result_dual = linprog(c_linprog, A_ub=A_ub_linprog, b_ub=b_ub_linprog, bounds=[(0, None)] * num_dual_vars, method='highs') # Using HiGHS solver
+    except ValueError as e:
+         # Sometimes specific solvers are not available or fail
+         print(f"   SciPy linprog(method='highs') failed: {e}. Trying 'simplex'.")
+         try:
+            result_dual = linprog(c_linprog, A_ub=A_ub_linprog, b_ub=b_ub_linprog, bounds=[(0, None)] * num_dual_vars, method='simplex')
+         except Exception as e_simplex:
+             return 1, f"SciPy linprog failed for dual problem with both 'highs' and 'simplex': {e_simplex}", None, None, None
+
+
+    if not result_dual.success:
+        # Check status for specific reasons
+        if result_dual.status == 2: # Infeasible
+             msg = "Dual problem is infeasible. Primal problem is unbounded (or infeasible)."
+        elif result_dual.status == 3: # Unbounded
+             msg = "Dual problem is unbounded. Primal problem is infeasible."
+        else:
+             msg = f"Failed to solve the dual problem. Status: {result_dual.status} - {result_dual.message}"
+        return result_dual.status, msg, None, None, None
+
+    # Optimal dual solution found
+    optimal_dual_p = result_dual.x
+    optimal_dual_obj = -result_dual.fun # Negate back to get Max value
+
+    dual_solution_dict = {f'p{i+1}': optimal_dual_p[i] for i in range(num_dual_vars)}
+
+    print("\n   Optimal Dual Solution Found:")
+    print(f"      Dual Variables (p*):")
+    for i in range(num_dual_vars):
+        print(f"         p{i+1} = {optimal_dual_p[i]:.6f}")
+    print(f"      Optimal Dual Objective Value (Max p*b): {optimal_dual_obj:.6f}")
+
+    print("\n--- Step 3: Check Strong Duality ---")
+    # The optimal objective value of the dual should equal the optimal objective
+    # value of the primal (after adjusting for Min/Max conversion).
+    expected_primal_obj = optimal_dual_obj * objective_sign_flip
+    print(f"   Strong duality implies the optimal primal objective value should be: {expected_primal_obj:.6f}")
+
+    print("\n--- Step 4 & 5: Use Complementary Slackness to find Primal Variables ---")
+
+    # Calculate Dual Slacks: dual_slack = dual_b - dual_A @ optimal_dual_p
+    # dual_b is primal_c_std
+    # dual_A is primal_A_std.T
+    # dual_slack_j = primal_c_std_j - (optimal_dual_p @ primal_A_std)_j
+    dual_slacks = dual_b - dual_A @ optimal_dual_p
+    print("   Calculating Dual Slacks (c'_j - p* A'_j):")
+    for j in range(num_primal_vars):
+        print(f"      Dual Slack for primal var x{j+1}: {dual_slacks[j]:.6f}")
+
+
+    # Identify conditions from Complementary Slackness (CS)
+    # 1. Dual Slackness: If dual_slack_j > TOLERANCE, then primal x*_j = 0
+    # 2. Primal Slackness: If optimal_dual_p_i > TOLERANCE, then i-th standardized primal constraint is binding
+    #    (primal_A_std[i] @ x* = primal_b_std[i])
+
+    binding_constraints_indices = []
+    zero_primal_vars_indices = []
+
+    print("\n   Applying Complementary Slackness Conditions:")
+    # Dual Slackness
+    print("      From Dual Slackness (if c'_j - p* A'_j > 0, then x*_j = 0):")
+    for j in range(num_primal_vars):
+        if dual_slacks[j] > TOLERANCE:
+            print(f"         Dual Slack for x{j+1} is {dual_slacks[j]:.4f} > 0 => x{j+1}* = 0")
+            zero_primal_vars_indices.append(j)
+        else:
+             print(f"         Dual Slack for x{j+1} is {dual_slacks[j]:.4f} approx 0 => x{j+1}* may be non-zero")
+
+
+    # Primal Slackness
+    print("      From Primal Slackness (if p*_i > 0, then primal constraint i is binding):")
+    for i in range(num_dual_vars):
+        if optimal_dual_p[i] > TOLERANCE:
+            print(f"         p*{i+1} = {optimal_dual_p[i]:.4f} > 0 => Primal constraint {i+1} (standardized) is binding.")
+            binding_constraints_indices.append(i)
+        else:
+            print(f"         p*{i+1} = {optimal_dual_p[i]:.4f} approx 0 => Primal constraint {i+1} (standardized) may be non-binding.")
+
+    # Construct system of equations for non-zero primal variables
+    # Equations come from binding primal constraints.
+    # Variables are x*_j where j is NOT in zero_primal_vars_indices.
+
+    active_primal_vars_indices = [j for j in range(num_primal_vars) if j not in zero_primal_vars_indices]
+    num_active_primal_vars = len(active_primal_vars_indices)
+
+    print(f"\n   Identifying system for active primal variables ({[f'x{j+1}' for j in active_primal_vars_indices]}):")
+
+    if num_active_primal_vars == 0:
+        # All primal vars are zero
+        primal_x_star = np.zeros(num_primal_vars)
+        print("      All primal variables determined to be 0 by dual slackness.")
+    elif len(binding_constraints_indices) < num_active_primal_vars:
+         print(f"      Warning: Number of binding constraints ({len(binding_constraints_indices)}) identified is less than the number of potentially non-zero primal variables ({num_active_primal_vars}).")
+         print("      Complementary slackness alone might not be sufficient, or there might be degeneracy/multiple solutions.")
+         print("      Attempting to solve using available binding constraints, but result might be unreliable.")
+         # Pad with zero rows if necessary, or indicate underspecified system. For now, proceed cautiously.
+         matrix_A_sys = primal_A_std[binding_constraints_indices][:, active_primal_vars_indices]
+         vector_b_sys = primal_b_std[binding_constraints_indices]
+
+    else:
+        # We have at least as many binding constraints as active variables.
+        # Select num_active_primal_vars binding constraints to form a square system (if possible).
+        # If more binding constraints exist, they should be consistent.
+        # We take the first 'num_active_primal_vars' binding constraints.
+        if len(binding_constraints_indices) > num_active_primal_vars:
+             print(f"      More binding constraints ({len(binding_constraints_indices)}) than active variables ({num_active_primal_vars}). Using the first {num_active_primal_vars}.")
+
+        matrix_A_sys = primal_A_std[binding_constraints_indices[:num_active_primal_vars]][:, active_primal_vars_indices]
+        vector_b_sys = primal_b_std[binding_constraints_indices[:num_active_primal_vars]]
+
+        print("      System Ax = b to solve:")
+        for r in range(matrix_A_sys.shape[0]):
+            print(f"         {' + '.join(f'{matrix_A_sys[r, c]:.2f}*x{active_primal_vars_indices[c]+1}' for c in range(num_active_primal_vars))} = {vector_b_sys[r]:.2f}")
+
+
+    # Solve the system if possible
+    if num_active_primal_vars > 0:
+        try:
+            # Use numpy.linalg.solve for square systems, lstsq for potentially non-square
+            if matrix_A_sys.shape[0] == matrix_A_sys.shape[1]:
+                 solved_active_vars = np.linalg.solve(matrix_A_sys, vector_b_sys)
+            elif matrix_A_sys.shape[0] > matrix_A_sys.shape[1]: # Overdetermined
+                 print("      System is overdetermined. Using least squares solution.")
+                 solved_active_vars, residuals, rank, s = np.linalg.lstsq(matrix_A_sys, vector_b_sys, rcond=None)
+                 # Check if residuals are close to zero for consistency
+                 if residuals and np.sum(residuals**2) > TOLERANCE * len(vector_b_sys):
+                       print(f"      Warning: Least squares solution has significant residuals ({np.sqrt(np.sum(residuals**2)):.4f}), CS conditions might be inconsistent?")
+            else: # Underdetermined
+                 # Cannot uniquely solve. This shouldn't happen if dual was optimal and non-degenerate.
+                 # Could use lstsq which gives one possible solution (minimum norm).
+                 print("      System is underdetermined. Using least squares (minimum norm) solution.")
+                 solved_active_vars, residuals, rank, s = np.linalg.lstsq(matrix_A_sys, vector_b_sys, rcond=None)
+
+
+            # Assign solved values back to the full primal_x_star vector
+            primal_x_star = np.zeros(num_primal_vars)
+            for i, active_idx in enumerate(active_primal_vars_indices):
+                primal_x_star[active_idx] = solved_active_vars[i]
+
+            print("\n      Solved values for active primal variables:")
+            for i, active_idx in enumerate(active_primal_vars_indices):
+                print(f"         x{active_idx+1}* = {solved_active_vars[i]:.6f}")
+
+        except np.linalg.LinAlgError:
+            print("      Error: Could not solve the system of equations derived from binding constraints (matrix may be singular).")
+            # Attempt to use linprog on the original primal as a fallback/check
+            print("      Attempting to solve primal directly with linprog as a fallback...")
+            primal_fallback_status, _, primal_fallback_sol, _, primal_fallback_obj = solve_primal_directly(
+                original_obj_type, c, A, relations, b)
+            if primal_fallback_status == 0:
+                 print("      Fallback solution found.")
+                 return 0, "Solved primal using fallback direct method after CS failure", primal_fallback_sol, dual_solution_dict, primal_fallback_obj
+            else:
+                 return 1, "Failed to solve system from CS, and fallback primal solve also failed.", None, dual_solution_dict, None
+
+
+    # Assemble final primal solution dictionary
+    primal_solution_dict = {f'x{j+1}': primal_x_star[j] for j in range(num_primal_vars)}
+
+    # --- Step 6: Verify Primal Feasibility and Objective Value ---
+    print("\n--- Step 6: Verify Primal Solution ---")
+    feasible = True
+    print("   Checking primal constraints:")
+    for i in range(num_primal_constraints):
+        lhs_val = primal_A[i] @ primal_x_star
+        rhs_val = primal_b[i]
+        rel = primal_relations[i]
+        constraint_met = False
+        if rel == '<=':
+            constraint_met = lhs_val <= rhs_val + TOLERANCE
+        elif rel == '>=':
+            constraint_met = lhs_val >= rhs_val - TOLERANCE
+        elif rel == '=':
+            constraint_met = abs(lhs_val - rhs_val) < TOLERANCE
+
+        status_str = "Satisfied" if constraint_met else "VIOLATED"
+        print(f"      Constraint {i+1}: {lhs_val:.4f} {rel} {rhs_val:.4f} -> {status_str}")
+        if not constraint_met:
+            feasible = False
+
+    print("   Checking non-negativity (x >= 0):")
+    non_negative = np.all(primal_x_star >= -TOLERANCE)
+    print(f"      All x_j >= 0: {non_negative}")
+    if not non_negative:
+        feasible = False
+        print(f"Violating variables: {[f'x{j+1}={primal_x_star[j]:.4f}' for j in range(len(primal_x_star)) if primal_x_star[j] < -TOLERANCE]}")
+
+    final_primal_obj = primal_c @ primal_x_star # Using original primal c
+    print(f"\n   Calculated Primal Objective Value: {final_primal_obj:.6f}")
+    print(f"   Expected Primal Objective Value (from dual): {expected_primal_obj:.6f}")
+
+    if abs(final_primal_obj - expected_primal_obj) > TOLERANCE * (1 + abs(expected_primal_obj)):
+        print("   Warning: Calculated primal objective value significantly differs from the dual objective value!")
+        feasible = False # Consider this a failure if strong duality doesn't hold
+
+    if feasible:
+        print("\n--- Primal Solution Found Successfully via Dual ---")
+        return 0, "Optimal solution found via dual.", primal_solution_dict, dual_solution_dict, final_primal_obj
+    else:
+        print("\n--- Failed to Find Feasible Primal Solution via Dual ---")
+        print("   The derived primal solution violates constraints or non-negativity, or strong duality failed.")
+        # You might want to return the possibly incorrect solution for inspection or None
+        return 1, "Derived primal solution is infeasible or inconsistent.", primal_solution_dict, dual_solution_dict, final_primal_obj
+

maths/university/operations_research/solve_primal_directly.py

@@ -0,0 +1,49 @@
+
+import numpy as np
+from scipy.optimize import linprog # Using SciPy for robust LP solving
+import warnings
+
+def solve_primal_directly(objective_type, c, A, relations, b):
+    """Helper to solve primal directly using linprog for comparison/fallback"""
+    primal_c = np.array(c, dtype=float)
+    primal_A = np.array(A, dtype=float)
+    primal_b = np.array(b, dtype=float)
+    num_vars = len(c)
+
+    A_ub, b_ub, A_eq, b_eq = [], [], [], []
+
+    sign_flip = 1.0
+    if objective_type.lower() == 'max':
+        primal_c = -primal_c
+        sign_flip = -1.0
+
+    for i in range(len(relations)):
+        if relations[i] == '<=':
+            A_ub.append(primal_A[i])
+            b_ub.append(primal_b[i])
+        elif relations[i] == '>=':
+            A_ub.append(-primal_A[i]) # Convert >= to <= for linprog A_ub
+            b_ub.append(-primal_b[i])
+        elif relations[i] == '=':
+            A_eq.append(primal_A[i])
+            b_eq.append(primal_b[i])
+
+    # Convert lists to arrays, handling empty cases
+    A_ub = np.array(A_ub) if A_ub else None
+    b_ub = np.array(b_ub) if b_ub else None
+    A_eq = np.array(A_eq) if A_eq else None
+    b_eq = np.array(b_eq) if b_eq else None
+
+    try:
+         result_primal = linprog(primal_c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=[(0, None)] * num_vars, method='highs') # 'highs' is default and robust
+
+         if result_primal.success:
+             primal_sol_vals = result_primal.x
+             primal_obj_val = result_primal.fun * sign_flip # Adjust obj value back if Max
+             primal_sol_dict = {f'x{j+1}': primal_sol_vals[j] for j in range(num_vars)}
+             return 0, "Solved directly", primal_sol_dict, None, primal_obj_val
+         else:
+             return result_primal.status, f"Direct solve failed: {result_primal.message}", None, None, None
+    except Exception as e:
+         return -1, f"Direct solve exception: {e}", None, None, None
+

maths/university/tests/__init__.py

@@ -0,0 +1,2 @@
+# This file makes 'tests' a Python package.
+# It can be empty.

maths/university/tests/test_differential_equations.py

@@ -0,0 +1,133 @@
+import unittest
+import numpy as np
+import math
+from numpy.testing import assert_array_almost_equal
+
+# Adjust import path as necessary
+from maths.university.differential_equations import solve_first_order_ode, solve_second_order_ode
+
+class TestDifferentialEquations(unittest.TestCase):
+
+    def test_solve_simple_first_order_ode_constant_rate(self):
+        """Test dy/dt = k, e.g., dy/dt = 2 with y(0)=1. Solution y(t) = 2t + 1."""
+        k = 2.0
+        y_initial = 1.0
+
+        def ode_func(t, y):
+            # For a system, y is an array. Here, it's a single equation, so y[0]
+            # solve_ivp always passes y as at least a 1-element array.
+            return k
+
+        t_span = (0, 5)
+        t_eval_count = 50
+        y0 = [y_initial] # Initial condition must be a list or 1D array for solve_ivp
+
+        result = solve_first_order_ode(ode_func, t_span, y0, t_eval_count=t_eval_count)
+
+        self.assertTrue(result['success'], msg=f"Solver failed: {result['message']}")
+        self.assertIsInstance(result['t'], np.ndarray)
+        self.assertIsInstance(result['y'], np.ndarray)
+
+        self.assertEqual(result['t'].shape, (t_eval_count,))
+        # solve_ivp returns y with shape (n_equations, n_timepoints)
+        self.assertEqual(result['y'].shape, (1, t_eval_count))
+
+        # Check analytical solution: y(t) = k*t + y0
+        expected_y = k * result['t'] + y_initial
+        assert_array_almost_equal(result['y'][0], expected_y, decimal=5,
+                                  err_msg="Numerical solution does not match analytical solution for dy/dt=k.")
+
+    def test_solve_simple_first_order_ode_exponential_decay(self):
+        """Test dy/dt = -k*y, e.g., dy/dt = -0.5*y with y(0)=10. Solution y(t) = 10*exp(-0.5t)."""
+        k = 0.5
+        y_initial = 10.0
+
+        def ode_func(t, y):
+            return -k * y[0] # y is [y_val]
+
+        t_span = (0, 3)
+        t_eval_count = 30
+        y0 = [y_initial]
+
+        result = solve_first_order_ode(ode_func, t_span, y0, t_eval_count=t_eval_count)
+
+        self.assertTrue(result['success'], msg=f"Solver failed for exponential decay: {result['message']}")
+        self.assertEqual(result['t'].shape, (t_eval_count,))
+        self.assertEqual(result['y'].shape, (1, t_eval_count))
+
+        # Check analytical solution: y(t) = y0 * exp(-k*t)
+        expected_y = y_initial * np.exp(-k * result['t'])
+        assert_array_almost_equal(result['y'][0], expected_y, decimal=5,
+                                  err_msg="Numerical solution does not match analytical for exponential decay.")
+
+
+    def test_solve_simple_second_order_ode_constant_acceleration(self):
+        """Test d²y/dt² = a, e.g., d²y/dt² = 2 with y(0)=1, y'(0)=0.5.
+           Solution y'(t) = a*t + y'(0) => y'(t) = 2t + 0.5
+           Solution y(t) = 0.5*a*t² + y'(0)*t + y(0) => y(t) = t² + 0.5t + 1
+        """
+        accel = 2.0
+        y_initial = 1.0
+        dy_dt_initial = 0.5
+
+        def ode_func_second_order(t, y_val, dy_dt_val):
+            return accel # d²y/dt² = constant
+
+        t_span = (0, 4)
+        t_eval_count = 40
+
+        result = solve_second_order_ode(
+            ode_func_second_order, t_span, y_initial, dy_dt_initial, t_eval_count=t_eval_count
+        )
+
+        self.assertTrue(result['success'], msg=f"Solver failed for 2nd order const accel: {result['message']}")
+        self.assertIsInstance(result['t'], np.ndarray)
+        self.assertIsInstance(result['y'], np.ndarray)
+        self.assertIsInstance(result['dy_dt'], np.ndarray)
+
+        self.assertEqual(result['t'].shape, (t_eval_count,))
+        self.assertEqual(result['y'].shape, (t_eval_count,)) # Output y is 1D array
+        self.assertEqual(result['dy_dt'].shape, (t_eval_count,)) # Output dy_dt is 1D array
+
+        # Check analytical solution for y(t)
+        expected_y = 0.5 * accel * result['t']**2 + dy_dt_initial * result['t'] + y_initial
+        assert_array_almost_equal(result['y'], expected_y, decimal=5,
+                                  err_msg="Numerical y(t) does not match analytical for const accel.")
+
+        # Check analytical solution for dy/dt(t)
+        expected_dy_dt = accel * result['t'] + dy_dt_initial
+        assert_array_almost_equal(result['dy_dt'], expected_dy_dt, decimal=5,
+                                  err_msg="Numerical dy/dt(t) does not match analytical for const accel.")
+
+    def test_solve_damped_oscillator_second_order(self):
+        """Test d²y/dt² = -b*(dy/dt) - k*y (damped harmonic oscillator).
+           This is more complex and won't have a trivial analytical solution form for all parameters,
+           so we mainly check if it runs and produces output of the correct shape.
+        """
+        damping_b = 0.5 # Damping coefficient
+        spring_k = 2.0  # Spring constant (normalized for m=1)
+        y_initial = 1.0
+        dy_dt_initial = 0.0
+
+        def damped_oscillator_func(t, y, dy_dt):
+            return -damping_b * dy_dt - spring_k * y
+
+        t_span = (0, 10)
+        t_eval_count = 100
+
+        result = solve_second_order_ode(
+            damped_oscillator_func, t_span, y_initial, dy_dt_initial, t_eval_count=t_eval_count
+        )
+
+        self.assertTrue(result['success'], msg=f"Solver failed for damped oscillator: {result['message']}")
+        self.assertEqual(result['t'].shape, (t_eval_count,))
+        self.assertEqual(result['y'].shape, (t_eval_count,))
+        self.assertEqual(result['dy_dt'].shape, (t_eval_count,))
+        # For a damped oscillator starting from rest at y=1, y should decrease initially (or oscillate around 0)
+        # This is just a sanity check, not a strict assertion of values.
+        if len(result['y']) > 1:
+            self.assertTrue(result['y'][0] > result['y'][-1] or result['y'][0] < result['y'][-1] or result['y'][0] != result['y'][1])
+
+
+if __name__ == '__main__':
+    unittest.main(argv=['first-arg-is-ignored'], exit=False)

maths/university/tests/test_linear_algebra.py

@@ -0,0 +1,132 @@
+import unittest
+import numpy as np
+from numpy.testing import assert_array_almost_equal, assert_raises
+
+# Adjust the import path based on your project structure if necessary
+# Assuming 'maths' is a top-level directory in PYTHONPATH or current working directory
+from maths.university.linear_algebra import (
+    matrix_add, matrix_subtract, matrix_multiply,
+    matrix_determinant, matrix_inverse,
+    vector_add, vector_subtract, vector_dot_product,
+    vector_cross_product, solve_linear_system
+)
+
+class TestLinearAlgebra(unittest.TestCase):
+
+    def test_matrix_add(self):
+        m1 = np.array([[1, 2], [3, 4]])
+        m2 = np.array([[5, 6], [7, 8]])
+        expected = np.array([[6, 8], [10, 12]])
+        assert_array_almost_equal(matrix_add(m1, m2), expected)
+        assert_array_almost_equal(matrix_add([[1,2],[3,4]], [[5,6],[7,8]]), expected)
+
+    def test_matrix_multiply(self):
+        m1 = np.array([[1, 2], [3, 4]])
+        m2 = np.array([[5, 6], [7, 8]]) # 2x2
+        expected = np.array([[19, 22], [43, 50]]) # (1*5+2*7), (1*6+2*8) etc.
+        assert_array_almost_equal(matrix_multiply(m1, m2), expected)
+
+        m3 = np.array([[1,2,3],[4,5,6]]) # 2x3
+        m4 = np.array([[7,8],[9,10],[11,12]]) # 3x2
+        expected2 = np.array([[58,64],[139,154]])
+        assert_array_almost_equal(matrix_multiply(m3,m4),expected2)
+
+        # Test incompatible shapes
+        with assert_raises(ValueError):
+            matrix_multiply(m1, m3) # 2x2 and 2x3 not compatible like this
+
+    def test_matrix_determinant(self):
+        m1 = np.array([[1, 2], [3, 4]]) # det = 1*4 - 2*3 = 4 - 6 = -2
+        self.assertAlmostEqual(matrix_determinant(m1), -2.0)
+
+        m2 = np.array([[3, 1, 0], [2, 0, 1], [0, 2, 4]])
+        # Det = 3(0-2) - 1(8-0) + 0 = -6 - 8 = -14
+        self.assertAlmostEqual(matrix_determinant(m2), -14.0)
+
+        m_singular = np.array([[1,2],[2,4]]) # det = 0
+        self.assertAlmostEqual(matrix_determinant(m_singular), 0.0)
+
+    def test_matrix_inverse(self):
+        m1 = np.array([[1, 2], [3, 7]]) # det = 7-6 = 1
+        # inv = 1/1 * [[7, -2], [-3, 1]]
+        expected_inv1 = np.array([[7, -2], [-3, 1]])
+        assert_array_almost_equal(matrix_inverse(m1), expected_inv1)
+
+        m_non_square = np.array([[1,2,3],[4,5,6]])
+        with assert_raises(ValueError): # Specific to our implementation if it checks before numpy
+            matrix_inverse(m_non_square)
+
+        m_singular = np.array([[1, 2], [2, 4]]) # Determinant is 0
+        with assert_raises(np.linalg.LinAlgError): # Numpy's error for singular matrix
+            matrix_inverse(m_singular)
+
+    def test_vector_dot_product(self):
+        v1 = np.array([1, 2, 3])
+        v2 = np.array([4, 5, 6])
+        # 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
+        self.assertAlmostEqual(vector_dot_product(v1, v2), 32.0)
+        self.assertAlmostEqual(vector_dot_product([1,0,-1], [1,1,1]), 0.0) # Orthogonal
+
+    def test_vector_cross_product(self):
+        v1 = np.array([1, 0, 0]) # i
+        v2 = np.array([0, 1, 0]) # j
+        expected_ij = np.array([0, 0, 1]) # k
+        assert_array_almost_equal(vector_cross_product(v1, v2), expected_ij)
+
+        v3 = np.array([1, 2, 3])
+        v4 = np.array([4, 5, 6])
+        # (2*6 - 3*5, 3*4 - 1*6, 1*5 - 2*4)
+        # (12 - 15, 12 - 6, 5 - 8)
+        # (-3, 6, -3)
+        expected_v3v4 = np.array([-3, 6, -3])
+        assert_array_almost_equal(vector_cross_product(v3, v4), expected_v3v4)
+
+        # Test non-3D vectors
+        v_2d_1 = [1,2]
+        v_2d_2 = [3,4]
+        with assert_raises(ValueError):
+            vector_cross_product(v_2d_1, v_2d_2)
+        with assert_raises(ValueError):
+            vector_cross_product(v1, v_2d_1) # One 3D, one 2D
+
+    def test_solve_linear_system(self):
+        # System 1:
+        # 2x + y = 5
+        # x - y = 1
+        # Solution: x=2, y=1
+        A1 = np.array([[2, 1], [1, -1]])
+        B1 = np.array([5, 1])
+        expected_X1 = np.array([2, 1])
+        assert_array_almost_equal(solve_linear_system(A1, B1), expected_X1, decimal=6)
+
+        # System 2:
+        # x + y + z = 6
+        #   2y + 5z = -4
+        # 2x + 5y - z = 27
+        # Solution: x=5, y=3, z=-2 (from online calculator)
+        A2 = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]])
+        B2 = np.array([6, -4, 27])
+        expected_X2 = np.array([5, 3, -2])
+        assert_array_almost_equal(solve_linear_system(A2, B2), expected_X2, decimal=6)
+
+        # Singular system (no unique solution)
+        A_singular = np.array([[1, 1], [2, 2]])
+        B_singular = np.array([1, 3]) # Inconsistent
+        with assert_raises(np.linalg.LinAlgError):
+            solve_linear_system(A_singular, B_singular)
+
+        # Non-square coefficient matrix
+        A_non_square = np.array([[1,1,1],[0,2,5]])
+        B_non_square = np.array([6,-4])
+        with assert_raises(ValueError):
+            solve_linear_system(A_non_square, B_non_square)
+
+        # Incompatible dimensions B vector
+        A_valid = np.array([[1,1],[0,2]])
+        B_invalid_dim = np.array([1,2,3])
+        with assert_raises(ValueError): # Or LinAlgError depending on numpy's internal checks order
+            solve_linear_system(A_valid, B_invalid_dim)
+
+
+if __name__ == '__main__':
+    unittest.main(argv=['first-arg-is-ignored'], exit=False)

requirements.txt

@@ -64,4 +64,17 @@ typing_extensions==4.14.0
 tzdata==2025.2
 urllib3==2.4.0
 uvicorn==0.34.3
-websockets==15.0.1
+websockets==15.0.1
+scipy==1.15.3
+cffi==1.17.1
+clarabel==0.11.0
+cvxpy==1.6.5
+joblib==1.5.1
+networkx==3.5
+osqp==1.0.4
+pycparser==2.22
+scs==3.2.7.post2
+setuptools==80.9.0
+tabulate==0.9.0
+mpmath==1.3.0
+sympy==1.14.0