ENGLISH TASK 4

Name : Sallaa Fikriyatul ‘Arifah

NPM : G1A023015
Class : A / Informatic

1. Write an essay based on the paper in drive (500 – 1000 words)

Demystifying the Maze: A Look Inside an Equation Matching Algorithm

Ever wondered how computers navigate the seemingly complex world of mathematical
expressions? Enter the equation matching algorithm, a powerful tool used in computer algebra
systems. This essay delves into the intricate steps outlined in a flowchart, revealing the
fascinating process behind determining whether two seemingly different expressions represent
the same mathematical truth.

The journey begins with the construction of a critical data structure - the expression tree.
Imagine a branching network, with each node representing an element (numbers, variables, or
operators) in the equation. This tree reflects the order of operations, ensuring the computer
interprets the expression correctly. Just like a roadmap guides a traveler, the expression tree
ensures the computer follows the correct sequence of calculations. Next comes the "reading"
phase, where the algorithm retrieves the equation, most likely from a text file or user input. Here,
the raw expression enters the system, ready to be transformed and analyzed.

Following this, the flowchart ushers in the "expansion" stage. Here, the algorithm tackles
terms hidden within parentheses or applies mathematical properties like the distributive property.
Think of it as meticulously unpacking the equation to expose its core structure. Imagine a tightly
wrapped package; the expansion stage carefully unwraps it, revealing the individual components
within. But wait, there's more! White spaces, those seemingly innocuous gaps, can throw a
wrench in the computational gears. The "remove whitespace" step streamlines the process by
discarding these unnecessary spaces, making the equation easier for the computer to interpret.
Just like a cluttered desk can impede clear thinking, unnecessary spaces can hinder the
computer's ability to understand the equation.

Now comes the crucial "normalization" step. Picture a cluttered desk being meticulously
organized. In the realm of computer algebra, normalization transforms the equation into a
standardized format. This could involve rearranging terms alphabetically or combining common
factors, ensuring a consistent presentation that facilitates comparison. Just like a well-organized
desk fosters clarity, normalization paves the way for efficient equation matching. Imagine two
libraries, one meticulously categorized and the other a chaotic jumble of books. Normalization
ensures both libraries are organized in a similar fashion, making it easier to find the desired
information (in this case, the solution to the equation).

Further refinement awaits in the "refine the expression" stage. This likely involves
combining like terms or canceling out common factors. Think of it as tidying up the equation
after the initial normalization. The result? A streamlined expression, ready for the final
transformation. Imagine a messy room being tidied up after the initial organization; this stage
ensures the equation is presented in its most concise form.

The penultimate step involves a shift in notation. The flowchart introduces "convert to
prefix notation," a mathematical language where the operator takes center stage, appearing
before its operands. For instance, the familiar 2 + 3 would transform into "+ 2 3" in prefix
notation. This change in perspective offers a unique vantage point for comparing equations.
Imagine looking at a map from a traditional north-south orientation versus a bird's-eye view
where all directions are readily apparent. Prefix notation provides a different way to view the
equation, potentially aiding in the comparison process.

Finally, the algorithm reaches its destination: the "export" stage. Here, the triumphant
outcome - the simplified and standardized equation - is written to a file or displayed on the
screen. This exported expression serves as the final verdict, ready for comparison with other
equations. Imagine a judge issuing a final ruling; the exported expression represents the
algorithm's final determination of whether the equations are equivalent.

While this essay explores the core steps of an equation matching algorithm, it's important
to acknowledge the complexities that lie beneath the surface. Each stage, from expansion to
refinement, could involve sophisticated techniques depending on the specific algorithm
implementation. For instance, how does the algorithm handle the use of nested parentheses or
more complex operations like matrix multiplication? Exploring these intricacies would provide a
deeper understanding of the algorithm's capabilities.
 Furthermore, the world of mathematics extends beyond basic arithmetic operations.
Derivatives and integrals, representing concepts like instantaneous change and accumulation,
pose additional challenges for equation matching algorithms. Delving into how these algorithms
handle such advanced mathematical structures would further illuminate their power and
versatility.

In conclusion, the equation matching algorithm serves as a testament to the power of

computer algebra systems. By meticulously constructing expression trees, manipulating
expressions, and employing various normalization techniques, these algorithms can efficiently
determine whether seemingly different expressions represent the same mathematical truth. While
this essay has focused on the core functionalities, the underlying techniques and their application
to more complex mathematical structures offer a rich avenue for further exploration. Ultimately,
the equation matching algorithm stands as a remarkable example of how computers can navigate
the intricate world of mathematics, enabling them to analyze and compare expressions with
remarkable precision.