chore: use lexicographic ordering for Word (#847)

* chore: use lexicographic ordering for `Word`

* chore: add changelog

* chore: add note on word ordering

---------

Co-authored-by: Bobbin Threadbare <43513081+bobbinth@users.noreply.github.com>

Author: PhilippGackstatter

CHANGELOG.md

@@ -1,6 +1,7 @@
-## 0.22.3 (unreleased)
+## 0.22.3 (2026-02-23)
 
 - Refactored to introduce a unified `Felt` type for on-chain and off-chain code ([#819](https://github.com/0xMiden/crypto/pull/819)).
+- Change `Ord for Word` to use lexicographic ordering ([#847](https://github.com/0xMiden/crypto/pull/847)).
 - Add `From<{u8, u16, u32}> for Felt` and `TryFrom<u64> for Felt` ([#848](https://github.com/0xMiden/crypto/pull/848)).
 
 ## 0.22.2 (2026-02-01)

miden-field/src/word/lexicographic.rs

@@ -70,19 +70,7 @@ impl<T: Into<Word> + Copy> Ord for LexicographicWord<T> {
         let self_word: Word = self.0.into();
         let other_word: Word = other.0.into();
 
-        for (felt0, felt1) in self_word
-            .iter()
-            .rev()
-            .map(Felt::as_canonical_u64)
-            .zip(other_word.iter().rev().map(Felt::as_canonical_u64))
-        {
-            let ordering = felt0.cmp(&felt1);
-            if let Ordering::Less | Ordering::Greater = ordering {
-                return ordering;
-            }
-        }
-
-        Ordering::Equal
+        self_word.cmp(&other_word)
     }
 }
 
@@ -132,31 +120,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn lexicographic_word_ordering() {
-        for (expected, key0, key1) in [
-            (Ordering::Equal, [0, 0, 0, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [1, 0, 0, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [0, 1, 0, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [0, 0, 1, 0u32], [0, 0, 0, 0u32]),
-            (Ordering::Greater, [0, 0, 0, 1u32], [0, 0, 0, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [1, 0, 0, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [0, 1, 0, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 1, 0u32]),
-            (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 0, 1u32]),
-            (Ordering::Greater, [0, 0, 0, 1u32], [1, 1, 1, 0u32]),
-            (Ordering::Greater, [0, 0, 1, 0u32], [1, 1, 0, 0u32]),
-            (Ordering::Less, [1, 1, 1, 0u32], [0, 0, 0, 1u32]),
-            (Ordering::Less, [1, 1, 0, 0u32], [0, 0, 1, 0u32]),
-        ] {
-            assert_eq!(
-                LexicographicWord::from(key0.map(Felt::from_u32))
-                    .cmp(&LexicographicWord::from(key1.map(Felt::from_u32))),
-                expected
-            );
-        }
-    }
-
     #[test]
     fn lexicographic_serialization() {
         let word = Word::from([1u64, 2, 3, 4].map(Felt::new));

miden-field/src/word/mod.rs

@@ -35,6 +35,9 @@ mod tests;
 // ================================================================================================
 
 /// A unit of data consisting of 4 field elements.
+///
+/// For ordering a word with `Ord` the word's elements are treated as limbs of an integer
+/// in little-endian limb order and thus comparison starts from the most significant element.
 #[derive(Default, Copy, Clone, Eq, PartialEq)]
 #[cfg_attr(
     not(all(target_family = "wasm", miden)),
@@ -306,10 +309,10 @@ impl IndexMut<Range<usize>> for Word {
 
 impl Ord for Word {
     fn cmp(&self, other: &Self) -> Ordering {
-        // Compare the canonical u64 representation of both elements.
+        // Compare the canonical u64 representation of both words.
         //
-        // It will iterate the elements and will return the first computation different than
-        // `Equal`. Otherwise, the ordering is equal.
+        // It will iterate the elements in reverse and will return the first computation different
+        // than `Equal`. Otherwise, the ordering is equal.
         //
         // We use `as_canonical_u64()` to ensure we're comparing the actual field element values
         // in their canonical form (that is, `x in [0,p)`). P3's Goldilocks field uses unreduced
@@ -319,14 +322,19 @@ impl Ord for Word {
         // 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.
-        self.as_elements_array()
+        for (felt0, felt1) in self
             .iter()
+            .rev()
             .map(Felt::as_canonical_u64)
-            .zip(other.as_elements_array().iter().map(Felt::as_canonical_u64))
-            .fold(Ordering::Equal, |ord, (a, b)| match ord {
-                Ordering::Equal => a.cmp(&b),
-                _ => ord,
-            })
+            .zip(other.iter().rev().map(Felt::as_canonical_u64))
+        {
+            let ordering = felt0.cmp(&felt1);
+            if let Ordering::Less | Ordering::Greater = ordering {
+                return ordering;
+            }
+        }
+
+        Ordering::Equal
     }
 }
 

miden-field/src/word/tests.rs

@@ -1,4 +1,5 @@
 use alloc::{collections::BTreeMap, string::String, vec::Vec};
+use core::cmp::Ordering;
 
 use miden_serde_utils::SliceReader;
 use proptest::prelude::*;
@@ -259,3 +260,27 @@ proptest! {
         prop_assert_eq!(map.get(&word), Some(&2));
     }
 }
+
+#[test]
+fn word_is_ordered_lexicographically() {
+    for (expected, key0, key1) in [
+        (Ordering::Equal, [0, 0, 0, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [1, 0, 0, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [0, 1, 0, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [0, 0, 1, 0u32], [0, 0, 0, 0u32]),
+        (Ordering::Greater, [0, 0, 0, 1u32], [0, 0, 0, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [1, 0, 0, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [0, 1, 0, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 1, 0u32]),
+        (Ordering::Less, [0, 0, 0, 0u32], [0, 0, 0, 1u32]),
+        (Ordering::Greater, [0, 0, 0, 1u32], [1, 1, 1, 0u32]),
+        (Ordering::Greater, [0, 0, 1, 0u32], [1, 1, 0, 0u32]),
+        (Ordering::Less, [1, 1, 1, 0u32], [0, 0, 0, 1u32]),
+        (Ordering::Less, [1, 1, 0, 0u32], [0, 0, 1, 0u32]),
+    ] {
+        assert_eq!(
+            Word::from(key0.map(Felt::from_u32)).cmp(&Word::from(key1.map(Felt::from_u32))),
+            expected
+        );
+    }
+}