---
class: mth302
---
# Miniproject 4
**Initial due date: Sunday, March 26 at 11:59pm ET**
## Overview
Eigenvalues of a matrix are incredibly useful and important for many applications. (Some of these applications are in Miniprojects 1-3.) But computing eigenvalues of a matrix, even of relatively small size, can be difficult or impossible to do exactly. So we need *numerical approximation methods* for most practical uses of eigenvalues. This miniproject will teach you one such method.
**Prerequisites:** You'll need to know what an eigenvalue and eigenvector for a matrix are, and how to find these using SymPy. You'll also need to know how to multiply matrices and vectors.
## Background
Complete the following warmup exercises first. These don't go in your writeup. They are just here to teach you some terminology you'll need in the main assignment.
>Definition: Suppose $A$ is an $n \times n$ matrix and $\lambda_1, \lambda_2, \dots, \lambda_n$ are its eigenvalues. Then $\lambda_1$ is called the **dominant eigenvalue** of $A$ if $|\lambda_1| > |\lambda_i|$ for all $i \neq 1$. The eigenvectors corresponding to $\lambda_1$ are called **dominant eigenvectors** of $A$.
**Example:** The matrix $A = \begin{bmatrix} -2 & 0 \\ 0 & 1 \end{bmatrix}$ has eigenvalues of $-2$ and $1$. Of these, $\lambda = -2$ is the dominant eigenvalue since $|-2| > |1|$. A dominant eigenvector for $A$ would be $[1,0]^T$ since that's an eigenvector corresponding to the dominant eigenvalue $\lambda = -2$.
**Example:** The matrix $A = \begin{bmatrix} -1 & 0 \\ 0 & 1 \end{bmatrix}$ doesn't have a dominant eigenvalue, since its two eigenvalues are $-1$ and $1$, and neither $|-1| > |1|$ nor $|1| > |-1|$.
**Exercise:** Find the dominant eigenvalue and a dominant eigenvector for
$$B = \left[\begin{matrix}11 & 0 & -4\\17 & -2 & -5\\30 & 0 & -11\end{matrix}\right]$$
*Answer:* $\lambda_1 = -2$ is the dominant eigenvalue and $\mathbf{v}_1 = [0,1,0]^T$ is a dominant eigenvector.
## Assignment
1. Suppose $A$ is a $100 \times 100$ matrix. This is actually considered "small" for most real-world applications. If we wanted to find its eigenvalues using the basic method we learned in class, we would need to solve the equation $\det(A - \lambda I_{100}) = 0$ for $\lambda$. How easy or hard would this be? Why?
The first problem illustrates the computational issues with using our basic method for finding eigenvalues. So rather than find the eigenvalues of a matrix algebraically, it's often enough to (1) find just the *dominant* eigenvalue, and (2) get a reasonable numerical approximation to it. The rest of this miniproject walks you through one method for doing this.
2. Let $A = \begin{bmatrix} -5 & 14 \\ 9 & 15 \end{bmatrix}$. Choose any nonzero vector in $\mathbb{R}^2$ and call it $\mathbf{x}_0$. Compute $\mathbf{x}_1 = A \mathbf{x}_0$.
3. Compute $\mathbf{x}_2 = A \mathbf{x}_1$. Notice, this is the same as $A \cdot A \cdot \mathbf{x}_0$ or $A^2 \mathbf{x}_0$.
4. Compute $\mathbf{x}_3 = A \mathbf{x}_2$, which is the same as $A^3 \mathbf{x}_0$.
5. The vectors you are computing are getting larger and larger in terms of their components, but how much is their overall *direction* changing? Take each of the vectors you computed ($\mathbf{x}_0, \mathbf{x}_1, \mathbf{x}_2, \mathbf{x}_3$) and find a **unit vector** that points in the same direction. ([Here is a short refresher on how to do this](https://www.youtube.com/watch?v=lHr0VCXmztI); make sure to turn your sound off!) And, see below for some SymPy notes on this.
6. Continue this process: For $i = 4, \dots, 10$, compute $A^i\mathbf{x}_0$ and then find a unit vector that points in the same direction.
7. You should notice that the results of your calculations seem to be stabilizing around a single unit vector. If this isn't apparent, check your work and/or do a few more iterations of this process. What is that unit vector?
8. Multiply the unit vector you found by the original matrix. Use the result to explain why the unit vector you found in the previous step is *approximately* an eigevector for the original matrix. What is the (approximate) eigenvalue associated with this approximate eigenvector?
9. Now use SymPy to find the exact values of the eigenvalues of $A$. Which one is dominant? Which of these eigenvalues did the method above produce? What was the percent error in your approximation?
10. Adapt the method from above to approximate the dominant eigenvalue and eigenvector for
$$B = \displaystyle \left[\begin{matrix}9 & -4 & 1 & 1\\0 & -3 & -4 & -3\\10 & -2 & -1 & -4\\-9 & 9 & 0 & -7\end{matrix}\right]$$
Be sure to fully explain your reasoning and show your code.
11. Use SymPy to find the exact value of the eigenvalues. The results will look like an explosion of math notation. So, after getting the exact values, run the following code to get approximations of the exact values:
```python=
for eigenvalue in B.eigenvals().keys():
print(N(eigenvalue))
```
This will print approximate values of the eigenvalues. Which one is dominant? What is the percentage error in your approximation?
## Notes on this Miniproject
**You will be really well served to use SymPy as much as possible on this miniproject.** You should be doing no work by hand; and moreover, tapping in to some of SymPy's capabilities will lighten your load considerably.
Here are some things you can do with SymPy that are relevant to this Miniproject.
- To raise a matrix to a power, use `**` just like we raise numbers or symbols to powers.
- Mathematically, to find the length of a vector, we compute $\sqrt{x_1^2 + x_2^2 + \cdots + x_n^2}$ where $x_1, x_2, \dots x_n$ are its components. But a more economical way to do it is to use the *dot product* and compute $\sqrt{\mathbf{v} \cdot \mathbf{v}}$. In SymPy, to find the dot product of the vector `a` with the vector `b`, enter `a.dot(b)`. To take the square root of an number $x$, enter `sqrt(x)`. You can put these functions together with what you already know how to do in SymPy to automate much of the math in question 5.
- SymPy works with *exact* values, but sometimes (like now) we need approximations. To convert an exact value to an approximation, wrap it in `N( )`. For example try `N(sqrt(5))`.
- Sometimes we want to print off a vector or a matrix *not* in its "pretty" form, but as plain text so it will not take up so much space. To do this in SymPy, just put `print( )` around the thing you want to display. For example, try `print(Matrix(2,2,[1,2,3,4]))`.
- The approximation method in this miniproject involves *iteration*, and computer languages are good at this. The `for` loop construction in Python is helpful. Here's an example of a `for` loop that would print off the squares of the numbers 1 through 100:
```python
for i in range(1,101):
print(i**2)
```
In Python, ranges stop *just before* the upper limit, so `range(1,101)` is 1, 2, 3, ..., 100.
## Submission and Grading
### Formatting and special items for grading
Please review the section on Miniprojects in the document [Standards For Student Work in MTH 302](https://github.com/RobertTalbert/linalg-diffeq/blob/main/course-docs/standards-for-student-work.md#standards-for-miniprojects) before attempting to write up your submission. Note that *all* Miniprojects:
- **Must be typewritten**. If any portion of the submission has handwritten work or drawings, it will be marked *Incomplete* and returned without further comment.
- **Must represent a good-faith effort at a complete, correct, clearly communicated, and professionally presented solution.** Omissions, partial work, work that is poorly organized or sloppily presented, or work that has numerous errors will be marked *Incomplete* and returned without further comment.
- **Must include clear verbal explanations of your work when indicated, not just math or code**. You can tell when verbal explanations are required because the problems say something like "Explain your reasoning".
Your work here is being evaluated *partially* on whether your math and code are correct; but just as much on whether your reasoning is correct and clearly expressed. Make sure to pay close attention to both.
Miniproject 3 **must be done in a Jupyter notebook using SymPy to carry out all mathematical calculations**. [A sample notebook, demonstrating the solution to a Calculus problem, can be found here](https://github.com/RobertTalbert/linalg-diffeq/blob/main/tutorials/Example_of_solution_in_a_notebook.ipynb). Study this first before writing up your work.
### How to submit
You will submit your work on Blackboard in the *Miniproject 4* folder under *Assignments > Miniprojects*. But you will *not* upload a PDF for Miniprojects. Instead you will **share a link that allows me (Talbert) to comment on your work**. [As explained in one of the Jupyter and Colab tutorials](https://gvsu.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=ef5c0e24-5c1d-437f-be05-af730108b6d8), the process goes like this:
1. In the notebook, click "Share" in the upper right.
2. **Do not share with me by entering my email.** Instead, go to *General Access*, and in the pulldown menu select "Anyone with the link", then set the permissions to "Commenter".
3. Then click "Copy Link".
4. **On Blackboard**, go to the *Assignments* area, then *Miniprojects*. Select Miniproject 4.
5. Under **Assignment Submission**, where it says *Text Submission*, click "Write Submission".
6. **Paste the link to your notebook in the text area that appears.**
7. Then click "Submit" to submit your work.
I will then evaluate your work using the link. Specific comments will be left on the notebook itself. General comments will be left on Blackboard.

Initial due date: Sunday, April 9 at 11:59pm ET Overview Our final miniproject reaches back into linear algebra to look at diagonalizable matrices and their uses in solving systems of differential equations. Prerequisites: You'll need to be able to solve basic systems of differential equations and find the eigenvalues and eigenvectors for a small matrix. You'll also need a basic comfort level with concepts of linear independence and matrix arithmetic from earlier in the course. Background This entire problem comes from Section 3.9.1 in your textbook. Here is a rephrased version of the introduction to that section.

3/29/2023Initial due date: Sunday, April 9 at 11:59pm ET Overview This miniproject will teach you about the Runge-Kutta method, a standard numerical solution technique for differential equations. Prerequisites: A strong grasp of Euler's Method for single DE's is needed. You will also need to be comfortable using a spreadsheet. Miniproject 6 (Euler's Method for systems) is also recommended. Background A description of the Runge-Kutta method along with an example is given in this tutorial. Read it carefully and make sure you can work along with the example before proceeding.

3/29/2023Initial due date: Sunday, April 9 at 11:59pm ET Overview This miniproject introduces a version of Euler's Method as a numerical solution technique for systems. Prerequisites: You will need to be comfortable with using Euler's method for single differential equations. You'll also benefit from some familiarity with spreadsheets or Python in order to automate the calculations. Background This tutorial gives you the background you need for this assignment. Please read it and make sure you understand the concepts and the example: https://github.com/RobertTalbert/linalg-diffeq/blob/main/assignments/Euler's_Method_for_Systems.ipynb

3/22/2023Initial due date: Sunday, March 12 at 11:59pm ET Overview In this miniproject, you'll apply concepts from linear algebra to study discrete dynamical systems. These are related to the idea of Markov chains that was the subject of Miniproject 1 and are the linear algebra analogue of systems of differential equations which we will study later. Prerequisites: You'll need to know what an eigenvalue and eigenvector for a matrix are, and how to find these using SymPy. This miniproject also requires some knowledge of matrix-vector multiplication. Background Complete the following before beginning this miniproject. These are not part of your writeup, but you'll need the knowledge before you can understand the tasks in the assignment.

2/21/2023
Published on ** HackMD**