Motivic foundation: A_C, the C-motivic Steenrod algebra engine over F₂[τ]

ext/crates/algebra/Cargo.toml

@@ -55,3 +55,7 @@ harness = false
 [[bench]]
 name = "nassau_milnor"
 harness = false
+
+[[bench]]
+name = "motivic"
+harness = false

ext/crates/algebra/benches/motivic.rs

@@ -0,0 +1,106 @@
+//! Benchmarks for the C-motivic Steenrod algebra engine.
+//!
+//! Three levels, from the kernel outwards:
+//!
+//!  - `motivic_product` — a single [`multiply_closed`], the Kong–Lin Theorem 5.1 product. This is
+//!    the arithmetic the whole layer is built on.
+//!  - `motivic_block` — [`MotivicMilnorAlgebra::fill_block`], the batch unit a resolution actually
+//!    asks for: every structure constant for one pair of topological degrees. Throughput is in
+//!    structure constants, so the numbers are comparable across degrees.
+//!  - `motivic_basis` — [`enum_basis`], the basis enumeration each new degree pays once.
+//!
+//! The `motivic_block` group is the one to watch when changing the coefficient representation:
+//! it is the only group that exercises the `DualElement` map, the index lookup, and the product
+//! together, in the proportion a resolution hits them.
+
+use algebra::{
+    MotivicMilnorAlgebra,
+    motivic::milnor::{Dual, Monomial, enum_basis, multiply_closed},
+};
+use criterion::{
+    BenchmarkGroup, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main,
+    measurement::WallTime,
+};
+use pprof::criterion::{Output, PProfProfiler};
+
+/// `Q(E)P(R)` from the `Q` indices and the ξ exponents, in the paper's indexing where `R[0]`
+/// belongs to ξ_0 = 1 and is skipped.
+fn elt(q: &[u32], xi: &[u32]) -> Dual<Monomial> {
+    let mut r = vec![0];
+    r.extend_from_slice(xi);
+    Dual(Monomial::from_paper(q.iter().map(|i| 1 << i).sum(), &r).unwrap())
+}
+
+fn bench_product(
+    g: &mut BenchmarkGroup<WallTime>,
+    name: &str,
+    a: Dual<Monomial>,
+    b: Dual<Monomial>,
+) {
+    g.bench_function(name, |bench| {
+        bench.iter(|| std::hint::black_box(multiply_closed(a, b)));
+    });
+}
+
+fn product(c: &mut Criterion) {
+    let mut g = c.benchmark_group("motivic_product");
+
+    // Pure ξ: the classical Milnor-matrix part of the formula, with no Y enumeration.
+    bench_product(&mut g, "xi/small", elt(&[], &[2]), elt(&[], &[2]));
+    bench_product(&mut g, "xi/medium", elt(&[], &[4, 1]), elt(&[], &[2, 1]));
+    bench_product(&mut g, "xi/large", elt(&[], &[6, 2, 1]), elt(&[], &[4, 1]));
+
+    // With a Q-part, which is what turns on the second (`Y`) matrix and the τ-rewriting.
+    bench_product(&mut g, "q/small", elt(&[0], &[1]), elt(&[1], &[1]));
+    bench_product(&mut g, "q/medium", elt(&[0, 1], &[2]), elt(&[2], &[1, 1]));
+    bench_product(&mut g, "q/large", elt(&[0, 2], &[3, 1]), elt(&[1], &[2, 1]));
+
+    g.finish();
+}
+
+fn block(c: &mut Criterion) {
+    let mut g = c.benchmark_group("motivic_block");
+
+    for t in [12, 16, 20] {
+        // Size the throughput by the number of structure constants in the block, so the
+        // per-product cost is comparable across degrees.
+        let dims = {
+            let alg = MotivicMilnorAlgebra::new();
+            alg.compute_basis(t);
+            alg.dimension(t)
+        };
+        g.throughput(Throughput::Elements((dims * dims) as u64));
+        g.bench_with_input(BenchmarkId::from_parameter(t), &t, |bench, &t| {
+            // A fresh algebra per iteration: `fill_block` is memoized, so reusing one would
+            // measure the cache rather than the product.
+            bench.iter_batched(
+                MotivicMilnorAlgebra::new,
+                |alg| alg.fill_block(t, t),
+                criterion::BatchSize::SmallInput,
+            );
+        });
+    }
+
+    g.finish();
+}
+
+fn basis(c: &mut Criterion) {
+    let mut g = c.benchmark_group("motivic_basis");
+
+    for t in [20, 30, 40] {
+        g.bench_with_input(BenchmarkId::from_parameter(t), &t, |bench, &t| {
+            bench.iter(|| std::hint::black_box(enum_basis(t)));
+        });
+    }
+
+    g.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .measurement_time(std::time::Duration::from_secs(3))
+        .with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = product, block, basis
+}
+criterion_main!(benches);

ext/crates/algebra/src/algebra/milnor_algebra.rs

@@ -122,7 +122,13 @@ pub type PPartEntry = u32;
 /// [`Self::MAX_DEGREE`], which [`MilnorAlgebra::compute_basis`] enforces up front, so the packing
 /// can never silently truncate. [`Self::set`] asserts it anyway, and [`Self::try_from_slice`]
 /// reports failure instead of panicking for input that has not been through that gate.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
+///
+/// The derived ordering compares the packed words. That is a total order and consistent with
+/// equality, which is all a sorted table needs, but it is *not* lexicographic in the exponents:
+/// entry `i` sits at [`Self::shift`]`(i)`, so `r_1` is the least significant field and therefore
+/// the last tie-breaker. Callers that need the exponents ordered lexicographically must compare
+/// [`Self::iter`] instead.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct PPart(u64);
 
 impl PPart {
@@ -1425,6 +1431,27 @@ impl PPartAllocation {
     }
 }
 
+/// The least `l > k` whose binary digits are disjoint from those of `sum`, **given that `k` is
+/// itself disjoint from `sum`**.
+///
+/// Equivalently, the least such `l` with $\binom{\mathrm{sum} + l}{l}$ odd: adding `l` to `sum`
+/// carries exactly where they share a set bit, and the 2-adic valuation of that binomial is the
+/// number of carries (Kummer). So this steps straight to the next value that keeps a Milnor
+/// coefficient non-zero mod 2, instead of testing candidates and discarding them.
+///
+/// # Panics
+///
+/// In debug builds, if `k & sum != 0`. The identity genuinely needs it: the increment is allowed
+/// to carry through `k`'s own bits but not through `sum`'s, so a `k` that overlaps `sum` can come
+/// back *smaller* than `k` (`next_disjoint(2, 2) == 1`). Every caller is walking a matrix whose
+/// entries are already pairwise disjoint along each anti-diagonal, so the precondition holds.
+///
+/// The result can exceed any bound the caller has in mind; compare it against that separately.
+pub const fn next_disjoint(sum: PPartEntry, k: PPartEntry) -> PPartEntry {
+    debug_assert!(k & sum == 0, "next_disjoint needs k disjoint from sum");
+    ((k | sum) + 1) & !sum
+}
+
 #[allow(non_snake_case)]
 pub struct PPartMultiplier<const MOD4: bool> {
     p: ValidPrime,
@@ -1525,7 +1552,7 @@ impl<const MOD4: bool> PPartMultiplier<MOD4> {
                         })
                         .unwrap_or(max + 1)
                 } else {
-                    ((k | sum) + 1) & !sum
+                    next_disjoint(sum, k)
                 }
             }
             _ => (k + 1..max + 1)
@@ -2200,6 +2227,29 @@ mod tests {
         }
     }
 
+    /// `next_disjoint` is the jump-to-valid form of the "is this binomial odd" test that the
+    /// Milnor coefficient needs; check it against the brute-force search it replaces, over every
+    /// input satisfying its precondition.
+    #[test]
+    fn next_disjoint_matches_brute_force() {
+        for sum in 0..64u32 {
+            for k in (0..64u32).filter(|k| k & sum == 0) {
+                let expected = (k + 1..)
+                    .find(|l| l & sum == 0)
+                    .expect("a disjoint value always exists");
+                assert_eq!(next_disjoint(sum, k), expected, "sum = {sum}, k = {k}");
+                // The characterisation it is actually used for.
+                assert_ne!(u32::binomial2(sum + expected, expected), 0);
+            }
+        }
+    }
+
+    #[test]
+    #[should_panic(expected = "next_disjoint needs k disjoint from sum")]
+    fn next_disjoint_rejects_overlapping_k() {
+        next_disjoint(2, 2);
+    }
+
     /// The packing is only sound because each field is wide enough for every entry that can occur
     /// at degree at most `MAX_DEGREE`. Check that against the $\xi$-degrees directly, so that
     /// changing `MAX_DEGREE` or `WIDTHS` without the other fails loudly.

ext/crates/algebra/src/algebra/mod.rs

@@ -18,6 +18,9 @@ pub use field::Field;
 pub mod milnor_algebra;
 pub use milnor_algebra::MilnorAlgebra;
 
+pub mod motivic;
+pub use motivic::MotivicMilnorAlgebra;
+
 mod steenrod_algebra;
 pub use steenrod_algebra::{AlgebraType, SteenrodAlgebra};