cargo fmt

air/src/air.rs

@@ -1,4 +1,5 @@
 use core::ops::{Add, Mul, Sub};
+
 use p3_field::{AbstractExtensionField, AbstractField, AbstractionOf, ExtensionField, Field};
 use p3_matrix::dense::RowMajorMatrix;
 use p3_matrix::MatrixRows;
@@ -209,9 +210,10 @@ impl<'a, AB: AirBuilder> AirBuilder for FilteredAirBuilder<'a, AB> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{Air, AirBuilder};
     use p3_matrix::MatrixRows;
 
+    use crate::{Air, AirBuilder};
+
     struct FibonacciAir;
 
     impl<AB: AirBuilder> Air<AB> for FibonacciAir {

air/src/virtual_column.rs

@@ -1,6 +1,7 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use core::ops::Mul;
+
 use p3_field::{AbstractField, Field};
 
 /// An affine function over columns in a PAIR.

brakedown/benches/encode.rs

@@ -1,3 +1,5 @@
+use std::any::type_name;
+
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use p3_brakedown::fast_registry;
 use p3_code::CodeOrFamily;
@@ -6,7 +8,6 @@ use p3_matrix::dense::RowMajorMatrix;
 use p3_mersenne_31::Mersenne31;
 use rand::distributions::{Distribution, Standard};
 use rand::thread_rng;
-use std::any::type_name;
 
 const BATCH_SIZE: usize = 1 << 12;
 

brakedown/src/brakedown_code.rs

@@ -1,4 +1,5 @@
 use alloc::boxed::Box;
+
 use p3_code::{
     Code, CodeOrFamily, LinearCode, SystematicCode, SystematicCodeOrFamily, SystematicLinearCode,
 };

brakedown/src/macros.rs

@@ -30,5 +30,4 @@ macro_rules! brakedown_to_rs {
     };
 }
 
-pub(crate) use brakedown;
-pub(crate) use brakedown_to_rs;
+pub(crate) use {brakedown, brakedown_to_rs};

brakedown/src/standard_fast.rs

@@ -1,7 +1,6 @@
-use crate::macros::{brakedown, brakedown_to_rs};
-use crate::BrakedownCode;
 use alloc::boxed::Box;
 use alloc::vec;
+
 use p3_code::{LinearCodeFamily, SLCodeRegistry};
 use p3_field::Field;
 use p3_matrix::sparse::CsrMatrix;
@@ -10,6 +9,9 @@ use rand::distributions::{Distribution, Standard};
 use rand::SeedableRng;
 use rand_chacha::ChaCha20Rng;
 
+use crate::macros::{brakedown, brakedown_to_rs};
+use crate::BrakedownCode;
+
 pub fn fast_registry<F, In>() -> impl LinearCodeFamily<F, In>
 where
     F: Field,

challenger/src/duplex_challenger.rs

@@ -1,6 +1,7 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use core::marker::PhantomData;
+
 use p3_field::Field;
 use p3_symmetric::permutation::ArrayPermutation;
 

challenger/src/hash_challenger.rs

@@ -1,10 +1,12 @@
-use crate::Challenger;
 use alloc::vec;
 use alloc::vec::Vec;
 use core::marker::PhantomData;
+
 use p3_field::Field;
 use p3_symmetric::hasher::CryptographicHasher;
 
+use crate::Challenger;
+
 #[derive(Clone)]
 pub struct HashChallenger<F: Field, H: CryptographicHasher<F, [F; OUT_LEN]>, const OUT_LEN: usize> {
     input_buffer: Vec<F>,

challenger/src/lib.rs

@@ -7,10 +7,10 @@ extern crate alloc;
 mod duplex_challenger;
 mod hash_challenger;
 
+use alloc::vec::Vec;
+
 pub use duplex_challenger::*;
 pub use hash_challenger::*;
-
-use alloc::vec::Vec;
 use p3_field::{AbstractExtensionField, Field};
 
 /// Observes prover messages during an IOP, and generates Fiat-Shamir challenges in response.

code/src/identity.rs

@@ -1,8 +1,9 @@
+use p3_field::Field;
+use p3_matrix::MatrixRows;
+
 use crate::{
     Code, CodeOrFamily, LinearCode, SystematicCode, SystematicCodeOrFamily, SystematicLinearCode,
 };
-use p3_field::Field;
-use p3_matrix::MatrixRows;
 
 /// The trivial code whose encoder is the identity function.
 pub struct IdentityCode {

code/src/registry.rs

@@ -1,12 +1,14 @@
-use crate::{
-    CodeFamily, CodeOrFamily, LinearCodeFamily, SystematicCodeFamily, SystematicCodeOrFamily,
-    SystematicLinearCode,
-};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
+
 use p3_field::Field;
 use p3_matrix::{Matrix, MatrixRows};
 
+use crate::{
+    CodeFamily, CodeOrFamily, LinearCodeFamily, SystematicCodeFamily, SystematicCodeOrFamily,
+    SystematicLinearCode,
+};
+
 /// A registry of systematic, linear codes for various message sizes.
 pub struct SLCodeRegistry<F: Field, In: Matrix<F>, Out: Matrix<F>> {
     /// Ordered by message length, ascending.

code/src/systematic.rs

@@ -1,7 +1,8 @@
-use crate::{Code, CodeFamily, CodeOrFamily, LinearCode};
 use p3_field::Field;
 use p3_matrix::MatrixRows;
 
+use crate::{Code, CodeFamily, CodeOrFamily, LinearCode};
+
 /// A systematic code, or a family thereof.
 // TODO: Remove? Not really used.
 pub trait SystematicCodeOrFamily<F: Field, In: for<'a> MatrixRows<'a, F>>:

commit/src/adapters/multi_from_uni_pcs.rs

@@ -1,11 +1,13 @@
-use crate::pcs::{UnivariatePCS, PCS};
-use crate::MultivariatePCS;
 use alloc::vec::Vec;
 use core::marker::PhantomData;
+
 use p3_challenger::Challenger;
 use p3_field::{ExtensionField, Field};
 use p3_matrix::MatrixRows;
 
+use crate::pcs::{UnivariatePCS, PCS};
+use crate::MultivariatePCS;
+
 pub struct MultiFromUniPCS<F, In, U>
 where
     F: Field,

commit/src/adapters/uni_from_multi_pcs.rs

@@ -1,8 +1,10 @@
-use crate::pcs::MultivariatePCS;
 use core::marker::PhantomData;
+
 use p3_field::Field;
 use p3_matrix::MatrixRows;
 
+use crate::pcs::MultivariatePCS;
+
 pub struct UniFromMultiPCS<F, In, M>
 where
     F: Field,

commit/src/mmcs.rs

@@ -1,4 +1,5 @@
 use alloc::vec::Vec;
+
 use p3_matrix::MatrixRows;
 
 /// A "Mixed Matrix Commitment Scheme" (MMCS) is a bit like a vector commitment scheme, but it

commit/src/pcs.rs

@@ -1,10 +1,10 @@
 //! Traits for polynomial commitment schemes.
 
 use alloc::vec;
-use p3_field::{ExtensionField, Field};
-
 use alloc::vec::Vec;
+
 use p3_challenger::Challenger;
+use p3_field::{ExtensionField, Field};
 use p3_matrix::MatrixRows;
 
 /// A (not necessarily hiding) polynomial commitment scheme, for committing to (batches of)

field/src/batch_inverse.rs

@@ -1,7 +1,8 @@
-use crate::field::Field;
 use alloc::vec;
 use alloc::vec::Vec;
 
+use crate::field::Field;
+
 /// Batch multiplicative inverses with Montgomery's trick
 /// This is Montgomery's trick. At a high level, we invert the product of the given field
 /// elements, then derive the individual inverses from that via multiplication.

field/src/field.rs

@@ -1,4 +1,3 @@
-use crate::packed::PackedField;
 use core::fmt::{Debug, Display};
 use core::hash::Hash;
 use core::iter::{Product, Sum};
@@ -7,6 +6,8 @@ use core::slice;
 
 use p3_util::log2_ceil_u64;
 
+use crate::packed::PackedField;
+
 /// A generalization of `Field` which permits things like
 /// - an actual field element
 /// - a symbolic expression which would evaluate to a field element

field/src/symbolic.rs

@@ -1,9 +1,10 @@
-use crate::field::{AbstractField, AbstractionOf, Field};
 use alloc::rc::Rc;
 use core::fmt::Debug;
 use core::iter::{Product, Sum};
 use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
+use crate::field::{AbstractField, AbstractionOf, Field};
+
 #[derive(Clone, Debug)]
 pub enum SymbolicField<F: Field, Var> {
     Variable(Var),

fri/src/lib.rs

@@ -4,15 +4,17 @@
 
 extern crate alloc;
 
-use crate::proof::FriProof;
-use crate::prover::prove;
-use crate::verifier::verify;
 use core::marker::PhantomData;
+
 use p3_challenger::Challenger;
 use p3_commit::{DirectMMCS, MMCS};
 use p3_field::{ExtensionField, Field};
 use p3_ldt::{LDTBasedPCS, LDT};
 
+use crate::proof::FriProof;
+use crate::prover::prove;
+use crate::verifier::verify;
+
 mod config;
 mod proof;
 mod prover;

fri/src/proof.rs

@@ -1,4 +1,5 @@
 use alloc::vec::Vec;
+
 use p3_commit::{DirectMMCS, MMCS};
 use p3_field::{ExtensionField, Field};
 

fri/src/prover.rs

@@ -1,14 +1,15 @@
-use crate::{FriConfig, FriProof};
 use alloc::vec;
 use alloc::vec::Vec;
 use core::cmp::Reverse;
+
 use itertools::Itertools;
 use p3_challenger::Challenger;
 use p3_commit::{DirectMMCS, MMCS};
 use p3_field::{AbstractField, ExtensionField, Field};
 use p3_matrix::{Matrix, MatrixRows};
-use p3_maybe_rayon::MaybeIntoParIter;
-use p3_maybe_rayon::ParallelIterator;
+use p3_maybe_rayon::{MaybeIntoParIter, ParallelIterator};
+
+use crate::{FriConfig, FriProof};
 
 pub(crate) fn prove<F, Challenge, M, MC, Chal>(
     codewords: &[M::ProverData],

fri/src/verifier.rs

@@ -1,8 +1,9 @@
-use crate::FriProof;
 use p3_challenger::Challenger;
 use p3_commit::{DirectMMCS, MMCS};
 use p3_field::{ExtensionField, Field};
 
+use crate::FriProof;
+
 pub(crate) fn verify<F, EF, M, MC, Chal>(
     _proof: &FriProof<F, EF, M, MC>,
     _challenger: &mut Chal,

goldilocks/src/lib.rs

@@ -7,6 +7,7 @@ use core::fmt::{Debug, Display, Formatter};
 use core::hash::{Hash, Hasher};
 use core::iter::{Product, Sum};
 use core::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};
+
 use p3_field::{AbstractField, Field, PrimeField, PrimeField64, TwoAdicField};
 use p3_util::{assume, branch_hint};
 use rand::distributions::{Distribution, Standard};

keccak/src/lib.rs

@@ -5,6 +5,7 @@
 extern crate alloc;
 
 use alloc::vec::Vec;
+
 use p3_symmetric::hasher::CryptographicHasher;
 use p3_symmetric::permutation::{ArrayPermutation, CryptographicPermutation};
 use tiny_keccak::{keccakf, Hasher, Keccak};

lde/src/naive.rs

@@ -1,14 +1,16 @@
-use crate::{TwoAdicCosetLDE, TwoAdicLDE, TwoAdicSubgroupLDE, UndefinedLDE};
 use alloc::vec::Vec;
+
 use p3_field::{
     batch_multiplicative_inverse, cyclic_subgroup_coset_known_order, cyclic_subgroup_known_order,
+    ExtensionField, Field, TwoAdicField,
 };
-use p3_field::{ExtensionField, Field, TwoAdicField};
 use p3_matrix::dense::RowMajorMatrix;
 use p3_matrix::stack::VerticalPair;
 use p3_matrix::{Matrix, MatrixRows};
 use p3_util::log2_strict_usize;
 
+use crate::{TwoAdicCosetLDE, TwoAdicLDE, TwoAdicSubgroupLDE, UndefinedLDE};
+
 /// A naive quadratic-time implementation of `LDE`, intended for testing.
 pub struct NaiveUndefinedLDE;
 

ldt/src/lib.rs

@@ -6,9 +6,9 @@ extern crate alloc;
 
 use alloc::vec::Vec;
 use core::marker::PhantomData;
+
 use p3_challenger::Challenger;
-use p3_commit::{DirectMMCS, MMCS};
-use p3_commit::{UnivariatePCS, PCS};
+use p3_commit::{DirectMMCS, UnivariatePCS, MMCS, PCS};
 use p3_field::{AbstractExtensionField, ExtensionField, Field, TwoAdicField};
 use p3_lde::TwoAdicLDE;
 use p3_matrix::dense::RowMajorMatrix;

matrix/src/dense.rs

@@ -1,9 +1,11 @@
-use crate::{Matrix, MatrixGet, MatrixRows};
 use alloc::vec::Vec;
+
 use p3_field::Field;
 use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 
+use crate::{Matrix, MatrixGet, MatrixRows};
+
 /// A dense matrix stored in row-major form.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RowMajorMatrix<T> {

matrix/src/lib.rs

@@ -4,9 +4,10 @@
 
 extern crate alloc;
 
-use crate::dense::RowMajorMatrix;
 use alloc::boxed::Box;
 
+use crate::dense::RowMajorMatrix;
+
 pub mod dense;
 pub mod mul;
 pub mod sparse;

matrix/src/mul.rs

@@ -1,10 +1,12 @@
-use crate::dense::RowMajorMatrix;
-use crate::sparse::CsrMatrix;
-use crate::{Matrix, MatrixRows};
 use alloc::vec;
+
 use p3_field::Field;
 use p3_maybe_rayon::{MaybeIntoParIter, ParallelIterator};
 
+use crate::dense::RowMajorMatrix;
+use crate::sparse::CsrMatrix;
+use crate::{Matrix, MatrixRows};
+
 /// Compute `C = A * B`, where `A` in a CSR matrix and `B` is a dense matrix.
 ///
 /// # Panics

matrix/src/sparse.rs

@@ -1,10 +1,12 @@
-use crate::Matrix;
 use alloc::vec::Vec;
 use core::iter;
 use core::ops::Range;
+
 use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 
+use crate::Matrix;
+
 /// A sparse matrix stored in the compressed sparse row format.
 pub struct CsrMatrix<T> {
     width: usize,

matrix/src/stack.rs

@@ -1,6 +1,7 @@
-use crate::{Matrix, MatrixRows};
 use core::marker::PhantomData;
 
+use crate::{Matrix, MatrixRows};
+
 /// A combination of two matrices, stacked together vertically.
 pub struct VerticalPair<T, First: Matrix<T>, Second: Matrix<T>> {
     first: First,