Update solver.py

solver.py

@@ -98,6 +98,7 @@ def process_expression(expr_str):
     try:
         processed_expr = preprocess_equation(expr_str)
         x = Symbol('x')
+        
 
         if expr_str.startswith('∫'):  # Integration
             expr_to_integrate = processed_expr[1:].strip()
@@ -139,83 +140,90 @@ def process_expression(expr_str):
         raise Exception(f"Error processing expression: {str(e)}")
 
 def solve_equation(equation_str):
-    """Solve the given equation and return the solution."""
+    """Solves an equation and returns a detailed step-by-step solution."""
     try:
         if '=' not in equation_str:
             return process_expression(equation_str)
 
-        # Preprocess equation
-        equation_str = preprocess_equation(equation_str)
-
-        # Split equation into left and right parts
+        # Split into left and right-hand sides
         left_side, right_side = [side.strip() for side in equation_str.split('=')]
-
-        # Parse both sides with implicit multiplication
+        
+        # Parse expressions
         transformations = standard_transformations + (implicit_multiplication_application,)
-        left_expr = parse_expr(left_side, transformations=transformations)
-        right_expr = parse_expr(right_side, transformations=transformations)
+        left_expr = sp.parse_expr(left_side, transformations=transformations)
+        right_expr = sp.parse_expr(right_side, transformations=transformations)
         equation = left_expr - right_expr
 
-        # Solve the equation
         x = Symbol('x')
-        solution = solve(equation, x)
+        solutions = solve(equation, x)
+
+        steps = []
+        steps.append(f"**Step 1:** Original equation: \n{format_expression(left_expr)} = {format_expression(right_expr)}")
+        steps.append(f"**Step 2:** Move all terms to one side: \n{format_expression(equation)} = 0")
 
-        # Format solution
-        if len(solution) == 0:
-            return "No solution exists"
-        elif len(solution) == 1:
-            return f"x = {format_expression(solution[0])}"
-        else:
-            return "x = " + ", ".join([format_expression(sol) for sol in solution])
+        # Factoring if possible
+        factored = sp.factor(equation)
+        if factored != equation:
+            steps.append(f"**Step 3:** Factorizing the equation: \n{format_expression(factored)} = 0")
+
+        # Solve for x
+        steps.append(f"**Step 4:** Solving for x:")
+        for sol in solutions:
+            steps.append(f"   x = {format_expression(sol)}")
+
+        # Verification
+        steps.append("**Step 5:** Verification:")
+        for sol in solutions:
+            verification = equation.subs(x, sol)
+            steps.append(f"   When x = {format_expression(sol)}, the equation evaluates to {format_expression(verification)}")
+
+        return "\n".join(steps)
 
     except Exception as e:
-        raise Exception(f"Invalid equation format: {str(e)}")
+        return f"Error: {str(e)}"
 
-def generate_steps(equation_str):
-    """Generate step-by-step solution for the equation or expression."""
-    steps = []
+def integrate_expression(expression_str):
+    """Computes the integral of a given expression and provides detailed steps."""
     try:
-        if '=' not in equation_str:
-            steps.append(f"1. Original expression: {equation_str}")
-            result = process_expression(equation_str)
-            steps.append(f"2. Result: {result}")
-            return steps
+        x = Symbol('x')
+        expr = sp.parse_expr(expression_str, transformations=standard_transformations + (implicit_multiplication_application,))
 
-        # Preprocess equation
-        processed_eq = preprocess_equation(equation_str)
+        steps = []
+        steps.append(f"**Step 1:** Original integral: \n∫ {format_expression(expr)} dx")
 
-        # Split equation into left and right parts
-        left_side, right_side = [side.strip() for side in processed_eq.split('=')]
+        # Check if substitution can simplify
+        if '^' in expression_str:
+            steps.append("**Step 2:** Substituting variables if needed")
+            # Example: If we have x^n, we might use substitution
+            # More cases can be handled as needed
 
-        # Parse expressions with implicit multiplication
-        transformations = standard_transformations + (implicit_multiplication_application,)
-        left_expr = parse_expr(left_side, transformations=transformations)
-        right_expr = parse_expr(right_side, transformations=transformations)
+        result = integrate(expr, x)
+        steps.append(f"**Step 3:** Applying integration formula(s):")
+        steps.append(f"   ∫ f(x) dx = F(x) + C")
+        steps.append(f"**Step 4:** Solution: \n{format_expression(result)} + C")
 
-        # Step 1: Show original equation
-        steps.append(f"1. Original equation: {format_expression(left_expr)} = {format_expression(right_expr)}")
+        return "\n".join(steps)
 
-        # Step 2: Move all terms to left side
-        equation = left_expr - right_expr
-        steps.append(f"2. Move all terms to left side: {format_expression(equation)} = 0")
+    except Exception as e:
+        return f"Error: {str(e)}"
 
-        # Step 3: Factor if possible
-        factored = sp.factor(equation)
-        if factored != equation:
-            steps.append(f"3. Factor the equation: {format_expression(factored)} = 0")
+def laplace_transform_expression(expression_str):
+    """Computes the Laplace transform of a given expression with detailed steps."""
+    try:
+        t, s = sp.symbols('t s')
+        expr = sp.parse_expr(expression_str, transformations=standard_transformations + (implicit_multiplication_application,))
 
-        # Step 4: Solve
-        x = Symbol('x')
-        solution = solve(equation, x)
-        steps.append(f"4. Solve for x: x = {', '.join([format_expression(sol) for sol in solution])}")
+        steps = []
+        steps.append(f"**Step 1:** Original function: \nL[{format_expression(expr)}](t)")
+
+        # Compute Laplace transform
+        L_transform = laplace_transform(expr, t, s, noconds=True)
 
-        # Step 5: Verify solutions
-        steps.append("5. Verify solutions:")
-        for sol in solution:
-            result = equation.subs(x, sol)
-            steps.append(f"   When x = {format_expression(sol)}, equation equals {format_expression(result)}")
+        steps.append(f"**Step 2:** Applying Laplace Transform:")
+        steps.append("   L[f(t)] = ∫ e^(-st) f(t) dt, from 0 to ∞")
+        steps.append(f"**Step 3:** Solution: \n{format_expression(L_transform)}")
 
-        return steps
+        return "\n".join(steps)
 
     except Exception as e:
-        raise Exception(f"Error generating steps: {str(e)}")
+        return f"Error: {str(e)}"