Lecture 5

Previously, arithmetic expressions were implemented as lists.
Example: 1 2 * a 3 + ( 2 7 - x )
Represented as: Num * Sym a3 Id + Sym ( Sym 27 Num - Sym x Id ) Sym
This list representation does not reflect the hierarchical structure of the expression.
It can become inconvenient, especially when brackets are involved.

Expressions can also be represented as trees which provides a more appropriate hierarchical structure.
Example: 1 2 * a 3 + ( 2 7 - x )
Represented as a tree with nodes: Mult, Add, Sub
The tree structure implies parentheses, making them explicit.

A redefinition of expressions using a grammar:
- <expression> ::= <term> { ‘+’ <term> | ‘-’ <term> }
- <term> ::= <factor> { ‘*’ <factor> | ‘/’ <factor> }
- <factor> ::= <number> | <identifier> | ‘(’ <expression> ‘)’
The question is posed: Can we eliminate the need for parentheses in our expression definition?
The suggestion is to move the operator to the front. This changes the order of operations, implying that the first operator encountered should be evaluated first.

Redefinition of expressions using prefix notation:
- <prefixExp> ::= <number> | <identifier> | ‘+’ <prefixExp> <prefixExp> | ‘-’ <prefixExp> <prefixExp> | ‘*’ <prefixExp> <prefixExp> | ‘/’ <prefixExp> <prefixExp>
Prefix expressions move the operator to the front of the expression.
Each operator is followed by exactly two operands.
This notation is also known as Łukasiewicz or Polish notation.
Examples:
- + 3 * t 7 is equivalent to $(3 + (t * 7))$
- * + 3 t 7 is equivalent to $((3 + t) * 7)$
More complex example and step-by-step evaluation:
- / + * 4 9 / 6 2 + 7 * 2 - 8 5 ?
- / + 36 3 + 7 * 2 3
- / + 36 3 + 7 6
- / 39 + 7 6
- / 39 13
- 3

The aim is to build a tree from a prefix expression.
This involves:
- Starting from an existing list expression.
- Reading in prefix expressions.
- Repurposing the token list scanner from week 2.
- Constructing a token tree.
- Evaluating numerical expression trees.
Existing list expression code includes:
- TokenType enum with NUMBER, IDENTIFIER, and SYMBOL.
- TokenList class with value, type, and next attributes.
Originally, a token list was constructed based on the list's structure.
New tree expression code includes:
- TokenType enum (imported from scanner.py) with NUMBER, IDENTIFIER, and SYMBOL.
- TreeNode class (imported from tree.py) with item, left, and right attributes.
- Token class with tokentype and value attributes.
The tree implementation is used to keep track of token information.

Goal: Transform a string into a tree.
Only symbols +, -, *, / are accepted as operators.
Each symbol should be associated with exactly two children.
Code snippets:
- is_operator(char: str) -> bool: checks if a character is an operator ( $+, -, *, /$ ).
- treenode(text: str, pos: int) -> tuple[TreeNode | None, int]: recursively constructs the expression tree.
  - It skips whitespace.
  - Matches numbers, identifiers, and symbols.
  - Creates a TreeNode with the appropriate Token.
  - If the token is an operator, it recursively calls treenode to create left and right children.
- generate_expression_tree(text: str) -> TreeNode | None: initiates the tree generation process.
- infix_expression_tree(tree: TreeNode) -> str: converts the expression tree back into infix notation.
Example:
- Expression + 3 2 in infix notation becomes (3 + 2).
- Expression +-*/2 3 4 5 6 in infix notation becomes (((((2 / 3) * 4) - 5) + 6)).
- Expression /* 4 2 2 in infix notation becomes ((4 * 2) / 2).

The aim is to evaluate the expression trees.
Will only evaluate correct trees without identifiers.
Code snippets:
- is_numerical_expression_tree(tree: TreeNode) -> bool: checks if the expression tree is purely numerical (no identifiers).
- evaluate_expression_tree(tree: TreeNode) -> float: evaluates the numerical expression tree.
  - If the node is a number, it returns the number's value.
  - If the node is an operator, it recursively evaluates the left and right operands and applies the corresponding operation.
Examples:
- Expression + 3 2 evaluates to $5$ .
- Expression +-*/2 3 4 5 6 evaluates to $3.6666666666666665$ .
- Expression /* 4 2 2 evaluates to $4.0$ .

Graphs are a generalization of trees.
A graph $G = (V, E)$ is a collection of nodes/vertices $V$ and edges $E$ .
An edge $e = (v, w)$ connects two nodes.
Edge $e$ is incident to $v$ or $w$ .
Edges may be directed or undirected.
Nodes $v$ and $w$ are neighbors and adjacent.
A path is a sequence $(v0, v1, …, vn)$ in which pairs $(vi, v_{i+1})$ are neighbors.
A path is simple if every node in it is different.
A cycle is a path with $v0 = vn$ .
A cycle is simple if it contains at least three nodes that are all (except the first and last) different.
A graph is connected if for every pair $v, w \\in V$ , there is a path from $v$ to $w$ .
A graph is simple if:
- It contains no loops $e = (v, v)$ .
- It contains no duplicate edges.

Leonhard Euler (1707 - 1783) is regarded as the "inventor" of graph theory.
The Seven Bridges of Königsberg (1735) problem: There are seven bridges crossing the river Pregel in Königsberg.
The question: Is there a walk that crosses each bridge exactly once?
Euler invented graph theory to solve this problem.
Pieces of land become nodes, and bridges become edges.
An Euler path is a path in which every edge occurs exactly once.
Problem analysis:
- Suppose an Euler path exists.
- In any node we pass through, we arrive and leave the same number of times; such a node has an even number of edges coming together.
- The path can have at most two nodes with an odd number of edges: the starting point and the endpoint.

Trees are graphs.
An undirected tree is a connected simple graph without cycles.
An undirected tree with $n$ nodes has $n - 1$ edges.
Adding another edge will create a cycle.
Removing any edge will make the graph unconnected.
Any node in the undirected tree can act as its root.
A spanning tree of graph $G = (V, E)$ is a tree that contains all nodes in $V$ and no edges that are not in $E$ .
A graph typically has multiple possible spanning trees.