In this section, a family of theorems are presented that pertain to the sequential software engineering methodology.
The sequential software engineering methodology will find solutions in static environments but not in dynamic environments. If a solution exists, and the
sequential software engineering methodology finds the solution, the best case performance is *O*(*N*), the
worst case performance is *O*(*N*), while the
average case performance is *O*(*N*) where N is the total number of steps in the environment.

Let
be the *n*_{a} requirements
leading to a possible analysis *A*
with *a*_{1} the initial problem statement.
Let
be the *n*_{d} architecture elements
leading to a possible design *D*.
Let
be the *n*_{i}
implementation components
leading
to a possible implementation *I*.
Let
be the *n*_{t}
testing suites leading
to a possible testing *T*
with *t*_{nt} being the final system acceptance
test.
Define a static environment that consists of the four planes of analysis, design, implementation, and testing with each lower plane being a refinement of the higher planes.
Define the solution as the tree, or in a more general sense,
the directed acyclic graph, of all steps from all four planes
used in the final system. This solution can be represented as a sequence of steps <*A*,*D*,*I*,*T*>.

See Figure 5.5 on page for a visual representation of the static environment. See Figure 5.9, Figure 5.10, and Figure 5.11, on pages through for a visual guide of the reasoning. The numbers associated with the steps represent the order visited by the methodology.

A sequential software engineering methodology leads to a
sequence of
steps.

The sequence represented by
<*A*,*D*,*I*,*T*>
is the solution.

These steps find a solution where steps at the higher levels are exhausted first before going into lower levels. If the environment is static, then all steps in the environment are known before the sequential methodology begins. The sequential methodology first discovers all steps in the analysis plane, followed by all steps in the design plane, followed by all steps in the implementation plane, and then followed by all steps in the testing plane. This can be accomplished because the environment is static and finite. Eventually in the static environment the solution is discovered. Thus, the sequential software engineering methodology is static complete.

In a sequential software engineering methodology, all of the high level steps are exercised before proceeding to the next plane of the space. If a new step is introduced once the sequential software engineering methodology has finished with this plane of the environment, the new step will not be part of the solution. The sequential methodology will no longer be able to find the solution.

Let the initial environment consist of
*n*_{a} analysis steps, *n*_{d} design steps, *n*_{i} implementation steps, and *n*_{t} testing steps.

At step *n*_{a} + 1 the sequential software engineering methodology has accomplished the steps
.
At this time
introduce a new requirement
*a*_{n<<1807>>a+1}. The
sequential software engineering methodology has already finished with the analysis plane and will not discover this new requirement.
Thus, a sequential software engineering methodology is dynamic incomplete.