diff --git a/component_failure_modes_definition/component_failure_modes_definition.tex b/component_failure_modes_definition/component_failure_modes_definition.tex
index 7cb5740..27dc551 100644
--- a/component_failure_modes_definition/component_failure_modes_definition.tex
+++ b/component_failure_modes_definition/component_failure_modes_definition.tex
@@ -349,9 +349,9 @@ Because of this, the failure mode set $F=fm(R)$ is `unitary~state'.
 
 Thus because both fault modes cannot be active at the same time, the intersection of $ R_{SHORTED} $ and $ R_{OPEN} $ cannot exist.
 
-$$ R_{SHORTED} \cap R_{OPEN} = \emptyset $$
+ The intersection of these is therefore the empty set, $ R_{SHORTED} \cap R_{OPEN} \eq \emptyset $,
 therefore
-$$ fm(R) \in \mathcal{U} $$
+$ fm(R) \in \mathcal{U} $.
 
 
 We can make this a general case by taking a set $F$ (where $f_1, f_2 \in F$) representing a collection
@@ -470,7 +470,7 @@ from $1$ to $cc$ thus
 %
 
 \begin{equation}
- |{\mathcal{P}_{cc}S}| = \sum^{k}_{1..cc} \frac{|{S}|!}{ k! ( |{S}| - k)!}    
+ |{\mathcal{P}_{cc}S}| = \sum^{cc}_{k=1} \frac{|{S}|!}{ k! ( |{S}| - k)!}    
  \label{eqn:ccps}
 \end{equation}
 
@@ -478,7 +478,7 @@ from $1$ to $cc$ thus
 
 \subsection{Actual Number of combinations to check \\ with Unitary State Fault mode sets}
 
-Where all the fault modes in $S$ were to be independent,
+If all of the fault modes in $S$ were independent,
 the cardinality constrained powerset
 calculation (in equation \ref {eqn:ccps}) would give the correct number of test case combinations to check.
 Because  sets of failure modes in FMMD analysis are constrained to be unitary state,
@@ -486,7 +486,7 @@ the actual number of test cases to check will usually
 be less than this. 
 This is because combinations of faults within a components failure mode set,
 are impossible under the conditions of  unitary state failure mode.
-To correct equation \ref{eqn:ccps} we must subtract the number of component `internal combinations'
+To modify equation \ref{eqn:ccps} for unitary state conditions, we must subtract the number of component `internal combinations'
 for each component in the functional group under analysis.
 Note we must sequentially subtract using combinations above 1 up to the cardinality constraint. 
 For example, say 
@@ -495,7 +495,7 @@ $|{n \choose 2}|$ and $|{n \choose 3}|$ for each component in the functional~gro
 
 \subsubsection{Example: Two Component functional group \\ cardinality Constraint of 2}
 
-For example: were we to have a simple functional group with two components R and T, of which
+For example: suppose we have a simple functional group with two components R and T, of which
 $$fm(R) = \{R_o, R_s\}$$ and $$fm(T) = \{T_o, T_s, T_h\}$$.
 
 This means that the functional~group $FG=\{R,T\}$ will have a component failure mode set 
@@ -504,7 +504,7 @@ of $fm(FG) = \{R_o, R_s, T_o, T_s, T_h\}$
 For a cardinality constrained powerset of 2, because there are 5 error modes ( $|fm(FG)|=5$),
 applying equation \ref{eqn:ccps} gives :-
 
-$$\frac{5!}{1!(5-1)!} + \frac{5!}{2!(5-2)!}  = 15$$
+$$ | P_2 (fm(FG)) |  = \frac{5!}{1!(5-1)!} + \frac{5!}{2!(5-2)!}  = 15$$.
 
 This is composed of ${5 \choose 1}$
 five single fault modes, and ${5 \choose 2}$ ten double fault modes.
@@ -525,7 +525,7 @@ $$ \mathcal{P}_{2}(fm(FG)) =  \{
  \}
 $$
 
-And by inspection
+And % by inspection
 $$ 
 | 
 \{
@@ -539,30 +539,30 @@ $$
 \subsubsection{Establishing Formulae for unitary state failure mode \\
 cardinality calculation}
 
-The cardinality constrained powerset in equation \ref{eqn:ccps}, can be corrected for 
+The cardinality constrained powerset in equation \ref{eqn:ccps}, can be modified for % corrected for 
 unitary state failure modes.
 This is written as a general formula in equation \ref{eqn:correctedccps}. 
 
 %\indent{
-where :
+To define terms :
 \begin{itemize}
 \item Let $C$ be a set of components (indexed by $j \in  J$)
 that are members of the functional group $FG$
 i.e. $ \forall j \in J | C_j \in FG $
 \item Let $|fm({C}_{j})|$
-indicate the number of mutually exclusive fault modes of each component
+indicate the number of mutually exclusive fault modes of component $C_j$.
 \item Let $fm(FG)$ be the collection of all failure modes
 from all the components in the functional group. 
-\item Let $SU$ be a set of failure modes from the functional group,
-where all contributing components $C_j$ 
-are guaranteed to be `unitary state' i.e. $(SU = fm(FG)) \wedge (\forall j \in J | fm(C_j) \in \mathcal{U}) $
+\item Let $SU$ be the set of failure modes from the {\fg} where all $FG$   is such that
+components $C_j$ are in
+`unitary state' i.e. $(SU = fm(FG)) \wedge (\forall j \in J | fm(C_j) \in \mathcal{U}) $
 \end{itemize}
 %}
 
 
 \begin{equation}
- |{\mathcal{P}_{cc}SU}| = {\sum^{k}_{1..cc}  \frac{|{SU}|!}{k!(|{SU}| - k)!}}  
-- \sum^{p}_{2..cc}{{\sum^{j}_{j \in J} {|FM({C_{j})}| \choose p}}} 
+ |{\mathcal{P}_{cc}SU}| = {\sum^{cc}_{k=1}  \frac{|{SU}|!}{k!(|{SU}| - k)!}}  
+- \sum^{cc}_{p=2}{{\sum{j \in J} {|FM({C_{j})}| \choose p}}} 
  \label{eqn:correctedccps}
 \end{equation}
 
@@ -570,16 +570,56 @@ Expanding the combination in equation \ref{eqn:correctedccps}
 
 
 \begin{equation}
- |{\mathcal{P}_{cc}SU}| = {\sum^{k}_{1..cc}  \frac{|{SU}|!}{k!(|{SU}| - k)!}}   
-- \sum^{p}_{2..cc}{{\sum^{j}_{j \in J}   \frac{|FM({C_j})|!}{p!(|FM({C_j})| - p)!}}  }
+ |{\mathcal{P}_{cc}SU}| = {\sum^{cc}_{k=1}  \frac{|{SU}|!}{k!(|{SU}| - k)!}}   
+- \sum^{cc}_{p=2}{{\sum{j \in J}   \frac{|FM({C_j})|!}{p!(|FM({C_j})| - p)!}}  }
  \label{eqn:correctedccps2}
 \end{equation}
 
+\paragraph{Use of Equation \ref{eqn:correctedccps2} }
 Equation \ref{eqn:correctedccps2} is useful for an automated tool that
 would verify that an `N' simultaneous failures model had complete failure mode coverage.
 By knowing how many test cases should be covered, and checking the cardinality
 associated with the test cases, complete coverage would be verified.
 
+\paragraph{Practicality}
+Functional Group may consist, typically of four or five components, which typically
+have two or three failure modes each. Taking a worst case of mutiplying these
+by a factor of five (the number of failure modes and components) would give
+$25 \times 15 = 375$
+
+
+
+\begin{verbatim}
+
+# define a factorial function
+# gives 1 for negative values as well
+define f(x) {
+  if (x>1) {
+    return (x * f (x-1))
+  }
+  return (1)
+
+}
+define u1(c,x) {
+ return f(c*x)/(f(1)*f(c*x-1))
+}
+define u2(c,x) {
+ return f(c*x)/(f(2)*f(c*x-2))
+}
+
+define uc(c,x) {
+ return c * f(x)/(f(2)*f(x-2))
+}
+
+# where c is number of components, and x is number of failure modes
+# define function u to calculate combinations to check for double sim failure modes
+define u(c,x) {
+f(c*x)/(f(1)*f(c*x-1)) + f(c*x)/(f(2)*f(c*x-2)) - c * f(c)/(f(2)*f(c-2))
+}
+
+
+\end{verbatim}
+
 
 \pagebreak[1]
 \section{Component Failure Modes \\ and Statistical Sample Space}
diff --git a/component_failure_modes_definition/unitary_state.bc b/component_failure_modes_definition/unitary_state.bc
new file mode 100644
index 0000000..fe703a3
--- /dev/null
+++ b/component_failure_modes_definition/unitary_state.bc
@@ -0,0 +1,42 @@
+# NOT FINISHED YET !!!!
+
+# define a factorial function
+# gives 1 for negative values as well
+define f(x) {
+  if (x>1) {
+    return (x * f (x-1))
+  }
+  return (1)
+}
+
+# determine how many combinations would be dis-allowed
+# from a cardinality constrained powerset
+# given unitary state failure mode conditions
+define uc(k,c,x) {
+ aa = 0;
+ for(i=2; i<=k; i++)  aa += c * f(c)/(f(i)*f(c-i));
+ return aa;
+}
+
+# cardinality constrained powerset
+# how many combinations of cardinality k
+# can we have from c number of components
+# with x number of failure modes
+define ccps(k,c,x) {
+ return f(c*x)/(f(k)*f(c*x-k))
+}
+
+
+
+define us(k,c,x) {
+	a=0;
+	for(i=1;i<=k;i++) a += ccps(i,c,x);
+	# a now holds all combinations 
+	# we must now subtract those combinations
+	# dis-allowed under unitary state conditions.
+	a -= uc(k,c,x);
+	return a;
+}
+
+
+us(2,3,3);