Update zkEVM - fixed equation rendering

Author: EmpieichO

docs/zkEVM/concepts/generic-state-machine/exec-trace-correct.md

@@ -198,12 +198,15 @@ As far as **boundary constraints** are concerned, we can, for instance,
 - create public 'variables'; $\texttt{input}$ and $\texttt{output}$,
 
 - set boundary constraints,
-  $$
-  \mathtt{L1(x) \cdot \big(FREE(\omega^0) - input\big) = 0} \\
-  \mathtt{L2(x) \cdot \big(A(\omega^{3}) - output\big) = 0}\quad \\
-  $$
-  where $\mathtt{L1(x)}$ and $\mathtt{L2(x)}$ are precomputed constant polynomials.
-   In fact, $\mathtt{L1(x) = [1,0,0,0]}$ and  $\mathtt{L2(x) = [0,0,0,1]}$.
+
+    $$
+    \mathtt{L1(x) \cdot \big(FREE(\omega^0) - input\big) = 0} \\
+    \mathtt{L2(x) \cdot \big(A(\omega^{3}) - output\big) = 0}\quad \\
+    $$
+
+    where $\mathtt{L1(x)}$ and $\mathtt{L2(x)}$ are precomputed constant polynomials.
+
+    In fact, $\mathtt{L1(x) = [1,0,0,0]}$ and  $\mathtt{L2(x) = [0,0,0,1]}$.
 
 In the big scheme of things, these are Lagrange polynomials emanating from interpolation. Verification relies on the fact that: these polynomial identities, including the boundary constraints, hold true *if, and only if* the execution trace is correct and faithful to the instructions in the zkASM program.
 

docs/zkEVM/concepts/generic-state-machine/plookup.md

@@ -81,7 +81,8 @@ The above concepts defined for multisets apply similarly to vectors, and the Plo
 
 A **vector** is a collection of ordered field elements, for some finite field $\mathbb{F}$, and it is denoted by $\mathbf{a} = ( a_1 , a_2 , \dots , a_n )$.
 
-A vector $\mathbf{a} = ( a_1 , a_2 , \dots , a_n )$ is **contained** in a vector $\mathbf{b} = ( b_1 , b_2 , \dots , b_d )$, denoted by $\mathbf{a} \sub \mathbf{b}$ , if each $a_i \in  \{ b_1 , b_2 , \dots , b_d \}$ for  $i \in \{ 1 , 2 , \dots , n \}$.
+A vector $\mathbf{a} = ( a_1 , a_2 , \dots , a_n )$ is **contained** in a vector $\mathbf{b} = ( b_1 , b_2 , \dots , b_d )$, denoted by 
+${\mathbf{a}} \subset {\mathbf{b}}$, if each $a_i \in  \{ b_1 , b_2 , \dots , b_d \}$ for  $i \in \{ 1 , 2 , \dots , n \}$.
 
 The **vector of differences** of a given vector $\mathbf{a} = ( a_1 , a_2 , \dots , a_n )$  is defined as the vector $\mathbf{a'} = (a_2 - a_1, a_3 - a_2, \dots , a_n - a_{n-1})$, which has one less component (or element) compared to $\mathbf{a}$. That is, $|\mathbf{a'}| = n - 1$  because $|\mathbf{a}| = n$.
 

docs/zkEVM/concepts/generic-state-machine/program-counter.md

@@ -15,9 +15,11 @@ Unlike the $\texttt{JMPZ(addr)}$ instruction, when the state machine executes $\
 ### Program Counter constraint related to JMP
 
 This is how the $\texttt{JMP(addr)}$ instruction is implemented: A new selector called $\texttt{JMP}$ is added, as a column to the execution trace. And, the Program Counter $\texttt{zkPC}$ now uses the following identity to keep track of the correct line of the assembly program to be executed next;
+
 $$
 \mathtt{zkPC' = (zkPC+1)+JMP \cdot \big(addr−(zkPC+1)\big)} \tag{Eqn 0*}
 $$
+
 $\texttt{JMP}$ therefore acts as a 'flag' where;
 
 - $\mathtt{zkPC' =  (zkPC+1)+ 0 \cdot \big(addr−(zkPC+1)\big) = zkPC+1}$, if $\texttt{JMP}$ is not activated (i.e., if $\texttt{JMP}$ is $\mathtt{0}$), or
@@ -154,12 +156,12 @@ $$
 \mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (0+1) + 0 \cdot \big( addr−(0+1) \big) = 0+1 = 1}.
 $$
 
-### Step 1: "−3=>B−3=>B"
+### Step 1: "−3=>B, −3=>B"
 
 In this step, a constant  $\mathtt{CONST = -3}$  is moved into the $\texttt{B}$ registry. Hence $\mathtt{setB = 1}$, $\mathtt{B' = -3}$, but $\mathtt{inB = 0}$, $\mathtt{inA = 0}$ and $\mathtt{inFREE = 0}$. This yields,
 
 $$
-\mathtt{op =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 0 \cdot A\ +\ 0 \cdot B\ +\ 0 \cdot FREE\ + (-3)    = -3}
+\mathtt{op =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 0 \cdot A\ +\ 0 \cdot B\ +\ 0 \cdot FREE\ + (-3)  = -3}
 $$
 
 and $\mathtt{invOp = (-3)^{-1}}$.
@@ -211,25 +213,31 @@ $$
 Here the sum of the registry values $\mathtt{A = 3}$ and $\mathtt{B = -3}$ is computed, and the result is moved into the registry $\mathtt{A}$. That is, $\mathtt{A' = 3 + (-3) = 0}$  and  $\mathtt{setA = 1}$. Also, $\mathtt{inA = 1}$ , $\mathtt{inB = 1}$ and $\mathtt{inFREE = 0}$.
 
 These values yield the following value of $\mathtt{op}$,
+
 $$
-\mathtt{op\ =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 1 \cdot 3\ +\ 1 \cdot (-3)\ +\ 0 \cdot FREE\ +\ 0\  =\ 0}.
+\mathtt{op\ = inA \cdot A + inB \cdot B + inFREE \cdot FREE + CONST = 1 \cdot 3 + 1 \cdot (-3) + 0 \cdot FREE + 0  = 0}.
 $$
+
 So, $\mathtt{invOp}$ is set to a randomly chosen non-zero $\mathtt{\alpha}$ in $\mathbb{F}_p$ , used to pass the identities related to $\texttt{isZero}$.
 
-And, $\mathtt{isZero\ := (1 − op \cdot invOp) = \big(1 − 0\cdot \alpha \big)\ =\ 1}$.
+And, $\mathtt{isZero := (1 − op \cdot invOp) = \big(1 − 0\cdot \alpha \big) = 1}$.
 
 Note that there are no jumps in the instruction, so $\mathtt{JMP = 0}$ and $\mathtt{JMPZ = 0}$. And therefore $\mathtt{zkPC′ = zkPC + 1}$.
 
 In order to verify that $\mathtt{zkPC′ = zkPC + 1 = 2 + 1 = 3}$, we use the constraints given as Eqn 4* above.
 
 Firstly, check $\mathtt{doJMP}$ as follows,
+
 $$
 \mathtt{doJMP\ :=\ JPMZ \cdot isZero + JMP\ = 0 \cdot 1\ +\ 0\ =\ 0}. \qquad\qquad\qquad\qquad\qquad \\
 $$
+
 Then,
+
 $$
-\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (2+1)\ +\ 0 \cdot \big( addr - (2+1)\big)\ =\ 3}.
+\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (2+1) + 0 \cdot \big( addr - (2+1)\big) = 3}.
 $$
+
 The Program Counter therefore moves to the subsequent line of instruction. That is, the next instruction to be executed must the one in $\texttt{line}$ $\texttt{3}$ of the Assembly code.
 
 ### Step 3: "A :JMPZ(finalWait)"
@@ -241,10 +249,10 @@ As mentioned above, the implicit address label "$\mathtt{finalWait}$" is compute
 Note that, $\mathtt{inB = 0}$ , $\mathtt{inFREE = 0}$ and $\mathtt{CONST = 0}$. Therefore,
 
 $$
-\mathtt{op\ =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 1 \cdot 0\ +\ 0 \cdot (-3)\ +\ 0 \cdot FREE\ +\ 0\  =\ 0}.
+\mathtt{op = inA \cdot A + inB \cdot B + inFREE \cdot FREE + CONST = 1 \cdot 0 + 0 \cdot (-3) + 0 \cdot FREE + 0 = 0}.
 $$
 
-Consequently,  $\mathtt{isZero\ := (1 − op \cdot invOp) = \big(1 − 0 \big)\ =\ 1}$. And since there are no unconditional jumps, $\mathtt{JMP = 0}$.  
+Consequently,  $\mathtt{isZero := (1 − op \cdot invOp) = \big(1 − 0 \big) = 1}$. And since there are no unconditional jumps, $\mathtt{JMP = 0}$.  
 
 We use Eqn 4 to check whether $\mathtt{zkPC′ = 5}$. Note that,
 
@@ -255,16 +263,18 @@ $$
 The next value of the Program Counter, according to Eqn 4, is
 
 $$
-\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big)\ =\ (3+1)\ +\ 1 \cdot \big(5−(3+1)\big)\ =\ 4 + (5-4)\ =\ 5.}
+\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (3+1) + 1 \cdot \big(5−(3+1)\big) = 4 + (5-4) = 5.}
 $$
 
 ### Step 4:  "{beforeLast()} :JMPZ(finalWait)"
 
 The $\texttt{beforeLast()}$ function, which keeps track of the number of steps being executed, reads the current step-number as a free input. Since the execution trace is currently at step $\mathtt{4}$ and not $\mathtt{6}$, then the executor returns a zero. And thus, $\mathtt{inFREE = 1}$ and $\mathtt{JMPZ = 1}$ but $\mathtt{inA = 0}$, $\mathtt{inB =0}$, $\mathtt{FREE = 0}$ and $\mathtt{CONST = 0}$. Consequently,
+
 $$
-\mathtt{op\ =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 0 \cdot A\ +\ 0 \cdot B\ +\ 1 \cdot 0\ +\ 0\  =\ 0}.
+\mathtt{op = inA \cdot A + inB \cdot B + inFREE \cdot FREE + CONST = 0 \cdot A + 0 \cdot B + 1 \cdot 0 + 0 = 0}.
 $$
-Therefore $\mathtt{isZero \ := (1 − op \cdot invOp)\ = (1 − 0 \cdot \alpha) = 1}$.
+
+Therefore $\mathtt{isZero := (1 − op \cdot invOp) = (1 − 0 \cdot \alpha) = 1}$.
 
 Hence according to $\texttt{JMPZ(finalWait)}$, a jump is executed. This means the executor must jump to the $\mathtt{offset = 5}$ address, as computed by the Assembly compiler. It follows that $\mathtt{zkPC′}$ must be $\mathtt{5}$.
 
@@ -277,7 +287,7 @@ $$
 The next value of the Program Counter is given by,
 
 $$
-\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big)\ =\ (5+1)\ +\ 1 \cdot \big(5−(5+1)\big)\ =\ 6 + (5-6)\ =\ 5.}
+\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (5+1) + 1 \cdot \big(5−(5+1)\big) = 6 + (5-6) = 5.}
 $$
 
 The execution trace is currently as follows,
@@ -317,7 +327,7 @@ As seen in Step 4, the $\texttt{beforeLast()}$ function checks if the execution
 Similarly, $\mathtt{inFREE = 1}$ and $\mathtt{JMPZ = 1}$ but $\mathtt{inA = 0}$, $\mathtt{inB =0}$, $\mathtt{FREE = 0}$ and $\mathtt{CONST = 0}$. As a result,
 
 $$
-\mathtt{op\ =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 0 \cdot A\ +\ 0 \cdot B\ +\ 1 \cdot 0\ +\ 0\  =\ 0},
+\mathtt{op = inA \cdot A + inB \cdot B + inFREE \cdot FREE + CONST = 0 \cdot A + 0 \cdot B + 1 \cdot 0 + 0  = 0},
 $$
 
 which means  $\mathtt{FREE = 0}$ and $\mathtt{isZero \ := (1 − op \cdot invOp)\ = (1 − 0 \cdot \alpha) = 1}$. So, again $\texttt{JMPZ(finalWait)}$ gets executed.
@@ -333,25 +343,29 @@ $$
 and use Eqn 4,
 
 $$
-\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big)\ =\ (5+1)\ +\ 1 \cdot \big(5−(5+1)\big)\ =\ 6 + (5-6)\ =\ 5.}
+\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (5+1) + 1 \cdot \big(5−(5+1)\big) = 6 + (5-6) = 5.}
 $$
 
 ### Step 6: "{beforeLast()} :JMPZ(finalWait)"
 
 In this case, the current step is the last but one step. That is, the $\texttt{beforeLast()}$ function holds true, and hence the executor must return a $\mathtt{1}$. So, $\mathtt{inFREE = 1}$ and $\mathtt{JMPZ = 1}$ while $\mathtt{inA = 0}$, $\mathtt{inB =0}$ and $\mathtt{CONST = 0}$. Then,
+
 $$
-\mathtt{op\ =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 0 \cdot A\ +\ 0 \cdot B\ +\ 1 \cdot 1\ +\ 0\  =\ 1}.
+\mathtt{op = inA \cdot A + inB \cdot B + inFREE \cdot FREE + CONST = 0 \cdot A + 0 \cdot B + 1 \cdot 1 + 0  = 1}.
 $$
+
 This means  $\mathtt{FREE = 1}$ and $\mathtt{isZero \ := (1 − op \cdot invOp)\ = (1 − 1 \cdot 1) = 0}$. And, this time $\texttt{JMPZ(finalWait)}$ is not executed, implying the next Program Counter, $\mathtt{zkPC′ = zkPC + 1}$.
 
 Since there are no jumps in this step, $\mathtt{JMP = 0}$ and $\mathtt{JMPZ = 0}$, yielding
+
 $$
 \mathtt{doJMP := JPMZ \cdot isZero + JMP = 0 \cdot 1 + 0 = 0}, \\
 $$
+
 and with a quick verification using Eqn 4*, we obtain
 
 $$
-\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big)\ =\ (5+1)\ +\ 0 \cdot \big(addr −(5+1)\big)\ =\ 6.}
+\mathtt{zkPC′ = (zkPC+1)+doJMP \cdot \big(addr−(zkPC+1)\big) = (5+1) + 0 \cdot \big(addr −(5+1)\big) = 6.}
 $$
 
 ### Step 7: "0=>A,B :JMP(start)"
@@ -363,10 +377,10 @@ It ends the execution by setting $\texttt{A}$ and $\texttt{B}$ to zero, and jump
 Hence, $\mathtt{setA = 1}$, $\mathtt{setB = 1}$ and $\mathtt{JMP = 1}$ but $\mathtt{inFREE = 0}$, $\mathtt{inA =0}$, $\mathtt{inB =0}$ and $\mathtt{CONST = 0}$. Consequently,
 
 $$
-\mathtt{op\ =\ inA \cdot A\ +\ inB \cdot B\ +\ inFREE \cdot FREE\ +\ CONST\ =\ 0 \cdot 0\ +\ 0 \cdot (-3)\ +\ 0 \cdot 1\ +\ 0\  =\ 0}.
+\mathtt{op = inA \cdot A + inB \cdot B + inFREE \cdot FREE + CONST = 0 \cdot 0 + 0 \cdot (-3) + 0 \cdot 1 + 0  = 0}.
 $$
 
-Therefore $\mathtt{isZero \ := (1 − op \cdot invOp)\ = (1 − 0 \cdot \alpha) = 1}$.
+Therefore $\mathtt{isZero := (1 − op \cdot invOp) = (1 − 0 \cdot \alpha) = 1}$.
 
 There are no conditional jumps, so $\mathtt{JMPZ = 0}$. Then, as a consequence of this,
 
@@ -382,26 +396,7 @@ $$
 
 This instruction, as the last step the Assembly program, achieves two things; Firstly, the program ends correctly with the specified size of the execution trace. Secondly, resetting $\texttt{A}$, $\texttt{B}$ and $\texttt{zkPC}$ to zero causes the execution trace to attain cyclicity.
 
-See the complete execution trace below,  
-
-<!-- $$
-\begin{aligned}
-\begin{array}{|l|c|}
-\hline
-\texttt{step} & \bf{instructions} \\ \hline
-\quad\texttt{0} & \mathtt{{getAFreeInput()} => A}\quad\qquad\qquad\\ \hline
-\quad\texttt{1} & \mathtt{-3 => B}\qquad\qquad\qquad\qquad\qquad\qquad\text{ }\text{ } \\ \hline
-\quad\texttt{2} & \mathtt{:ADD}\qquad\quad\qquad\qquad\qquad\qquad\qquad\ \\ \hline
-\quad\texttt{3} & \mathtt{A \qquad :JMPZ(finalWait)}\qquad\qquad \\ \hline
-\quad\texttt{4} & \mathtt{\{beforeLast()\}\quad:JMPZ(finalWait)} \\ \hline
-\quad\texttt{5} & \mathtt{\{beforeLast()\}\quad:JMPZ(finalWait)}\\ \hline
-\quad\texttt{6} & \mathtt{\{beforeLast()\}\quad:JMPZ(finalWait)}\\ \hline
-\quad\texttt{7} & \mathtt{0 => A,B \quad\qquad\ \ :JMP(start)}\qquad \\ \hline
-\end{array}
-\end{aligned}
-$$ -->
-
-<!-- \hspace{0.02cm} -->
+See the complete execution trace below,
 
 $$
 \small
@@ -420,26 +415,6 @@ $$
 \end{aligned}
 $$
 
-<!-- \hspace{0.02cm} -->
-
-<!-- $$
-\begin{aligned}
-\begin{array}{|l|c|c|c|c|c|c|c|}\hline
-\mathtt{op} & \mathtt{isZero} & \mathtt{doJMP} \\\hline
-\text{ }\mathtt{3} & \mathtt{0} & \mathtt{0} \\\hline
-\mathtt{-3} &\mathtt{0} & \mathtt{0}\\\hline
-\text{ }\mathtt{0} & \mathtt{1} & \mathtt{0} \\\hline
-\text{ }\mathtt{0} & \mathtt{1} & \mathtt{1}\\\hline
-\text{ }\mathtt{0} & \mathtt{1} & \mathtt{1} \\\hline
-\text{ }\mathtt{0} &\mathtt{1} & \mathtt{1} \\\hline
-\text{ }\mathtt{1} & \mathtt{0} & \mathtt{0} \\\hline
-\text{ }\mathtt{0} & \mathtt{1} & \mathtt{1}\\\hline
-\end{array}
-\end{aligned}
-$$ -->
-
-<!-- \hspace{0.02cm} -->
-
 $$
 \small
 \begin{aligned}

docs/zkEVM/concepts/mfibonacci/commitment-scheme.md

@@ -115,17 +115,23 @@ $$
 Since  $p_i(X) = 0$  for all  $X \in \mathcal{H} = \{ \omega, \omega^2, \omega^3, \dots , \omega^n = 1 \}$, then;
 
 $$
-p_i(X)\ =\ \big((X-1)\cdot(X-\omega)\cdot(X-\omega^2)\cdots(X-\omega^{n-1})\big)\cdot q_i(X)\ =\ \big( X^{n} - 1 \big) \cdot q_i(X)
+    p_i(X)\ =\ \big((X-1)\cdot(X-\omega)\cdot(X-\omega^2)\cdots(X-\omega^{n-1})\big)\cdot q_i(X)\ =\ \big( X^{n} - 1 \big) \cdot q_i(X)
 $$
 
 for some quotient polynomial $q_i(X)$, for each $i \in \{ 1, 2, 3 \}$.
 
 The polynomial identities of our mFibonacci state machine can therefore be rewritten as:
 
 $$
-\big( 1 − R(X) \big) \cdot \big[ P(X\cdot \omega) − Q(X) \big] = \mathtt{Z}_{\mathcal{H}}(X)\cdot q_1(X) \qquad\quad\text{ }\text{ }\text{ }\text{ } \\
-\big(1 − R(X)\big) · [Q(X\cdot \omega) − (P(X) · Q(X))] = \mathtt{Z}_{\mathcal{H}}(X)\cdot q_2(X) \text{}\text{ }\\
-\big(P(\omega^{\mathtt{T}}) - \mathcal{K} \big)\cdot R(X) = \mathtt{Z}_{\mathcal{H}}(X)\cdot q_3(X) \qquad\text{}\text{}\quad\qquad\qquad\qquad\text{ }
+    \big( 1 − R(X) \big) \cdot \big[ P(X\cdot \omega) − Q(X) \big] = \mathtt{Z}_{\mathcal{H}}(X)\cdot q_1(X) \qquad\quad\text{ }\text{ }\text{ }\text{ } \\
+$$
+
+$$
+    \big(1 − R(X)\big) · [Q(X\cdot \omega) − (P(X) · Q(X))] = \mathtt{Z}_{\mathcal{H}}(X)\cdot q_2(X) \text{}\text{ }\\
+$$
+
+$$
+    \big(P(\omega^{\mathtt{T}}) - \mathcal{K} \big)\cdot R(X) = \mathtt{Z}_{\mathcal{H}}(X)\cdot q_3(X) \qquad\text{}\text{}\quad\qquad\qquad\qquad\text{ }
 $$
 
 The representatives $R(X)$ and $Z_{\mathcal{H}}(X)$ in the PCS, can be preprocessed and be made public (i.e., known to both the Prover and the Verifier). The Verifier can check specific openings of these polynomials, $R(X)$ and $Z_{\mathcal{H}}(X)$.

docs/zkEVM/concepts/mfibonacci/mfibonacci-example.md

@@ -3,6 +3,7 @@ Consider a proof/verification scheme, using an arbitrary Polynomial Commitment S
 ## What is a multiplicative Fibonacci series?
 
 The multiplicative Fibonacci Series (or simply mFibonacci Series), denoted by
+
 $$
 \mathbf{a_0, a_1, a_2, \dots , a_n}
 $$
@@ -24,12 +25,14 @@ The task therefore, is to first build a state machine that would enable anyone t
 ## Constructing mFibonacci state machine
 
 Consider a state machine with two registries $\mathbf{A}$ and $\mathbf{B}$ where
+
 $$
 \begin{aligned}
-\mathbf{A} = [A_0, A_1, \dots , A_T ], \\
-\mathbf{B} = [B_0, B_ 1, \dots , B_T]
+    &\mathbf{A} = [A_0, A_1, \dots , A_T ], \\
+    &\mathbf{B} = [B_0, B_ 1, \dots , B_T]
 \end{aligned}
 $$
+
 such that the i-th state is the pair $\big( A_i , B_i \big)$.
 
 Such a state machine is an **mFibonacci state machine** if indeed the registry values conform to the format of the mFibonnacci Series. See Figure 4 below, for an mFibonacci state machine with the initial conditions, $A_0 = 2$ and $B_0 = 1$.
@@ -52,9 +55,11 @@ The aim here is to; express the evolution of the execution trace in terms of pol
 The polynomials that represent the two registries are taken from the set of polynomials $\mathbb{F}_p [X]$, where the coefficients are elements of a prime field $\mathbb{F}_p$ and $p = 2^{64} − 2^{32} + 1$.
 
 The polynomials are evaluated over the subgroup
+
 $$
 {\mathcal{H}} = \{ \omega, \omega^2, \omega^3, \dots , \omega^7, \omega^8 = 1 = \omega^0 \} = \langle \omega \rangle \subseteq \mathbb{F}_p^*
 $$
+
 of order $8$.
 
 Define two polynomials $P(X)$ and $Q(X)$ such that:
@@ -129,6 +134,7 @@ Hence the mFibonacci SM is as depicted in Figure 5 below.
 ![mFibonacci SM with three registries](../../../img/zkEVM/fib7-mfibon-sm-3-regs.png)
 
 The corresponding polynomial $R(x)$ is defined as follows;
+
 $$
 R(\omega^i) = C[i]
 $$
@@ -195,7 +201,9 @@ In addition to transition constraints, are **boundary constraints**. A **boundar
 
 ### Varied initial conditions
 
-Note that instead of being restricted to the given initial conditions $\big( A_0 , B_0 \big) = \big( 2 , 1 \big)\$, the mFibonacci state machine together with its polynomial identities can be adjusted to any initial conditions $\big( A_0 , B_0 \big)\$.
+Note that instead of being restricted to the given initial conditions 
+$\big(A_0, B_0\big) = \big(2, 1\big)$
+the mFibonacci state machine together with its polynomial identities can be adjusted to any initial conditions $\big(A_0, B_0\big)$.
 
 For example, for $A_0 = 23$ and $B_0 = 46$, the constraints should be;
 
@@ -206,7 +214,7 @@ $$
 \end{aligned}
 $$
 
-In the context of our mFibonacci SM, the verifier can set the initial conditions $\big( A_0 , B_0 \big)\$ to values of his or her own choice, and generate the state machine while keeping $\A_0\$ and $\B_0\$ secret. The prover's task is therefore, to prove knowledge of $\A_0\$ and $\B_0\$ that led to a given N-th term of the mFibonacci Series.
+In the context of our mFibonacci SM, the verifier can set the initial conditions $\big( A_0 , B_0 \big)$ to values of his or her own choice, and generate the state machine while keeping $A_0$ and $B_0$ secret. The prover's task is therefore, to prove knowledge of $A_0$ and $B_0$ that led to a given N-th term of the mFibonacci Series.
 
 ### Boundary constraints