Remove unused field traits and strategies

crates/field/Cargo.toml

@@ -59,10 +59,6 @@ harness = false
 name = "packed_field_multiply"
 harness = false
 
-[[bench]]
-name = "packed_field_mul_alpha"
-harness = false
-
 [[bench]]
 name = "packed_field_slice_iter"
 harness = false

crates/field/benches/packed_field_invert.rs

@@ -20,19 +20,14 @@ fn invert_main<T: PackedField>(val: T) -> T {
 cfg_if! {
 	if #[cfg(feature = "benchmark_alternative_strategies")] {
 		use binius_field::{
-			arch::{PackedStrategy, PairwiseRecursiveStrategy, PairwiseStrategy,
-				PairwiseTableStrategy, },
+			arch::{PackedStrategy, PairwiseStrategy, PairwiseTableStrategy},
 			arithmetic_traits::TaggedInvertOrZero,
 		};
 
 		fn invert_pairwise<T: TaggedInvertOrZero<PairwiseStrategy>>(val: T) -> T {
 			val.invert_or_zero()
 		}
 
-		fn invert_pairwise_recursive<T: TaggedInvertOrZero<PairwiseRecursiveStrategy>>(val: T) -> T {
-			val.invert_or_zero()
-		}
-
 		fn invert_pairwise_table<T: TaggedInvertOrZero<PairwiseTableStrategy>>(val: T) -> T {
 			val.invert_or_zero()
 		}
@@ -47,7 +42,6 @@ cfg_if! {
 			strategies @ (
 				(main, PackedField, invert_main),
 				(pairwise, TaggedInvertOrZero::<PairwiseStrategy>, invert_pairwise),
-				(pairwise_recursive, TaggedInvertOrZero::<PairwiseRecursiveStrategy>, invert_pairwise_recursive),
 				(pairwise_table, TaggedInvertOrZero::<PairwiseTableStrategy>, invert_pairwise_table),
 				(packed, TaggedInvertOrZero::<PackedStrategy>, invert_packed),
 			)

crates/field/benches/packed_field_multiply.rs

@@ -24,8 +24,7 @@ fn mul_main<T: SelfMul>(lhs: T, rhs: T) -> T {
 cfg_if! {
 	if #[cfg(feature = "benchmark_alternative_strategies")] {
 		use binius_field::{
-			arch::{PackedStrategy, PairwiseRecursiveStrategy, PairwiseStrategy,
-				PairwiseTableStrategy, },
+			arch::{PackedStrategy, PairwiseStrategy, PairwiseTableStrategy},
 			arithmetic_traits::TaggedMul
 		};
 
@@ -37,10 +36,6 @@ cfg_if! {
 			TaggedMul::<PairwiseTableStrategy>::mul(lhs, rhs)
 		}
 
-		fn mul_pairwise_recursive<T: TaggedMul<PairwiseRecursiveStrategy>>(lhs: T, rhs: T) -> T {
-			TaggedMul::<PairwiseRecursiveStrategy>::mul(lhs, rhs)
-		}
-
 		fn mul_packed<T: TaggedMul<PackedStrategy>>(lhs: T, rhs: T) -> T {
 			TaggedMul::<PackedStrategy>::mul(lhs, rhs)
 		}
@@ -51,7 +46,6 @@ cfg_if! {
 			strategies @ (
 				(main, SelfMul, mul_main),
 				(pairwise, TaggedMul::<PairwiseStrategy>, mul_pairwise),
-				(pairwise_recursive, TaggedMul::<PairwiseRecursiveStrategy>, mul_pairwise_recursive),
 				(pairwise_table, TaggedMul::<PairwiseTableStrategy>, mul_pairwise_table),
 				(packed, TaggedMul::<PackedStrategy>, mul_packed),
 			)

crates/field/benches/packed_field_square.rs

@@ -20,19 +20,14 @@ fn square_main<T: PackedField>(val: T) -> T {
 cfg_if! {
 	if #[cfg(feature = "benchmark_alternative_strategies")] {
 		use binius_field::{
-			arch::{PackedStrategy, PairwiseStrategy, PairwiseRecursiveStrategy,
-				PairwiseTableStrategy},
+			arch::{PackedStrategy, PairwiseStrategy, PairwiseTableStrategy},
 			arithmetic_traits::TaggedSquare
 		};
 
 		fn square_pairwise<T: TaggedSquare<PairwiseStrategy>>(val: T) -> T {
 			val.square()
 		}
 
-		fn square_pairwise_recursive<T: TaggedSquare<PairwiseRecursiveStrategy>>(val: T) -> T {
-			val.square()
-		}
-
 		fn square_pairwise_table<T: TaggedSquare<PairwiseTableStrategy>>(val: T) -> T {
 			val.square()
 		}
@@ -47,7 +42,6 @@ cfg_if! {
 			strategies @ (
 				(main, PackedField, square_main),
 				(pairwise, TaggedSquare::<PairwiseStrategy>, square_pairwise),
-				(pairwise_recursive, TaggedSquare::<PairwiseRecursiveStrategy>, square_pairwise_recursive),
 				(pairwise_table, TaggedSquare::<PairwiseTableStrategy>, square_pairwise_table),
 				(packed, TaggedSquare::<PackedStrategy>, square_packed),
 			)

crates/field/src/aes_field.rs

@@ -49,14 +49,6 @@ impl TowerField for AESTowerField8b {
 			_ => 3,
 		}
 	}
-
-	fn mul_primitive(self, iota: usize) -> Self {
-		match iota {
-			0..=1 => self * ISOMORPHIC_ALPHAS[iota],
-			2 => self.multiply_alpha(),
-			_ => panic!("iota {iota} must be less than tower level 3"),
-		}
-	}
 }
 
 /// A 3- step transformation :
@@ -82,13 +74,6 @@ where
 	}
 }
 
-/// Values isomorphic to 0x02, 0x04 and 0x10 in BinaryField8b
-const ISOMORPHIC_ALPHAS: [AESTowerField8b; 3] = [
-	AESTowerField8b(0xBC),
-	AESTowerField8b(0xB0),
-	AESTowerField8b(0xD3),
-];
-
 impl SerializeBytes for AESTowerField8b {
 	fn serialize(&self, write_buf: impl BufMut) -> Result<(), SerializationError> {
 		self.0.serialize(write_buf)
@@ -111,9 +96,7 @@ mod tests {
 	use rand::prelude::*;
 
 	use super::*;
-	use crate::{
-		Random, binary_field::tests::is_binary_field_valid_generator, underlier::WithUnderlier,
-	};
+	use crate::{Random, binary_field::tests::is_binary_field_valid_generator};
 
 	fn check_square(f: impl Field) {
 		assert_eq!(f.square(), f * f);
@@ -185,30 +168,6 @@ mod tests {
 		assert!(is_binary_field_valid_generator::<AESTowerField8b>());
 	}
 
-	fn test_mul_primitive_valid<F: TowerField + WithUnderlier<Underlier: From<u8>>>(
-		val: F,
-		iota: usize,
-	) {
-		let result = val.mul_primitive(iota);
-		let expected =
-			val * F::from_underlier(F::Underlier::from(ISOMORPHIC_ALPHAS[iota].to_underlier()));
-		assert_eq!(result, expected);
-	}
-
-	proptest! {
-		#[test]
-		fn test_mul_primitive_8b(val in 0u8.., iota in 0usize..3) {
-			test_mul_primitive_valid::<AESTowerField8b>(val.into(), iota)
-		}
-	}
-
-	#[test]
-	#[should_panic(expected = "must be less than tower level")]
-	fn test_mul_primitive_out_of_range() {
-		let val = AESTowerField8b::from(1u8);
-		val.mul_primitive(3);
-	}
-
 	#[test]
 	fn test_serialization() {
 		let mut buffer = BytesMut::new();

crates/field/src/arch/aarch64/packed_128.rs

@@ -15,7 +15,6 @@ define_packed_binary_fields!(
 			mul: (BitwiseAndStrategy),
 			square: (BitwiseAndStrategy),
 			invert: (BitwiseAndStrategy),
-			mul_alpha: (BitwiseAndStrategy),
 			transform: (PackedStrategy),
 		},
 	]

crates/field/src/arch/aarch64/packed_aes_128.rs

@@ -6,14 +6,13 @@ use std::ops::Mul;
 use super::{
 	m128::M128,
 	simd_arithmetic::{
-		packed_aes_16x8b_invert_or_zero, packed_aes_16x8b_mul_alpha, packed_aes_16x8b_multiply,
-		packed_aes_16x8b_square,
+		packed_aes_16x8b_invert_or_zero, packed_aes_16x8b_multiply, packed_aes_16x8b_square,
 	},
 };
 use crate::{
 	aes_field::AESTowerField8b,
 	arch::portable::packed::PackedPrimitiveType,
-	arithmetic_traits::{InvertOrZero, MulAlpha, Square},
+	arithmetic_traits::{InvertOrZero, Square},
 	underlier::WithUnderlier,
 };
 
@@ -41,12 +40,6 @@ impl InvertOrZero for PackedAESBinaryField16x8b {
 	}
 }
 
-impl MulAlpha for PackedAESBinaryField16x8b {
-	fn mul_alpha(self) -> Self {
-		self.mutate_underlier(packed_aes_16x8b_mul_alpha)
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use proptest::prelude::*;

crates/field/src/arch/aarch64/packed_ghash_128.rs

@@ -60,7 +60,6 @@ define_packed_binary_field!(
 	(GhashStrategy),
 	(GhashStrategy),
 	(GhashStrategy),
-	(None),
 	(None)
 );
 

crates/field/src/arch/aarch64/simd_arithmetic.rs

@@ -53,12 +53,6 @@ pub fn packed_aes_16x8b_square(x: M128) -> M128 {
 	}
 }
 
-#[inline]
-pub fn packed_aes_16x8b_mul_alpha(x: M128) -> M128 {
-	// 0xD3 corresponds to 0x10 after isomorphism from BinaryField8b to AESField
-	packed_aes_16x8b_multiply(x, M128::from_le_bytes([0xD3; 16]))
-}
-
 #[inline]
 pub fn packed_aes_16x8b_multiply(a: M128, b: M128) -> M128 {
 	//! Performs a multiplication in GF(2^8) on the packed bytes.

crates/field/src/arch/portable/bitwise_and_arithmetic.rs

@@ -4,7 +4,7 @@ use super::packed::PackedPrimitiveType;
 use crate::{
 	BinaryField1b,
 	arch::BitwiseAndStrategy,
-	arithmetic_traits::{TaggedInvertOrZero, TaggedMul, TaggedMulAlpha, TaggedSquare},
+	arithmetic_traits::{TaggedInvertOrZero, TaggedMul, TaggedSquare},
 	underlier::UnderlierWithBitOps,
 };
 
@@ -34,12 +34,3 @@ impl<U: UnderlierWithBitOps> TaggedInvertOrZero<BitwiseAndStrategy>
 		self
 	}
 }
-
-impl<U: UnderlierWithBitOps> TaggedMulAlpha<BitwiseAndStrategy>
-	for PackedPrimitiveType<U, BinaryField1b>
-{
-	#[inline]
-	fn mul_alpha(self) -> Self {
-		self
-	}
-}

crates/field/src/arch/portable/mod.rs

@@ -32,7 +32,6 @@ pub(crate) mod univariate_mul_utils_128;
 pub(super) mod bitwise_and_arithmetic;
 pub(crate) mod packed_arithmetic;
 pub(super) mod pairwise_arithmetic;
-pub(super) mod pairwise_recursive_arithmetic;
 pub(super) mod pairwise_table_arithmetic;
 pub(super) mod reuse_multiply_arithmetic;
 pub(super) mod scaled_arithmetic;

crates/field/src/arch/portable/packed.rs

@@ -22,7 +22,7 @@ use rand::{
 
 use crate::{
 	BinaryField, Divisible, ExtensionField, Field, PackedField,
-	arithmetic_traits::{InvertOrZero, MulAlpha, Square},
+	arithmetic_traits::{InvertOrZero, Square},
 	field::FieldOps,
 	underlier::{NumCast, UnderlierType, UnderlierWithBitOps, WithUnderlier},
 };
@@ -551,20 +551,3 @@ where
 
 	PT1::from_underlier(PT1::Underlier::num_cast_from(bigger_result.to_underlier()))
 }
-
-/// Multiply by alpha `PT1` values by upcasting to wider `PT2` type with the same scalar.
-/// This is useful for the cases when SIMD multiply by alpha is faster.
-#[allow(dead_code)]
-pub fn mul_alpha_as_bigger_type<PT1, PT2>(val: PT1) -> PT1
-where
-	PT1: PackedField + WithUnderlier,
-	PT2: PackedField<Scalar = PT1::Scalar> + WithUnderlier + MulAlpha,
-	PT2::Underlier: From<PT1::Underlier>,
-	PT1::Underlier: NumCast<PT2::Underlier>,
-{
-	let bigger_val = PT2::from_underlier(val.to_underlier().into());
-
-	let bigger_result = bigger_val.mul_alpha();
-
-	PT1::from_underlier(PT1::Underlier::num_cast_from(bigger_result.to_underlier()))
-}

crates/field/src/arch/portable/packed_1.rs

@@ -17,7 +17,6 @@ define_packed_binary_fields!(
 			mul: (BitwiseAndStrategy),
 			square: (BitwiseAndStrategy),
 			invert: (BitwiseAndStrategy),
-			mul_alpha: (BitwiseAndStrategy),
 			transform: (PackedStrategy),
 		},
 	]

crates/field/src/arch/portable/packed_128.rs

@@ -16,7 +16,6 @@ define_packed_binary_fields!(
 			mul: (BitwiseAndStrategy),
 			square: (BitwiseAndStrategy),
 			invert: (BitwiseAndStrategy),
-			mul_alpha: (BitwiseAndStrategy),
 			transform: (PackedStrategy),
 		},
 	]

crates/field/src/arch/portable/packed_16.rs

@@ -14,7 +14,6 @@ define_packed_binary_fields!(
 			mul: (BitwiseAndStrategy),
 			square: (BitwiseAndStrategy),
 			invert: (BitwiseAndStrategy),
-			mul_alpha: (BitwiseAndStrategy),
 			transform: (PackedStrategy),
 		},
 	]

crates/field/src/arch/portable/packed_2.rs

@@ -17,7 +17,6 @@ define_packed_binary_fields!(
 			mul: (BitwiseAndStrategy),
 			square: (BitwiseAndStrategy),
 			invert: (BitwiseAndStrategy),
-			mul_alpha: (BitwiseAndStrategy),
 			transform: (PackedStrategy),
 		},
 	]

crates/field/src/arch/portable/packed_256.rs

@@ -20,7 +20,6 @@ define_packed_binary_fields!(
 			mul:       (ScaledStrategy),
 			square:    (ScaledStrategy),
 			invert:    (ScaledStrategy),
-			mul_alpha: (ScaledStrategy),
 			transform: (ScaledStrategy),
 		},
 	]