diff --git a/LaTeX/thesis.tex b/LaTeX/thesis.tex
index 6b8fa2c..d4e8f3d 100644
--- a/LaTeX/thesis.tex
+++ b/LaTeX/thesis.tex
@@ -602,12 +602,95 @@
 				The most basic building block of any trajectory is a physical model for simulating
 				natural trajectories from one point forward in time. The approach taken by this
 				paper uses the solution to Kepler's equation put forward by
-				Conway\cite{laguerre_conway} in 1986.
+				Conway\cite{laguerre_conway} in 1986 in order to provide simple and very
+				processor-efficient propagation without the use of integration. The code logic
+				itself is actually quite simple, providing an approach similar to the Newton-Raphson
+				approach for finding the roots of the Battin form of Kepler's equation.
+
+				The following pseudo-code outlines the approach taken for the elliptical case. The
+				approach is quite similar when $a<0$:
+
+				% TODO: Some symbols here aren't recognized by the font
+				\begin{singlespacing}
+				\begin{verbatim}
+					i = 0
+					# First declare some useful variables from the state
+					σ0 = (position ⋅ velocity) / √(μ)
+					a = 1 / ( 2/norm(position) - norm(velocity)^2/μ )
+					coeff = 1 - norm(position)/a
+
+					# This loop is essentially a second-order Newton solver for ΔE
+					ΔM = ΔE_new = √(μ/a^3) * time
+					ΔE = 1000
+					while abs(ΔE - ΔE_new) > 1e-10
+						ΔE = ΔE_new
+						F = ΔE - ΔM + σ0 / √(a) * (1-cos(ΔE)) - coeff * sin(ΔE)
+						dF = 1 + σ0 / √(a) * sin(ΔE) - coeff * cos(ΔE)
+						d2F = σ0 / √(a) * cos(ΔE) + coeff * sin(ΔE)
+						ΔE_new = ΔE - n*F / ( dF + sign(dF) * √(abs((n-1)^2*dF^2 - n*(n-1)*F*d2F )))
+						i += 1
+					end
+
+					# ΔE can then be used to determine the F/Ft and G/Gt coefficients
+					F = 1 - a/norm(position) * (1-cos(ΔE))
+					G = a * σ0/ √(μ) * (1-cos(ΔE)) + norm(position) * √(a) / √(μ) * sin(ΔE)
+					r = a + (norm(position) - a) * cos(ΔE) + σ0 * √(a) * sin(ΔE)
+					Ft = -√(a)*√(μ) / (r*norm(position)) * sin(ΔE)
+					Gt = 1 - a/r * (1-cos(ΔE))
+
+					# Which provide transformations from the original position and velocity to the
+					# final
+					final_position = F*position + G*velocity
+					final_velocity = Ft*position + Gt*velocity
+				\end{verbatim}
+				\end{singlespacing}
+
+				This approach was validated by generating known good orbits in the 2 Body Problem.
+				For example, from the orbital parameters of a certain state, the orbital period can
+				be determined. If the system is then propagated for an integer multiple of the orbit
+				period, the state should remain exactly the same as it began. In
+				Figure~\ref{laguerre_plot} an example of such an orbit is provided.
+
+				\begin{figure}
+					\centering
+					\includegraphics[width=\textwidth]{fig/kepler}
+					\caption{Example of a natural trajectory propagated via the Laguerre-Conway
+					approach to solving Kepler's Problem}
+					\label{laguerre_plot}
+				\end{figure}
+				% TODO: Generate an orbit figure for here
+				% TODO: Consider adding a paragraph about the improvements in processor time
 
 			\subsection{Sims-Flanagan Propagator}
-				Discuss how this algorithm can then be expanded by using SFT to propagate any number of
-				low-thrust steps over a specific arc. Mention validation. Here I can also mention the ``Sc''
-				object and talk about how those parameters were chosen and effected the propagator.
+
+				Until this point, we've not yet discussed how best to model the low-thrust
+				trajectory arcs themselves. The Laguerre-Conway algorithm efficiently determines
+				natural trajectories given an initial state, but it still remains, given a control
+				law, that we'd like to determine the trajectory of a system with continuous input
+				thrust.
+
+				For this, we leverage the Sims-Flanagan transcription mentioned earlier. This allows
+				us to break a single phase into a number of ($n$) different arcs. At the center of
+				each of these arcs we can place a small impulsive burn, scaled appropriately for the
+				thruster configured on the spacecraft of interest. Therefore, for any given phase,
+				we actually split the trajectory into $2n$ sub-trajectories, with $n$ scaled
+				impulsive thrust events. As $n$ is increased, the trajectory becomes increasingly
+				accurate as a model of low-thrust propulsion in the 2BP. This allows the mission
+				designer to trade-off speed of propagation and the fidelity of the results quite
+				effectively.
+
+				\begin{figure}
+					\centering
+					\includegraphics[width=\textwidth]{fig/kepler}
+					\caption{An example trajectory showing that classic continuous-thrust orbit
+					shapes, such as this orbit spiral, are easily achievable using a Sims-Flanagan
+					model}
+					\label{sft_plot}
+				\end{figure}
+				% TODO: Generate an orbit figure for here
+
+				Figure~\ref{sft_plot} shows that the Sims-Flanagan transcription model can be used
+				to effectively model these types of orbit trajectories.
 
 			\subsection{Non-Linear Problem Solver}
 				Mention the package being used to solve NLPs and how it works, highlighting the trust region
diff --git a/Makefile b/Makefile
index c8ed8c9..dce770c 100644
--- a/Makefile
+++ b/Makefile
@@ -22,7 +22,7 @@ thesis_pdf/:
 	mkdir $@
 
 $(THESIS_PDF): $(THESIS) LaTeX/thesis.bib
-	mkdir temp
+	mkdir -p temp
 	cp -r LaTeX/fig .
 	cp -r LaTeX/flowcharts .
 	cp -r LaTeX/thesis.tex .