refactor(Word): Remove LexicographicWord (#918)

The type was previously used to perform lexicographic comparisons
between words, but that behavior is now encapsulated in the default
`Ord` instance for word, so the type is unnecessary.

Author: iamrecursion

CHANGELOG.md

@@ -3,6 +3,7 @@
 - [BREAKING] Removed `AlgebraicSponge::merge_with_int()` method ([#894](https://github.com/0xMiden/crypto/pull/894)).
 - Added the ability to configure the sync-to-disk behavior of the persistent backend using its config ([#912](https://github.com/0xMiden/crypto/pull/912)).
 - Adds `LargeSmtForest::add_lineages` which provides an efficient means of adding multiple new lineages at once ([#910](https://github.com/0xMiden/crypto/pull/910)).
+- [BREAKING] Removed `LexicographicWord` as `Word` itself now implements the correct comparison behavior. Any place where the former is used should be able to seamlessly swap to the latter.
 
 ## 0.23.0 (2026-03-11)
 

miden-crypto/benches/word.rs

@@ -1,15 +1,15 @@
 //! Comprehensive Word operation benchmarks
 //!
 //! This module benchmarks all Word operations implemented in the library
-//! with a focus on type conversions, serialization, and lexicographic ordering.
+//! with a focus on type conversions, serialization, and ordering.
 //!
 //! # Organization
 //!
 //! The benchmarks are organized by:
 //! 1. Word creation and basic operations
 //! 2. Type conversions (bool, u8, u16, u32, u64)
 //! 3. Serialization and deserialization
-//! 4. Lexicographic ordering
+//! 4. Ordering (lexicographic)
 //! 5. Batch operations
 //!
 //! # Adding New Word Benchmarks
@@ -22,7 +22,7 @@
 
 use criterion::{Criterion, criterion_group, criterion_main};
 // Import Word modules
-use miden_crypto::{Felt, LexicographicWord, Word};
+use miden_crypto::{Felt, Word};
 
 // Import common utilities
 mod common;
@@ -198,82 +198,42 @@ benchmark_with_setup! {
     },
 }
 
-// === Lexicographic Ordering Benchmarks ===
+// === Ordering Benchmarks ===
 
-// Lexicographic word creation
-benchmark_with_setup! {
-    word_lexicographic_new,
-    DEFAULT_MEASUREMENT_TIME,
-    DEFAULT_SAMPLE_SIZE,
-    "new",
-    || {},
-    |b: &mut criterion::Bencher| {
-        b.iter(|| {
-            for word in &TEST_WORDS {
-                let _lex_word = LexicographicWord::new(*word);
-            }
-        })
-    },
-}
-
-// Lexicographic word access
-benchmark_with_setup_data! {
-    word_lexicographic_access,
-    DEFAULT_MEASUREMENT_TIME,
-    DEFAULT_SAMPLE_SIZE,
-    "inner_access",
-    || {
-        let lex_words: Vec<LexicographicWord> =
-            TEST_WORDS.iter().map(|w| LexicographicWord::new(*w)).collect();
-        lex_words
-    },
-    |b: &mut criterion::Bencher, lex_words: &Vec<LexicographicWord>| {
-        b.iter(|| {
-            for lex_word in lex_words {
-                let _inner = lex_word.inner();
-            }
-        })
-    },
-}
-
-// Lexicographic ordering comparisons
+// Word ordering comparisons (lexicographic)
 benchmark_with_setup_data! {
-    word_lexicographic_ordering,
+    word_cmp,
     DEFAULT_MEASUREMENT_TIME,
     DEFAULT_SAMPLE_SIZE,
-    "partial_cmp",
+    "cmp",
     || {
-        let lex_words: Vec<LexicographicWord> =
-            TEST_WORDS.iter().map(|w| LexicographicWord::new(*w)).collect();
-        lex_words
+        TEST_WORDS.to_vec()
     },
-    |b: &mut criterion::Bencher, lex_words: &Vec<LexicographicWord>| {
+    |b: &mut criterion::Bencher, words: &Vec<Word>| {
         b.iter(|| {
-            for i in 0..lex_words.len() {
-                for j in i..lex_words.len() {
-                    let _result = lex_words[i].partial_cmp(&lex_words[j]);
+            for i in 0..words.len() {
+                for j in i..words.len() {
+                    let _result = words[i].cmp(&words[j]);
                 }
             }
         })
     },
 }
 
-// Lexicographic equality comparison
+// Word equality comparison
 benchmark_with_setup_data! {
-    word_lexicographic_eq,
+    word_eq,
     DEFAULT_MEASUREMENT_TIME,
     DEFAULT_SAMPLE_SIZE,
     "eq",
     || {
-        let lex_words: Vec<LexicographicWord> =
-            TEST_WORDS.iter().map(|w| LexicographicWord::new(*w)).collect();
-        lex_words
+        TEST_WORDS.to_vec()
     },
-    |b: &mut criterion::Bencher, lex_words: &Vec<LexicographicWord>| {
+    |b: &mut criterion::Bencher, words: &Vec<Word>| {
         b.iter(|| {
-            for i in 0..lex_words.len() {
-                for j in 0..lex_words.len() {
-                    let _result = lex_words[i] == lex_words[j];
+            for i in 0..words.len() {
+                for j in 0..words.len() {
+                    let _result = words[i] == words[j];
                 }
             }
         })
@@ -321,11 +281,9 @@ criterion_group!(
     // Serialization benchmarks
     word_to_hex,
     word_to_vec,
-    // Lexicographic ordering benchmarks
-    word_lexicographic_new,
-    word_lexicographic_access,
-    word_lexicographic_ordering,
-    word_lexicographic_eq,
+    // Ordering benchmarks
+    word_cmp,
+    word_eq,
     // Batch operations benchmarks
     word_batch_elements,
 );

miden-crypto/src/lib.rs

@@ -16,7 +16,7 @@ pub mod utils;
 
 // RE-EXPORTS
 // ================================================================================================
-pub use miden_field::{Felt, LexicographicWord, Word, WordError, word};
+pub use miden_field::{Felt, Word, WordError, word};
 
 pub mod field {
     //! Traits and utilities for working with the Goldilocks finite field (i.e.,

miden-field/src/lib.rs

@@ -36,4 +36,4 @@ pub use p3_field::{
     },
     integers::QuotientMap,
 };
-pub use word::{LexicographicWord, Word, WordError};
+pub use word::{Word, WordError};

miden-field/src/word/lexicographic.rs

@@ -25,9 +25,6 @@ use p3_field::integers::QuotientMap;
 use super::Felt;
 use crate::utils::bytes_to_hex_string;
 
-mod lexicographic;
-pub use lexicographic::LexicographicWord;
-
 #[cfg(test)]
 mod tests;
 
@@ -322,8 +319,8 @@ impl Ord for Word {
         // though the field order is p = 2^64 - 2^32 + 1. This method canonicalizes to [0, p).
         //
         // We must iterate over and compare each element individually. A simple bytestring
-        // comparison would be inappropriate because the `Word`s are represented in
-        // "lexicographical" order.
+        // comparison would be inappropriate because `Word`s internal representation is not
+        // naturally lexicographically comparable.
         for (felt0, felt1) in self
             .iter()
             .rev()