Math Engine

​

ExpressionNormalizer

from app.utils.math_engine import ExpressionNormalizer

normalizer = ExpressionNormalizer()

​

Constructor

• Standard SymPy transformations
• Implicit multiplication application (e.g., 2x → 2*x)
• XOR conversion

• Mathematical functions: log, ln, exp, sqrt, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh
• Constants: e, pi
• Calculus: Integral, Derivative
• Special functions: Piecewise, Heaviside, floor, ceiling, Max, Min
• Relational operators: Eq, Ne, Lt, Gt, Le, Ge

​

normalize_expression()

normalized = normalizer.normalize_expression("2*x + 3")
# Returns: "2*x + 3" (canonical string form)

normalized = normalizer.normalize_expression(r"\frac{x^2 + 2x + 1}{x + 1}")
# Returns canonical form of the expression

• expression_str (str): The mathematical expression to normalize

• str: Stable canonical string representation

1. Parse to SymPy expression
2. Apply canonicalization
3. Convert to stable string

​

expressions_equivalent()

# Standard mathematical expressions
result = normalizer.expressions_equivalent("2*x + 3", "3 + 2*x")
# Returns: True

# Factored vs expanded forms
result = normalizer.expressions_equivalent("x^2 + 2*x + 1", "(x + 1)^2")
# Returns: True

# LaTeX vs standard notation
result = normalizer.expressions_equivalent(r"c\left(a+b\right)", "c*(a+b)")
# Returns: True

• expr1 (str): First mathematical expression
• expr2 (str): Second mathematical expression

• bool: True if expressions are mathematically equivalent

1. Parse both expressions to SymPy
2. Convert to difference form
3. Check if difference is symbolically zero
4. Fall back to numeric probing if symbolic methods inconclusive
5. Final fallback to structural comparison

​

get_canonical_form()

canonical = normalizer.get_canonical_form("3 + 2*x")
# Returns: "2*x + 3" (canonical form)

• expression_str (str): Expression to canonicalize

• str: Canonical string representation for consistent storage

​

Public Functions

​

compare_mathematical_expressions()

from app.utils.math_engine import compare_mathematical_expressions

user_answer = "2*x + 3"
correct_answer = "3 + 2*x"
is_correct = compare_mathematical_expressions(user_answer, correct_answer)
# Returns: True

• user_answer (str): User’s submitted answer
• correct_answer (str): Expected correct answer

• bool: True if expressions are equivalent

​

normalize_expression_for_storage()

from app.utils.math_engine import normalize_expression_for_storage

expression = "3 + 2*x"
stored_form = normalize_expression_for_storage(expression)
# Returns: "2*x + 3"

• expression (str): Expression to normalize

• str: Canonical form suitable for database storage

​

latex_to_sympy_string()

from app.utils.math_engine import latex_to_sympy_string

latex_expr = r"\frac{x^2 + 2x + 1}{x + 1}"
sympy_str = latex_to_sympy_string(latex_expr)
# Returns: "(x**2 + 2*x + 1)/(x + 1)"

• latex_expr (str): LaTeX formatted expression

• str: SymPy string representation

• Prefers latex2sympy2 library when available
• Falls back to SymPy’s parser for non-LaTeX or parsing failures

​

latex_to_simplified_latex()

from app.utils.math_engine import latex_to_simplified_latex

latex_expr = r"\frac{2x + 2}{2}"
simplified = latex_to_simplified_latex(latex_expr)
# Returns simplified LaTeX form

• latex_expr (str): LaTeX formatted expression

• str: Simplified LaTeX expression

1. Try latex2latex for quick simplification (when available)
2. Fall back to parse → SymPy canonicalize → LaTeX printer
3. Return original if all methods fail

​

LaTeX Support

​

Supported LaTeX Features

r"\frac{numerator}{denominator}"

r"\sqrt{expression}"  # Square root
r"\sqrt[n]{expression}"  # nth root

r"\sin(x)", r"\cos(x)", r"\tan(x)"
r"\log(x)", r"\ln(x)", r"\exp(x)"

r"\cdot"  # Multiplication
r"\times" # Multiplication
r"\div"   # Division

r"\left( \right)"  # Parentheses
r"\left[ \right]"  # Brackets
r"\left\{ \right\}"  # Braces

"x^{2}"    # Superscript
"x_{i}"    # Subscript

​

LaTeX Detection

• Math mode markers: $, \(, \), \[, \]
• LaTeX commands: \frac, \sqrt, \sin, \cos, etc.
• LaTeX operators: \cdot, \times, \div
• Superscripts/subscripts: ^{, _{

​

Expression Normalization Strategies

​

Canonicalization Pipeline

1. Basic Simplification: sp.simplify(expr)
2. Rational Functions: sp.together() and sp.cancel()
3. Logarithm Expansion: sp.expand_log() and sp.logcombine()
4. Power Simplification: sp.powsimp() and sp.powdenest()
5. Multiplication Expansion: sp.expand_mul()
6. Term Factoring: sp.factor_terms()
7. Final Simplification: sp.simplify()
8. Term Ordering: Lexicographic sorting of terms

​

Equivalence Checking Methods

• Canonicalize and check if difference equals 0
• Apply sp.simplify(), sp.together(), sp.cancel()

• Evaluates difference at random points
• 8 trials with domain -5 to 6
• Tolerance: 1e-9
• Skips domain errors (division by zero, etc.)

• Final fallback comparing canonicalized string forms

​

Security Features

​

Dangerous Pattern Detection

• Python builtins: exec, eval, compile, __import__
• Attribute access: getattr, setattr, delattr
• File operations: open, file
• User input: input
• Special attributes: __name__, __dict__, etc.
• Import statements
• Lambda expressions

​

Usage Examples

​

Basic Expression Validation

from app.utils.math_engine import compare_mathematical_expressions

# In a route handler for answer submission
def validate_answer(user_input, correct_answer):
    is_correct = compare_mathematical_expressions(user_input, correct_answer)
    return is_correct

​

Database Integration

from app.utils.math_engine import normalize_expression_for_storage

# Store canonical form for efficient lookup
canonical = normalize_expression_for_storage(user_input)
question.canonical_answer = canonical
db.session.commit()

​

LaTeX Form Handling

from app.utils.math_engine import compare_mathematical_expressions

# Handle LaTeX from mathematical input fields
latex_input = request.form.get('answer')  # e.g., r"\frac{x^2}{2}"
standard_answer = "(x^2)/2"
is_correct = compare_mathematical_expressions(latex_input, standard_answer)

​

Error Handling

1. Primary: LaTeX parsing via latex2sympy2
2. Secondary: SymPy parsing with transformations
3. Tertiary: SymPy parsing without transformations
4. Fallback: Basic string normalization

​

Dependencies

• sympy >= 1.12.0 - Symbolic mathematics engine

• latex2sympy2 - Enhanced LaTeX parsing (recommended)