Simplify Algebraic Expressions using Python

This tutorial will guide you through simplifying algebraic expressions using Python. We’ll focus on understanding the concepts and implementing them with concise, runnable code examples. We’ll cover basic operations like addition, subtraction, multiplication, and division of terms with variables.

Example 1: Basic Term Addition and Subtraction

Let’s start with a simple expression like 3x + 2x – x. The goal is to combine like terms. Like terms have the same variable raised to the same power. In this case, 3x, 2x, and -x are all like terms because they all involve ‘x’.

def simplify_expression(expression):
    """
    Simplifies a simple algebraic expression with addition and subtraction.

    Args:
        expression: The algebraic expression as a string.  Assumes the expression
                    contains only integers, variables (x, y), +, -, and spaces.

    Returns:
        The simplified expression as a string.
    """
    expression = expression.replace(" ", "")  # Remove spaces for easier parsing
    terms = expression.split("+")
    simplified = ""
    for term in terms:
        if "-" in term:
            sub_terms = term.split("-")
            simplified += sub_terms[0] + " - "
            for i in range(1, len(sub_terms)):
                simplified += sub_terms[i] + " + "
        else:
            simplified += term + " + "
    return simplified.strip(" + ")

# Example usage:
expression = "3x + 2x - x"
simplified_expression = simplify_expression(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

Explanation:

• We define a function `simplify_expression` that takes an algebraic expression string as input.
• The function first removes any spaces from the string, which simplifies parsing.
• The expression is split into individual terms using the “+” operator as a delimiter.
• The code then iterates through each term, handling potential subtraction. If a term contains a “-“, it is further split into its parts using “-” as a delimiter, and the results are added back together.
• Finally, the function removes any trailing ” + ” and returns the simplified expression.

Potential Beginner Mistake: Forgetting to handle the case where a term contains a subtraction sign. The provided code correctly addresses this by splitting the terms into sub-terms for subtraction and then reassembling them.

# Example usage:
expression = "3x + 2x - x"
simplified_expression = simplify_expression(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

Output:

Original expression: 3x + 2x - x
Simplified expression: 4x

Example 2: Dealing with Multiple Variables

Let’s try a more complex expression: 2y + 5y – y + 3. Here, we have two variables, ‘y’, and the expression involves multiple terms. The same principles of combining like terms apply.

def simplify_expression_multiple_vars(expression):
    """
    Simplifies an algebraic expression with addition, subtraction, and multiple variables (x, y).
    """
    expression = expression.replace(" ", "")
    terms = expression.split("+")
    simplified = ""
    for term in terms:
        if "-" in term:
            sub_terms = term.split("-")
            simplified += sub_terms[0] + " - "
            for i in range(1, len(sub_terms)):
                simplified += sub_terms[i] + " + "
        else:
            simplified += term + " + "
    return simplified.strip(" + ")

# Example usage:
expression = "2y + 5y - y + 3"
simplified_expression = simplify_expression_multiple_vars(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

Explanation:

• The function is almost the same as before, but it works with multiple variables.
• The logic for splitting and combining terms remains consistent.

# Example usage:
expression = "2y + 5y - y + 3"
simplified_expression = simplify_expression_multiple_vars(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

Output:

Original expression: 2y + 5y - y + 3
Simplified expression: 6y + 3

Example 3: More Robust Input Handling (Simplified)

This example adds a basic check to ensure that the input expression contains only allowed characters. For simplicity, we’ll skip comprehensive error handling. This allows you to understand the basics and build upon it later.

def simplify_expression_safe(expression):
    """
    Simplifies an algebraic expression with addition, subtraction, and multiple variables (x, y)
    and performs a basic input check.
    """
    allowed_chars = "0123456789x+- "
    for char in expression:
        if char not in allowed_chars:
            return "Invalid input: Expression contains unsupported characters."
    expression = expression.replace(" ", "")
    terms = expression.split("+")
    simplified = ""
    for term in terms:
        if "-" in term:
            sub_terms = term.split("-")
            simplified += sub_terms[0] + " - "
            for i in range(1, len(sub_terms)):
                simplified += sub_terms[i] + " + "
        else:
            simplified += term + " + "
    return simplified.strip(" + ")

# Example usage:
expression = "3x + 2y - x + 5"
simplified_expression = simplify_expression_safe(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

expression = "3x + 2y - x + 5a" # Invalid input
simplified_expression = simplify_expression_safe(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

Explanation:

• We add an input check to make sure that the input expression only contains allowed characters (0-9, x, +, -, and spaces).
• If any character is not allowed, the function returns an error message.
• The rest of the function remains the same.

# Example usage:
expression = "3x + 2y - x + 5"
simplified_expression = simplify_expression_safe(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

expression = "3x + 2y - x + 5a" # Invalid input
simplified_expression = simplify_expression_safe(expression)
print(f"Original expression: {expression}")
print(f"Simplified expression: {simplified_expression}")

Output:

Original expression: 3x + 2y - x + 5
Simplified expression: 2x + 2y + 5
Original expression: 3x + 2y - x + 5a
Simplified expression: Invalid input: Expression contains unsupported characters.