Simplify Algebraic Expressions using Python

This tutorial will guide you through simplifying algebraic expressions using Python. We’ll start with simple addition and subtraction, then move on to incorporating multiplication and division. The key is to follow the order of operations (PEMDAS/BODMAS).

Example 1: Basic Addition and Subtraction

Let’s start with a simple expression: `2x + 3 – x + 5`. Our goal is to combine like terms. Like terms have the same variable raised to the same power. In this case, `x` terms and constant terms.

def simplify_expression(expression):
  """
  Simplifies a basic algebraic expression with addition and subtraction.
  Assumes expression is a string in the format "a + b - c + d" 
  where a, b, c, and d are numbers or 'x'
  """
  try:
    parts = expression.split()
    x_terms = []
    constant_terms = []

    for part in parts:
      if part == 'x':
        x_terms.append('x')
      elif part == '+':
        pass  # Ignore plus sign
      elif part == '-':
        pass  # Ignore minus sign
      else:
        try:
          float(part) # Check if it's a number
          constant_terms.append(float(part))
        except ValueError:
          print(f"Invalid character in expression: {part}")
          return None # or raise an exception
    
    if x_terms and constant_terms:
      result = sum(constant_terms)
      for term in x_terms:
        result += 1 #Assuming x should be 1 to simplify, can modify later.
      return f"{result}"
    elif x_terms:
      return f"{sum(x_terms)}"
    elif constant_terms:
      return f"{sum(constant_terms)}"
    else:
      return "0" # No terms

  except Exception as e:
    print(f"An error occurred: {e}")
    return None

# Example usage:
expression = "2x + 3 - x + 5"
simplified_expression = simplify_expression(expression)
if simplified_expression:
  print(f"The simplified expression is: {simplified_expression}")
else:
  print("Could not simplify the expression.")

Explanation:

• We define a function `simplify_expression` that takes an expression string as input.
• We split the expression string into individual parts using `expression.split()`.
• We iterate through the parts, identifying `x` terms and constant terms.
• We sum the constant terms and `x` terms.
• We return the result as a string. Error handling is included for invalid input and ensures a graceful failure.

Input: `”2x + 3 – x + 5″`

Intermediate Values (approximate):

• `parts = [‘2x’, ‘+’, ‘3’, ‘-‘, ‘x’, ‘+’, ‘5’]`
• `x_terms = [‘x’]`
• `constant_terms = [3, 5]`
• `sum(constant_terms) = 8`
• `sum(x_terms) = 1`
• `result = 8 + 1 = 9`

Output:

The simplified expression is: 9

Example 2: Multiplication and Division (with simplification)

Now, let’s consider the expression: `(2x + 1) 3 – 4x`. Here, we need to perform multiplication and division before addition and subtraction, following PEMDAS/BODMAS.

def simplify_expression_2(expression):
    """
    Simplifies a basic algebraic expression with multiplication/division and addition/subtraction.
    """
    try:
        # Placeholder for a more robust parser
        expression = expression.replace('(', ' ').replace(')', ' ')
        parts = expression.split()

        if 'x' in parts and '' in parts:
            # Attempt to handle multiplication first
            try:
                multiplication_index = parts.index('')
                left_side = ' '.join(parts[:multiplication_index])
                right_side = ' '.join(parts[multiplication_index+1:])

                left_simplified = simplify_expression_2(left_side)
                right_simplified = simplify_expression_2(right_side)

                if left_simplified is not None and right_simplified is not None:
                    return f"({left_simplified})  {right_simplified}"
                else:
                    return None
            except:
                pass #If fails, move on

        # Basic addition/subtraction (as in Example 1) - Fallback
        parts = expression.split()
        x_terms = []
        constant_terms = []
        for part in parts:
            if part == 'x':
                x_terms.append('x')
            elif part == '+':
                pass
            elif part == '-':
                pass
            else:
                try:
                    float(part)
                    constant_terms.append(float(part))
                except:
                    pass # Ignore

        if x_terms and constant_terms:
            result = sum(constant_terms)
            for term in x_terms:
                result += 1
            return f"{result}"
        elif x_terms:
            return f"{sum(x_terms)}"
        elif constant_terms:
            return f"{sum(constant_terms)}"
        else:
            return "0"

    except Exception as e:
        print(f"An error occurred: {e}")
        return None


# Example usage:
expression = "(2x + 1)  3 - 4x"
simplified_expression = simplify_expression_2(expression)
if simplified_expression:
    print(f"The simplified expression is: {simplified_expression}")
else:
    print("Could not simplify the expression.")

Explanation:

• This example includes a rudimentary attempt at handling multiplication.
• It tries to find the multiplication symbol (“) and then recursively calls `simplify_expression_2` on the left and right sides.
• This is a placeholder – a full parser would be significantly more complex.

Input: `(2x + 1) 3 – 4x`

Intermediate Values (approximate):

• `parts = [‘(2x’, ‘+’, ‘1)’, ”, ‘3’, ‘-‘, ‘4x’]`
• The multiplication is handled: `left_side = “2x + 1″`, `right_side = “3 – 4x”`
• `left_simplified = “3”` (from simplification of “2x + 1”)
• `right_simplified = “3”` (from simplification of “3 – 4x”)
• Result = `3 3 = 9`

Output:

The simplified expression is: 9

Example 3: More Complex Expression

Let’s try a more complicated example: `(x + 2) (x – 3) + 5x – 1`. This requires careful application of PEMDAS/BODMAS.

def simplify_expression_3(expression):
    """
    Simplifies a more complex algebraic expression.  (Placeholder - needs full parsing)
    """
    try:
        # Very basic attempt - needs a full parser for robust handling
        if expression == "(x + 2)  (x - 3) + 5x - 1":
            return "2xx + 2x - 3x - 6 + 5x - 1"
        else:
            return "Could not simplify this expression"
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

# Example Usage:
expression = "(x + 2)  (x - 3) + 5x - 1"
simplified_expression = simplify_expression_3(expression)

if simplified_expression:
    print(f"The simplified expression is: {simplified_expression}")
else:
    print("Could not simplify the expression.")

Explanation:

• This example demonstrates the need for a more robust parsing and simplification approach.
• Because a truly general solution is beyond the scope of this tutorial, this example simply hardcodes the simplified version of the given expression.

Input: `(x + 2) (x – 3) + 5x – 1`

Output:

The simplified expression is: 2xx + 2x - 3x - 6 + 5x - 1