Last update fixing table & equation rendering

Author: EmpieichO

docs/zkEVM/architecture/zkprover/arithmetic-sm.md

@@ -1,6 +1,6 @@
-The **Arithmetic State Machine** is a secondary state machine that also **has an executor (the Arithmetic SM Executor)** and **an internal Arithmetic program (a set of verification rules written in the PIL language)**. The Arithmetic SM Executor is available in two languages: Javascript and C/C++.
+The Arithmetic State Machine is a secondary state machine that also has an executor (the Arithmetic SM Executor) and an internal Arithmetic program (a set of verification rules written in the PIL language). The Arithmetic SM Executor is available in two languages: Javascript and C/C++.
 
-It is **one of the six secondary state machines** receiving instructions from the Main SM Executor. The main purpose of the Arithmetic SM is to carry out elliptic curve arithmetic operations, such as Point Addition and Point Doubling as well as performing 256-bit operations like addition, product or division.
+It is one of the six secondary state machines receiving instructions from the Main SM Executor. The main purpose of the Arithmetic SM is to carry out elliptic curve arithmetic operations, such as Point Addition and Point Doubling as well as performing 256-bit operations like addition, product or division.
 
 ## Standard elliptic curve arithmetic
 
@@ -55,7 +55,7 @@ For instance, if $C = 0$, then $\bf{Eqn\ A}$ states that the result of multiplyi
 
 Or, if $B = 1$,  $\bf{Eqn\ A}$ states that the result of adding $A$ and $C$ is the same as before: $E$ with a carry of $D$. Similarly, division and modular reductions can also be expressed as derivatives of $\bf{Eqn\ A}$.
 
-**These operations are performed in the Arithmetic State Machine, with registers satisfying the following PIL relation**,
+These operations are performed in the Arithmetic State Machine, with registers satisfying the following PIL relation,
 
 $$
 \text{EQ}_0 \colon \quad x_1 \cdot y_1 + x_2 - y_2 \cdot 2^{256} - y_3 = 0
@@ -81,7 +81,7 @@ $$
 
 where $q_0,q_1,q_2 \in \mathbb{Z}$, implying that these equations hold true over the integers.
 
-This approach is taken because of the need to compute divisions by $p$. Note that **only three possible computation scenarios can arise**:
+This approach is taken because of the need to compute divisions by $p$. Note that only three possible computation scenarios can arise:
 
 1. $\text{EQ}_0$ is activated while the rest are deactivated,
 2. $\text{EQ}_1$, $\text{EQ}_3$ and $\text{EQ}_4$ are activated but $\text{EQ}_0$ and $\text{EQ}_2$ are deactivated,
@@ -175,6 +175,6 @@ $$
 
 The Polygon zkEVM repository is available on [GitHub](https://github.com/0xPolygonHermez).
 
-**Arithmetic SM Executor**: [sm_arith folder](https://github.com/0xPolygonHermez/zkevm-proverjs/tree/main/src/sm/sm_arith)
+Arithmetic SM Executor: [sm_arith folder](https://github.com/0xPolygonHermez/zkevm-proverjs/tree/main/src/sm/sm_arith)
 
-**Arithmetic SM PIL**: [arith.pil](https://github.com/0xPolygonHermez/zkevm-proverjs/blob/main/pil/arith.pil)
+Arithmetic SM PIL: [arith.pil](https://github.com/0xPolygonHermez/zkevm-proverjs/blob/main/pil/arith.pil)

docs/zkEVM/architecture/zkprover/bits2field-sm.md

@@ -1,16 +1,16 @@
-The **Bits2Field State Machine** is one of the auxiliary state machines used specifically for parallelizing the implementation of KECCAK-F SM. Its source code is available [here](https://github.com/0xPolygonHermez/zkevm-prover/blob/main/src/sm/bits2field/bits2field_executor.cpp).
+The Bits2Field state machine is one of the auxiliary state machines used specifically for parallelizing the implementation of KECCAK-F SM. Its source code is available [here](https://github.com/0xPolygonHermez/zkevm-prover/blob/main/src/sm/bits2field/bits2field_executor.cpp).
 
-The Bits2Field state machine ensures correct packing of $\mathtt{44}$ bits from $\mathtt{44}$ different $\mathtt{1600}$-row blocks of the Padding-KK-Bit SM into a single field element. Therefore, **it operates like a (44 bits to 1 field element) multiplexer between the Padding-KK-Bit SM and the Keccak-F SM**.
+The Bits2Field state machine ensures correct packing of $\mathtt{44}$ bits from $\mathtt{44}$ different $\mathtt{1600}$-row blocks of the Padding-KK-Bit SM into a single field element. Therefore, it operates like a (44 bits to 1 field element) multiplexer between the Padding-KK-Bit SM and the Keccak-F SM.
 
-In simpler terms, it takes bits from $\mathtt{44}$ different blocks, places them into the first 44 bit-positions of a single field element, whereupon the KECCAK-F circuit runs. **The name Bits2Field State Machine refers to the processing where $44$ **bits** from $44$ different blocks of the Padding-KK-Bit SM are inserted into a single field element**.
+In simpler terms, it takes bits from $\mathtt{44}$ different blocks, places them into the first 44 bit-positions of a single field element, whereupon the KECCAK-F circuit runs. The name Bits2Field state machine refers to the processing where $44$ bits from $44$ different blocks of the Padding-KK-Bit SM are inserted into a single field element.
 
-Although the KECCAK-F SM is a binary circuit, instead of executing on a bit-by-bit basis, **it is implemented to execute KECCAK-F operations on a 44bits-by-44bits basis**. This is tantamount to running $\mathtt{44}$ KECCAK-F hashing circuits in parallel.
+Although the KECCAK-F SM is a binary circuit, instead of executing on a bit-by-bit basis, it is implemented to execute KECCAK-F operations on a 44bits-by-44bits basis. This is tantamount to running $\mathtt{44}$ KECCAK-F hashing circuits in parallel.
 
 ![The 44 bits to 1 field-element Multiplexing](../../../img/zkEVM/01b2f-44-2-one-multiplex.png)
 
 ## Mapping 44 Bits To A 64-bit Field Element
 
-Suppose operations are carried out in a field $\mathbb{F}_p$ of $\mathtt{64}$-bit numbers. **The smallest field used in the zkProver is the Goldilocks Field $\mathbb{F}_p$ where $p = 2^{64} - 2^{32}+1$**.
+Suppose operations are carried out in a field $\mathbb{F}_p$ of $\mathtt{64}$-bit numbers. The smallest field used in the zkProver is the Goldilocks Field $\mathbb{F}_p$ where $p = 2^{64} - 2^{32}+1$.
 
 After multiplexing, the 44 bits are loaded into the first 44 least significant bit-positions of the field element as depicted in the figure below.
 

docs/zkEVM/architecture/zkprover/construct-key-path.md

@@ -96,7 +96,7 @@ The quadruple structure of the path bits and the level of leaves therefore have
 
 Since **addition modulo n** is an expensive computation in the state machine context, it is important to find a more efficient algorithm to achieve the same result.
 
-## Alternate Cyclic Group Of Order 4
+## Alternate cyclic group of order 4
 
 In order to explore cyclic groups of order 4, take the vector  $\mathbf{x} = (1,0,0,0)$ , and rotate the components of $\mathbf{x}$ one position to the left.
 
@@ -129,7 +129,7 @@ $$
 \text{00} \mapsto (1,0,0,0),\ \ \text{01} \mapsto (0,1,0,0),\ \ \text{10} \mapsto (0,0,1,0)\  \text{ and }\ \text{11} \mapsto (0,0,0,1).
 $$
 
-## Special Cyclic Register For Leaf Levels
+## Special cyclic register for leaf levels
 
 Define a register called `LEVEL` which is vector of four bits, three **0** bits and one **1** bit. And the operation  `ROTATE_LEVEL`  which is the **left rotation** of `LEVEL`'s bits by one position.
 
@@ -141,7 +141,7 @@ $$
 
 Therefore, `LEVEL` is cyclic under `ROTATE_LEVEL`, and is in fact algebraically the same as the cyclic group $\mathbf{G_4}$ described above.
 
-### Using `LEVEL` Register in Key Reconstruction
+### Using `LEVEL` register in key reconstruction
 
 First note that, when navigating the tree, the leaf level can be indicated by one of the four possible states of the `LEVEL` register. And this works for all possible leaf levels because, for any positive integer $j$:
 

docs/zkEVM/architecture/zkprover/executor-pil.md

@@ -1,5 +1,3 @@
-## The Storage executor
-
 The Storage Executor is like a slave-worker to the master, the Storage Assembly code. It carries out all Storage Actions in accordance with rules and logic that the Assembly code has set out.
 
 As per instruction of the Main SM, the Storage Executor makes function calls to the Storage ROM for a specific secondary Assembly code stored as a JSON-file, by using the same aforementioned **selectors** of secondary Assembly codes.
@@ -30,7 +28,7 @@ are actually performed by the Storage Executor. The values being fetched are car
 
 Also, since all Storage Actions require some hashing, the Storage SM delegates all hashing actions to the POSEIDON SM. However, from within the Storage SM, it is best to treat the POSEIDON SM as a blackbox. The Storage Executor simply specifies the sets of twelve values to be digested. And the POSEIDON SM then returns the required digests of the values.
 
-## The Storage PIL
+## Storage PIL
 
 All computations executed in the Storage SM must be verifiable. A special Polynomial Identity Language (PIL) code is therefore used to set up all the polynomial constraints the verifier needs so as to validate correctness of execution.
 
@@ -63,7 +61,7 @@ Therefore, instead of performing some expensive computations in order to verify
 
 The verifier takes the execution trace, and tests if it satisfies the polynomial constraints (or identities) in the PIL code. This technique helps the zkProver to achieve succintness as a zero-knowledge proof/verification system.
 
-## The Poseidon hash
+## Poseidon hash
 
 Poseidon SM is more straightforward once one understands the internal mechanism of the original Poseidon hash function. The hash function's permutation process translates readily to the Poseidon SM states.
 

docs/zkEVM/architecture/zkprover/intro-storage-sm.md

@@ -1,12 +1,10 @@
-## Introduction
-
 A standard state machine is characterized by sets of states (as inputs) stored in registers, instructions on how the states should transition, and the resultant states (as outputs) stored as new values in the same registers. The below figure demonstrates a standard state machine.
 
-![A Generic State Machine](../../../img/zkEVM/fig1-gen-state-mchn.png)
+![A Generic state machine](../../../img/zkEVM/fig1-gen-state-mchn.png)
 
 State machine can be monolithic, where it is a prototype of one particular computation, while others may specialise with certain types of computations. Depending on the computational algorithm, a state machine may have to run through a number of state transitions before producing the desired output. Iterations of the same sequence of operations may be required, to the extend that most common state machines are cyclic by nature.
 
-The **Storage State Machine** is one of the **secondary zkProver state machine responsible for all operations on data stored in the zkProver's storage**. It receives instructions from the Main State Machine, called **Storage Actions**. The Main State Machine performs typical database operations such as: **Create, Read, Update and Delete (CRUD)**; and then instructs the Storage State Machine to verify whether these were correctly performed.
+The **Storage state machine** is one of the **secondary zkProver state machine responsible for all operations on data stored in the zkProver's storage**. It receives instructions from the Main state machine, called **Storage Actions**. The Main state machine performs typical database operations such as: **Create, Read, Update and Delete (CRUD)**; and then instructs the Storage state machine to verify whether these were correctly performed.
 
 ## A microprocessor-type state machine
 

docs/zkEVM/architecture/zkprover/keccakf-sm.md

@@ -1,4 +1,4 @@
-The Keccak-F State Machine is one of the secondary zkProver state machines. It computes message string hashes and validates the accuracy of those computations upon the request of Main SM.
+The Keccak-F state machine is one of the secondary zkProver state machines. It computes message string hashes and validates the accuracy of those computations upon the request of Main SM.
 
 Although the architecture of the original Keccak hash function is simple, the Keccak-F SM is not just a state machine or a simple automated version of the cryptographic hash function.
 
@@ -10,7 +10,7 @@ Thirdly, the Keccak-F circuit is constructed in such a way that executing it onc
 
 The Keccak-F circuit is briefly described in this article, along with a thorough explanation of the widely used Keccak-256 hash function and its specific parameters as they apply to the Polygon zkEVM implementation.
 
-## Keccak-F Circuit
+## Keccak-F circuit
 
 The Keccak-F circuit has two types of gates, types $\mathtt{0}$ and $\mathtt{1}$, corresponding to the two binary operations it performs, the $\mathtt{XOR}$ and $\mathtt{ANDP}$.
 
@@ -49,11 +49,11 @@ for each $i \in \{ 0, 1, 2, 3 \}$.
 
 This covers the Keccak-F circuit in a nutshell together with its PIL code. See the codes of [sm_keccakf.js](https://github.com/0xPolygonHermez/zkevm-proverjs/blob/main/src/sm/sm_keccakf/sm_keccakf.js) and [keccakf.pil](https://github.com/0xPolygonHermez/zkevm-proverjs/blob/main/pil/keccakf.pil) on GitHub.
 
-## Keccak-256 Hash Function
+## Keccak-256 hash function
 
 There are seven Keccak-F permutation functions, each indicated by $\texttt{Keccak}$-$f[b]$, where $b = 5\times 5\times 2^l$ is the size of the internal state of the hash function, for $0 \leq l \leq w$.
 
-The zkProver's Keccak State Machine is a verifiable automisation of a Keccak-F permutation function, which amounts to an irreversible scrambling of bits of a string $\mathbf{s} \in \mathbb{Z}_2^b$, where $b = 5\times 5\times 2^6 = 1600$.
+The zkProver's Keccak state machine is a verifiable automisation of a Keccak-F permutation function, which amounts to an irreversible scrambling of bits of a string $\mathbf{s} \in \mathbb{Z}_2^b$, where $b = 5\times 5\times 2^6 = 1600$.
 
 The EVM utilises the Keccak-256 hash function, which is a sponge construction with capacity $c = 512$ bits, and denoted by Keccak$[512]$. That is, the Keccak-256 notation puts emphasis on the $256$-bit security level, while the Keccak$[512]$ notation seeks to depict the actual capacity of $512$ bits.
 
@@ -155,7 +155,7 @@ $$
 
 ## Keccak-F rounds
 
-The Keccak-F State Machine runs 24 rounds, each of which is a composition of five step mappings; $\mathtt{\theta}$, $\mathtt{\rho}$, $\mathtt{\pi}$, $\mathtt{\chi}$, and $\mathtt{\iota}$, denoted by
+The Keccak-F state machine runs 24 rounds, each of which is a composition of five step mappings; $\mathtt{\theta}$, $\mathtt{\rho}$, $\mathtt{\pi}$, $\mathtt{\chi}$, and $\mathtt{\iota}$, denoted by
 
 $$
 \texttt{Rnd(A, ir)} = ι( χ( π( ρ( θ(A) ) ) ), \mathtt{ir})