Typos fix (#527)

* typo-Update continuations.md

* typo-Update folding.md

* typos-Update rv_trace.rs

book/src/future/continuations.md

@@ -10,7 +10,7 @@ Jolt will pursue both approaches to prover space control. Below, we provide more
 
 Continuations work by breaking a large computation into “chunks”, proving each chunk (almost) independently, and recursively aggregating the proofs (i.e., proving one knows the proofs for each chunk). 
 
-Continuations come in two flavors: "brute-force recursion" and folding. In brute-force recursion, the proofs for different chunks are aggregated by having the prover prove it knows each proof. Roughly speaking, the verifier of each proof is repesented as a circuit, and a SNARK is used to prove that the prover knows a satisfying assignment for each circuit. 
+Continuations come in two flavors: "brute-force recursion" and folding. In brute-force recursion, the proofs for different chunks are aggregated by having the prover prove it knows each proof. Roughly speaking, the verifier of each proof is represented as a circuit, and a SNARK is used to prove that the prover knows a satisfying assignment for each circuit. 
 
 In folding schemes, the "proof" for each chunk is actually only a "partial proof", in particular omitting any evaluation proofs for any committed polynomials. The partial proofs for each chunk are not explicitly checked by anyone. Rather, they are "aggregated" into a single partial proof, and that partial proof is then "completed" into a full SNARK proof. In folding schemes, the prover winds up recursively proving that it correctly aggregated the partial proofs. This has major performance benefits relative to "brute force recursion", because aggregating proofs is much simpler than checking them. Hence, proving aggregation was done correctly is much cheaper than proving full-fledged proof verification was done correctly.
 

book/src/future/folding.md

@@ -3,7 +3,7 @@
 The plan to implement folding is simple, with a (very) sketchy overview provided below. 
 
 <OL>
-  <LI> Verifying Jolt proofs involves two procedures: verifiying sum-check proofs, and folding 
+  <LI> Verifying Jolt proofs involves two procedures: verifying sum-check proofs, and folding 
 polynomial evaluation claims for committed polynomials. </LI>
 
 <LI> Running Nova with BN254 as the primary curve, we can simply verify sum-check proofs natively. </LI>

common/src/rv_trace.rs

@@ -38,7 +38,7 @@ fn sum_u64_i32(a: u64, b: i32) -> u64 {
         }
         a - abs_b
     } else {
-        let b_u64: u64 = b.try_into().expect("failed u64 convesion");
+        let b_u64: u64 = b.try_into().expect("failed u64 conversion");
         a + b_u64
     }
 }
@@ -201,7 +201,7 @@ pub enum CircuitFlags {
     Virtual,
     /// 1 if the instruction is an assert, as defined in Section 6.1.1 of the Jolt paper.
     Assert,
-    /// Used in virtual sequences; the program counter should be the same for the full seqeuence.
+    /// Used in virtual sequences; the program counter should be the same for the full sequence.
     DoNotUpdatePC,
 }
 pub const NUM_CIRCUIT_FLAGS: usize = CircuitFlags::COUNT;