# Section7.1Continuous Quantum Walks

One goal of this section is to introduce you to the joys of numerical linear algebra with Sage.

Suppose $A$ is the adjacency matrix of $X$. We define $H(t)=H_X(t)$ by

$H =\exp(iAt)$
We are concerned with the absolute values of the entries $H(t)$, and in particular want to know when we can have
$|H(\tau)_{u,v}| =1$
for some time $\tau$ and some vertices $u$ and $v$. Since $A$ is symmetric it has a spectral decomposition
$A =\sum_\th \th E_\th$
and consequently
$H(t) = \sum_\th \exp(i\th t)E_\th$

To use this formula we need an orthogonal basis for each eigenspace. The difficulty if that if we work in floating point, then we have to decide which eigenvalues are actually equal before we determine an eigenspace.

We are going to use scipy and numpy. It seems that numpy is basically an array package, which provides such things as $k$-dimensional arrays. (Computer scientists seem to think these are useful, I have no idea why.) Scipy builds on numpy, providing access to standard linear algebra routines (eigenthings, svd, etc.) There is on-line documentation for scipy and numpy, but it is not very good. (For example it illustrates how to solve linear equations by inverting the matrix of coefficients.) The syntax for scipy and numpy is not consistent with Sage, or with python.

Anyway, here is the opening incantation:

We will go through some simple computations, so you can get a feel for things.

Now with

we get the eigenvalues of $AP$ (in $\la$) and the eigenvectors (in $v$). The routine linalg.eigh takes a Hermitian matrix and returns real eigenvalues. Eigenvectors corresponding to distinct eigenvalues are orthogonal. Note that the eigenvectors are returned by linalg.eigh as numpy arrays, and there is a argument for wrapping it in a routine that immediately transforms them into Sage vectors.

We intend to make use of the fact that if the vectors $\seq z1m$ are an orthogonal basis for a subspace then the matrix representing projection onto the subspace is

$z_1z_1^T+\cdots+z_mz_m^T$
The problem is that our eigenvalues have been computed in floating point, and so we need a routine with arguments $\la$ and $\eps$ which divides the eigenvalues into equivalence classes, where two eigenvalues are equivalent if their difference is less than $\eps$. The output of the routine is a dictionary keyed on distinct eigenvalues and the entry with given eigenvalue is the set of indices of the eigenvalues equivalent to the key.

Given this it is straightforward to write the code that takes this dictionary and returns a list of pairs consisting of an eigenvalue and its associated projection.