Upload 15 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+generated-icon.png filter=lfs diff=lfs merge=lfs -text

.replit

@@ -0,0 +1,62 @@
+modules = ["python-3.11", "nodejs-20", "postgresql-16"]
+
+[nix]
+channel = "stable-24_05"
+
+[deployment]
+deploymentTarget = "autoscale"
+run = ["sh", "-c", "streamlit run main.py --server.port 5000"]
+
+[workflows]
+runButton = "Project"
+
+[[workflows.workflow]]
+name = "Project"
+mode = "parallel"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "Streamlit App"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "Backend Server"
+
+[[workflows.workflow]]
+name = "Streamlit App"
+author = "agent"
+
+[workflows.workflow.metadata]
+agentRequireRestartOnSave = false
+
+[[workflows.workflow.tasks]]
+task = "packager.installForAll"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "streamlit run main.py --server.port 5000"
+waitForPort = 5000
+
+[[workflows.workflow]]
+name = "Backend Server"
+author = "agent"
+
+[workflows.workflow.metadata]
+agentRequireRestartOnSave = false
+
+[[workflows.workflow.tasks]]
+task = "packager.installForAll"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "PYTHONPATH=/home/runner/workspace python -m uvicorn backend.main:app --host 0.0.0.0 --port 8000 --log-level debug"
+waitForPort = 8000
+
+[[ports]]
+localPort = 5000
+externalPort = 80
+
+[[ports]]
+localPort = 8000
+externalPort = 8000

app.py

@@ -0,0 +1,327 @@
+import streamlit as st
+import sympy as sp
+from solver import solve_equation, generate_steps
+from plotter import plot_function
+from utils import load_css, initialize_session_state
+from auth import (
+    login_user, signup_user, is_logged_in, logout_user,
+    update_profile, get_user_profile, change_password
+)
+from models import History, SessionLocal, init_db
+import base64
+from io import BytesIO
+
+# Initialize database
+init_db()
+
+def save_to_history(equation: str, solution: str):
+    """Save equation and solution to user's history."""
+    if not is_logged_in():
+        return
+
+    db = SessionLocal()
+    try:
+        history = History(
+            user_id=st.session_state.user_id,
+            equation=equation,
+            solution=solution
+        )
+        db.add(history)
+        db.commit()
+    finally:
+        db.close()
+
+def load_user_history():
+    """Load user's solution history."""
+    if not is_logged_in():
+        return []
+
+    db = SessionLocal()
+    try:
+        return db.query(History).filter(
+            History.user_id == st.session_state.user_id
+        ).order_by(History.created_at.desc()).all()
+    finally:
+        db.close()
+
+def render_math_symbols():
+    """Render mathematical symbols for input."""
+    st.markdown("### Mathematical Operators")
+
+    cols = st.columns(8)
+    all_symbols = {
+        # Basic arithmetic
+        '×': '*',
+        '÷': '/',
+        '^': '^',
+        '=': '=',
+        '(': '(',
+        ')': ')',
+
+        # Functions and special operators
+        '√': '√',
+        '∫': '∫',
+        'd/dx': 'd/dx',
+        '!': '!',
+        'ℒ': 'L',
+        '∑': 'sum',
+        '∏': 'prod',
+        '|': '|',
+
+        # Constants
+        'π': 'pi',
+        'e': 'e',
+        'i': 'i',
+        '∞': 'oo',
+
+        # Trigonometric
+        'sin': 'sin(',
+        'cos': 'cos(',
+        'tan': 'tan(',
+        'csc': 'csc(',
+        'sec': 'sec(',
+        'cot': 'cot(',
+
+        # Inverse trigonometric
+        'sin⁻¹': 'sin⁻¹(',
+        'cos⁻¹': 'cos⁻¹(',
+        'tan⁻¹': 'tan⁻¹(',
+
+        # Other functions
+        'ln': 'ln(',
+        'log': 'log(',
+        'e^': 'e^',
+        '|x|': 'abs(',
+    }
+
+    for i, (label, symbol) in enumerate(all_symbols.items()):
+        col_idx = i % 8
+        if cols[col_idx].button(label, key=f"btn_{label}", help=f"Insert {label}"):
+            if 'equation' not in st.session_state:
+                st.session_state.equation = ''
+            st.session_state.equation += symbol
+
+def render_profile_settings():
+    """Render user profile settings page."""
+    st.title("Profile Settings")
+
+    user = get_user_profile(st.session_state.user_id)
+
+    # Profile photo upload
+    st.subheader("Profile Photo")
+    uploaded_file = st.file_uploader("Choose a profile photo", type=['jpg', 'jpeg', 'png'])
+    if uploaded_file:
+        # Convert to base64
+        bytes_data = uploaded_file.getvalue()
+        base64_image = base64.b64encode(bytes_data).decode()
+        success, message = update_profile(st.session_state.user_id, profile_photo=base64_image)
+        if success:
+            st.success("Profile photo updated!")
+        else:
+            st.error(message)
+
+    # Display current photo if exists
+    if user.profile_photo:
+        st.image(base64.b64decode(user.profile_photo), width=150)
+
+    # Personal Information
+    st.subheader("Personal Information")
+    with st.form("profile_form"):
+        full_name = st.text_input("Full Name", value=user.full_name or "")
+        email = st.text_input("Email", value=user.email or "")
+        school = st.text_input("School", value=user.school or "")
+        grade = st.text_input("Grade/Year", value=user.grade or "")
+
+        if st.form_submit_button("Update Profile"):
+            success, message = update_profile(
+                st.session_state.user_id,
+                full_name=full_name,
+                email=email,
+                school=school,
+                grade=grade
+            )
+            if success:
+                st.success("Profile updated successfully!")
+            else:
+                st.error(message)
+
+    # Password Change
+    st.subheader("Change Password")
+    with st.form("password_form"):
+        current_password = st.text_input("Current Password", type="password")
+        new_password = st.text_input("New Password", type="password")
+        confirm_password = st.text_input("Confirm New Password", type="password")
+
+        if st.form_submit_button("Change Password"):
+            if new_password != confirm_password:
+                st.error("New passwords do not match")
+            else:
+                success, message = change_password(
+                    st.session_state.user_id,
+                    current_password,
+                    new_password
+                )
+                if success:
+                    st.success("Password updated successfully!")
+                else:
+                    st.error(message)
+
+def render_auth_page():
+    """Render login/signup page."""
+    st.title("Mathematical Problem Solver")
+
+    tab1, tab2 = st.tabs(["Login", "Sign Up"])
+
+    with tab1:
+        st.header("Login")
+        login_username = st.text_input("Username", key="login_username")
+        login_password = st.text_input("Password", type="password", key="login_password")
+
+        if st.button("Login"):
+            if login_user(login_username, login_password):
+                st.success("Successfully logged in!")
+                st.rerun()
+            else:
+                st.error("Invalid username or password")
+
+    with tab2:
+        st.header("Sign Up")
+        signup_username = st.text_input("Username", key="signup_username")
+        signup_password = st.text_input("Password", type="password", key="signup_password")
+        confirm_password = st.text_input("Confirm Password", type="password")
+
+        st.info("Password must be at least 8 characters long and contain at least one uppercase letter.")
+
+        if st.button("Sign Up"):
+            if signup_password != confirm_password:
+                st.error("Passwords do not match")
+            else:
+                success, message = signup_user(signup_username, signup_password)
+                if success:
+                    st.success("Account created successfully!")
+                    st.rerun()
+                else:
+                    st.error(message)
+
+def main():
+    # Initialize session state and load CSS
+    initialize_session_state()
+    load_css()
+
+    if not is_logged_in():
+        render_auth_page()
+        return
+
+    # Main app header with settings and logout buttons
+    col1, col2, col3 = st.columns([6, 1, 1])
+    with col1:
+        st.title("Mathematical Problem Solver")
+    with col2:
+        if st.button("Settings"):
+            st.session_state.show_settings = True
+            st.rerun()
+    with col3:
+        if st.button("Logout"):
+            logout_user()
+            st.rerun()
+
+    st.markdown(f"Welcome, {st.session_state.username}!")
+
+    # Show settings or main app
+    if st.session_state.get('show_settings', False):
+        render_profile_settings()
+        if st.button("Back to Calculator"):
+            st.session_state.show_settings = False
+            st.rerun()
+    else:
+        # Main calculator interface
+        # Sidebar for history
+        with st.sidebar:
+            st.header("Solution History")
+            history = load_user_history()
+            if history:
+                for idx, item in enumerate(history):
+                    with st.expander(f"Problem {idx + 1}"):
+                        st.write(f"Input: {item.equation}")
+                        st.write(f"Solution: {item.solution}")
+                        st.write(f"Date: {item.created_at.strftime('%Y-%m-%d %H:%M')}")
+
+        # Input method selection
+        input_method = st.radio(
+            "Choose input method:",
+            ["Type equation/expression", "Use camera", "Example problems"]
+        )
+
+        if input_method == "Type equation/expression":
+            # Add math symbols
+            render_math_symbols()
+
+            # Equation input
+            if 'equation' not in st.session_state:
+                st.session_state.equation = ''
+
+            equation = st.text_input(
+                "Enter your equation or expression:",
+                value=st.session_state.equation,
+                help="""Examples:
+                - Equation: x^2 + 2x + 1 = 0
+                - Integration: ∫sin x
+                - Derivative: d/dx(x^2)
+                - Factorial: 5!
+                - Laplace: ℒ(t^2)"""
+            )
+            st.session_state.equation = equation
+
+        elif input_method == "Use camera":
+            st.info("📸 Camera input feature is coming soon! For now, please type your equation or choose from examples.")
+            equation = ""
+
+        else:
+            equation = st.selectbox(
+                "Select an example:",
+                [
+                    "x^2 + 2x + 1 = 0",
+                    "∫sin x",
+                    "d/dx(x^3)",
+                    "sin^2 x + cos^2 x",
+                    "5!",
+                    "2x + 3 = 7",
+                    "e^x + 1 = 0",
+                    "log(x) = 1"
+                ]
+            )
+
+        if st.button("Solve"):
+            if equation:
+                try:
+                    # Solve the equation or expression
+                    solution = solve_equation(equation)
+                    steps = generate_steps(equation)
+
+                    # Display solution
+                    st.markdown("### Solution")
+                    st.write(solution)
+
+                    # Display steps
+                    st.markdown("### Step-by-step Solution")
+                    for step in steps:
+                        st.write(step)
+
+                    # Plot the function if possible
+                    try:
+                        st.markdown("### Function Visualization")
+                        fig = plot_function(equation)
+                        st.plotly_chart(fig)
+                    except Exception as plot_error:
+                        st.info("Visualization not available for this type of expression.")
+
+                    # Save to history
+                    save_to_history(equation, solution)
+
+                except Exception as e:
+                    st.error(f"Error: {str(e)}")
+            else:
+                st.warning("Please enter an equation or expression")
+
+if __name__ == "__main__":
+    main()

auth.py

@@ -0,0 +1,131 @@
+import streamlit as st
+import hashlib
+import re
+from models import User, SessionLocal
+
+def validate_password(password: str) -> tuple[bool, str]:
+    """Validate password requirements."""
+    if len(password) < 8:
+        return False, "Password must be at least 8 characters long"
+    if not any(c.isupper() for c in password):
+        return False, "Password must contain at least one uppercase letter"
+    return True, ""
+
+def hash_password(password: str) -> str:
+    """Hash a password for storing."""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def verify_password(stored_password: str, provided_password: str) -> bool:
+    """Verify a stored password against one provided by user"""
+    return stored_password == hash_password(provided_password)
+
+def login_user(username: str, password: str) -> bool:
+    """Verify user credentials and log them in."""
+    db = SessionLocal()
+    try:
+        user = db.query(User).filter(User.username == username).first()
+        if user and verify_password(user.password, password):
+            st.session_state.user_id = user.id
+            st.session_state.username = user.username
+            return True
+        return False
+    finally:
+        db.close()
+
+def signup_user(username: str, password: str) -> tuple[bool, str]:
+    """Create a new user account."""
+    # Validate password
+    is_valid, message = validate_password(password)
+    if not is_valid:
+        return False, message
+
+    db = SessionLocal()
+    try:
+        # Check if username already exists
+        if db.query(User).filter(User.username == username).first():
+            return False, "Username already exists"
+
+        # Create new user
+        user = User(
+            username=username,
+            password=hash_password(password)
+        )
+        db.add(user)
+        db.commit()
+
+        # Log in the new user
+        st.session_state.user_id = user.id
+        st.session_state.username = user.username
+        return True, "Account created successfully"
+    except Exception as e:
+        db.rollback()
+        return False, str(e)
+    finally:
+        db.close()
+
+def update_profile(user_id: int, **profile_data) -> tuple[bool, str]:
+    """Update user profile information."""
+    db = SessionLocal()
+    try:
+        user = db.query(User).filter(User.id == user_id).first()
+        if not user:
+            return False, "User not found"
+
+        # Update user fields
+        for field, value in profile_data.items():
+            if hasattr(user, field):
+                setattr(user, field, value)
+
+        db.commit()
+        return True, "Profile updated successfully"
+    except Exception as e:
+        db.rollback()
+        return False, str(e)
+    finally:
+        db.close()
+
+def get_user_profile(user_id: int) -> User:
+    """Get user profile information."""
+    db = SessionLocal()
+    try:
+        return db.query(User).filter(User.id == user_id).first()
+    finally:
+        db.close()
+
+def change_password(user_id: int, current_password: str, new_password: str) -> tuple[bool, str]:
+    """Change user password."""
+    # Validate new password
+    is_valid, message = validate_password(new_password)
+    if not is_valid:
+        return False, message
+
+    db = SessionLocal()
+    try:
+        user = db.query(User).filter(User.id == user_id).first()
+        if not user:
+            return False, "User not found"
+
+        # Verify current password
+        if not verify_password(user.password, current_password):
+            return False, "Current password is incorrect"
+
+        # Update password
+        user.password = hash_password(new_password)
+        db.commit()
+        return True, "Password updated successfully"
+    except Exception as e:
+        db.rollback()
+        return False, str(e)
+    finally:
+        db.close()
+
+def is_logged_in() -> bool:
+    """Check if user is logged in."""
+    return 'user_id' in st.session_state
+
+def logout_user():
+    """Log out the current user."""
+    if 'user_id' in st.session_state:
+        del st.session_state.user_id
+    if 'username' in st.session_state:
+        del st.session_state.username

models.py

@@ -0,0 +1,45 @@
+from datetime import datetime
+import sqlalchemy as sa
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import create_engine
+import os
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = 'users'
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    username = sa.Column(sa.String(50), unique=True, nullable=False)
+    password = sa.Column(sa.String(255), nullable=False)
+    full_name = sa.Column(sa.String(100))
+    email = sa.Column(sa.String(100))
+    school = sa.Column(sa.String(100))
+    grade = sa.Column(sa.String(20))
+    profile_photo = sa.Column(sa.Text)  # Store photo as base64
+    created_at = sa.Column(sa.DateTime, default=datetime.utcnow)
+    updated_at = sa.Column(sa.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class History(Base):
+    __tablename__ = 'history'
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    user_id = sa.Column(sa.Integer, sa.ForeignKey('users.id'), nullable=False)
+    equation = sa.Column(sa.String(255), nullable=False)
+    solution = sa.Column(sa.Text, nullable=False)
+    created_at = sa.Column(sa.DateTime, default=datetime.utcnow)
+
+# Database setup
+engine = create_engine(os.environ['DATABASE_URL'])
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+def init_db():
+    Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "workspace",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@mui/icons-material": "^6.4.4",
+    "@mui/material": "^6.4.4",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "@types/react-plotly.js": "^2.6.3",
+    "@types/react-router-dom": "^5.3.3",
+    "axios": "^1.7.9",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-plotly.js": "^2.6.0",
+    "react-router-dom": "^7.1.5",
+    "typescript": "^5.7.3"
+  }
+}

plotter.py

@@ -0,0 +1,79 @@
+import numpy as np
+import plotly.graph_objects as go
+from sympy import symbols, lambdify
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application
+from solver import preprocess_equation
+
+def plot_function(input_str):
+    """Create an interactive plot of the function."""
+    try:
+        # Preprocess input
+        processed_input = preprocess_equation(input_str)
+
+        # Handle different types of input
+        if '=' in processed_input:
+            # Equation: move everything to left side
+            left_side, right_side = [side.strip() for side in processed_input.split('=')]
+            transformations = standard_transformations + (implicit_multiplication_application,)
+            expr = parse_expr(left_side, transformations=transformations) - parse_expr(right_side, transformations=transformations)
+        elif input_str.startswith('∫'):
+            # Integration: plot the original function
+            expr = parse_expr(processed_input[1:].strip(), transformations=(standard_transformations + (implicit_multiplication_application,)))
+        elif input_str.startswith('d/dx'):
+            # Derivative: plot the original function
+            expr = parse_expr(processed_input[4:].strip(), transformations=(standard_transformations + (implicit_multiplication_application,)))
+        else:
+            # Regular expression
+            expr = parse_expr(processed_input, transformations=(standard_transformations + (implicit_multiplication_application,)))
+
+        # Create lambda function for numpy evaluation
+        x = symbols('x')
+        f = lambdify(x, expr, 'numpy')
+
+        # Generate x values
+        x_vals = np.linspace(-10, 10, 1000)
+
+        # Calculate y values
+        y_vals = f(x_vals)
+
+        # Create plot
+        fig = go.Figure()
+
+        # Add function curve
+        fig.add_trace(go.Scatter(
+            x=x_vals,
+            y=y_vals,
+            mode='lines',
+            name='f(x)',
+            line=dict(color='#FF4B4B', width=2)
+        ))
+
+        # Add x-axis line
+        fig.add_trace(go.Scatter(
+            x=x_vals,
+            y=[0]*len(x_vals),
+            mode='lines',
+            name='x-axis',
+            line=dict(color='black', width=1)
+        ))
+
+        # Update layout
+        fig.update_layout(
+            title='Function Visualization',
+            xaxis_title='x',
+            yaxis_title='y',
+            showlegend=True,
+            hovermode='x',
+            plot_bgcolor='white',
+            width=800,
+            height=500
+        )
+
+        # Update axes
+        fig.update_xaxes(zeroline=True, zerolinewidth=1, zerolinecolor='black', gridcolor='lightgray')
+        fig.update_yaxes(zeroline=True, zerolinewidth=1, zerolinecolor='black', gridcolor='lightgray')
+
+        return fig
+
+    except Exception as e:
+        raise Exception(f"Error creating plot: {str(e)}")

pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115.8",
+    "numpy>=2.2.3",
+    "openai>=1.63.0",
+    "passlib[bcrypt]>=1.7.4",
+    "plotly>=6.0.0",
+    "psycopg2-binary>=2.9.10",
+    "python-jose[cryptography]>=3.3.0",
+    "python-multipart>=0.0.20",
+    "sqlalchemy>=2.0.38",
+    "streamlit>=1.42.0",
+    "sympy>=1.13.3",
+    "twilio>=9.4.5",
+    "uvicorn>=0.34.0",
+]

replit.nix

@@ -0,0 +1,6 @@
+{pkgs}: {
+  deps = [
+    pkgs.postgresql
+    pkgs.glibcLocales
+  ];
+}

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+sympy
+sqlalchemy
+plotly
+pandas

solver.py

@@ -0,0 +1,182 @@
+import sympy as sp
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application
+from sympy.solvers import solve
+from sympy import integrate, diff, simplify, expand, log, exp, sin, cos, tan, asin, acos, atan, Symbol, factorial, laplace_transform
+
+def format_expression(expr):
+    """Format expression to make it more readable."""
+    # Convert string representation to a more readable format
+    str_expr = str(expr)
+    replacements = {
+        '**': '^',
+        '*x': 'x',
+        'exp': 'e^',
+        'sqrt': '√',
+        'factorial': '!'
+    }
+    for old, new in replacements.items():
+        str_expr = str_expr.replace(old, new)
+    return str_expr
+
+def preprocess_equation(equation_str):
+    """Convert user-friendly equation format to SymPy format."""
+    try:
+        # Replace common mathematical notations
+        replacements = {
+            '^': '**',
+            'sin⁻¹': 'asin',
+            'cos⁻¹': 'acos',
+            'tan⁻¹': 'atan',
+            'e^': 'exp',
+            'ln': 'log',
+            '!': 'factorial',
+        }
+        for old, new in replacements.items():
+            equation_str = equation_str.replace(old, new)
+
+        # Handle exponential expressions
+        if 'exp' in equation_str:
+            parts = equation_str.split('exp')
+            for i in range(1, len(parts)):
+                if parts[i] and parts[i][0] != '(':
+                    parts[i] = '(' + parts[i]
+                    if '=' in parts[i]:
+                        exp_part, rest = parts[i].split('=', 1)
+                        parts[i] = exp_part + ')=' + rest
+                    else:
+                        parts[i] = parts[i] + ')'
+            equation_str = 'exp'.join(parts)
+
+        # Add multiplication symbol where needed
+        processed = ''
+        i = 0
+        while i < len(equation_str):
+            if i + 1 < len(equation_str):
+                if equation_str[i].isdigit() and equation_str[i+1] == 'x':
+                    processed += equation_str[i] + '*'
+                    i += 1
+                    continue
+            processed += equation_str[i]
+            i += 1
+
+        return processed
+    except Exception as e:
+        raise Exception(f"Error in equation format: {str(e)}")
+
+def process_expression(expr_str):
+    """Process mathematical expressions without equations."""
+    try:
+        # Preprocess the expression
+        processed_expr = preprocess_equation(expr_str)
+        x = Symbol('x')
+
+        # Check for special operations
+        if expr_str.startswith('∫'):  # Integration
+            expr_to_integrate = processed_expr[1:].strip()
+            expr = parse_expr(expr_to_integrate, transformations=(standard_transformations + (implicit_multiplication_application,)))
+            result = integrate(expr, x)
+            return f"∫{format_expression(expr)} = {format_expression(result)}"
+
+        elif expr_str.startswith('d/dx'):  # Differentiation
+            expr_to_diff = processed_expr[4:].strip()
+            if expr_to_diff.startswith('(') and expr_to_diff.endswith(')'):
+                expr_to_diff = expr_to_diff[1:-1]
+            expr = parse_expr(expr_to_diff, transformations=(standard_transformations + (implicit_multiplication_application,)))
+            result = diff(expr, x)
+            return f"d/dx({format_expression(expr)}) = {format_expression(result)}"
+
+        elif 'factorial' in processed_expr:  # Factorial
+            expr = parse_expr(processed_expr, transformations=(standard_transformations + (implicit_multiplication_application,)))
+            result = expr.doit()
+            return f"{format_expression(expr)} = {format_expression(result)}"
+
+        else:  # Regular expression simplification
+            expr = parse_expr(processed_expr, transformations=(standard_transformations + (implicit_multiplication_application,)))
+            simplified = simplify(expr)
+            expanded = expand(simplified)
+            return f"Simplified: {format_expression(simplified)}\nExpanded: {format_expression(expanded)}"
+
+    except Exception as e:
+        raise Exception(f"Error processing expression: {str(e)}")
+
+def solve_equation(equation_str):
+    """Solve the given equation and return the 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
+        left_side, right_side = [side.strip() for side in equation_str.split('=')]
+
+        # Parse both sides 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)
+        equation = left_expr - right_expr
+
+        # Solve the equation
+        x = Symbol('x')
+        solution = solve(equation, x)
+
+        # 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])
+
+    except Exception as e:
+        raise Exception(f"Invalid equation format: {str(e)}")
+
+def generate_steps(equation_str):
+    """Generate step-by-step solution for the equation or expression."""
+    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
+
+        # Preprocess equation
+        processed_eq = preprocess_equation(equation_str)
+
+        # Split equation into left and right parts
+        left_side, right_side = [side.strip() for side in processed_eq.split('=')]
+
+        # 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)
+
+        # Step 1: Show original equation
+        steps.append(f"1. Original equation: {format_expression(left_expr)} = {format_expression(right_expr)}")
+
+        # 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")
+
+        # Step 3: Factor if possible
+        factored = sp.factor(equation)
+        if factored != equation:
+            steps.append(f"3. Factor the equation: {format_expression(factored)} = 0")
+
+        # 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])}")
+
+        # 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)}")
+
+        return steps
+
+    except Exception as e:
+        raise Exception(f"Error generating steps: {str(e)}")

style.css

@@ -0,0 +1,158 @@
+/* Custom styles for the application */
+body {
+    font-family: 'Arial', sans-serif;
+    color: #FFFFFF;
+    background-color: #181818;
+}
+
+/* Button styling */
+.stButton>button {
+    min-width: 40px !important;
+    height: 30px !important;
+    padding: 2px 8px !important;
+    margin: 2px !important;
+    background-color: #2D5BE3;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 14px;
+    font-weight: bold;
+    text-shadow: 0 1px 2px rgba(0,0,0,0.2);
+    box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+}
+
+.stButton>button:hover {
+    background-color: #3DDC84;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.3);
+}
+
+/* Input field styling */
+.stTextInput>div>div>input {
+    border-radius: 5px;
+    border: 2px solid #2D5BE3;
+    padding: 0.5rem;
+    background-color: #242424;
+    color: #FFFFFF;
+    font-weight: 500;
+}
+
+.stTextInput>div>div>input:focus {
+    border-color: #FFDD44;
+    box-shadow: 0 0 0 2px rgba(255, 221, 68, 0.2);
+}
+
+/* Sidebar styling */
+.sidebar .sidebar-content {
+    background-color: #242424;
+    padding: 1rem;
+    border-right: 2px solid #2D5BE3;
+}
+
+/* Solution display styling */
+.stExpander {
+    background-color: #242424;
+    border-radius: 8px;
+    margin-bottom: 10px;
+    box-shadow: 0 2px 6px rgba(0,0,0,0.3);
+    border: 1px solid #3DDC84;
+}
+
+/* Plot container styling */
+.plot-container {
+    background-color: #242424;
+    border-radius: 8px;
+    padding: 1rem;
+    margin: 1rem 0;
+    border: 1px solid #2D5BE3;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+}
+
+/* Solution steps styling */
+.solution-step {
+    background-color: #242424;
+    padding: 1rem;
+    margin: 0.75rem 0;
+    border-radius: 6px;
+    border-left: 4px solid #3DDC84;
+}
+
+/* Mathematical symbols grid */
+.math-symbols-grid {
+    display: grid;
+    grid-template-columns: repeat(8, 1fr);
+    gap: 4px;
+    margin: 10px 0;
+}
+
+/* Headers styling */
+h1, h2, h3 {
+    color: #FFFFFF;
+    font-weight: bold;
+    text-shadow: 0 2px 4px rgba(0,0,0,0.3);
+}
+
+/* Interactive elements */
+.stSelectbox select,
+.stMultiSelect select {
+    background-color: #242424;
+    color: #FFFFFF;
+    border: 2px solid #2D5BE3;
+}
+
+/* Radio buttons and checkboxes */
+.stRadio > div {
+    border-radius: 6px;
+    padding: 0.5rem;
+    background-color: #242424;
+}
+
+.stRadio label {
+    color: #FFFFFF !important;
+}
+
+.stRadio label:hover {
+    color: #FFDD44 !important;
+}
+
+/* Tabs */
+.stTabs {
+    background-color: #242424;
+    border-radius: 8px;
+    padding: 1rem;
+    margin: 1rem 0;
+}
+
+/* Success/Info messages */
+.stSuccess, .stInfo {
+    background-color: #3DDC84;
+    color: #181818;
+    font-weight: bold;
+    border-radius: 6px;
+    padding: 0.75rem;
+}
+
+/* Error messages */
+.stError {
+    background-color: #FF4444;
+    color: #FFFFFF;
+    font-weight: bold;
+    border-radius: 6px;
+    padding: 0.75rem;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .stButton>button {
+        min-width: 30px !important;
+        height: 25px !important;
+        padding: 1px 6px !important;
+        font-size: 12px;
+    }
+
+    .stTextInput>div>div>input {
+        font-size: 16px;
+    }
+}

utils.py

@@ -0,0 +1,49 @@
+import streamlit as st
+
+def initialize_session_state():
+    """Initialize session state variables."""
+    if 'history' not in st.session_state:
+        st.session_state.history = []
+
+def load_css():
+    """Load custom CSS styles."""
+    st.markdown("""
+        <style>
+            .stButton>button {
+                width: 100%;
+                background-color: #FF4B4B;
+                color: white;
+            }
+            
+            .stTextInput>div>div>input {
+                border-radius: 5px;
+            }
+            
+            .stMarkdown {
+                font-family: 'Arial', sans-serif;
+            }
+            
+            h1, h2, h3 {
+                color: #262730;
+            }
+            
+            .sidebar .sidebar-content {
+                background-color: #F0F2F6;
+            }
+            
+            .stExpander {
+                background-color: white;
+                border-radius: 5px;
+                margin-bottom: 10px;
+            }
+            
+            .stRadio > div {
+                display: flex;
+                gap: 1rem;
+            }
+            
+            .stSelectbox {
+                margin-bottom: 1rem;
+            }
+        </style>
+    """, unsafe_allow_html=True)