diff --git a/src/tick.rs b/src/tick.rs
index eee072231..4fbdf8656 100644
--- a/src/tick.rs
+++ b/src/tick.rs
@@ -11,9 +11,9 @@ impl Tick {
     ///
     /// ```
     /// use loomination::tick::Tick;
-    /// assert_eq!(Tick::new(0, 1).n, 1)
+    /// assert_eq!(Tick::run(0, 1).n, 1)
     /// ```
-    pub fn new(seed: u64, n: u64) -> Self {
+    pub fn run(seed: u64, n: u64) -> Self {
         use std::collections::hash_map::DefaultHasher;
         use std::hash::{Hash, Hasher};
         let data = None;
@@ -29,13 +29,13 @@ impl Tick {
     ///
     /// ```
     /// use loomination::tick::Tick;
-    /// assert!(Tick::new(0, 0).verify(0)); // base case
-    /// assert!(!Tick::new(0, 0).verify(1)); // base case, bad
-    /// assert!(Tick::new(0, 1).verify(0)); // inductive case
-    /// assert!(!Tick::new(0, 1).verify(1)); // inductive case, bad
+    /// assert!(Tick::run(0, 0).verify(0)); // base case
+    /// assert!(!Tick::run(0, 0).verify(1)); // base case, bad
+    /// assert!(Tick::run(0, 1).verify(0)); // inductive case
+    /// assert!(!Tick::run(0, 1).verify(1)); // inductive case, bad
     /// ```
     pub fn verify(self: &Self, seed: u64) -> bool {
-        self.hash == Self::new(seed, self.n).hash
+        self.hash == Self::run(seed, self.n).hash
     }
 }
 
@@ -44,21 +44,21 @@ impl Tick {
 /// ```
 /// use loomination::tick::{verify_slice, Tick};
 /// assert!(verify_slice(&vec![], 0)); // base case
-/// assert!(verify_slice(&vec![Tick::new(0, 0)], 0)); // singleton case 1
-/// assert!(!verify_slice(&vec![Tick::new(0, 0)], 1)); // singleton case 2, bad
-/// assert!(verify_slice(&vec![Tick::new(0, 0), Tick::new(0, 0)], 0)); // lazy inductive case
-/// assert!(!verify_slice(&vec![Tick::new(0, 0), Tick::new(1, 0)], 0)); // lazy inductive case, bad
+/// assert!(verify_slice(&vec![Tick::run(0, 0)], 0)); // singleton case 1
+/// assert!(!verify_slice(&vec![Tick::run(0, 0)], 1)); // singleton case 2, bad
+/// assert!(verify_slice(&vec![Tick::run(0, 0), Tick::run(0, 0)], 0)); // lazy inductive case
+/// assert!(!verify_slice(&vec![Tick::run(0, 0), Tick::run(1, 0)], 0)); // lazy inductive case, bad
 /// ```
 pub fn verify_slice(ticks: &[Tick], seed: u64) -> bool {
     use rayon::prelude::*;
-    let genesis = [Tick::new(seed, 0)];
+    let genesis = [Tick::run(seed, 0)];
     let tick_pairs = genesis.par_iter().chain(ticks).zip(ticks);
     tick_pairs.all(|(x, x1)| x1.verify(x.hash))
 }
 
 /// Verifies the hashes and ticks serially. Exists only for reference.
 pub fn verify_slice_seq(ticks: &[Tick], seed: u64) -> bool {
-    let genesis = [Tick::new(seed, 0)];
+    let genesis = [Tick::run(seed, 0)];
     let tick_pairs = genesis.iter().chain(ticks).zip(ticks);
     tick_pairs.into_iter().all(|(x, x1)| x1.verify(x.hash))
 }
@@ -67,7 +67,7 @@ pub fn verify_slice_seq(ticks: &[Tick], seed: u64) -> bool {
 pub fn create_ticks(seed: u64, hashes_per_tick: u64, len: usize) -> Vec<Tick> {
     use itertools::unfold;
     let mut ticks_iter = unfold(seed, |state| {
-        let tick = Tick::new(*state, hashes_per_tick);
+        let tick = Tick::run(*state, hashes_per_tick);
         *state = tick.hash;
         return Some(tick);
     });