MGM.09 Eigensense: Diagonalizable Matrices,
Matrix Exponential, Matrix Powers and Dynamical Systems
 BASICS

Needs["LinearAlgebra`MatrixManipulation`"];
Needs["Graphics`Colors`"];
Off[General::"spell"];
Off[General::"spell1"];
Off[ParametricPlot3D::"ppcom"];
Off[ParametricPlot::"ppcom"];
Off[Plot::"plnr"];
SetOptions[Limit, Analytic -> True];
$Pre = Chop;

CMView = {2.7, 1.6, 1.2};

Vector Drawer

\(\(\( (*\ \(\(:\)\(Date : \ \ Copyright\ 2001\)\), \ 
      Math\ Everywhere, \ \(\(Inc\)\(.\)\)\ 
*) \)\(
\)\( (*
Original\ Conception\ to\ create\ a\ vector\ drawer\ is\ due\ to\ Bill\ Davis . 
Current\ code\ is\ by\ Bruce\ \(\(Carpenter\)\(.\)\)
*) \)\(
\)\( (*\ \ \(\(\(:\)\(Drawbacks : \ \ Since\ the\ vectors\ are\ drawn\ out\ of\)\)\ 

      \ \ \ \ \ context\), \ 
      the\ shapes\ of\ the\ arrowheads\ are\ only\ 
\ \ \ \ \ correct\ with\ AspectRatio\ set\ to\ \(\(Automatic\)\(.\)\)
*) \)\)\)

BeginPackage["Vector3D`","Graphics`Colors`"];

Axes3D::usage = "Axes3D[a, b] creates a Graphics3D object of cartesian axes with x, y, and z running from -a/3 to a, and with axes labels b units beyond the tips of the axes.  Axes3D[a] is Axes3D[a, a/8].";

Perpend::usage = "Perpend[a] returns a unit vector which is perpendicular to the vector a.";

Arrow::usage = "Arrow[a] produces a 2 or 3 dimensional vector from the origin to a. Arrow[a, Tail -> tail] gives a vector from tail to a.";
	
Vector::usage = "Vector[a, b] gives a 2D or 3D vector from a to b.";

ArrowHead::usage = "ArrowHead[a, vec] produces an arrowhead with its tip placed at the point a, pointing in the direction of the vector vec.";

Tail::usage = "Tail -> point puts the tail of the vector at point.";

Norm::usage = "Norm[vec] returns the Euclidean length of vec.";

Normalize::usage = "Normalize[vec] returns a unit vector in the direction of vec, provided vec is nonzero.";

Aperture::usage = "Aperture is the ratio of the radius of the base to the length of the head of a vector.";

TipSize::usage = "TipSize specifies an absolute size for the inner tip length of the head of a vector.";

TipRatio::usage = "TipRatio is the ratio of the inner length of the arrowhead to the length of the shaft of a vector.";

HeadRatio::usage = "HeadRatio is the ratio of the outer length of the arrowhead to the length of the shaft of a vector.";

HeadSize::usage = "HeadSize specifies an absolute size for the head of a vector.";

ScaleFactor::usage = "ScaleFactor specifies the amount to scale a vector in length and may be either a number or a pure function.";

ZeroVectorPointSize::usage = "ZeroVectorPointSize is the size of the point used to represent a zero vector.";

Options[Vector] = Options[Arrow] = Options[ArrowHead] =
{HeadRatio -> 0.18, TipRatio -> 0.14, Aperture -> 0.3, ScaleFactor -> 1, HeadType -> Polygon, ShaftQ -> True, EdgesQ -> True, VectorColor -> RGBColor[0,0,1], ShaftWidth -> 0.005, ZeroVectorPointSize -> 0.01};
		
Begin["`Private`"];

SetOptions[ParametricPlot,AspectRatio -> Automatic];
SetOptions[Plot,AspectRatio -> Automatic];
SetOptions[Graphics,AspectRatio -> Automatic];

Axes3D[u_,v_] := 
      Graphics3D[{
            {Blue,Line[{{-u/3,0,0},{u,0,0}}]},
                    Text["x",{u + v,0,0}],
            {Blue,Line[{{0,-u/3,0},{0,u,0}}]},
                    Text["y",{0, u + v,0}],
            {Blue,Line[{{0,0,-u/3},{0,0,u}}]},
                    Text["z",{0,0,u + v}]}]; 
Axes3D[u_] := Axes3D[u,u/8];
				
Norm[a_?VectorQ] := N[Sqrt[a.a]];

Normalize[a_?VectorQ] := If[a.a == 0, a, a/Norm[a]];

Perpend[a_?VectorQ] := Normalize[{a[[2]],-a[[1]]}]/;Length[a]==2;

Perpend[a_?VectorQ]:=
    Normalize[If[a[[1]]==0,{1,0,0},{a[[2]],-a[[1]],0}]]/;
      Length[a]==3;
      
Base3D = Table[{Cos[2 k Pi/8.], Sin[2 k Pi/8.]},{k,0,8}]; 

Vector[from_?VectorQ, to_?VectorQ, opts___] := Module[
   {sq, sw, ht, hs, hr, tr, ap, sf, vc, zvps, diff = to - from, tip},
   {sq, sw, ht, hs, hr, ts, tr, ap, sf, vc, zvps} = {ShaftQ, ShaftWidth, HeadType, HeadSize, HeadRatio, TipSize, TipRatio, Aperture, ScaleFactor, VectorColor, ZeroVectorPointSize} /. {opts} /. Options[Vector];
   If[from==to, Return[Graphics[{PointSize[zvps],vc,Point[from]}]]];
   diff = If[NumberQ[N[sf]], sf diff, sf[diff]];
   tip = from + diff;
   If[NumberQ[hs], hr = hs/Norm[diff]; tr = 0.75 hr];
   If[NumberQ[ts], tr = ts/Norm[diff]];
   Graphics[{If[sq,{vc,Thickness[sw],Line[{from,tip - tr diff}]},{}],
      With[{trans = ap hr Norm[diff] Perpend[diff]},
      {vc, Thickness[sw], ht[{tip,
                   (tip - hr diff + trans),
                   (tip - tr diff),
                   (tip - hr diff - trans),tip}]}]}]
] /; Length[from]==Length[to]==2

Vector[from_?VectorQ, to_?VectorQ, opts___] := Module[
   {sq, eq, sw, hs, hr, tr,ap, sf, vc, zvps, diff = to - from, tip},
   {sq, eq, sw, hs, hr, ap, sf, vc, zvps} = {ShaftQ, EdgesQ, ShaftWidth, HeadSize, HeadRatio, Aperture, ScaleFactor, VectorColor, ZeroVectorPointSize} /. {opts} /. Options[Vector];
   If[from==to, Return[Graphics3D[{PointSize[zvps],vc,Point[from]}]]];
   diff = If[NumberQ[N[sf]], sf diff, sf[diff]];
   tip = from + diff;
   If[NumberQ[hs], hr = hs/Norm[diff]];
   tr = hr/2;
   Graphics3D[{If[sq,{vc,Thickness[sw],Line[{from,tip-tr diff}]},{}], If[eq, {}, EdgeForm[]], {SurfaceColor[vc],
      With[{temp = Perpend[diff]},
      Polygon[Append[#,tip]]& /@ Partition[(tip - hr diff + #)&/@((ap hr Norm[diff] Base3D) . {temp,Normalize[Cross[temp,diff]]}),2,1]]}}]
] /; Length[from]==Length[to]==3


Arrow[a_, Tail->b_, opts___] := Vector[b,a+b,opts]

Arrow[a_, opts___] := Vector[Table[0,{Length[a]}],a,opts]

ArrowHead[a_, b_, opts___] := Vector[a-b,a,ShaftQ->False,opts];

End[];

EndPackage[];
Null

Graphics`Colors`GosiaGreen = 
        RGBColor[0,  0.392187,  0];

ThreeAxes[u,v]

ThreeAxes[u_, v_] := 
        Graphics3D[{{Blue, Line[{{-u, 0, 0}, {u, 0, 0}}]}, 
            Text["x", {u + v, 0, 0}], {Blue, 
              Line[{{0, -u, 0}, {0, u, 0}}]}, 
            Text["y", {0, u + v, 0}], {Blue, 
              Line[{{0, 0, 0}, {0, 0, u}}]}, 
            Text["z", {0, 0, u + v}]}];
ThreeAxes[u_] := ThreeAxes[u, (u/8)];
ThreeAxes::"usage" = "ThreeAxes[a,b] makes a standard cartesian \
axis graphics object with x, y, and z running from -a to a, and with axis \
labels b units beyond the tips of the axes.  ThreeAxes[a] is \
ThreeAxes[a,a/8].";

Needs["Statistics`ContinuousDistributions`"];

Clear[matrixplucker];
matrixplucker[expr_, 
        vars_] := Simplify[
          Outer[D, {expr}, 
            vars]][[1]]

B.1) The kD diagonalizable matrices are those whose hits stretch or stretch and flip some basis of kD

B.1.a.i) Making a matrix that stretches basis vectors

Here's a basis of 2D:

Clear[spanner];
spanner[1]  =  {0.5, 0.3};
spanner[2]  =  {-0.7, 0.2};
basis  =  {spanner[1], spanner[2]}

See them:

\(\(ranger\  = \ 
        1.5\ Sqrt[
            Max[{spanner[1] . spanner[1], 
                spanner[2] . spanner[2]}]];\)
\)
\(\(basisplot\  = \ {Arrow[spanner[1], Tail -> {0, 0}, 
            VectorColor -> 
              CadmiumOrange], 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Arrow[spanner[2], Tail -> {0, 0}, 
            VectorColor -> NavyBlue]};\)\)
\(\(basislabels\  = \ {Graphics[{Black, 
              Text["spanner[1]", 
                0.5\ \ spanner[
                    1]]}], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Graphics[{Black, 
              Text["spanner[2]", 0.5\ \ spanner[2]]}]};\)\)
\(\(before\  = \ 
        Show[basisplot, 
          basislabels, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Before", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), 
                ranger}, {\(-ranger\), ranger}}];\)\)

As you can see, the vectors
          {spanner[1], spanner[2]} 
form a linearly independent set which spans all of 2D. 
In short,
          {spanner[1], spanner[2]} 
is a basis of 2D.
 Your job is to make a 2D matrix A so that
          A . spanner[1] = 2.0  spanner[1]
and
         A . spanner[2] = 1.3  spanner[2]

Go with the spanner matrix corresponding to this basis:

SpannerMatrix  =  Transpose[basis];
MatrixForm[SpannerMatrix]

The goal is to make a 2D matrix A so that
          A . spanner[1]=2.0 spanner[1]
and
         A . spanner[2]=1.3  spanner[
            2]
 Put:
         A=SpannerMatrix.(({{2.0, 0}, {0, 1.3}})). (SpannerMatrix^(-1)):

A = SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).Inverse[SpannerMatrix];
MatrixForm[A]

Check out whether
          A . spanner[1]=2.0  spanner[1]
and
         A . spanner[2]=1.3  spanner[2]:

A . spanner[1] == 2.0 spanner[1]
A . spanner[2] == 1.3 spanner[2]

This checks.
See it:

Show[before];
hitbasisplot = 
{Arrow[A . spanner[1],Tail -> {0, 0},VectorColor -> CadmiumOrange],Arrow[A . spanner[2],Tail -> {0, 0},VectorColor -> NavyBlue]};
\(hitbasislabels\  = \ {Graphics[{Black, 
              Text["A.spanner[1]", 
                0.5\ A . \ 
                    spanner[
                      1]]}], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Graphics[{Black, 
              Text["A.spanner[2]", 
                0.5\ \ A . spanner[2]]}]};\)
\(afer = \ 
        Show[hitbasisplot, 
          hitbasislabels, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, 
          AxesLabel -> {"x", "y"}, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotLabel -> "After hit with A", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}];\)

Do the same thing for a random basis of 2D:

Clear[spanner, 
        t];
spanner[1]  =  {Cos[t], Sin[t]} /. 
          t -> Random[
              Real, {-(π/4), (π/4)}];
spanner[
          2]  =  {Cos[t], Sin[t]} /. 
          t -> Random[
              Real, {(π/3) , 
                1.5 π}];
basis  =  {spanner[1], spanner[2]};
SpannerMatrix  =  Transpose[basis];
A = SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).Inverse[SpannerMatrix];
ranger  =  
          1.5 Sqrt[
              Max[{spanner[1] . spanner[1], spanner[2] . spanner[2]}]];

\(basisplot\  = \ {Arrow[spanner[1], Tail -> {0, 0}, 
            VectorColor -> 
              CadmiumOrange], 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Arrow[spanner[2], Tail -> {0, 0}, 
            VectorColor -> 
              NavyBlue]};\)
\(basislabels\  = \ {Graphics[{Black, 
              Text["spanner[1]", 
                0.5\ \ spanner[
                    1]]}], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Graphics[{Black, 
              Text["spanner[2]", 
                0.5\ \ spanner[2]]}]};\)
\(before\  = \ 
        Show[basisplot, 
          basislabels, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Before", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), 
                ranger}, {\(-ranger\), ranger}}];\)
hitbasisplot = 
{Arrow[A . spanner[1],Tail -> {0, 0},VectorColor -> CadmiumOrange],Arrow[A . spanner[2],Tail -> {0, 0},VectorColor -> NavyBlue]};
\(hitbasislabels\  = \ {Graphics[{Black, 
              Text["A.spanner[1]", 
                0.5\ A . \ 
                    spanner[
                      1]]}], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Graphics[{Black, 
              Text["A.spanner[2]", 
                0.5\ \ A . spanner[2]]}]};\)
\(afer = \ 
        Show[hitbasisplot, 
          hitbasislabels, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, 
          AxesLabel -> {"x", "y"}, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotLabel -> "After hit with A", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}];\)

B.1.a.ii) Why that worked

Why did that work?

Do another one:

Clear[spanner, 
        t];
spanner[1]  =  {Cos[t], Sin[t]} /. 
          t -> Random[
              Real, {-(π/4), (π/4)}];
spanner[
          2]  =  {Cos[t], Sin[t]} /. 
          t -> Random[
              Real, {(π/3) , 
                1.5 π}];
basis  =  {spanner[1], spanner[2]};
SpannerMatrix  =  Transpose[basis];
A = SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).Inverse[SpannerMatrix];
ranger  =  
          1.9 Sqrt[
              Max[{spanner[1] . spanner[1], spanner[2] . spanner[2]}]];

\(basisplot\  = \ {Arrow[spanner[1], Tail -> {0, 0}, 
            VectorColor -> 
              CadmiumOrange], 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Arrow[spanner[2], Tail -> {0, 0}, 
            VectorColor -> 
              NavyBlue]};\)
\(basislabels\  = \ {Graphics[{Black, 
              Text["spanner[1]", 
                0.5\ \ spanner[
                    1]]}], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Graphics[{Black, 
              Text["spanner[2]", 
                0.5\ \ spanner[2]]}]};\)
\(before\  = \ 
        Show[basisplot, 
          basislabels, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Before", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), 
                ranger}, {\(-ranger\), ranger}}];\)
Clear[
      hitbasisplot]
hitbasisplot[matrix_] := 
{Arrow[matrix . spanner[1],Tail -> {0, 0},VectorColor -> CadmiumOrange],Arrow[matrix . spanner[2],Tail -> {0, 0},VectorColor -> NavyBlue]};
\(hitbasislabels\  = \ {Graphics[{Black, 
              Text["A.spanner[1]", 
                0.5\ A . \ 
                    spanner[
                      1]]}], 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Graphics[{Black, 
              Text["A.spanner[2]", 
                0.5\ \ A . spanner[2]]}]};\)
\(afer = \ 
        Show[hitbasisplot[A], 
          hitbasislabels, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, 
          AxesLabel -> {"x", "y"}, 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotLabel -> "After hit with A", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}];\)

You put:
         A=SpannerMatrix.(({{2.0, 0}, {0, 1.3}})). (SpannerMatrix^(-1)):
See what the hit with (SpannerMatrix^(-1)) does to the basis vectors:

\(\(\(stage1\  = \ 
        Show[hitbasisplot[
            Inverse[SpannerMatrix]], 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> \*""Hit with (SpannerMatrix^(-1))"", 
		\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}];\)\(
\)\)\)

The hit with (SpannerMatrix^(-1)) aligns spanner[1] on the x-axis and aligns spanner[2] on the y-axis.

In fact,  (SpannerMatrix^(-1)).spanner[1] = {1, 0} and (SpannerMatrix^(-1)).spanner[2] = {0, 1}.

Inverse[SpannerMatrix] . spanner[1]

Inverse[SpannerMatrix] . spanner[2]

See what the hit with  (({{2.0, 0}, {0, 1.3}})). (SpannerMatrix^(-1))does to the basis vectors:

stage2 = Show[hitbasisplot[(({{2.0, 0}, {0, 1.3}})).Inverse[SpannerMatrix]],
		                               Axes -> True,AxesLabel -> {"x", "y"},\(PlotLabel -> \*""Hit with DiagonalMatrix.(SpannerMatrix^(-1))""\),
		                               PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}];

The hit with  (({{2.0, 0}, {0, 1.3}})). (SpannerMatrix^(-1))stretches  
\(by\ a\ factor\ of\ \ 2.5\ along\ the\ x - 
          axis\ and\ \ by\ a\ factor\ of\ 1.3\ along\ the\ y - 
          axis . 
				
See\ what\ the\ hit\ with\ \ A\)=  SpannerMatrix.(({{2.5, 0}, {0, 1.3}})). (SpannerMatrix^(-1))does to the basis vectors

stage3 = Show[hitbasisplot[SpannerMatrix.(({{2.5, 0}, {0, 1.3}})).Inverse[SpannerMatrix]],
	              Graphics[{Black, 
                Text["A.spanner[1]", 0.5 A .  spanner[1]]}],
                                       Graphics[{Black, Text["A.spanner[2]", 0.5  A .  spanner[2]]}],
		                               Axes -> True,AxesLabel -> {"x", "y"},PlotLabel -> "Hit with A",
		                               PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}];

The hit with SpannerMatrix hangs the result on the given basis.
Just for the heck of it, animate these two plots:

Show[before];
Show[stage3];

A . spanner[1] = 2.0  spanner[1]
and
         A . spanner[2] = 1.3 spanner[2]

You can also see why this works through formulas that correspond to the pictures above.
You go with the spanner matrix corresponding to the given basis:

And you put:
         A=SpannerMatrix.(({{2.0, 0}, {0, 1.3}})). (SpannerMatrix^(-1)):
When you hit A on spanner[1], you get
         A . spanner[1]  =SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).(SpannerMatrix^(-1)). spanner[1]

= SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).{1, 0}

=  SpannerMatrix.{2.0,0}

= 2.0 SpannerMatrix . {1, 0}
	
   =2.0  spanner[1].

So you are guaranteed that    A . spanner[1] = 2.0 spanner[1].

When you hit A on spanner[2], you get
         A . spanner[2] =SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).(SpannerMatrix^(-1)) ..spanner[2]
	             =    SpannerMatrix.(({{2.0, 0}, {0, 1.3}})).{0, 1}

=  SpannerMatrix.{0,1.3}

=  1.3SpannerMatrix . {0, 1}

= 1.3  spanner[2]

So you are guaranteed that
           A . spanner[2] = 1.3 spanner[2].

B.1.a.iii) Relation between aligners and hangers

Those plots hint strongly of the aligners and the hangers in earlier part of the course.
Is this an accident?
If not, what gives?

Answer:

Get ready.

The relationship is this:
If your given basis is a perpendicular frame (orthonormal), then 
->  SpannerMatrix is the hanger matrix  corresponding to the given perpendicular frame  and
->  (SpannerMatrix^(-1)) is the aligner matrix corresponding to the given perpendicular frame.

Try it out for a random 2D perpendicular frame:

Clear[perpframe];
s = Random[Real, {0, 2 π}];
\(\({perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + π\/2], 
            Sin[s + π\/2]}};\)
\)
basis = {perpframe[1], perpframe[2]}

SpannerMatrix = Transpose[basis];
aligner = {perpframe[1], perpframe[2]};
hanger = Transpose[{perpframe[1], perpframe[2]}];

SpannerMatrix == 
      hanger
Inverse[SpannerMatrix] == aligner

B.1.a.iv) Diagonalizable matrices

What is a diagonalizable matrix?

The matrix made in part i) is diagonalizable. 
More generally, a  diagonalizable matrix kD is any matrix A you can make by going with a basis
          {spanner[1], spanner[2], . . ., 
        spanner[k]} 
 of kD and going with numbers (positive,or negative or 0)
            s[1], s[2],  ... , s[k]
and putting
    A  = SpannerMatrix. (({{s[1], 0, 0, \(•\ •\ •\), 0}, {0, s[2], 0, \(•\ •\ •\), 0}, {0, 0, s[3], \(•\ •\ •\), 0}, {\(•\ •\ •\), • • •, • • •, \(•\ •\ •\), \(•\ •\ •\)}, {0, 0, 0, \(•\ •\ •\), s[k]}})) (SpannerMatrix^(-1))

In this case you are guaranteed that 
              A . spanner[j]=s[j] spanner[j] 
for all j = 1, 2, . . ., k. So that hits with A stretch or stretch and flip the basis vectors 
              spanner[1], spanner[2], . . ., 
      spanner[k]

B.1.a.v) Another sample

Here's a spanning set for a subspace S of 5D:

Clear[s, i, spanner];
spanner[1] = {3.43, -0.57, 8.19, -0.94, 0.78};
spanner[2] = {0.97, 1.29, 0.83, 5.23, 0.0};
spanner[3] = {-6.14, 
          3.08, -5.00, -1.97, -2.45};
spanner[4] = {0.0, 1.07, -2.10, 0.89, 2.51};
spanner[5] = {1.07, 0.0, 3.18, 1.73, 0.0};
\(\(spanners = Table[spanner[i], {i, 1, 5}];\)
\)
ColumnForm[spanners]

The dimension of S is:

SpannerMatrix = Transpose[spanners];
rank = 
      Length[SingularValues[
            SpannerMatrix][[2]]]

S is a five dimensional subspace of 5D; so S is all of 5D: 
And the spanning set consists of five vectors.
This is enough to tell you that 
           {spanner[1], spanner[2],  .   .   . , spanner[5]} 
is a basis for all of 5D.
Knowing this much, go ahead and make a 5D matrix A so that
         A . spanner[1]  =   2.5 spanner[1]A . spanner[2]  =   1.4 spanner[2]A . spanner[3]  = -2.0  spanner[3]A . spanner[4]  = -1.7 spanner[4]A . spanner[5]  =   0.0 spanner[5]

Answer:

Full speed ahead.
You want
           A . spanner[1]  =   2.5 spanner[1]A . spanner[2]  =   1.4 spanner[2]A . spanner[3]  = -2.0  spanner[3]A . spanner[4]  = -1.7 spanner[4]A . spanner[5]  =   0.0 spanner[5]

Put:

diagonalmatrix  =  
          DiagonalMatrix[{2.5, 1.4, -2.0, -1.7, 0.0}];
MatrixForm[
      diagonalmatrix]

Now put:

basis  =  spanners;
SpannerMatrix  =  Transpose[basis];
MatrixForm[
      SpannerMatrix]

The matrix A you are after is:

A = SpannerMatrix.diagonalmatrix.Inverse[SpannerMatrix];
MatrixForm[
      A]

Check whether
          A . spanner[1]  =   2.5 spanner[1] :

A.spanner[1]

2.5 spanner[1]

Check whether
          A . spanner[2]  =   1.4 spanner[2] :

A.spanner[2]

1.4 spanner[2]

Check whether
         A . spanner[3]  =   -2.0 spanner[3] :

A . spanner[3]

-2.0  spanner[3]

Check whether
          A . spanner[4]  = -1.7 spanner[4] :

A . spanner[4]

-1.7 spanner[4]

Check whether
          A . spanner[5]  =   0.0 spanner[5] :

A.spanner[5]

0.0 spanner[5]

Was there ever a doubt?

B.1.a.iv) Spanning set forms a basis

In part iii) above, there was a big deal made about whether the given spanning set was a basis for all of 5D. Why was this such a big deal?

You put:

A=SpannerMatrix.(({{2.5`, 0, 0, 0, 0}, {0, 1.39999999999999991`, 0, 0, 0}, {0, 0, -2.`, 0, 0}, {0, 0, 0, -1.7`, 0}, {0, 0, 0, 0, 0}})).(SpannerMatrix^(-1)).

The columns of the SpannerMatrix are the 5D vectors
          {spanner[1], spanner[2],  .   .   . , spanner[5]}.
 In order to be able to be sure that SpannerMatrix is invertible,
 -> You need the SpannerMatrix to hit on 5D (So that SpannerMatrix is a square matrix).This means you need five spanners.
→ You need the  SpannerMatrix to be of full rank. This means the columns of SpannerMatrix must be linearly independent.
 The result: You need
        {spanner[1], spanner[2],  .   .   . , spanner[5]}.
to be a basis of 5D.

B.2) Given a kD matrix A, a kD vector X is an eigenvector of A if A.X and X point in the same or opposite direction.
Using eigenvectors to find a basis that is stretched or stretched and flipped by a hit with a matrix.
Any kD diagonalizable matrix looks like this:

(({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})).(({{eigenval[1], 0, •••, 0}, {0, eigenval[2], •••, 0}, {•••, •••, •••, •••}, {0, 0, •••, eigenval[k]}})).(((({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})))^(-1))

Using eigenvectors to recognize non-diagonalizable matrices.

B.2.a.i) Eigenvalues and eigenvectors

Here is a 2D matrix A:

A = (({{2.1, 0.6}, {-0.1, 1.4}}));
MatrixForm[A]

Let Mathematica calculate the unit eigenvectors of A:

Clear[eigenvalue, eigenvector];
{eigenvector[1], eigenvector[2]}  =  Eigenvectors[A]

Look at these plots which show the calculated eigenvectors of A and what you get when you hit these eigenvectors  with A:

\(\(ranger = 
        Max[\(SingularValues[
              A]\)[[2]]];\)
\)
\(\(eigenplot = {Arrow[eigenvector[1], Tail -> {0, 0}, 
            VectorColor -> CadmiumOrange], 
          Arrow[eigenvector[2], Tail -> {0, 0}, 
            VectorColor -> NavyBlue]};\)
\)
\(\(labels = {Graphics[{Black, 
              Text["eigenvector[1]", 0.5\ eigenvector[1]]}], 
          Graphics[{Black, 
              Text["eigenvector[2]", 
                0.5\ eigenvector[2]]}]};\)
\)
\(\(Show[eigenplot, labels, Axes -> True, 
        AxesLabel -> {"x", "y"}, 
        PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}, 
        PlotLabel -> "Two eigenvectors"];\)
\)
\(\(hiteigenplot = {Arrow[A . eigenvector[1], Tail -> {0, 0}, 
            VectorColor -> CadmiumOrange], 
          Arrow[A . eigenvector[2], Tail -> {0, 0}, 
            VectorColor -> NavyBlue]};\)
\)
\(\(hitlabels = {Graphics[{Black, 
              Text["A.eigenvector[1]", 0.5\ A . eigenvector[1]]}], 
          Graphics[{Black, 
              Text["A.eigenvector[2]", 
                0.5\ A . eigenvector[2]]}]};\)
\)
Show[hiteigenplot, hitlabels, Axes -> True, 
        AxesLabel -> {"x", "y"}, 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "After hit with A"];

Look familiar?
Try another:

A = (({{1.7, 0.4}, {-0.2, -1.3}}));
MatrixForm[A]

Clear[eigenvalue, eigenvector];
{eigenvector[1], eigenvector[2]}  =  Eigenvectors[A]

\(\(ranger = 
        Max[\(SingularValues[
              A]\)[[2]]];\)
\)
\(\(eigenplot = {Arrow[eigenvector[1], Tail -> {0, 0}, 
            VectorColor -> CadmiumOrange], 
          Arrow[eigenvector[2], Tail -> {0, 0}, 
            VectorColor -> NavyBlue]};\)
\)
\(\(labels = {Graphics[{Black, 
              Text["eigenvector[1]", 0.5\ eigenvector[1]]}], 
          Graphics[{Black, 
              Text["eigenvector[2]", 
                0.5\ eigenvector[2]]}]};\)
\)
\(\(Show[eigenplot, labels, Axes -> True, 
        AxesLabel -> {"x", "y"}, 
        PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}, 
        PlotLabel -> "Two eigenvectors"];\)
\)
\(\(hiteigenplot = {Arrow[A . eigenvector[1], Tail -> {0, 0}, 
            VectorColor -> CadmiumOrange], 
          Arrow[A . eigenvector[2], Tail -> {0, 0}, 
            VectorColor -> NavyBlue]};\)
\)
\(\(hitlabels = {Graphics[{Black, 
              Text["A.eigenvector[1]", 0.5\ A . eigenvector[1]]}], 
          Graphics[{Black, 
              Text["A.eigenvector[2]", 
                0.5\ A . eigenvector[2]]}]};\)
\)
Show[hiteigenplot, hitlabels, Axes -> True, 
        AxesLabel -> {"x", "y"}, 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "After hit with A"];

What do these graphics tell you about eigenvectors of a matrix A?

Folks all across the planet say that vector X is an eigenvector of a matrix A if 
          A . X is a multiple of X.

In other words X is an eigenvector of A if 
          X and A.X point in the same or opposite directions.

This is the same as saying that a vector X is an eigenvector of a matrix A  if there is a number s so that
                         A . X=s X.
In this case, the same folks say that s is the eigenvalue of  A  associated with the eigenvector X .
Try it out for the matrix A immediately above:

Clear[eigenvalue, eigenvector];
{eigenvector[1], eigenvector[2]}  =  Eigenvectors[A]

{eigenvalue[1], eigenvalue[2]}  =  Eigenvalues[A]

\(\(\(
\)\(\(A\)\(.\)\(eigenvector[1]\)\(\ \)\)\)\)

eigenvalue[1] eigenvector[1]

\(\(\(
\)\(\(A\)\(.\)\(eigenvector[2]\)\(\ \)\)\)\)

eigenvalue[2] eigenvector[2]

B.2.a.ii) Using eigenvectors and eigenvalues to recognize diagonalizable matrices

Go with this 3D matrix A:

A = (({{3., -0.7, 1.3}, {-0.3, 2.1, 1.8}, {0.9, 1.6, -1.8}}));
MatrixForm[A]

Calculate the eigenvectors of A:

Clear[eigenvector];
spanners  =   Eigenvectors[A]

Calculate the dimension of the subspace of 3D spanned by the eigenvectors of A:

SpannerMatrix  =  Transpose[spanners];
eigendim  =  
      Length[SingularValues[SpannerMatrix][[2]]]

This tells you that the eigenvectors of A form a basis for all of 3D and that the spanner matrix is invertible.
Explain why this signals that A is diagonalizable.

To see that A is diagonalizable, you have to be able to duplicate A with a matrix of this form:
          SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1))
The SpannerMatrix you need is already available:

Clear[eigenvector];
spanners  =   Eigenvectors[A];
SpannerMatrix  =  Transpose[spanners];
MatrixForm[SpannerMatrix]

The diagonal matrix comes from the eigenvalues of A:

diagonalmatrix  =  DiagonalMatrix[Eigenvalues[A]];
MatrixForm[
      diagonalmatrix]

Here's a look at
          SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)):

MatrixForm[SpannerMatrix.diagonalmatrix.Inverse[SpannerMatrix]]

Here's a look at A:

MatrixForm[A]

The upshot:
         A = SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)):
So A is diagonalizable.

B.2.a.iii) Explanation: If you have a matrix A that hits on kD and hangs in kD so that the unit eigenvectors of A form a basis (linearly independent spanning set) for all of kD, then A is diagonalizable.
In fact Any kD diagonalizable matrix A looks like this:
(({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})).(({{eigenval[1], 0, •••, 0}, {0, eigenval[2], •••, 0}, {•••, •••, •••, •••}, {0, 0, •••, eigenval[k]}}))(((({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})))^(-1))

Why did that work and why will it work in any dimension?
Specifically: 
Go with a matrix A that hits on kD and hangs in kD so that the unit eigenvectors of A form a basis (linearly independent spanning set) for all of kD. 
Explain why A is guaranteed to be diagonalizable.

Go with a matrix A that hits on kD and hangs in kD so that the unit eigenvectors of A form a basis (linearly independent spanning set) for all of kD.

Arrange the eigenvectors into the SpannerMatrix with eigenvector[j] in the jth vertical column of SpannerMatrix.

SpannerMatrix = . (({{eigenvector[1], eigenvector[
                    2], eigenvector[
                    3], \(•\ •\ •\), eigenvector[k]}, {↓, ↓, ↓, \(•\ •\ •\), ↓}, {↓, ↓, ↓, \(•\ •\ •\), ↓}, {\(•\ •\ •\), • • •, • • •, \(•\ •\ •\), \(•\ •\ •\)}, {↓, ↓, ↓, \(•\ •\ •\), ↓}}))

And then you take the corresponding eigenvalues of A and make

        diagonalmatrix= DiagonalMatrix[{eigenvalue[1], eigenvalue[2],  ... , eigenvalue[k]}]

= . (({{eigenvalue[1], 0, 0, \(•\ •\ •\), 0}, {0, eigenvalue[2], 0, \(•\ •\ •\), 0}, {0, 0, eigenvalue[3], \(•\ •\ •\), 0}, {\(•\ •\ •\), • • •, • • •, \(•\ •\ •\), \(•\ •\ •\)}, {0, 0, 0, \(•\ •\ •\), eigenvalue[k]}}))

You put
         B=SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)). so that

B = (({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})).(({{eigenval[1], 0, •••, 0}, {0, eigenval[2], •••, 0}, {•••, •••, •••, •••}, {0, 0, •••, eigenval[k]}})).(((({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})))^(-1))

If you were around in B.1) you know that this results in
                    B . eigenvector[j]=eigenvalue[j]  eigenvector[j]
for all j = 1, 2,  ... , k.

But by the very nature of eigenvalues and eigenvectors of A, you know
           A . eigenvector[j]=eigenvalue[j]  eigenvector[
            j]
for all j = 1, 2,  ... , k.

And because
          {eigenvector[1], eigenvector[2], . . ., 
        eigenvector[k]}
 is a basis for all of kD, this tells you that 
           A . X = B . X
for all X in kD. And this is enough to tell you that 
           B = A.
And because
 B = SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1)),
you get
 A = SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1)).
 So A is guaranteed to be diagonalizable.

B.2.a.iv) Using eigenvectors and eigenvalues to recognize  matrices that are not diagonalizable

Go with this 2D matrix A:

A = (({{1.0, 1.0}, {0.0, 1.0}}));
MatrixForm[A]

Calculate the eigenvectors of A:

Clear[eigenvector];
spanners  =   Eigenvectors[A]

Calculate the dimension of the subspace of 2D spanned by the eigenvectors of A:

SpannerMatrix  =  Transpose[spanners];
eigendim  =  
      Length[SingularValues[SpannerMatrix][[2]]]

This tells you that the eigenvectors of A do NOT form a basis for all of 2D. 
Explain why this signals that A is not diagonalizable.

For a matrix A to diagonalizable, you have to be able to duplicate A with a matrix of this form:
        A =   (({{eigenvector[1], eigenvector[2]}, {↓, ↓}})).(({{eigenvalue[1], 0}, {0, eigenvalue[2]}})).(({{eigenvector[1], eigenvector[2]}, {↓, ↓}}))\( . \^\(-1\)\)

The trouble here is that (({{eigenvector[1], eigenvector[2]}, {↓, ↓}})) is not invertible because its columns are not linearly independent.

B.3) Functions of diagonalizable matrices.
If 
A = (({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})).(({{eigenval[1], 0, •••, 0}, {0, eigenval[2], •••, 0}, {•••, •••, •••, •••}, {0, 0, •••, eigenval[k]}})).(((({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})))^(-1)),
 then
f[A] = (({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})).(({{f[eigenval[1]], 0, •••, 0}, {0, f[eigenval[2]], •••, 0}, {•••, •••, •••, •••}, {0, 0, •••, f[eigenval[k]]}})).(((({{eigenvect[1], eigenvect[2], •••, eigenvect[k]}, {↓, ↓, •••, ↓}, {•••, •••, •••, •••}, {↓, ↓, •••, ↓}})))^(-1)).
The matrix exponential (E^( At)) for a diagonalizable matrix A.
The derivative with respect to t of (E^(A t)) is  A . (E^(A t))

B.3.a.i) Hitting a diagonalizable matrix with a function f[x] .

How do you apply a function f[x] such as 
          f[x] = (x^2)
          f[x] = (x^6)
          f[x] = 1/x
          f[x] =Sin[x]
  to a diagonalizable matrix?

Here's a 3D matrix A:

A = (({{1.40, 0.66, -1.10}, {0.57, 0.68, -3.06}, {-0.81, -3.08, -2.53}}));
MatrixForm[A]

Check whether A is diagonalizable:

spanners  =   Eigenvectors[A];
SpannerMatrix  =  Transpose[spanners];
eigendim  =  
      Length[SingularValues[SpannerMatrix][[2]]]

Good. A has three linearly independent eigenvectors and this signals that A is diagonalizable.
The diagonal matrix comes from the eigenvalues of A:

diagonalmatrix  =  DiagonalMatrix[Eigenvalues[A]];
MatrixForm[diagonalmatrix]

Here's a look at
          SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1)):

MatrixForm[
      SpannerMatrix . diagonalmatrix . Inverse[SpannerMatrix]]

Here's a look at A:

MatrixForm[A]

Good. A is diagonalizable.

To calculate A, you multiply out
   
  SpannerMatrix.(({{-4.45082773635864192`, 0, 0}, {0, 3.09764458183442759`, 0}, {0, 0, 0.823183154524218529`}})).(SpannerMatrix^(-1)):
To calculate f[A], you multiply out
      
   SpannerMatrix.(({{f[-4.45082773635864192`], 0, 0}, {0, f[3.09764], 0}, {0, 0, f[0.823183]}})).(SpannerMatrix^(-1)):


That's all there is to it. 
The advantage of working with diagonalizable matrices is:
You can apply functions to diagonalizable matrices with almost no work.

Try it out by calculating A.A this way:

Clear[f, x];
f[x_]  =  (x^2);
fdiagonalmatrix = DiagonalMatrix[Map[f,Eigenvalues[A]]];
fA = SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix];
MatrixForm[
      fA]

Compare:

MatrixForm[A . A]

Nailed it.
Try it out by calculating A.A.A.A.A.A this way:

Clear[f, x];
f[x_]  =  (x^6);
fdiagonalmatrix = DiagonalMatrix[Map[f,Eigenvalues[A]]];
fA = SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix];
MatrixForm[
      fA]

Compare:

MatrixForm[A . A . A . A . A . A ]

Nailed it again.
Try it out by calculating (A^(-1)) this way:

Clear[f, x];
f[x_]  = (1/x);
fdiagonalmatrix = DiagonalMatrix[Map[f,Eigenvalues[A]]];
fA = SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix];
MatrixForm[
      fA]

Compare:

MatrixForm[Inverse[A]]

It looks like you're onto something.
Hell, you can even calculate the Sine of A:

Clear[f, x];
f[x_]  = Sin[x];
fdiagonalmatrix = DiagonalMatrix[Map[f,Eigenvalues[A]]];
fA = SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix];
MatrixForm[
      fA]

Nothing can stop you.

B.3.a.ii) The matrix exponential  (E^(A t))

Here's a 2D matrix A:

A = (({{2.0, -0.3}, {-0.5, 1.7}}));
MatrixForm[A]

The diagonal matrix comes from the eigenvalues of A:

diagonalmatrix  =  DiagonalMatrix[Eigenvalues[A]];
MatrixForm[diagonalmatrix]

Here's a look at
          SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1)):

spanners  =   Eigenvectors[A];
SpannerMatrix  =  Transpose[spanners];
MatrixForm[
      SpannerMatrix . diagonalmatrix . Inverse[SpannerMatrix]]

Compare:

MatrixForm[A]

Good. A is diagonalizable.
Use what you see to calculate
               (E^( A t)) and Sin[At].

To calculate A, you multiply out
   
  SpannerMatrix.(({{2.26533119314590347`, 0}, {0, 1.43466880685409625`}})).(SpannerMatrix^(-1)):
  
To calculate (E^(A t)), you multiply out
      
   SpannerMatrix.(({{(E^(2.26533 t)), 0}, {0, (E^(1.43467 t))}})).(SpannerMatrix^(-1))

Here's some code:

Clear[f, x, t];
f[x_]  =  (E^(x t));
fdiagonalmatrix  =  
        DiagonalMatrix[Map[f, Eigenvalues[A]]];
fA  =  
        SpannerMatrix . fdiagonalmatrix . Inverse[SpannerMatrix];
MatrixForm[fA]

Check with Mathematica:

MatrixForm[MatrixExp[A t]]

Nailed it.

Calculate Sin[A t] this way:

Clear[f, x];
f[x_]  =  Sin[x t];
fdiagonalmatrix  =  
        DiagonalMatrix[Map[f, Eigenvalues[A]]];
fA  =  
        SpannerMatrix . fdiagonalmatrix . Inverse[SpannerMatrix];
MatrixForm[fA]

Mathematica has no built in function that calculates Sin[A t]; so you can't check whether this one is correct.
You can take this on faith or you can go onto the next part to see why this procedure is guaranteed to work for you.:

B.3.a.iii) Why it works

Why is the procedure used above guaranteed to work on all diagonalizable matrices?

Here's the idea in 2D: The same idea (with more writing) works in all dimensions.
A 2D diagonalizable matrix A is of the form

  A =SpannerMatrix.(({{eigenvalue[1], 0}, {0, eigenvalue[2]}})).(SpannerMatrix^(-1))
 
 Just to keep everything from bouncing off the screen, use this shorthand:
            SM = SpannerMatrix
            e[1] = eigenvalue[1]
            e[2] = eigenvalue[2].
            
In this shorthand,a  2D diagonalizable matrix A is of the form
             A = SM.(({{e[1], 0}, {0, e[2]}})).(SM^(-1)).
This gives:
          
A . A= SM.(({{e[1], 0}, {0, e[2]}})).(SM^(-1)). SM.(({{e[1], 0}, {0, e[2]}})).(SM^(-1))
         
             = SM.(({{e[1], 0}, {0, e[2]}})).(({{e[1], 0}, {0, e[2]}})).(SM^(-1)).

So
   A.A = SM.(({{e[1], 0}, {0, e[2]}})).(({{e[1], 0}, {0, e[2]}})).(SM^(-1))
   
           = SM.(({{((e[1])^( 2)), 0}, {0, ((e[2])^( 2))}})).(SM^(-1))

This explains why when you go with f[x] = (x^2), then you are guaranteed that

             A.A =  SM.(({{f[e[1]], 0}, {0, f[e[2]]}})).(SM^(-1)).
             
 To see why when you go with f[x] = (x^3), then you are guaranteed that

             A.A.A =  SM.(({{f[e[1]], 0}, {0, f[e[2]]}})).(SM^(-1)),
 calculate
             A . A . A
		  =A . (A . A) 
			= SM.(({{e[1], 0}, {0, e[2]}})).(SM^(-1))SM.(({{e[1]^2, 0}, {0, e[2]^2}})).(SM^(-1))
		 
       = SM.(({{e[1], 0}, {0, e[2]}})).(({{e[1]^( 2), 0}, {0, e[2]^( 2)}})).(SM^(-1))
			
        = SM.(({{e[1]^( 3), 0}, {0, e[2]^( 3)}})).(SM^(-1)) 
        = SM.(({{f[e[1]], 0}, {0, f[e[2]]}})).(SM^(-1))

The same ideas (but more writing) explain why the method performs as it should for all power functions f[x] = (x^k).  And because other functions normally used in science and engineering such as 
              (E^x), Sin[x], Cos[x], (1/x), etc.
can be built from combinations of power functions (expansions in powers of x, Taylor series, etc.), the method is guaranteed to work for these functions as well.

B.3.a.iv) The derivative with respect to t of (E^((A t))) is  A . (E^((A t))) .

Given a diagonalizable matrix A, the derivative with respect to t of 
       (E^((A t))) 
is
       A . (E^((A t))) .
Explain this juicy fact.

Answer:

Here's the idea in 2D: The same idea (with more writing) works in all dimensions.
A 2D diagonalizable matrix A is of the form

  A =SpannerMatrix.(({{eigenvalue[1], 0}, {0, eigenvalue[2]}})).(SpannerMatrix^(-1))
 
 Just to keep everything from bouncing off the screen, use this shorthand:
            SM = SpannerMatrix
            e[1] = eigenvalue[1]
            e[2] = eigenvalue[2].
            
In this shorthand, a  2D diagonalizable matrix A is of the form
             A = SM.(({{e[1], 0}, {0, e[2]}})).(SM^(-1)).
This gives:
            A t = t SM.(({{e[1], 0}, {0, e[2] }})).(SM^(-1))=  SM.(({{t e[1], 0}, {0, t e[2] }})).(SM^(-1))
         
So.
             (E^(A t))=SM.(({{(E^(t e[1])), 0}, {0, (E^(t e[2]))}})).(SM^(-1)).
Differentiate with respect to t to get
             D[(E^(A t)), t]=SM.(({{D[(E^(t e[1])),t], 0}, {0, D[(E^(t e[2])),t]}})).(SM^(-1))

= SM.(({{e[1](E^(t e[1])), 0}, {0, e[2](E^(t e[2] ))}})).(SM^(-1))

= SM.(({{e[1], 0}, {0, e[2]}})).(({{(E^(t e[1])), 0}, {0, (E^(t e[2] ))}})).(SM^(-1))

= SM.(({{e[1], 0}, {0, e[2]}}))(((SM))^(-1)) . SM.(({{(E^(t e[1])), 0}, {0, (E^(t e[2] ))}}))(SM^(-1))

= SM.(({{e[1], 0}, {0, e[2]}})). (SM^(-1))   .SM.(({{(E^(t e[1])), 0}, {0, (E^(t e[2] ))}}))(SM^(-1))

=   A. (E^(A t))

And you're out of here.

B.4) The Mathematica instruction MatrixExp[A] for calculating (E^(A ))quickly without going to the trouble of calculating eigenvalues and eigenvectors.

How you can calculate (E^A)  via series in the case that A is not diagonalizable

B.4.a)  Using MatrixExp[A] to calculating (E^(A )) without going to the trouble of calculating eigenvalues and eigenvectors

Here's a random 2D matrix A:

A = (({{Random[Real, {-2, 2}], Random[Real, {-2, 2}]}, {Random[Real, {-2, 2}], Random[Real, {-2, 2}]}}));
MatrixForm[A]

Now look at this:

Clear[B, t];
B =  MatrixExp[A t];
MatrixForm[B]

What is this new matrix?

It is (E^(A t)).
If you feed a matrix A t  into the Mathematica instruction MatrixExp[], Mathematica tries to calculate (E^(A t)). 
This is all to your advantage because you can use this instruction to calculate (E^(A t)) without going to the trouble of calculating the eigenvalues and eigenvectors of A.

B.4.a.ii)  Sometimes MatrixExp[ ] balks

Does the Mathematica MatrixExp instruction ever fail?

Not usually, but you can get strange output when you enter the matrix using exact fractions or integers. See this happen:

A = (({{1, -1}, {(3/2), -(3/4)}}));
MatrixForm[
      MatrixExp[A]]

Yuck. Looks bad and feels worse.
You will get agreeable results when you enter the matrix through decimal entries like this:

decimalA = N[(({{1, -1}, {(3/2), -(3/4)}}))];
MatrixForm[
      decimalA]

Now look at the calculation of (e^A):

MatrixForm[MatrixExp[decimalA]]

Sweet and nice.

B.4.b.i) In the rare situations in which A is not diagonalizable, you can use a series

If A is not diagonalizable, how can you do an approximate calculation of  (E^A)?

You can perturb the matrix A a bit or you can go to series approximations.
It's not a lot of fun, but it can be done. 
Take a non-diagonalizable A:

A  =  {{0.5, 0.5}, {-0.5, 1.5}};
MatrixForm[A]

This matrix is not diagonalizable because its eigenvectors are not linearly independent:

Eigenvectors[A]

To try to calculate (E^A), start with a series approximation of (E^x):

khigh  =  5;
Clear[x, k];
\(	Eseries\  = \ Normal[Series[E^x, {x, 0, khigh}]]\)

This  is the same as:

1 + (∑_(k = 1)^khigh) ((x^k)/(k!))

To approximate (E^A), change 1 to the identity matrix and change each (x^k)to MatrixPower[A,k]:

approx  = 
        IdentityMatrix[
            2]  +   (∑_(k = 1)^khigh) MatrixPower[A, k]/(k!);
MatrixForm[approx]

Compare:

MatrixForm[MatrixExp[A]]

Not too bad. If you want a better approximation, just raise khigh:

khigh  =  25;
approx  = 
        IdentityMatrix[
            2]  +   (∑_(k = 1)^khigh) MatrixPower[A, k]/(k!);
MatrixForm[approx]

Compare:

MatrixForm[MatrixExp[A]]

B.4.b.ii) The advantage you get when you work with a diagonalizable matrix

What advantage do you get when you work with a diagonalizable matrix ?

You don't have to fool around with perturbations or with series approximations.

B.5) Real eigenvalues of A reveal how (E^(A t)) . X plots out as t gets large
 Eigenvalues and eigenvectors of A reveal the ultimate direction of (E^(A t)) . X as t gets large

B.5.a.i)  If A has two negative eigenvalues, then (E^(A t)).X  ⟶{0,0} as t gets large

Here's a 2D matrix A:

A = (({{-1.76, 1.11}, {0.90, -0.75}}));
MatrixForm[A]

Here are six random points
        {starter[1], starter[2], starter[3], starter[4], starter[5], 
        starter[6]} 
in 2D :

\(\(Clear[pointer, \ trajectoryplot, eigenplot, scaler, eigenvector, 
        starter, thigh, k, j];\)
\)
\(\(trajectoryplot[thigh_, starter_]\  := \ 
        ParametricPlot[MatrixExp[A\ t] . starter, {t, 0, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          DisplayFunction -> Identity];\)

\)
\(\(pointer[thigh_, starter_]\  := \ 	ArrowHead[
          MatrixExp[A\ \ thigh]\  . 
            starter, \((D[MatrixExp[A\ t], t] /. t -> thigh)\)\  . 
            starter, \ 
			\ \ \ \ \ \ \ \ HeadSize -> 0.6, 
          VectorColor -> Black, Aperture -> 0.4];\)
\)
\(\(starterplots\  = \ 
        Table[Graphics[{NavyBlue, PointSize[0.03], Point[starter[j]]}], {j, 
            1, 6}];\)\ 
\)
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
          Random[Real, {-10, -4}]};
starter[5] =  {Random[Real, {-10, -4}], 0};
\(\(starter[6] = \ {Random[Real, {4, 10}], 0};\)
\)
thigh  =  0.01;
\(\(Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}]\ , 
        starterplots, PlotLabel -> "Starting points", 
        DisplayFunction -> $DisplayFunction];\)
\)

Here is how the curves
 \(E\^\(A\ t\) . starter[1], E\^\(A\ t\) . starter[2], 
      E\^\(A\ t\) . starter[3], 
E\^\(A\ t\) . starter[4], 
      E\^\(A\ t\) . starter[5], E\^\(A\ t\) . starter[6]\)
plot out as t advances from 0 to 1.5

thigh  =  1.5;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 4:

thigh  =  4;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

And here's what happens as t advances from 0 to 6:

thigh  =  6;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

This isn't as scary as it looks.
See what happens as t advances from 0 to 10:

thigh  =  10;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 20:

thigh  =  20;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Eventually all the plots head to {0,0} and stall at {0,0}.
Now look at the eigenvalues of A:

Eigenvalues[A]

Both negative. 
Explain this statement:
If A is any diagonalizable matrix and both its eigenvalues are negative, then no matter what X is, you are guaranteed that the plot of
          (E^(A t)) . X
heads to {0,0} and stalls at {0,0}.

Arrange the eigenvectors of A into the SpannerMatrix with eigenvect[1]in the leftmost vertical column and eigenvect[2] in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.	(({{eigval[1], 0}, {0, eigval[2]}})).(SpannerMatrix^(-1)).
This gives 
        (E^(A t))=SpannerMatrix.	(({{(E^(eigval[1] t)), 0}, {0, (E^(eigval[2] t))}})).(SpannerMatrix^(-1))
And
        (E^(A t)) . X = SpannerMatrix.	(({{(E^(eigval[1] t)), 0}, {0, (E^(eigval[2] t))}})).(SpannerMatrix^(-1)).X.
Because eigenval[1] < 0 and eigenval[2] < 0, the functions involved ((E^(eigval[1] t)) and (E^(eigval[2] t))) both go to 0 as t gets large. The result:
          (E^(A t)) . X -> SpannerMatrix.(({{0, 0}, {0, 0}})).(SpannerMatrix^(-1)).X = {0, 0} 
 as t gets large.

B.5.a.ii)  If A has two positive eigenvalues, then ||(E^(A t)) . X|| ⟶ ∞  as t gets large

Here's a new 2D matrix A:

A = (({{0.84, -0.10}, {-0.20, 0.40}}));
MatrixForm[A]

Here are six random points
        {starter[1], starter[2], starter[3], starter[4], starter[5], 
        starter[6]} 
in 2D :

\(\(Clear[pointer, \ trajectoryplot, eigenplot, scaler, eigenvector, 
        starter, thigh, k, j];\)
\)
\(\(trajectoryplot[thigh_, starter_]\  := \ 
        ParametricPlot[MatrixExp[A\ t] . starter, {t, 0, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          DisplayFunction -> Identity];\)

\)
\(\(pointer[thigh_, starter_]\  := \ 	ArrowHead[
          MatrixExp[A\ \ thigh]\  . 
            starter, \((D[MatrixExp[A\ t], t] /. t -> thigh)\)\  . 
            starter, \ 
			\ \ \ \ \ \ VectorColor -> Black, 
          Aperture -> 0.4];\)
\)
\(\(starterplots\  = \ 
        Table[Graphics[{NavyBlue, PointSize[0.03], Point[starter[j]]}], {j, 
            1, 6}];\)\ 
\)
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
          Random[Real, {-10, -4}]};
starter[5] =  {Random[Real, {-10, -4}], 0};
\(\(starter[6] = \ {Random[Real, {4, 10}], 0};\)
\)
thigh  =  0.01;
\(\(Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}]\ , 
        starterplots, PlotLabel -> "Starting points", 
        DisplayFunction -> $DisplayFunction];\)
\)

Here is how the curves
 \(E\^\(A\ t\) . starter[1], E\^\(A\ t\) . starter[2], 
      E\^\(A\ t\) . starter[3], 
E\^\(A\ t\) . starter[4], 
      E\^\(A\ t\) . starter[5], E\^\(A\ t\) . starter[6]\)
plot out as t advances from 0 to 1.5:

thigh  =  1.5;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 3.0:

thigh  =  3.0;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

And here's what happens as t advances from 0 to 7.0:

thigh  =  7.0;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Eventually all the plots head away from {0,0} and try to run off the screen.
Now look at the eigenvalues of A:

Eigenvalues[A]

Both positive. 
Explain this statement:
If A is any diagonalizable matrix and both its eigenvalues are positive, then as long as X ≠ {0,0}, you are guaranteed that, as t gets large,
           ||(E^(A t)) . X|| ⟶ ∞.

Arrange the eigenvectors of A into the SpannerMatrix with eigenvect[1]in the leftmost vertical column and eigenvect[2] in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.(({{eigval[1], 0}, {0, eigval[2]}})).(SpannerMatrix^(-1)).

This gives 
        (E^(A t))=SpannerMatrix.(({{(E^(eigval[1] t)), 0}, {0, (E^(eigval[2] t))}})).(SpannerMatrix^(-1))

And
        (E^(A t)) . X = SpannerMatrix.(({{(E^(eigval[1] t)), 0}, {0, (E^(eigval[2] t))}})).(SpannerMatrix^(-1)).X.

Because eigenval[1] > 0 and eigenval[2] > 0, the functions involved ((E^(eigval[1] t)) and (E^(eigval[2] t))) both become huge as t gets large. The result: 
Unless X = {0,0},

||(E^(A t)) . X|| ⟶ ∞

as t gets large.

B.5.b.i) Eigenvalues and eigenvectors of A reveal the ultimate direction of (E^(A t)) . X as t gets large

Here's a 2D matrix A:

A = (({{1.8, 0.1}, {-0.4, 1.1}}));
		MatrixForm[A]

Here are six random points
        {starter[1], starter[2], starter[3], starter[4], starter[5], 
        starter[6]} 
in 2D shown with scaled versions of the eigenvectors of A:

\(\(Clear[trajectoryplot, eigenplot, scaler, eigenvector, starter, thigh, 
        k, j];\)
\)
trajectoryplot[thigh_, starter_]  :=  
        ParametricPlot[MatrixExp[A t] . starter, {t, 0, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          DisplayFunction -> Identity];
\(\(starterplots\  = \ 
        Table[Graphics[{Blue, PointSize[0.03], Point[starter[j]]}], {j, 1, 
            6}];\)\ 
\)
\(scaler[
        thigh_] := \ 
	\(\(0.9\)\(\ \)\(Sqrt[\((MatrixExp[A\ thigh] . 
                starter[1])\) . \((MatrixExp[A\ thigh] . 
                starter[1])\)]\)\(
\)\)\)
{eigenvector[1], eigenvector[2]}  =  Eigenvectors[A];
\(\(eigenplot[khigh_, 
          j_] := \ 
\ \ \ \ \ \ \ \ \ {Arrow[scaler[khigh]\ eigenvector[j], 
            Tail -> {0, 0}, 
            VectorColor -> 
              Black], 
\ \ \ \ \ \ \ \ \ \ \ Arrow[\(-scaler[
                  khigh]\)\ \ eigenvector[j], Tail -> {0, 0}, 
            VectorColor -> Black]};\)
\)
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
          Random[Real, {-10, -4}]};
starter[5] =  {Random[Real, {-10, 0}], 0};
\(\(starter[6] = \ {Random[Real, {0, 10}], 0};\)
\)
thigh  =  0.01;
\(\(Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}]\ , 
        starterplots, eigenplot[thigh, 1], eigenplot[thigh, 2], 
        PlotLabel -> "Starting points with scaled eigenvectors", 
        DisplayFunction -> $DisplayFunction];\)
\)

Here's how the curves
 \(E\^\(A\ t\) . starter[1], E\^\(A\ t\) . starter[2], 
      E\^\(A\ t\) . starter[3], 
E\^\(A\ t\) . starter[4], 
      E\^\(A\ t\) . starter[5], E\^\(A\ t\) . starter[6]\)
plot out as t advances from 0 to 0.5 shown with scaled eigenvectors of A:

thigh  =  0.5;
ranger  =  scaler[thigh];
Show[
        Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , starterplots, 
        eigenplot[thigh, 1], eigenplot[thigh, 2], 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "Trajectories with scaled eigenvectors", 
        DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 1.2:

thigh  =  1.2;
ranger  =  scaler[thigh];
Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , 
        starterplots, eigenplot[thigh, 1], eigenplot[thigh, 2], 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "Trajectories with scaled eigenvectors", 
        DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 2.0:

thigh  =  2.0;
ranger  =  scaler[thigh];
Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , 
        starterplots, eigenplot[thigh, 1], eigenplot[thigh, 2], 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "Trajectories with scaled eigenvectors", 
        DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 5.0:

thigh  =  5.0;
ranger  =  scaler[thigh];
Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , 
        starterplots, eigenplot[thigh, 1], eigenplot[thigh, 2], 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "Trajectories with scaled eigenvectors", 
        DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 10.0:

thigh  =  10.0;
ranger  =  scaler[thigh];
Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , 
        starterplots, eigenplot[thigh, 1], eigenplot[thigh, 2], 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "Trajectories with scaled eigenvectors", 
        DisplayFunction -> $DisplayFunction];

As t gets large, the curves
           E^(A t) . starter[j] 
seem to shy away from one of the eigenvectors and to gravitate to the line through {0,0} defined by the ultimate eigenvector.
How do you identify the ultimate eigenvector?

Look at the eigenvectors of A:

Clear[eigenvector];
{eigenvector[1], eigenvector[2]}  =  Eigenvectors[A]

Look at the eigenvalues:

Clear[eigenvalue];
{eigenvalue[1], eigenvalue[2]}  =  Eigenvalues[A]

Note that
          eigenvalue[1] > eigenvalue[2].

This means that as t gets large the plots of
            (E^(A t)) . starter[j] 
are eventually attracted to the line through {0, 0} defined by eigenvector[1] .
See it happen in this plot which displays only the line through {0, 0} defined by eigenvector[1].

thigh  =  20.0;
ranger  =  scaler[thigh]; 
    Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , starterplots, 
      eigenplot[thigh, 1], 
      PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
      PlotLabel -> "Trajectories with ultimate eigenvector", 
      DisplayFunction -> $DisplayFunction];

As t gets large, the plots of
           (E^(A t)) . starter[j]  
 just laugh at the line through {0,0} defined by eigenvector[2]:

thigh  =  20.0;
ranger  =  scaler[thigh]; 
    Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , starterplots, 
      eigenplot[thigh, 2], 
      PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
      PlotLabel -> "Trajectories with non-ultimate eigenvector", 
      DisplayFunction -> $DisplayFunction];

This happens because 
        eigenvalue[1] > eigenvalue[2].   

There is one theoretical exception: If starter[j] is an exact multiple of eigenvector[2], then the curves (E^(A t))  .  starter[j] stay on the line through {0,0} defined by eigenvector[2].
 See this happen:

starter[1] =  20  eigenvector[2];
starter[2] =  -20 eigenvector[2];
starter[3] =  10  eigenvector[2];
starter[4] =  -10 eigenvector[2];
starter[5] =  5 eigenvector[2];
starter[6] =  -5 eigenvector[2];
thigh  =  1.0;
ranger  =  scaler[thigh]; 
    Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , starterplots, 
      eigenplot[thigh, 2], 
      PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
      DisplayFunction -> $DisplayFunction];

thigh  =  10.0;
ranger  =  scaler[thigh]; 
    Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}] , starterplots, 
      eigenplot[thigh, 2], 
      PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
      DisplayFunction -> $DisplayFunction];

The reason for this is that starter[1], starter[2], starter[3], starter[4], startere[5] and starter[6] are all multiples of eigenvector[2].

B.5.b.ii) Why ultimate eigenvectors work they way they do - preliminary step

As a preliminary step toward explaining why ultimate eigenvectors work the way they do, explain this:

When you go with a diagonalizable 2D matrix A and calculate its eigenvalues, eigenval[1], eigenval[2] and its eigenvectors eigenvect[1] and eigenvect[2],
then  you are guaranteed that
 \(E\^\(A\ t\) . \((u\ eigenvect[1]\  + \ 
              v\ eigenvect[2])\)
		
		 = \ \ \(E\^\(eigenval[
                  1]\ t\)\) \((u\ eigvect[1] + \ 
              v\ E\^\(\((eigenval[2] - eigenval[1])\)\ t\)\ eigvect[2])\)\)

Arrange the eigenvectors of A into the SpannerMatrix with eigenvect[1]in the leftmost vertical column and eigenvect[2] in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.(({{eigval[1], 0}, {0, eigval[2]}})).(SpannerMatrix^(-1)).
and
         A . eigvect[j] = eigval[j] eigvect[j]
for j = 1,2.

This gives 
        (E^(A t))=SpannerMatrix.(({{(E^(eigval[1] t)), 0}, {0, (E^(eigval[2] t))}})).(SpannerMatrix^(-1))
This tells you that
         (E^(A t)) . eigvect[j] = (E^eigval)[j] eigvect[j]
for  j = 1, 2.
So 
          (E^(A t)) . (u eigvect[1] + v eigvect[2])
      
      =  u (E^(eigenval[1] t))  eigvect[1] +  
        v (E^(eigval[2] t)) eigvect[2].
This is the same as:
         (E^(eigenval[1] t))  (u eigvect[1]+ v (E^(eigval[2] t )) (E^(-eigenval[1] t))eigvect[2]).
This is the same as
         (E^(eigenval[1] t))  (u eigvect[1]+ v (E^(eigval[2] t  -  eigval[1] t))eigvect[2]).
 And this is the same as
         (E^(eigenval[1] t))  (u eigvect[1]+ v (E^((eigval[2]  -  eigval[1]) t))eigvect[2]).
        
This explains why
          (E^(A t)) . (u eigvect[1] + v eigvect[2])
is the same as:
       
         (E^(eigenval[1] t))  (u eigvect[1]+ v (E^((eigval[2]  -  eigval[1]) t))eigvect[2]).

B.5.b.iii)  Why ultimate eigenvectors work they way they do -full explanation

Explain this:
If A is a diagonalizable 2D matrix , if
        eigval[1] > eigval[2], 
 and if X is a given point NOT ON the line through {0,0} defined by eigenvect[2],
then as t gets large
         E\(\^\(A\ t\) . X\) 
 gravitates to the line through {0, 0} defined by  eigenvect[1].

Because {eigenvect[1], eigenvect[2]} is a basis of 2D,you are guaranteed that X is of the form
          X  = u eigenvect[1]  +  v eigenvect[2].
 So  
          (E^(A t)) . X =  
        (E^(A t)) . (u eigenvect[1]  +  v eigenvect[2]).
The part immediately above tells you that
         (E^At) . 
          X = (E^At) ..  (u eigenvect[1] + 
                v eigenvect[2])=
         =  (E^(eigenval[1] t)) (u eigvect[1] +  
              v (E^((eigenval[2] - eigenval[1]) t)) eigvect[
                  2])
         
And because X is  not on the line through {0,0} defined by eigenvect[2], you are guaranteed that u ≠ 0. 

So (E^At) . X  points in the same direction as
        (u eigvect[1]+ v (E^((eigval[2]  -  eigval[1]) t))eigvect[2])..
Now because
               eigval[1] > eigval[2], 
it is certain that
                 (E^((eigval[2]  -  eigval[1]) t)) -> 0 
as t gets large.

Because
          eigval[1] > eigval[2], 
 you know that
           eigval[2] - eigval[1]  <  0 , 
  so
            (E^((eigval[2]  -  eigval[1]) t)) -> 0 as t gets large.
 See (E^(r t)) -> 0as t gets large for some random negative numbers r:

\(\(r = \ Random[Real, {\(-1\), \(-0.1\)}];\)
\)
Cleart[t];
\(	\(Plot[
        E^\((r\ t)\), {t, \ 0, 
          100}, 
	\ \ \ \ \ \ PlotStyle -> {{Thickness[0.02], Red}}, 
        PlotRange -> All, AspectRatio -> 1/GoldenRatio, 
        AxesOrigin -> {0, 
            0}, 
	\ \ \ \ \ AxesLabel -> {"t", "E^(r t)"}, 
        PlotLabel -> r\ "= r"];\)\)

The upshot: As t gets large the limiting direction of
             (E^(A t)) . X
is
   \(\((u\ \ eigvect[1] + \ v \((0)\)\ eigvect[2])\)

 = \ 
        u\ \(\(eigenvect[1]\)\(.\)\)\)
   
   
And now because u ≠ 0 this tells you that the limiting direction of
 E^(A t).X is on the line through {0,0} defined by eigenvect[1].

B.6) Eigenvalues of A tell how (A^k) . X plots out as k gets large
Eigenvalues and eigenvectors of A reveal the ultimate direction of (A^k) . X as k gets large

B.6.a.i)  If A is any diagonalizable matrix and the absolute values of all the eigenvalues of A are less than 1, then no matter what X is, you are guaranteed that 
          (A^k) . X -> {0, 0}.

Here's a 2D matrix A:

A = (({{0.8, 0.1}, {-0.4, -0.3}}));
MatrixForm[A]

Here are four random points
        {starter[1], starter[2], starter[3], starter[4]} 
in 2D:

A =  (({{0.8, 0.1}, {-0.4, -0.3}}));
Clear[iterationplot, interationplotter, eigenplot, 
        scaler, point, pointcolor, eigenvector, starter, khigh, k, j, 
        iterationpoints];
point[k_, starter_]  := 
        MatrixPower[A, k]  . starter ;
pointcolor[k_, khigh_]  :=  
        RGBColor[Sin[(Pi/2) k/(khigh + 0.1)], 
          Cos[(Pi/2) k/(khigh  +  0.1)], 
          E^(-k/(khigh + 0.1))] 

\(iterationpoints[starter_, khigh_]\  := 

          Table[Graphics[\ \ {pointcolor[k, khigh], PointSize[0.03], 
                Point[MatrixPower[A, k]\  . starter]}], {k, 0, khigh}];\)

iterationplotter[khigh_]:=Show[Table[iterationpoints[starter[j], khigh], {j, 1, 4}],Axes -> True,AxesLabel -> {"x", "y"},PlotLabel->"\!\(\*
StyleBox[\"Hits\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)(A^2)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"..\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)(A^khigh)",
		AspectRatio -> 1/GoldenRatio,DisplayFunction -> Identity];

starter[
          1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[
          2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[
          3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
            Random[Real, {-10, -4}]};

khigh  =  0;
Show[iterationplotter[khigh], 
          PlotLabel -> "Four starting points ", 
          DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A:

khigh  =  1;
Show[iterationplotter[khigh],
	                    PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A and with A.A:

khigh  = 2;
Show[iterationplotter[khigh],
	                    PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"and\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A, A.A and A.A.A:

khigh  = 3;
Show[iterationplotter[khigh],
	   PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"and\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",     
         DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A, A . A, (A^3), (A^4), and (A^5):

khigh  = 5;
Show[iterationplotter[khigh],  
        DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with  A, A . A, (A^3), (A^4),  .   .   . , (A^9) , (A^10):

khigh  = 10;
Show[iterationplotter[khigh], 
        DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points  with 
          A, A . A, (A^3), (A^4),  .   .   . , (A^19) , (A^20):

khigh  = 20;
Show[iterationplotter[khigh], 
        DisplayFunction -> $DisplayFunction];

As k gets large,
         (A^k) . starter[j] -> {0, 0}.
Now look at the eigenvalues of A:

Clear[eigenvalue];
{eigenval[1], eigenval[2]}  =  Eigenvalues[A]

Take note that
              |eigenval[1]|<1  and |eigenval[2]|<1.
The absolute values of the eigenvalues of A are both less than 1.
Explain this statement:
If A is any diagonalizable matrix and the absolute values of all the eigenvalues of A are less than 1, then no matter what X is, you are guaranteed that 
          (A^k) . X -> {0, 0}.

Arrange the eigenvectors of A into the SpannerMatrix with eigenvect[1]in the leftmost vertical column and eigenvect[2] in the second vertical column of SpannerMatrix.

So that

A=SpannerMatrix.(({{eigval[1], 0}, {0, eigval[2]}})).(SpannerMatrix^(-1)).

This gives

(A^k)=SpannerMatrix.(({{((eigval[1])^( k)), 0}, {0, ((eigval[2])^( k))}})).(SpannerMatrix^(-1))

So

(A^k).X = SpannerMatrix.(({{((eigval[1])^( k)), 0}, {0, ((eigval[2] )^k)}})).(SpannerMatrix^(-1)).X

Because |eigenval[1]|<1  and |eigenval[
          2]|<1, you are guaranteed that 
             ((eigenval[1])^( k))->0 and ((eigenval[2])^( k ))⟶0 
as k gets large .

Go with a random x with -1 < x < 1 and plot the powers
          x, (x^2), (x^3),  ... ,  (x^99), (x^100):

x  =  Random[Real, {-1, 1}];
xpowers =Table[{k,(x^k)},{k, 1, 100}];
\(ListPlot[
        xpowers, 
	\ \ \ \ \ \ PlotStyle -> {PointSize[0.02], 
            TurquoiseBlue}, 
        PlotRange -> All, 
	\ \ \ \ \ AxesLabel -> {"k", "x^k"}, 
        PlotLabel -> x "= x"];\)

So as k gets large
        (A^k) . X -> SpannerMatrix.(({{0, 0}, {0, 0}})).(SpannerMatrix^(-1)).X = {0, 0}.

B.6.a.ii) If A is any diagonalizable matrix and the absolute values of both eigenvalues of A are both bigger than 1, then no matter what X is (as long as X ≠ {0,0}), you are guaranteed that 
          ||(A^k) . X||->∞.

Here's a new 2D matrix A:

A = (({{1.8, 0.2}, {-0.3, -1.4}}));
MatrixForm[A]

Here are four random points
        {starter[1], starter[2], starter[3], starter[4]} 
in 2D:

A = (({{1.8, 0.2}, {-0.3, -1.4}}));
Clear[iterationplot, 
        interationplotter, eigenplot, scaler, point, pointcolor, eigenvector, 
        starter, khigh, k, j, 
        iterationpoints];
point[k_, starter_]  := 
        MatrixPower[A, k]  . starter ;
pointcolor[k_, khigh_]  :=  
        RGBColor[Sin[(Pi/2) k/(khigh + 0.1)], 
          Cos[(Pi/2) k/(khigh  +  0.1)], 
          E^(-k/(khigh + 0.1))] 

\(iterationpoints[starter_, khigh_]\  := 

          Table[Graphics[\ \ {pointcolor[k, khigh], PointSize[0.03], 
                Point[MatrixPower[A, k]\  . starter]}], {k, 0, khigh}];\)

iterationplotter[khigh_]:=Show[Table[iterationpoints[starter[j], khigh], {j, 1, 4}],Axes -> True,AxesLabel -> {"x", "y"},PlotLabel->"\!\(\*
StyleBox[\"Hits\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)(A^2)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"..\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)(A^khigh)",
		AspectRatio -> 1/GoldenRatio,DisplayFunction -> Identity];
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[
          2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[
          3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
            Random[Real, {-10, -4}]};

khigh  =  0;
Show[iterationplotter[khigh],PlotLabel->"\!\(\*
StyleBox[\"Four\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starting\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"points\",\nFontColor->RGBColor[0, 0, 1]]\) ",DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A:

khigh  =  1;
Show[iterationplotter[khigh],
	 PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A and A.A:

khigh  = 2;
Show[iterationplotter[khigh],
 PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"and\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A, A.A and A.A.A:

khigh  = 3;
Show[iterationplotter[khigh],
 PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"and\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original four starting points with A, A . A, (A^3), (A^4), and (A^5):

khigh  = 5;
Show[iterationplotter[khigh],  
        DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with  A, A . A, (A^3), (A^4),  .   .   . , (A^9) , (A^10):

khigh  = 10; 
Show[
        iterationplotter[
          khigh],   DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points  with 
          A, A . A, (A^3), (A^4),  .   .   . , (A^19) , (A^20):

khigh  = 20;
\(Show[
        iterationplotter[
          khigh], 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)

As k gets large,
         ((||A))^k) . 
            starter[j]|| -> ∞.
Now look at the eigenvalues of A:

Clear[eigenvalue];
{eigenval[1], eigenval[2]}  =  Eigenvalues[A]

|eigenval[1]|>1  and |eigenval[2]|>1.
The absolute values of the eigenvalues of A are both bigger than 1.
Explain this statement:
If A is any diagonalizable matrix and the absolute values of the of both eigenvalues of A are both bigger than 1, then no matter what as long as X ≠ {0,0}, you are guaranteed that 
          ||(A^k) . X|| -> ∞.

Arrange the eigenvectors of A into the SpannerMatrix with eigenvect[1] in the leftmost vertical column and eigenvect[2] in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.(({{eigval[1], 0}, {0, eigval[2]}})).(SpannerMatrix^(-1)).
This gives 
        (A^k)=SpannerMatrix.(({{((eigval[1])^( k)), 0}, {0, ((eigval[2])^( k))}})).(SpannerMatrix^(-1))
So
         (A^k).X = SpannerMatrix.(({{((eigval[1])^( k)), 0}, {0, ((eigval[2])^( k))}})).(SpannerMatrix^(-1)).X
Because |eigenval[1]|>1  and |eigenval[
          2]|>1, you are guaranteed that 
             |((eigenval[1] )^k)|->∞ and |((eigenval[2])^( k))|->∞  
as k gets large .

Go with a random x with |x| > 1 and plot the powers
         \(\(\(\ \)\(\(\(|\)\(x\)\(|\)\), \(\(|\)\(x\)\( | \^2\)\), \(\(|\)\(x\)\( | \^3\)\),  ... , \ \(\(|\)\(x\)\( | \^39\)\), \(\(|\)\(x\)\( | \^40\)\)\)\)\):

x  =  (-1)^Random[Integer, {0, 1}]  Random[
            Real, {1, 5}];
xpowers  = Table[{k, Abs[x]^k}, {k, 1, 40}];
\(\(ListPlot[
        xpowers, 
	\ \ \ \ \ \ PlotStyle -> {PointSize[0.03], 
            GeraniumLake}, 
        PlotRange -> 
          All, 
	\ \ \ \ \ AxesLabel -> {"k", "Abs[x]^k"}, 
        PlotLabel -> x "= x"];\)\)

The result: 
Unless X = {0,0},
        ||(A^k) . 
            X||  ->  ∞ .
as k gets large.

B.6.b.i) If |eigenvalue[
          1]|>|eigenvalue[2]|, then the ultimate direction of (A^k).X as k gets large is in the direction of eigenvector[1] (unless X is a multiple of eigenvector[2])

Here's a 2D matrix A:

A = (({{1.20, 0.11}, {-0.43, 0.32}}));
MatrixForm[A]

Here are four random points
        {starter[1], starter[2], starter[3], starter[4]} 
in 2D shown with scaled versions of the eigenvectors of A:

A = (({{1.20, 0.11}, {-0.43, 0.32}}));
Clear[iterationplot, interationplotter, eigenplot, 
        point, scaler, pointcolor, eigenvector, starter, khigh, k, j, 
        iterationpoints];
point[k_, starter_]  := 
        MatrixPower[A, k]  . starter ;
pointcolor[k_, khigh_]  :=  
        RGBColor[Sin[(Pi/2) k/(khigh + 0.1)], 
          Cos[(Pi/2) k/(khigh  +  0.1)], 
          E^(-k/(khigh + 0.1))] 

\(iterationpoints[starter_, khigh_]\  := 

          Table[Graphics[\ \ {pointcolor[k, khigh], PointSize[0.03], 
                Point[MatrixPower[A, k]\  . starter]}], {k, 0, khigh}];\)

iterationplotter[khigh_]:=Show[Table[iterationpoints[starter[j], khigh], {j, 1, 4}],Axes -> True,AxesLabel -> {"x", "y"},PlotLabel->"\!\(\*
StyleBox[\"Hits\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)(A^2)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"..\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)(A^khigh)",
		AspectRatio -> 1/GoldenRatio,DisplayFunction -> Identity];


scaler[khigh_] :=  
          0.9 Sqrt[point[khigh, starter[1]] . point[khigh, starter[1]] ];

{eigenvector[1], eigenvector[2]}  =  
        Eigenvectors[A];
\(eigenplot[khigh_, 
            j_] := \ 
\ \ \ \ \ \ \ \ \ {Arrow[
              scaler[khigh]\ eigenvector[j], Tail -> {0, 0}, 
              VectorColor -> 
                Black], 
\ \ \ \ \ \ \ \ \ \ \ Arrow[\(-scaler[
                    khigh]\)\ \ eigenvector[j], Tail -> {0, 0}, 
              VectorColor -> Black]};\)


	        

starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[
          2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[
          3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
            Random[Real, {-10, -4}]};

khigh  =  0;
Show[iterationplotter[khigh],eigenplot[khigh, 1],eigenplot[khigh, 2],PlotLabel->"\!\(\*
StyleBox[\"Four\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starting\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"points\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"scaled\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"eigenvectors\",\nFontColor->RGBColor[0, 0, 1]]\)",DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A:

khigh  =  1;
Show[iterationplotter[khigh],eigenplot[khigh, 1],eigenplot[khigh, 2],
	                    PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A and A.A:

khigh  = 2;
Show[iterationplotter[khigh],eigenplot[khigh, 1],eigenplot[khigh, 2],
	  PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"and\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A, A.A and A.A.A:

khigh  = 3;
Show[iterationplotter[khigh],eigenplot[khigh, 1],eigenplot[khigh, 2],
	                    PlotLabel->"\!\(\*
StyleBox[\"Hit\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"with\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\",\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"and\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\" \",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"A\",\nFontColor->RGBColor[0, 0, 1]]\)",  DisplayFunction -> $DisplayFunction];

Here are the same four starter points together with the points you get when you hit each of the original starting points with A, A . A, (A^3), (A^4), and (A^5):

khigh  = 5;
\(Show[iterationplotter[khigh], eigenplot[khigh, 1], 
        eigenplot[khigh, 
          2], 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)

Here are the same four starter points together with the points you get when you hit each of the original starting points with  A, A . A, (A^3), (A^4),  .   .   . , (A^9) , (A^10):

khigh  = 10;
\(Show[iterationplotter[khigh], eigenplot[khigh, 1], 
        eigenplot[khigh, 
          2], 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)

Here are the same four starter points together with the points you get when you hit each of the original starting points  with 
          A, A . A, (A^3), (A^4), . . ., (A^19) , 
      (A^20):

khigh  = 20;
\(Show[iterationplotter[khigh], eigenplot[khigh, 1], 
        eigenplot[khigh, 
          2], 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)

Here are the same four starter points together with the points you get when you hit each of the original starting points  with 
          A, A . A, (A^3), (A^4),  .   .   . , (A^49) , (A^50):

khigh  = 50;
\(Show[iterationplotter[khigh], eigenplot[khigh, 1], 
        eigenplot[khigh, 
          2], 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)

As k gets large, the points
           (A^k) . starter[j] 
seem to shy away from one of the eigenvectors and to gravitate to the line through {0,0} defined by the ultimate eigenvector.
How do you identify the ultimate eigenvector?

Look at the eigenvectors of A:

Clear[eigenvector];
{eigenvector[1], eigenvector[2]}  =  Eigenvectors[A]

Look at the eigenvalues:

Clear[eigenvalue];
{eigenvalue[1], eigenvalue[2]}  =  Eigenvalues[A]

Note that
          | eigenvalue[1] |  > | eigenvalue[2] | .

This means that as k gets large, the plotted points
            (A^k) . starter[j] 
are attracted to the line through {0, 0} defined by eigenvector[1] .
See it happen in this plot which displays only the line through {0, 0} defined by eigenvector[1].

khigh  = 60;
\(\(Show[iterationplotter[khigh], eigenplot[khigh, 1], 
        PlotRange -> 
          All, 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)\)

As k gets large, the points
           (A^k) . starter[j]  
 just laugh at the line through {0,0} defined by eigenvector[2]:

khigh  = 60;
\(\(Show[iterationplotter[khigh], eigenplot[khigh, 2], 
        PlotRange -> 
          All, 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> $DisplayFunction];\)\)

This happens because 
        | eigenvalue[1] |  > | eigenvalue[2] | .   

The is one theoretical exception: If starter is an exact multiple of eigenvector[2], then the plotted points (A^k) . starter[j]stay on the line through {0,0} defined by eigenvector[2].
 See this happen:

starter[1] =  10  eigenvector[2];
starter[2] =  -10 eigenvector[2];
starter[3] =  5  eigenvector[2];
starter[4] =  -5 eigenvector[2];
khigh  = 0;
\(\(Show[iterationplotter[khigh], eigenplot[0, 2], 
        PlotRange -> {{\(-10\), 10}, {\(-10\), 
              10}}, 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotLabel -> "Starting points", DisplayFunction -> $DisplayFunction];\)\)

khigh  = 12;
\(Show[iterationplotter[khigh], eigenplot[0, 2], 
        PlotRange -> {{\(-10\), 10}, {\(-10\), 
              10}}, 
	\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ PlotLabel -> "Starting points and one hit with A", 
        DisplayFunction -> $DisplayFunction];\)

The reason for this is that starter[1], starter[2], starter[3] and starter[4] are all multiples of eigenvector[2].

B.6.b.ii) Explanation-Preliminary step

As a preliminary step toward explaining why ultimate eigenvectors work the way they do, explain this:
When you go with a diagonalizable 2D matrix A and calculate its eigenvalues,
                 eigenval[1] and eigenval[2] 
and its corresponding eigenvectors 
                    eigenvect[1] and eigenvect[2],
then 
 (A^k).(s eigenvect[1]  +  t eigenvect[2])
		
		=  ((eigval[1 ])^( k))(s  eigvect[1]+ t (((eigval[2]/eigval[1]))^k) eigvect[2])

Arrange the eigenvectors of A into the SpannerMatrix with eigenvect[1]in the leftmost vertical column and eigenvect[2] in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.(({{eigval[1], 0}, {0, eigval[2]}})).(SpannerMatrix^(-1)).
This gives 
        (A^k)=SpannerMatrix.(({{((eigval[1])^( k)), 0}, {0, ((eigval[2])^( k))}})).(SpannerMatrix^(-1))
This tells you that
         (A^k).eigvect[j]=((eigval[j])^k) eigvect[j]
for  j = 1, 2.
So 
          (A^k).(s eigvect[1] + t eigvect[2])
      
      =  s ((eigval[1])^k) eigvect[1]+ t ((eigval[2])^k) eigvect[2].
Factor out eigval[1]^kto get::
            (A^k) . (s eigvect[1] + t eigvect[2])
= ((eigval[1])^k)(s  eigvect[1]+ t (((eigval[2])^k)/((eigval[1])^( k))) eigvect[2])
=  ((eigval[1])^k)(s  eigvect[1]+ t (((eigval[2]/eigval[1]))^k) eigvect[2]).
Explanation complete.

B.6.b.iii) Full explanation

Explain this:
If A is a diagonalizable 2D matrix ,if
        | eigval[1] |  >  | eigval[2] | , 
 and if X is a given point NOT ON the line through {0,0} defined by eigenvect[2],
then as k gets large
          (A^k) . X  
 gravitates to the line through {0, 0} defined by  eigenvect[1].

Because {eigenvect[1], eigenvect[2]} is a basis of 2D,you are guaranteed that X is of the form
          X  = s eigenvect[1]  +  t eigenvect[2].
 So  
          (A^k) . X  =  
        (A^k) . (s eigenvect[1]  +  t eigenvect[2]).
The part immediately above tells you that
         (A^k) . X = (A^k) . (s eigenvect[1]  +  t eigenvect[2])
		
		      =  eigval[1]^k(s  eigvect[1] +  
                    t (((eigval[2]/eigval[1]))^k) eigvect[2]).
         
And because X is  not on the line through {0,0} defined by eigenvect[2], you are guaranteed that s ≠ 0. 

So (A^k) . X  points in the same direction as
        ±(s  eigvect[1]+ t (((eigval[2]/eigval[1]))^k) eigvect[2]).
Now because
               |eigval[1]|>|eigval[2]|, 
it's  certain that
                -1 < eigenval[2]/eigenval[1] < 1 .
                
So as k gets large (((eigval[2]/eigval[1]))^(k ))closes in on 0..

Go with a random x with -1 < x < 1 and plot the powers
          x, (x^2), (x^3),  ... ,  (x^99), (x^100):

x  =  Random[Real, {-1, 1}];
xpowers  = Table[{k, x^k}, {k, 1, 100}];
\(\(ListPlot[
        xpowers, 
	\ \ \ \ \ \ PlotStyle -> {PointSize[0.02], Red}, 
        PlotRange -> All, 
	\ \ \ \ \ AxesLabel -> {"k", "x^k"}, 
        PlotLabel -> x "= x"];\)\)

The upshot: As k gets large the limiting direction of
     (A^k) . X
is
   \(\(\(\ \)\(\(±\((s\ \ eigvect[1] + \ 
              t \((0)\)\ eigvect[2])\)\)

 = \ \(±\ 
            s\)\ \(\(eigenvect[1]\)\(.\)\)\)\)\)
   
   
And now because s ≠ 0 this tells you that the limiting direction of
 (A^k) . X is on the line through {0,0} defined by eigenvect[1].

B.6.b.iv) Staying on a line

Explain this:
If A is a diagonalizable 2D matrix ,if
and if X is  ON the line through {0,0} defined by eigenvect[j],
then as k gets large
          (A^k) . X  
 stays on to the line through {0, 0} defined by  eigenvect[j].

Because X is on the line through {0,0} defined by eigenvector[j] , you know that
          X  =  t eigenvect[j].
 So  
          (A^k) . X  =  (A^k) .  t eigenvect[2]  =  
          t eigenval[j]^k eigenvect[j].
The upshot:
No matter what k is, (A^k).X  is on the line through {0,0} defined by eigenvect[j]

B.7) Sometimes you have to go to complex kD  to diagonalize a matrix.
The matrix exponential for matrices diagonalizable with complex numbers
How (E^(A t)) . X  swirls when A is diagonalizable with complex numbers.

Background on Complex kD

For usual  kD, you go with vectors whose slots are real numbers.
For complex kD, you go with vectors whose slots are complex numbers a + i b
where i = (Sqrt[-1]).
Here is a random vector in complex3D:

dim  =  3;
Clear[k];
complexX  =  
      Table[Random[Real, {-10, 10}] Random[Complex], {k, 1, 
          dim}]

Here is a random member of complex5D:

dim  =  5;
Clear[k];
complexX  =  
      Table[Random[Real, {-10, 10}] Random[Complex], {k, 1, 
          dim}]

You can't plot them but you can add and subtract them and you can multiply them by complex numbers.

B.7.a.i) Complex eigenvectors can happen, but they don't block your path

Go with this 2D matrix A:

A = (({{0.2, 1.2}, {-1.5, 0.4}}));
MatrixForm[A]

Calculate the eigenvectors of A:

Clear[eigenvector];
spanners  =   Eigenvectors[A]

Note the presence of i = (Sqrt[-1]).
In spite of this, calculate the dimension of the subspace of complex 2D spanned by the eigenvectors of A:

SpannerMatrix  =  Transpose[spanners];
eigendim  =  
      Length[SingularValues[SpannerMatrix][[2]]]

This tells you that the eigenvectors of A form a basis for all of complex2D and that the spanner matrix is invertible.
Explain why this signals that A is diagonalizable with complex numbers.

To see that A is diagonalizable with complex numbers, you have to be able to duplicate A with a matrix of this form:
          SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1))
The SpannerMatrix you need is already available:

Clear[eigenvector];
spanners  =   Eigenvectors[A];
SpannerMatrix  =  Transpose[spanners];
MatrixForm[SpannerMatrix]

The diagonal matrix comes from the eigenvalues of A:

diagonalmatrix = DiagonalMatrix[Eigenvalues[A]];
MatrixForm[
      diagonalmatrix]

Here's a look at
          SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1)):

MatrixForm[SpannerMatrix.diagonalmatrix.Inverse[SpannerMatrix]]

Here's a look at A:

MatrixForm[A]

The upshot:
         A  =  SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1)):
So A is diagonalizable with complex numbers..

B.7.a.ii)  3D sample

Do one in 3D.

Happy to oblige.
Go with:

A = (({{0.2, 1.2, 1.2}, {-1.5, 0.4, 0.7}, {0.5, 1.2, -0.3}}));
MatrixForm[A]

Calculate the eigenvectors of A:

Clear[eigenvector];
spanners  =   Eigenvectors[A]

Note the presence of i = (Sqrt[-1]).
In spite of this, calculate the dimension of the subspace of complex3D spanned by the eigenvectors of A:

SpannerMatrix  =  Transpose[spanners];
eigendim  =  
      Length[SingularValues[SpannerMatrix][[2]]]

This tells you that the eigenvectors of A form a basis for all of complex3D and that the spanner matrix is invertible.

To diagonalize A with complex numbers, you have to be able to duplicate A with a matrix of this form:
          SpannerMatrix . diagonalmatrix . (SpannerMatrix^(-1))
The SpannerMatrix you need is already available:

Clear[eigenvector];
spanners  =   Eigenvectors[A];
SpannerMatrix  =  Transpose[spanners];
MatrixForm[
      SpannerMatrix]

The diagonal matrix comes from the eigenvalues of A:

diagonalmatrix  =  DiagonalMatrix[Eigenvalues[A]];
MatrixForm[
      diagonalmatrix]

Here's a look at
          SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)):

MatrixForm[SpannerMatrix.diagonalmatrix.Inverse[SpannerMatrix]]

Here's a look at A:

MatrixForm[A]

The upshot:
         A = SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)):
So A is diagonalizable with complex numbers..

B.7.b.i)  The matrix exponential  (E^(A t)) for matrices that are diagonalizable with complex numbers

Here's a new 2D matrix A:

A = (({{0.3, 1.2}, {-1.5, -0.4}}));
MatrixForm[A]

Calculate the eigenvectors of A:

Clear[eigenvector];
spanners  =   Eigenvectors[A]

Note the presence of  i = (Sqrt[-1]).
In spite of this, calculate the matrix exponential  (E^(A t)).

Check:

SpannerMatrix  =  Transpose[spanners];
eigendim  =  
      Length[SingularValues[SpannerMatrix][[2]]]

This tells you that the eigenvectors of A form a basis for all of complex2D and that the spanner matrix is invertible.

To diagonalize A with complex numbers, you have to be able to duplicate A with a matrix of this form:
          SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1))
The SpannerMatrix you need is already available:

Clear[eigenvector];
spanners  =   Eigenvectors[A];
SpannerMatrix  =  Transpose[spanners];
MatrixForm[SpannerMatrix]

The diagonal matrix comes from the eigenvalues of A:

diagonalmatrix  =  DiagonalMatrix[Eigenvalues[A]];
MatrixForm[
      diagonalmatrix]

Here's a look at
          SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)):

MatrixForm[SpannerMatrix.diagonalmatrix.Inverse[SpannerMatrix]]

Here's a look at A:

MatrixForm[A]

The upshot:
         A = SpannerMatrix.diagonalmatrix.(SpannerMatrix^(-1)):
So A is diagonalizable with complex numbers. 

To calculate  (E^(A t)), look at::

diagonalmatrix  =  DiagonalMatrix[Eigenvalues[A]];
MatrixForm[
      diagonalmatrix]

Replace this diagonal matrix with the new diagonal matrix you get by hitting the diagonal terms with the function 
          f[x] = (E^(x t)):

Clear[f, x, t];
f[x_]  =  (E^(x t));
fdiagonalmatrix  =  
        DiagonalMatrix[Map[f, Eigenvalues[A]]];
MatrixForm[fdiagonalmatrix]

Here is (E^(A t)) in raw form:

\(\(\(rawform\)\(=\)\(\ \)\(Simplify[\ 
        SpannerMatrix . fdiagonalmatrix . 
          Inverse[SpannerMatrix]]\)\(\ \)\(
\)\)\)

Check with Mathematica's built-in instruction:

MatrixExp[A t]

The calculation checks.
That's sort of a mess. 
Here's a simplified version of (E^(A t)):

cleanversion = ComplexExpand[SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix]]

That's still quite a pill. But notice that 
           i = (Sqrt[-1]) 
 has disappeared.

B.7.b.ii) Euler's Formula: (E^((a+i b)t)) =  (E^(a t))( Cos[b t]  + i Sin[b t])

Keep everything from part i) immediately above alive.
When (E^(A t)) was calculated the first time the result was:

rawform= Simplify[ SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix]]

Then a cleaner version of (E^(A t)) without i = (Sqrt[-1]) was calculated:

cleanversion = ComplexExpand[SpannerMatrix.fdiagonalmatrix.Inverse[SpannerMatrix]]

How was the cleaner version derived from the original version?

Mathematica took the original version and replaced all terms
of the form 
            :(E^((a+i b)t)) 
with the equivalent form 
          (E^(a t))( Cos[b t]  + i Sin[b t])
This equivalence is so important that it's even programmed into Mathematica:

Clear[a, b, t];
ComplexExpand[(E^((a+I b)t))]

And it even has a name: "Euler's formula."

This is from MEI's Calculus&Mathematica course.
 The complex exponential and the Euler's formula

Background

Look at these partial expansions of
           Cos[x], Sin[x] and (E^x) 
in powers of x:

Clear[x]
cosexpansion=Normal[Series[Cos[x], {x, 0, 8}]]

sinexpansion=Normal[Series[Sin[x], {x, 0, 8}]]

eexpansion=Normal[Series[(E^x), {x, 0, 8}]]

Notice that the terms in the expansion of 
         (E^x)
seem to have been lifted from the expansions of
         Cos[x] and Sin[x]. 
Complex numbers explain this phenom. 
Here's how.

Activate the complex (imaginary) number i = (Sqrt[-1]):

I

(I^2)

Now replace x by i x in the expansion of (E^x):

Normal[Series[(E^x), {x, 0, 10}]]/.x -> I x

Embedded in this is the expansion of Cos[x]:

Normal[Series[Cos[x], {x, 0, 10}]]

You can also see i times the expansion of Sin[x]:

Expand[I Normal[Series[Sin[x], {x, 0, 10}]]]

In fact:

k = Random[Integer, {15, 30}];
Normal[Series[(E^x),{x, 0, k}]]/.x -> I  x

Normal[Series[Cos[x],{x, 0, k}]]+Expand[I  Normal[Series[Sin[x],{x, 0, k}]]]

That's why folks all agree that
               (E^(i x)) = Cos[x] + i Sin[x]

B.7.b.iii) Eigenvalues p + q (Sqrt[-1])  and p - q (Sqrt[-1])with p<0 and q ≠ 0
 signal that (E^(A t)) . X swirls toward {0, 0}

Go with this 2D matrix A:

A = (({{-0.5, -1.1}, {1.6, -0.8}}));
MatrixForm[
      A]

Here are six random points
        {starter[1], starter[2], starter[3], starter[4], starter[5], 
        starter[6]} 
in 2D :

\(\(Clear[pointer, trajectoryplot, eigenplot, scaler, eigenvector, 
        starter, thigh, k, j];\)
\)
\(\(trajectoryplot[thigh_, starter_]\  := \ 
        ParametricPlot[MatrixExp[A\ t] . starter, {t, 0, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          DisplayFunction -> Identity];\)

\)
\(\(pointer[thigh_, starter_]\  := \ 	ArrowHead[
          MatrixExp[A\ \ thigh]\  . 
            starter, \((D[MatrixExp[A\ t], t] /. t -> thigh)\)\  . 
            starter, \ 
			\ \ \ \ \ \ \ \ HeadSize -> 0.6, 
          VectorColor -> Black, Aperture -> 0.4];\)
\)
\(\(starterplots\  = \ 
        Table[Graphics[{NavyBlue, PointSize[0.03], Point[starter[j]]}], {j, 
            1, 6}];\)\ 
\)
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
          Random[Real, {-10, -4}]};
starter[5] =  {Random[Real, {-10, -4}], 0};
\(\(starter[6] = \ {Random[Real, {4, 10}], 0};\)
\)
thigh  =  0.01;
\(\(Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}]\ , 
        starterplots, PlotLabel -> "Starting points", 
        DisplayFunction -> $DisplayFunction];\)
\)

Here is how the curves
        \(E\^\(A\ t\) . starter[1], E\^\(A\ t\) . starter[2], 
      E\^\(A\ t\) . starter[3], 
E\^\(A\ t\) . starter[4], 
      E\^\(A\ t\) . starter[5], E\^\(A\ t\) . starter[6]\)
plot out as t advances from 0 to 1.5

thigh  =  1.5;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Swirling.
Here's what happens as t advances from 0 to 4:

thigh  =  4;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 10:

thigh  =  10;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Eventually all the plots swirl to {0,0} and stall at {0,0}.
Now look at the eigenvalues of A:

Eigenvalues[A]

Negative real part, nonzero imaginary part. 

Explain this bold statement:
If A is any 2D matrix that is diagonalizable matrix with complex numbers and its complex eigenvalues are of the form
         p+I q and p-I q    with p<0 and q ≠ 0, 
then no matter what X is, you are guaranteed that the plot of
          (E^(A t)) . X
swirls to {0,0} and stalls at {0,0}.

Arrange the complex eigenvectors of A into the SpannerMatrix with the eigenvector corresponding to p + I q in the leftmost vertical column and the eigenvector corresponding to p - I q in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.	(({{p  +  I q, 0}, {0, p  -  I q}})).(SpannerMatrix^(-1)).
Use shorthand notation by putting
              SpannerMatrix = SM 
 so that
         A=SM.(({{p + I q, 0}, {0, p - I q}})).(SM^(-1))

This gives 
         (E^(A t))=SM.(({{(E^((p + I q) t)), 0}, {0, (E^((p - I q)t))}})).(SM^(-1))

And
        (E^(A t)) . X = SM.(({{(E^((p + I q) t)), 0}, {0, (E^((p - I q)t))}})).(SM^(-1)).X.

This is the same as

(E^(A t)) . X = SM.(({{(E^(pt)), 0}, {0, (E^(pt))}}))(({{(E^Iqt), 0}, {0, (E^(-Iqt))}})).(SM^(-1)).X

Because p<0 ,  you know that (E^(p t))->0 as t gets large. The result:

(E^(A t)) . X -> SM.(({{0, 0}, {0, 0}})).(({{(E^Iqt), 0}, {0, (E^(-Iqt))}})).(SM^(-1)).X = {0, 0}

as t gets large. 
This explains why the plots head to {0,0} and stall there.
 
 To see why the plots swirl, look at

(E^(A t)) . X = SM.(({{(E^(pt)), 0}, {0, (E^(pt))}}))(({{(E^Iqt), 0}, {0, (E^(-Iqt))}})).(SM^(-1)).X

and remember that
           (E^(I q t)) = Cos[q t] + I Sin[q t] and   (E^(-I q t)) = Cos[q t] - I Sin[q t].
 The presence of the oscillatory functions
           Sin[q t] and Cos[q t] 
 explains why the plots swirl.
 In fact the bigger q is, the more vivid the swirl. 
 Reason: The bigger q is, the faster Sin[q t] and Cos[q t] oscillate.

B.7.b.iv) Eigenvalues p + q (Sqrt[-1])  and p - q (Sqrt[-1])with p>0 and q ≠ 0
 signal that (E^(A t)) . X swirls away from {0, 0}

Go with this new 2D matrix A:

A = (({{0.5, 1.2}, {-1.5, 0.8}}));
MatrixForm[A]

Here are six random points
        {starter[1], starter[2], starter[3], starter[4], starter[5], 
        starter[6]} 
in 2D :

\(\(Clear[trajectoryplot, eigenplot, scaler, pointer, eigenvector, 
        starter, thigh, k, headsize, j];\)
\)
\(\(trajectoryplot[thigh_, starter_]\  := \ 
        ParametricPlot[MatrixExp[A\ t] . starter, {t, 0, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          DisplayFunction -> Identity];\)

\)
\(\(pointer[thigh_, starter_]\  := \ 	ArrowHead[
          MatrixExp[A\ \ thigh]\  . 
            starter, \((D[MatrixExp[A\ t], t] /. t -> thigh)\)\  . 
            starter, \ 
			\ \ \ \ \ \ \ \ HeadSize -> headsize, 
          VectorColor -> Black, Aperture -> 0.4];\)
\)
\(\(starterplots\  = \ 
        Table[Graphics[{NavyBlue, PointSize[0.03], Point[starter[j]]}], {j, 
            1, 6}];\)\ 
\)
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
          Random[Real, {-10, -4}]};
starter[5] =  {Random[Real, {-10, -4}], 0};
\(\(starter[6] = \ {Random[Real, {4, 10}], 0};\)
\)
thigh  =  0.01;
\(\(Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}]\ , 
        starterplots, PlotLabel -> "Starting points", 
        DisplayFunction -> $DisplayFunction];\)
\)

Here is how the curves
                    \(E\^\(A\ t\) . starter[1], E\^\(A\ t\) . starter[2], 
      E\^\(A\ t\) . starter[3], 
E\^\(A\ t\) . starter[4], 
      E\^\(A\ t\) . starter[5], E\^\(A\ t\) . starter[6]\)
plot out as t advances from 0 to 1.5

thigh  =  1.5;
headsize  =  2;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 4:

thigh  =  4;
headsize  =  10;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Eventually all the plots swirl away from to {0,0} .
Now look at the eigenvalues of A:

Eigenvalues[A]

Positive real part, nonzero imaginary part. 
Explain this statement:

If A is any 2D matrix that is diagonalizable matrix with complex numbers and its complex eigenvalues are of the form
         p+I q and p-I q    with p>0 and q ≠ 0, 
then no matter what X is, you are guaranteed that the plot of
          (E^(A t)) . X
swirls away from {0,0}..

Arrange the complex eigenvectors of A into the SpannerMatrix with the eigenvector corresponding to p + I q in the leftmost vertical column and the eigenvector corresponding to p - I q in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.	(({{p  +  I q, 0}, {0, p  -  I q}})).(SpannerMatrix^(-1)).
Use shorthand notation by putting
              SpannerMatrix = SM 
 so that
         A=SM.(({{p + I q, 0}, {0, p - I q}})).(SM^(-1))

This gives 
         (E^(A t))=SM.(({{(E^((p + I q) t)), 0}, {0, (E^((p - I q)t))}})).(SM^(-1))

And
        (E^(A t)) . X = SM.(({{(E^((p + I q) t)), 0}, {0, (E^((p - I q)t))}})).(SM^(-1)).X.

This is the same as

(E^(A t)) . X = SM.(({{(E^(pt)), 0}, {0, (E^(pt))}}))(({{(E^Iqt), 0}, {0, (E^(-Iqt))}})).(SM^(-1)).X

Because p>0 ,  you know that (E^(p t))->∞ as t gets large. The result:

(E^(A t)) . X -> SM.(({{∞, 0}, {0, ∞}})).(({{(E^Iqt), 0}, {0, (E^(-Iqt))}})).(SM^(-1)).X

as t gets large. So the plots try to leave the screen.

 
 To see why the plots swirl, look at

(E^(A t)) . X = SM.(({{(E^(pt)), 0}, {0, (E^(pt))}}))(({{(E^Iqt), 0}, {0, (E^(-Iqt))}})).(SM^(-1)).X

and remember that
           (E^(I q t)) = Cos[q t] + I Sin[q t] and   (E^(-I q t)) = Cos[q t] - I Sin[q t].
 The presence of the oscillatory functions
           Sin[q t] and Cos[q t] 
 explains why the plots swirl.
 In fact the bigger q is, the more vivid the swirl. 
 Reason: The bigger q is, the faster Sin[q t] and Cos[q t] oscillate.

B.7.b.v) Eigenvalues p + q (Sqrt[-1])  and p - q (Sqrt[-1])with p=0 and q ≠ 0 
signal that (E^(A t)) . X oscillates around {0, 0} on closed curves

Go with this new 2D matrix A:

A = (({{-0.2, 1.2}, {-1.5, 0.2}}));
MatrixForm[A]

Here are six random points
        {starter[1], starter[2], starter[3], starter[4], starter[5], 
        starter[6]} 
in 2D :

\(\(Clear[trajectoryplot, eigenplot, scaler, pointer, eigenvector, 
        starter, thigh, k, headsize, j];\)
\)
\(\(trajectoryplot[thigh_, starter_]\  := \ 
        ParametricPlot[MatrixExp[A\ t] . starter, {t, 0, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          DisplayFunction -> Identity];\)

\)
\(\(pointer[thigh_, starter_]\  := \ 	ArrowHead[
          MatrixExp[A\ \ thigh]\  . 
            starter, \((D[MatrixExp[A\ t], t] /. t -> thigh)\)\  . 
            starter, \ 
			\ \ \ \ \ \ \ \ HeadSize -> 1, 
          VectorColor -> Black, Aperture -> 0.4];\)
\)
\(\(starterplots\  = \ 
        Table[Graphics[{NavyBlue, PointSize[0.03], Point[starter[j]]}], {j, 
            1, 6}];\)\ 
\)
starter[1] =  {Random[Real, {4, 10}], 
          Random[Real, {4, 10}]};
starter[2] =  {Random[Real, {-10, -4}], 
          Random[Real, {-10, -4}]};
starter[3] =  {Random[Real, {-10, -4}], 
          Random[Real, {4, 10}]};
starter[4] =  {Random[Real, {4, 10}], 
          Random[Real, {-10, -4}]};
starter[5] =  {Random[Real, {-10, -4}], 0};
\(\(starter[6] = \ {Random[Real, {4, 10}], 0};\)
\)
thigh  =  0.01;
\(\(Show[Table[trajectoryplot[thigh, starter[j]], {j, 1, 6}]\ , 
        starterplots, PlotLabel -> "Starting points", 
        DisplayFunction -> $DisplayFunction];\)
\)

Here is how the curves
 \(E\^\(A\ t\) . starter[1], E\^\(A\ t\) . starter[2], 
      E\^\(A\ t\) . starter[3], 
E\^\(A\ t\) . starter[4], 
      E\^\(A\ t\) . starter[5], E\^\(A\ t\) . starter[6]\)
plot out as t advances from 0 to 1.5

thigh  =  1.5;
headsize  =  2;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 4:

thigh  =  4;
headsize  =  2;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

Here's what happens as t advances from 0 to 10:

thigh  =  10;
headsize  =  2;
Show[Table[trajectoryplot[thigh, starter[k]], {k, 1, 6}] ,
	Table[pointer[thigh, starter[k]], {k, 1, 6}],starterplots,PlotRange -> All,PlotLabel->"Plots of \!\(\*
StyleBox[\(E\^\(A\\\\t\)\),\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\".\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"starter\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"[\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"k\",\nFontColor->RGBColor[0, 0, 1]]\)\!\(\*
StyleBox[\"]\",\nFontColor->RGBColor[0, 0, 1]]\) for 0 < t"<thigh,DisplayFunction -> $DisplayFunction];

The plots oscillate on closed curves centered at {0,0} .
Now look at the eigenvalues of A:

Eigenvalues[A]

Zero real part, nonzero imaginary part. 
Explain this statement:

If A is any 2D matrix that is diagonalizable matrix with complex numbers and its complex eigenvalues are of the form
         p + I q and p - I q    with p = 0 and q ≠ 0, 
then no matter what X is, you are guaranteed that the plot of
          (E^(A t)) . X
oscillate on closed curves centered at {0,0} .

Arrange the complex eigenvectors of A into the SpannerMatrix with the eigenvector corresponding to  I q in the leftmost vertical column and the eigenvector corresponding to - I q in the second vertical column of SpannerMatrix.

So that
         A=SpannerMatrix.(({{ I q, 0}, {0, - I q}})).(SpannerMatrix^(-1)).
Use shorthand notation by putting
              SpannerMatrix = SM 
 so that
         A=SM.(({{i  q, 0}, {0,  - i  q}})).(SM^(-1))

This gives

(E^(A t))=SM.(({{(E^( i  q  t)), 0}, {0, (E^(- i  q t))}})).(SM^(-1))

And

(E^(A t)) . X = SM.(({{(E^( i  q  t)), 0}, {0, (E^(- i  q t))}})).(SM^(-1)).X.

This is the same as

(E^(A t)) . X = SM.(({{Cos[q t]  +  i Sin[q t], 0}, {0, Cos[q t]  -  i Sin[q t]}})).(SM^(-1)).X.

To see why the oscillate on closed curves centered at {0,0} ,remember that
           (E^(I q t)) = Cos[q t] + I Sin[q t] and   (E^(-I q t)) = Cos[q t] - I Sin[q t].
 The presence of the periodic oscillatory functions
           Sin[q t] and Cos[q t] 
 explains why the plots repeat themselves over and over on closed curves centered at {0,0}.
 In fact the bigger q is, the faster the oscillation. 
 Reason: The bigger q is, the faster Sin[q t] and Cos[q t] oscillate.