chore : nit

README.md

@@ -20,11 +20,11 @@ We try to follow these guidelines.
 - Memory is fixed at 30,000 cells by default, but is configurable.
 - Memory wraps on overflow/underflow.
   - It can be used for memory value `mv` and memory pointer `mp`,
-  but it will usually panic for `mp` as the memory size will be much smaller than $2^{31} - 1$.
+    but it will usually panic for `mp` as the memory size will be much smaller than $2^{31} - 1$.
 - Inputs are line-buffered (ends with the linefeed ASCII character `10`).
 - CLI uses Stdin and Stdout for IO.
 - For library use, input can be simulated by any reader (e.g. `Cursor`) and
-output with any writer (e.g. a custom writer).
+  output with any writer (e.g. a custom writer).
 
 ## Acknowledgements
 
@@ -33,7 +33,11 @@ and sibling article from Neptune Cash[^4].
 The Brainfuck compiler and interpreter have been adapted from rkdud007[^5]
 
 [^1]: [Brainfuck Language](https://esolangs.org/wiki/Brainfuck)
+
 [^2]: [Stwo repository](https://github.com/starkware-libs/stwo)
+
 [^3]: [BrainSTARK - Alan Szepieniec](https://aszepieniec.github.io/stark-brainfuck/)
+
 [^4]: [BrainSTARK - Neptune Cash](https://neptune.cash/learn/brainfuck-tutorial)
+
 [^5]: [rkdud007 brainfuck-zkvm repo](https://github.com/rkdud007/brainfuck-zkvm)

crates/brainfuck_vm/src/bin/brainfuck_vm.rs

@@ -45,9 +45,6 @@ fn main() -> Result<(), MachineError> {
     tracing::info!("Provide inputs separated by linefeeds: ");
     bf_vm.execute().unwrap();
     if args.trace {
-        if args.pad_trace {
-            bf_vm.pad_trace();
-        };
         let trace = bf_vm.trace();
         tracing::info!("Execution trace: {:#?}", trace);
     }

crates/brainfuck_vm/src/machine.rs

@@ -241,19 +241,6 @@ impl Machine {
         self.trace.clone()
     }
 
-    pub fn pad_trace(&mut self) {
-        let last_register = &self.state.registers;
-        let trace_len = self.trace.len() as u32;
-        let padding_offset = trace_len.next_power_of_two() + 1 - trace_len;
-        for i in 1..padding_offset {
-            let dummy = Registers {
-                clk: BaseField::from(last_register.clk.0 + i),
-                ..last_register.clone()
-            };
-            self.trace.push(dummy);
-        }
-    }
-
     pub const fn program(&self) -> &ProgramMemory {
         &self.program
     }
@@ -439,59 +426,4 @@ mod tests {
         assert_eq!(trace, vec![initial_state, intermediate_state, final_state]);
         Ok(())
     }
-
-    #[test]
-    fn test_pad_trace() -> Result<(), MachineError> {
-        // '++'
-        let code = vec![BaseField::from(43), BaseField::from(43)];
-        let (mut machine, _) = create_test_machine(&code, &[]);
-        machine.execute()?;
-
-        // Initial state + executed instructions
-        let trace = machine.trace();
-        let initial_state = Registers {
-            clk: BaseField::zero(),
-            ip: BaseField::zero(),
-            ci: BaseField::from(43),
-            ni: BaseField::from(43),
-            mp: BaseField::zero(),
-            mv: BaseField::zero(),
-            mvi: BaseField::zero(),
-        };
-        let intermediate_state = Registers {
-            clk: BaseField::one(),
-            ip: BaseField::one(),
-            ci: BaseField::from(43),
-            ni: BaseField::zero(),
-            mp: BaseField::zero(),
-            mv: BaseField::one(),
-            mvi: BaseField::one(),
-        };
-        let final_state = Registers {
-            clk: BaseField::from(2),
-            ip: BaseField::from(2),
-            ci: BaseField::zero(),
-            ni: BaseField::zero(),
-            mp: BaseField::zero(),
-            mv: BaseField::from(2),
-            mvi: BaseField::from(2).inverse(),
-        };
-
-        assert_eq!(trace.len(), 3);
-        assert_eq!(trace[0], initial_state);
-        assert_eq!(trace[1], intermediate_state);
-        assert_eq!(trace[2], final_state);
-
-        machine.pad_trace();
-        let trace = machine.trace();
-        let dummy = Registers { clk: final_state.clk + BaseField::one(), ..final_state };
-
-        assert_eq!(trace.len(), 4);
-        assert_eq!(trace[0], initial_state);
-        assert_eq!(trace[1], intermediate_state);
-        assert_eq!(trace[2], final_state);
-        assert_eq!(trace[3], dummy);
-
-        Ok(())
-    }
 }