ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean

full_name: RingHom.isIntegralElem_map
code: theorem RingHom.isIntegralElem_map {x : R} : f.IsIntegralElem (f x) 
goal: f.IsIntegralElem (f x)

full_name: isIntegral_algebraMap
code: theorem isIntegral_algebraMap {x : R} : IsIntegral R (algebraMap R A x) 
goal: IsIntegral R ((algebraMap R A) x)

full_name: IsIntegral.map
code: theorem IsIntegral.map {B C F : Type*} [Ring B] [Ring C] [Algebra R B] [Algebra A B] [Algebra R C]
    [IsScalarTower R A B] [Algebra A C] [IsScalarTower R A C] {b : B}
    [FunLike F B C] [AlgHomClass F A B C] (f : F)
    (hb : IsIntegral R b) : IsIntegral R (f b) 
goal: IsIntegral R (f b)

full_name: isIntegral_algHom_iff
code: theorem isIntegral_algHom_iff {x : A} : IsIntegral R (f x) ↔ IsIntegral R x 
goal: IsIntegral R (f x) ↔ IsIntegral R x

full_name: Submodule.span_range_natDegree_eq_adjoin
code: theorem Submodule.span_range_natDegree_eq_adjoin {R A} [CommRing R] [Semiring A] [Algebra R A]
    {x : A} {f : R[X]} (hf : f.Monic) (hfx : aeval x f = 0) :
    span R (Finset.image (x ^ ·) (Finset.range (natDegree f))) =
      Subalgebra.toSubmodule (Algebra.adjoin R {x}) 
goal: Submodule.span R ↑(Finset.image (fun x_1 => x ^ x_1) (Finset.range f.natDegree)) =
  Subalgebra.toSubmodule (Algebra.adjoin R {x})

full_name: IsIntegral.fg_adjoin_singleton
code: theorem IsIntegral.fg_adjoin_singleton {x : B} (hx : IsIntegral R x) :
    (Algebra.adjoin R {x}).toSubmodule.FG 
goal: (Subalgebra.toSubmodule (Algebra.adjoin R {x})).FG

full_name: RingHom.isIntegralElem_zero
code: theorem RingHom.isIntegralElem_zero : f.IsIntegralElem 0 
goal: f.IsIntegralElem 0

full_name: isIntegral_zero
code: theorem isIntegral_zero : IsIntegral R (0 : B) 
goal: IsIntegral R 0

full_name: RingHom.isIntegralElem_one
code: theorem RingHom.isIntegralElem_one : f.IsIntegralElem 1 
goal: f.IsIntegralElem 1

full_name: isIntegral_one
code: theorem isIntegral_one : IsIntegral R (1 : B) 
goal: IsIntegral R 1

full_name: IsIntegral.of_pow
code: theorem IsIntegral.of_pow {x : B} {n : ℕ} (hn : 0 < n) (hx : IsIntegral R <| x ^ n) :
    IsIntegral R x 
goal: IsIntegral R x
File: Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Defs.lean

full_name: IsIntegralClosure.isIntegral_iff
code: /-- `IsIntegralClosure A R B` is the characteristic predicate stating `A` is
the integral closure of `R` in `B`,
i.e. that an element of `B` is integral over `R` iff it is an element of (the image of) `A`.
-/
class IsIntegralClosure (A R B : Type*) [CommRing R] [CommSemiring A] [CommRing B] [Algebra R B]
  [Algebra A B] : Prop where
  algebraMap_injective' : Function.Injective (algebraMap A B)
  isIntegral_iff : ∀ {x : B}, IsIntegral R x ↔ ∃ y, algebraMap A B y = x
goal: IsIntegral R x ↔ ∃ y, (algebraMap A B) y = x

full_name: IsIntegralClosure
code: /-- `IsIntegralClosure A R B` is the characteristic predicate stating `A` is
the integral closure of `R` in `B`,
i.e. that an element of `B` is integral over `R` iff it is an element of (the image of) `A`.
-/
class IsIntegralClosure (A R B : Type*) [CommRing R] [CommSemiring A] [CommRing B] [Algebra R B]
  [Algebra A B] : Prop where
  algebraMap_injective' : Function.Injective (algebraMap A B)
  isIntegral_iff : ∀ {x : B}, IsIntegral R x ↔ ∃ y, algebraMap A B y = x
goal: Prop

full_name: IsIntegralClosure.algebraMap_injective'
code: /-- `IsIntegralClosure A R B` is the characteristic predicate stating `A` is
the integral closure of `R` in `B`,
i.e. that an element of `B` is integral over `R` iff it is an element of (the image of) `A`.
-/
class IsIntegralClosure (A R B : Type*) [CommRing R] [CommSemiring A] [CommRing B] [Algebra R B]
  [Algebra A B] : Prop where
  algebraMap_injective' : Function.Injective (algebraMap A B)
  isIntegral_iff : ∀ {x : B}, IsIntegral R x ↔ ∃ y, algebraMap A B y = x
goal: Function.Injective ⇑(algebraMap A B)
File: Mathlib/RingTheory/IntegralClosure/Algebra/Defs.lean

full_name: Algebra.IsIntegral
code: /-- An algebra is integral if every element of the extension is integral over the base ring. -/
protected class Algebra.IsIntegral : Prop :=
  isIntegral : ∀ x : A, IsIntegral R x
goal: Prop

full_name: Algebra.IsIntegral.isIntegral
code: /-- An algebra is integral if every element of the extension is integral over the base ring. -/
protected class Algebra.IsIntegral : Prop :=
  isIntegral : ∀ x : A, IsIntegral R x
goal: IsIntegral R x

full_name: Algebra.isIntegral_def
code: lemma Algebra.isIntegral_def : Algebra.IsIntegral R A ↔ ∀ x : A, IsIntegral R x 
goal: Algebra.IsIntegral R A ↔ ∀ (x : A), IsIntegral R x
File: Mathlib/Testing/SlimCheck/Gen.lean

full_name: SlimCheck.Gen
code: /-- Monad to generate random examples to test properties with.
It has a `Nat` parameter so that the caller can decide on the
size of the examples. -/
abbrev Gen (α : Type u) 
goal: Type u

full_name: SlimCheck.Gen.chooseAny
code: /-- Lift `Random.random` to the `Gen` monad. -/
def chooseAny (α : Type u) [Random Id α] : Gen α 
goal: SlimCheck.Gen α

full_name: SlimCheck.Gen.choose
code: /-- Lift `BoundedRandom.randomR` to the `Gen` monad. -/
def choose (α : Type u) [Preorder α] [BoundedRandom Id α] (lo hi : α) (h : lo ≤ hi) :
    Gen {a // lo ≤ a ∧ a ≤ hi} 
goal: SlimCheck.Gen { a // lo ≤ a ∧ a ≤ hi }

full_name: SlimCheck.Gen.chooseNatLt_aux
code: lemma chooseNatLt_aux {lo hi : Nat} (a : Nat) (h : Nat.succ lo ≤ a ∧ a ≤ hi) :
    lo ≤ Nat.pred a ∧ Nat.pred a < hi 
goal: lo ≤ a.pred ∧ a.pred < hi

full_name: SlimCheck.Gen.chooseNatLt
code: /-- Generate a `Nat` example between `x` and `y` (exclusively). -/
def chooseNatLt (lo hi : Nat) (h : lo < hi) : Gen {a // lo ≤ a ∧ a < hi} 
goal: SlimCheck.Gen { a // lo ≤ a ∧ a < hi }

full_name: SlimCheck.Gen.getSize
code: /-- Get access to the size parameter of the `Gen` monad. -/
def getSize : Gen Nat 
goal: SlimCheck.Gen ℕ

full_name: SlimCheck.Gen.resize
code: /-- Apply a function to the size parameter. -/
def resize {α : Type*} (f : Nat → Nat) (x : Gen α) : Gen α 
goal: SlimCheck.Gen α

full_name: SlimCheck.Gen.arrayOf
code: /-- Create an `Array` of examples using `x`. The size is controlled
by the size parameter of `Gen`. -/
def arrayOf (x : Gen α) : Gen (Array α) 
goal: SlimCheck.Gen (Array α)

full_name: SlimCheck.Gen.listOf
code: /-- Create a `List` of examples using `x`. The size is controlled
by the size parameter of `Gen`. -/
def listOf (x : Gen α) : Gen (List α) 
goal: SlimCheck.Gen (List α)

full_name: SlimCheck.Gen.oneOf
code: /-- Given a list of example generators, choose one to create an example. -/
def oneOf (xs : Array (Gen α)) (pos : 0 < xs.size := by decide) : Gen α 
goal: SlimCheck.Gen α

full_name: SlimCheck.Gen.elements
code: /-- Given a list of examples, choose one to create an example. -/
def elements (xs : List α) (pos : 0 < xs.length) : Gen α 
goal: SlimCheck.Gen α

full_name: SlimCheck.Gen.permutationOf
code: /-- Generate a random permutation of a given list. -/
def permutationOf : (xs : List α) → Gen { ys // xs ~ ys }
  
goal: SlimCheck.Gen { ys // xs.Perm ys }

full_name: SlimCheck.Gen.prodOf
code: /-- Given two generators produces a tuple consisting out of the result of both -/
def prodOf {α : Type u} {β : Type v} (x : Gen α) (y : Gen β) : Gen (α × β) 
goal: SlimCheck.Gen (α × β)

full_name: SlimCheck.Gen.run
code: /-- Execute a `Gen` inside the `IO` monad using `size` as the example size-/
def Gen.run {α : Type} (x : Gen α) (size : Nat) : BaseIO α 
goal: BaseIO α
File: Mathlib/RingTheory/ZMod.lean

full_name: ZMod.ker_intCastRingHom
code: /-- The ring homomorphism `ℤ → ZMod n` has kernel generated by `n`. -/
theorem ZMod.ker_intCastRingHom (n : ℕ) :
    RingHom.ker (Int.castRingHom (ZMod n)) = Ideal.span ({(n : ℤ)} : Set ℤ) 
goal: RingHom.ker (Int.castRingHom (ZMod n)) = Ideal.span {↑n}

full_name: ZMod.ringHom_eq_of_ker_eq
code: /-- Two ring homomorphisms into `ZMod n` with equal kernels are equal. -/
theorem ZMod.ringHom_eq_of_ker_eq {n : ℕ} {R : Type*} [CommRing R] (f g : R →+* ZMod n)
    (h : RingHom.ker f = RingHom.ker g) : f = g 
goal: f = g

full_name: isReduced_zmod
code: /-- `ZMod n` is reduced iff `n` is square-free (or `n=0`). -/
@[simp]
theorem isReduced_zmod {n : ℕ} : IsReduced (ZMod n) ↔ Squarefree n ∨ n = 0 
goal: IsReduced (ZMod n) ↔ Squarefree n ∨ n = 0

full_name: instIsReducedZModOfFactSquarefreeNat
code: instance {n : ℕ} [Fact <| Squarefree n] : IsReduced (ZMod n) 
goal: IsReduced (ZMod n)
File: Mathlib/LinearAlgebra/RootSystem/RootPositive.lean

full_name: RootPairing.IsRootPositive
code: /-- A Prop-valued class for a bilinear form to be compatible with a root pairing. -/
class IsRootPositive (P : RootPairing ι R M N) (B : M →ₗ[R] M →ₗ[R] R) : Prop where
  zero_lt_apply_root : ∀ i, 0 < B (P.root i) (P.root i)
  symm : ∀ x y, B x y = B y x
  apply_reflection_eq : ∀ i x y, B (P.reflection i x) (P.reflection i y) = B x y
goal: Prop

full_name: RootPairing.IsRootPositive.apply_reflection_eq
code: /-- A Prop-valued class for a bilinear form to be compatible with a root pairing. -/
class IsRootPositive (P : RootPairing ι R M N) (B : M →ₗ[R] M →ₗ[R] R) : Prop where
  zero_lt_apply_root : ∀ i, 0 < B (P.root i) (P.root i)
  symm : ∀ x y, B x y = B y x
  apply_reflection_eq : ∀ i x y, B (P.reflection i x) (P.reflection i y) = B x y
goal: (B ((P.reflection i) x)) ((P.reflection i) y) = (B x) y

full_name: RootPairing.IsRootPositive.zero_lt_apply_root
code: /-- A Prop-valued class for a bilinear form to be compatible with a root pairing. -/
class IsRootPositive (P : RootPairing ι R M N) (B : M →ₗ[R] M →ₗ[R] R) : Prop where
  zero_lt_apply_root : ∀ i, 0 < B (P.root i) (P.root i)
  symm : ∀ x y, B x y = B y x
  apply_reflection_eq : ∀ i x y, B (P.reflection i x) (P.reflection i y) = B x y
goal: 0 < (B (P.root i)) (P.root i)

full_name: RootPairing.IsRootPositive.symm
code: /-- A Prop-valued class for a bilinear form to be compatible with a root pairing. -/
class IsRootPositive (P : RootPairing ι R M N) (B : M →ₗ[R] M →ₗ[R] R) : Prop where
  zero_lt_apply_root : ∀ i, 0 < B (P.root i) (P.root i)
  symm : ∀ x y, B x y = B y x
  apply_reflection_eq : ∀ i x y, B (P.reflection i x) (P.reflection i y) = B x y
goal: (B x) y = (B y) x

full_name: RootPairing.two_mul_apply_root_root
code: lemma two_mul_apply_root_root :
    2 * B (P.root i) (P.root j) = P.pairing i j * B (P.root j) (P.root j) 
goal: 2 * (B (P.root i)) (P.root j) = P.pairing i j * (B (P.root j)) (P.root j)

full_name: RootPairing.zero_lt_apply_root_root_iff
code: @[simp]
lemma zero_lt_apply_root_root_iff : 0 < B (P.root i) (P.root j) ↔ 0 < P.pairing i j 
goal: 0 < (B (P.root i)) (P.root j) ↔ 0 < P.pairing i j

full_name: RootPairing.zero_lt_pairing_iff
code: lemma zero_lt_pairing_iff : 0 < P.pairing i j ↔ 0 < P.pairing j i 
goal: 0 < P.pairing i j ↔ 0 < P.pairing j i

full_name: RootPairing.coxeterWeight_non_neg
code: lemma coxeterWeight_non_neg : 0 ≤ P.coxeterWeight i j 
goal: 0 ≤ P.coxeterWeight i j

full_name: RootPairing.apply_root_root_zero_iff
code: @[simp]
lemma apply_root_root_zero_iff : B (P.root i) (P.root j) = 0 ↔ P.pairing i j = 0 
goal: (B (P.root i)) (P.root j) = 0 ↔ P.pairing i j = 0

full_name: RootPairing.pairing_zero_iff
code: lemma pairing_zero_iff : P.pairing i j = 0 ↔ P.pairing j i = 0 
goal: P.pairing i j = 0 ↔ P.pairing j i = 0

full_name: RootPairing.coxeterWeight_zero_iff_isOrthogonal
code: lemma coxeterWeight_zero_iff_isOrthogonal : P.coxeterWeight i j = 0 ↔ P.IsOrthogonal i j 
goal: P.coxeterWeight i j = 0 ↔ P.IsOrthogonal i j
File: Mathlib/LinearAlgebra/FreeModule/Determinant.lean

full_name: LinearMap.det_zero''
code: @[simp]
theorem LinearMap.det_zero'' {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
    [Module.Free R M] [Module.Finite R M] [Nontrivial M] : LinearMap.det (0 : M →ₗ[R] M) = 0 
goal: LinearMap.det 0 = 0
File: Mathlib/LinearAlgebra/FreeModule/Finite/Basic.lean

full_name: Module.Free.ChooseBasisIndex.fintype
code: /-- If a free module is finite, then the arbitrary basis is finite. -/
noncomputable instance ChooseBasisIndex.fintype [Module.Finite R M] :
    Fintype (Module.Free.ChooseBasisIndex R M) 
goal: Fintype (Module.Free.ChooseBasisIndex R M)

full_name: Module.Finite.of_basis
code: /-- A free module with a basis indexed by a `Fintype` is finite. -/
theorem _root_.Module.Finite.of_basis {R M ι : Type*} [Semiring R] [AddCommMonoid M] [Module R M]
    [_root_.Finite ι] (b : Basis ι R M) : Module.Finite R M 
goal: Module.Finite R M

full_name: Module.Finite.matrix
code: instance _root_.Module.Finite.matrix {ι₁ ι₂ : Type*} [_root_.Finite ι₁] [_root_.Finite ι₂] :
    Module.Finite R (Matrix ι₁ ι₂ R) 
goal: Module.Finite R (Matrix ι₁ ι₂ R)
File: Mathlib/LinearAlgebra/FreeModule/StrongRankCondition.lean

full_name: commRing_strongRankCondition
code: /-- Any nontrivial commutative ring satisfies the `StrongRankCondition`. -/
instance (priority := 100) commRing_strongRankCondition : StrongRankCondition R 
goal: StrongRankCondition R
File: Mathlib/LinearAlgebra/PID.lean

full_name: LinearMap.trace_restrict_eq_of_forall_mem
code: /-- If a linear endomorphism of a (finite, free) module `M` takes values in a submodule `p ⊆ M`,
then the trace of its restriction to `p` is equal to its trace on `M`. -/
lemma trace_restrict_eq_of_forall_mem [IsDomain R] [IsPrincipalIdealRing R]
    (p : Submodule R M) (f : M →ₗ[R] M)
    (hf : ∀ x, f x ∈ p) (hf' : ∀ x ∈ p, f x ∈ p := fun x _ ↦ hf x) :
    trace R p (f.restrict hf') = trace R M f 
goal: (LinearMap.trace R ↥p) (f.restrict hf') = (LinearMap.trace R M) f
File: Mathlib/LinearAlgebra/FreeModule/Norm.lean

full_name: associated_norm_prod_smith
code: /-- For a nonzero element `f` in an algebra `S` over a principal ideal domain `R` that is finite and
free as an `R`-module, the norm of `f` relative to `R` is associated to the product of the Smith
coefficients of the ideal generated by `f`. -/
theorem associated_norm_prod_smith [Fintype ι] (b : Basis ι R S) {f : S} (hf : f ≠ 0) :
    Associated (Algebra.norm R f) (∏ i, smithCoeffs b _ (span_singleton_eq_bot.not.2 hf) i) 
goal: Associated ((Algebra.norm R) f) (∏ i : ι, Ideal.smithCoeffs b (Ideal.span {f}) ⋯ i)

full_name: instFiniteDimensionalQuotientPolynomialIdealSpanSingletonSetSmithCoeffs
code: instance (b : Basis ι F[X] S) {I : Ideal S} (hI : I ≠ ⊥) (i : ι) :
    FiniteDimensional F (F[X] ⧸ span ({I.smithCoeffs b hI i} : Set F[X])) 
goal: FiniteDimensional F (F[X] ⧸ Ideal.span {Ideal.smithCoeffs b I hI i})

full_name: finrank_quotient_span_eq_natDegree_norm
code: /-- For a nonzero element `f` in a `F[X]`-module `S`, the dimension of $S/\langle f \rangle$ as an
`F`-vector space is the degree of the norm of `f` relative to `F[X]`. -/
theorem finrank_quotient_span_eq_natDegree_norm [Algebra F S] [IsScalarTower F F[X] S]
    (b : Basis ι F[X] S) {f : S} (hf : f ≠ 0) :
    FiniteDimensional.finrank F (S ⧸ span ({f} : Set S)) = (Algebra.norm F[X] f).natDegree 
goal: FiniteDimensional.finrank F (S ⧸ Ideal.span {f}) = ((Algebra.norm F[X]) f).natDegree
File: Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean

full_name: _private.Mathlib.LinearAlgebra.FreeModule.Finite.Matrix.0.linearMapEquivFun
code: private noncomputable def linearMapEquivFun : (M →ₗ[R] N) ≃ₗ[S] ChooseBasisIndex R M → N 
goal: (M →ₗ[R] N) ≃ₗ[S] Module.Free.ChooseBasisIndex R M → N

full_name: Module.Free.linearMap
code: instance Module.Free.linearMap [Module.Free S N] : Module.Free S (M →ₗ[R] N) 
goal: Module.Free S (M →ₗ[R] N)

full_name: Module.Finite.linearMap
code: instance Module.Finite.linearMap [Module.Finite S N] : Module.Finite S (M →ₗ[R] N) 
goal: Module.Finite S (M →ₗ[R] N)

full_name: FiniteDimensional.rank_linearMap
code: theorem FiniteDimensional.rank_linearMap :
    Module.rank S (M →ₗ[R] N) = lift.{w} (Module.rank R M) * lift.{v} (Module.rank S N) 
goal: Module.rank S (M →ₗ[R] N) = Cardinal.lift.{w, v} (Module.rank R M) * Cardinal.lift.{v, w} (Module.rank S N)

full_name: FiniteDimensional.finrank_linearMap
code: /-- The finrank of `M →ₗ[R] N` as an `S`-module is `(finrank R M) * (finrank S N)`. -/
theorem FiniteDimensional.finrank_linearMap :
    finrank S (M →ₗ[R] N) = finrank R M * finrank S N 
goal: FiniteDimensional.finrank S (M →ₗ[R] N) = FiniteDimensional.finrank R M * FiniteDimensional.finrank S N

full_name: FiniteDimensional.rank_linearMap_self
code: theorem FiniteDimensional.rank_linearMap_self :
    Module.rank S (M →ₗ[R] S) = lift.{u'} (Module.rank R M) 
goal: Module.rank S (M →ₗ[R] S) = Cardinal.lift.{u', v} (Module.rank R M)

full_name: FiniteDimensional.finrank_linearMap_self
code: theorem FiniteDimensional.finrank_linearMap_self : finrank S (M →ₗ[R] S) = finrank R M 
goal: FiniteDimensional.finrank S (M →ₗ[R] S) = FiniteDimensional.finrank R M

full_name: Finite.algHom
code: instance Finite.algHom : Finite (M →ₐ[K] L) 
goal: Finite (M →ₐ[K] L)

full_name: cardinal_mk_algHom_le_rank
code: theorem cardinal_mk_algHom_le_rank : #(M →ₐ[K] L) ≤ lift.{v} (Module.rank K M) 
goal: Cardinal.mk (M →ₐ[K] L) ≤ Cardinal.lift.{v, u_2} (Module.rank K M)

full_name: card_algHom_le_finrank
code: theorem card_algHom_le_finrank : Nat.card (M →ₐ[K] L) ≤ finrank K M 
goal: Nat.card (M →ₐ[K] L) ≤ FiniteDimensional.finrank K M

full_name: Module.Finite.addMonoidHom
code: instance Module.Finite.addMonoidHom [Module.Finite ℤ N] : Module.Finite ℤ (M →+ N) 
goal: Module.Finite ℤ (M →+ N)

full_name: Module.Free.addMonoidHom
code: instance Module.Free.addMonoidHom [Module.Free ℤ N] : Module.Free ℤ (M →+ N) 
goal: Module.Free ℤ (M →+ N)

full_name: Matrix.rank_vecMulVec
code: theorem Matrix.rank_vecMulVec {K m n : Type u} [CommRing K] [Fintype n]
    [DecidableEq n] (w : m → K) (v : n → K) : (Matrix.vecMulVec w v).toLin'.rank ≤ 1 
goal: (Matrix.toLin' (Matrix.vecMulVec w v)).rank ≤ 1
File: Mathlib/LinearAlgebra/FreeModule/IdealQuotient.lean

full_name: Ideal.quotientEquivPiSpan
code: /-- We can write the quotient of an ideal over a PID as a product of quotients by principal ideals.
-/
noncomputable def quotientEquivPiSpan (I : Ideal S) (b : Basis ι R S) (hI : I ≠ ⊥) :
    (S ⧸ I) ≃ₗ[R] ∀ i, R ⧸ span ({I.smithCoeffs b hI i} : Set R) 
goal: (S ⧸ I) ≃ₗ[R] (i : ι) → R ⧸ Ideal.span {Ideal.smithCoeffs b I hI i}

full_name: Ideal.quotientEquivPiZMod
code: /-- Ideal quotients over a free finite extension of `ℤ` are isomorphic to a direct product of
`ZMod`. -/
noncomputable def quotientEquivPiZMod (I : Ideal S) (b : Basis ι ℤ S) (hI : I ≠ ⊥) :
    S ⧸ I ≃+ ∀ i, ZMod (I.smithCoeffs b hI i).natAbs 
goal: S ⧸ I ≃+ ((i : ι) → ZMod (Ideal.smithCoeffs b I hI i).natAbs)

full_name: Ideal.fintypeQuotientOfFreeOfNeBot
code: /-- A nonzero ideal over a free finite extension of `ℤ` has a finite quotient.

Can't be an instance because of the side condition `I ≠ ⊥`, and more importantly,
because the choice of `Fintype` instance is non-canonical.
-/
noncomputable def fintypeQuotientOfFreeOfNeBot [Module.Free ℤ S] [Module.Finite ℤ S]
    (I : Ideal S) (hI : I ≠ ⊥) : Fintype (S ⧸ I) 
goal: Fintype (S ⧸ I)

full_name: Ideal.quotientEquivDirectSum
code: /-- Decompose `S⧸I` as a direct sum of cyclic `R`-modules
  (quotients by the ideals generated by Smith coefficients of `I`). -/
noncomputable def quotientEquivDirectSum :
    (S ⧸ I) ≃ₗ[F] ⨁ i, R ⧸ span ({I.smithCoeffs b hI i} : Set R) 
goal: (S ⧸ I) ≃ₗ[F] DirectSum ι fun i => R ⧸ Ideal.span {Ideal.smithCoeffs b I hI i}

full_name: Ideal.finrank_quotient_eq_sum
code: theorem finrank_quotient_eq_sum {ι} [Fintype ι] (b : Basis ι R S) [Nontrivial F]
    [∀ i, Module.Free F (R ⧸ span ({I.smithCoeffs b hI i} : Set R))]
    [∀ i, Module.Finite F (R ⧸ span ({I.smithCoeffs b hI i} : Set R))] :
    FiniteDimensional.finrank F (S ⧸ I) =
      ∑ i, FiniteDimensional.finrank F (R ⧸ span ({I.smithCoeffs b hI i} : Set R)) 
goal: FiniteDimensional.finrank F (S ⧸ I) = ∑ i : ι, FiniteDimensional.finrank F (R ⧸ Ideal.span {Ideal.smithCoeffs b I hI i})
File: Mathlib/LinearAlgebra/CliffordAlgebra/CategoryTheory.lean

full_name: QuadraticModuleCat.cliffordAlgebra_obj_carrier
code: /-- The "clifford algebra" functor, sending a quadratic `R`-module `V` to the clifford algebra on
`V`.

This is `CliffordAlgebra.map` through the lens of category theory. -/
@[simps]
def QuadraticModuleCat.cliffordAlgebra : QuadraticModuleCat.{u} R ⥤ AlgebraCat.{u} R 
goal: ↑(QuadraticModuleCat.cliffordAlgebra.obj M) = CliffordAlgebra M.form

full_name: QuadraticModuleCat.cliffordAlgebra
code: /-- The "clifford algebra" functor, sending a quadratic `R`-module `V` to the clifford algebra on
`V`.

This is `CliffordAlgebra.map` through the lens of category theory. -/
@[simps]
def QuadraticModuleCat.cliffordAlgebra : QuadraticModuleCat.{u} R ⥤ AlgebraCat.{u} R 
goal: QuadraticModuleCat R ⥤ AlgebraCat R

full_name: QuadraticModuleCat.cliffordAlgebra_map
code: /-- The "clifford algebra" functor, sending a quadratic `R`-module `V` to the clifford algebra on
`V`.

This is `CliffordAlgebra.map` through the lens of category theory. -/
@[simps]
def QuadraticModuleCat.cliffordAlgebra : QuadraticModuleCat.{u} R ⥤ AlgebraCat.{u} R 
goal: QuadraticModuleCat.cliffordAlgebra.map f = CliffordAlgebra.map f.toIsometry
File: Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean

full_name: CliffordAlgebra.instStarRing
code: instance instStarRing : StarRing (CliffordAlgebra Q) 
goal: StarRing (CliffordAlgebra Q)

full_name: CliffordAlgebra.star_def
code: theorem star_def (x : CliffordAlgebra Q) : star x = reverse (involute x) 
goal: star x = CliffordAlgebra.reverse (CliffordAlgebra.involute x)

full_name: CliffordAlgebra.star_def'
code: theorem star_def' (x : CliffordAlgebra Q) : star x = involute (reverse x) 
goal: star x = CliffordAlgebra.involute (CliffordAlgebra.reverse x)

full_name: CliffordAlgebra.star_ι
code: @[simp]
theorem star_ι (m : M) : star (ι Q m) = -ι Q m 
goal: star ((CliffordAlgebra.ι Q) m) = -(CliffordAlgebra.ι Q) m

full_name: CliffordAlgebra.star_smul
code: /-- Note that this not match the `star_smul` implied by `StarModule`; it certainly could if we
also conjugated all the scalars, but there appears to be nothing in the literature that advocates
doing this. -/
@[simp]
theorem star_smul (r : R) (x : CliffordAlgebra Q) : star (r • x) = r • star x 
goal: star (r • x) = r • star x

full_name: CliffordAlgebra.star_algebraMap
code: @[simp]
theorem star_algebraMap (r : R) :
    star (algebraMap R (CliffordAlgebra Q) r) = algebraMap R (CliffordAlgebra Q) r 
goal: star ((algebraMap R (CliffordAlgebra Q)) r) = (algebraMap R (CliffordAlgebra Q)) r
File: Mathlib/LinearAlgebra/GeneralLinearGroup.lean

full_name: LinearMap.GeneralLinearGroup
code: /-- The group of invertible linear maps from `M` to itself -/
abbrev GeneralLinearGroup 
goal: Type u_2

full_name: LinearMap.GeneralLinearGroup.toLinearEquiv
code: /-- An invertible linear map `f` determines an equivalence from `M` to itself. -/
def toLinearEquiv (f : GeneralLinearGroup R M) : M ≃ₗ[R] M 
goal: M ≃ₗ[R] M

full_name: LinearMap.GeneralLinearGroup.ofLinearEquiv
code: /-- An equivalence from `M` to itself determines an invertible linear map. -/
def ofLinearEquiv (f : M ≃ₗ[R] M) : GeneralLinearGroup R M 
goal: LinearMap.GeneralLinearGroup R M

full_name: LinearMap.GeneralLinearGroup.generalLinearEquiv
code: /-- The general linear group on `R` and `M` is multiplicatively equivalent to the type of linear
equivalences between `M` and itself. -/
def generalLinearEquiv : GeneralLinearGroup R M ≃* M ≃ₗ[R] M 
goal: LinearMap.GeneralLinearGroup R M ≃* M ≃ₗ[R] M

full_name: LinearMap.GeneralLinearGroup.generalLinearEquiv_to_linearMap
code: @[simp]
theorem generalLinearEquiv_to_linearMap (f : GeneralLinearGroup R M) :
    (generalLinearEquiv R M f : M →ₗ[R] M) = f 
goal: ↑((LinearMap.GeneralLinearGroup.generalLinearEquiv R M) f) = ↑f

full_name: LinearMap.GeneralLinearGroup.coeFn_generalLinearEquiv
code: @[simp]
theorem coeFn_generalLinearEquiv (f : GeneralLinearGroup R M) :
    (generalLinearEquiv R M f) = (f : M → M) 
goal: ⇑((LinearMap.GeneralLinearGroup.generalLinearEquiv R M) f) = ⇑↑f