ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean

full_name: ExteriorAlgebra.GradedAlgebra.ι
code: /-- A version of `ExteriorAlgebra.ι` that maps directly into the graded structure. This is
primarily an auxiliary construction used to provide `ExteriorAlgebra.gradedAlgebra`. -/
-- Porting note: protected
protected def GradedAlgebra.ι :
    M →ₗ[R] ⨁ i : ℕ, ⋀[R]^i M 
goal: M →ₗ[R] DirectSum ℕ fun i => ↥(⋀[R]^i M)

full_name: ExteriorAlgebra.GradedAlgebra.ι_apply
code: theorem GradedAlgebra.ι_apply (m : M) :
    GradedAlgebra.ι R M m =
      DirectSum.of (fun i : ℕ => ⋀[R]^i M) 1
        ⟨ι R m, by simpa only [pow_one] using LinearMap.mem_range_self _ m⟩ 
goal: (ExteriorAlgebra.GradedAlgebra.ι R M) m = (DirectSum.of (fun i => ↥(⋀[R]^i M)) 1) ⟨(ExteriorAlgebra.ι R) m, ⋯⟩

full_name: ExteriorAlgebra.instGradedMonoidNatSubmoduleExteriorPower
code: instance : SetLike.GradedMonoid fun i : ℕ ↦ ⋀[R]^i M 
goal: SetLike.GradedMonoid fun i => ⋀[R]^i M

full_name: ExteriorAlgebra.GradedAlgebra.ι_sq_zero
code: theorem GradedAlgebra.ι_sq_zero (m : M) : GradedAlgebra.ι R M m * GradedAlgebra.ι R M m = 0 
goal: (ExteriorAlgebra.GradedAlgebra.ι R M) m * (ExteriorAlgebra.GradedAlgebra.ι R M) m = 0

full_name: ExteriorAlgebra.GradedAlgebra.liftι
code: /-- `ExteriorAlgebra.GradedAlgebra.ι` lifted to exterior algebra. This is
primarily an auxiliary construction used to provide `ExteriorAlgebra.gradedAlgebra`. -/
def GradedAlgebra.liftι :
    ExteriorAlgebra R M →ₐ[R] ⨁ i : ℕ, ⋀[R]^i M 
goal: ExteriorAlgebra R M →ₐ[R] DirectSum ℕ fun i => ↥(⋀[R]^i M)

full_name: ExteriorAlgebra.GradedAlgebra.liftι_eq
code: theorem GradedAlgebra.liftι_eq (i : ℕ) (x : ⋀[R]^i M) :
    GradedAlgebra.liftι R M x = DirectSum.of (fun i => ⋀[R]^i M) i x 
goal: (ExteriorAlgebra.GradedAlgebra.liftι R M) ↑x = (DirectSum.of (fun i => ↥(⋀[R]^i M)) i) x

full_name: ExteriorAlgebra.gradedAlgebra
code: /-- The exterior algebra is graded by the powers of the submodule `(ExteriorAlgebra.ι R).range`. -/
instance gradedAlgebra : GradedAlgebra (fun i : ℕ ↦ ⋀[R]^i M) 
goal: GradedAlgebra fun i => ⋀[R]^i M

full_name: ExteriorAlgebra.ιMulti_span
code: /-- The union of the images of the maps `ExteriorAlgebra.ιMulti R n` for `n` running through
all natural numbers spans the exterior algebra. -/
lemma ιMulti_span :
    Submodule.span R (Set.range fun x : Σ n, (Fin n → M) => ιMulti R x.1 x.2) = ⊤ 
goal: Submodule.span R (Set.range fun x => (ExteriorAlgebra.ιMulti R x.fst) x.snd) = ⊤
File: Mathlib/LinearAlgebra/FiniteSpan.lean

full_name: LinearEquiv.isOfFinOrder_of_finite_of_span_eq_top_of_mapsTo
code: /-- A linear equivalence which preserves a finite spanning set must have finite order. -/
lemma LinearEquiv.isOfFinOrder_of_finite_of_span_eq_top_of_mapsTo
    {R M : Type*} [CommSemiring R] [AddCommMonoid M] [Module R M]
    {Φ : Set M} (hΦ₁ : Φ.Finite) (hΦ₂ : span R Φ = ⊤) {e : M ≃ₗ[R] M} (he : MapsTo e Φ Φ) :
    IsOfFinOrder e 
goal: IsOfFinOrder e
File: Mathlib/LinearAlgebra/JordanChevalley.lean

full_name: Module.End.exists_isNilpotent_isSemisimple_of_separable_of_dvd_pow
code: theorem exists_isNilpotent_isSemisimple_of_separable_of_dvd_pow {P : K[X]} {k : ℕ}
    (sep : P.Separable) (nil : minpoly K f ∣ P ^ k) :
    ∃ᵉ (n ∈ adjoin K {f}) (s ∈ adjoin K {f}), IsNilpotent n ∧ IsSemisimple s ∧ f = n + s 
goal: ∃ n ∈ Algebra.adjoin K {f}, ∃ s ∈ Algebra.adjoin K {f}, IsNilpotent n ∧ s.IsSemisimple ∧ f = n + s

full_name: Module.End.exists_isNilpotent_isSemisimple
code: /-- **Jordan-Chevalley-Dunford decomposition**: an endomorphism of a finite-dimensional vector space
over a perfect field may be written as a sum of nilpotent and semisimple endomorphisms. Moreover
these nilpotent and semisimple components are polynomial expressions in the original endomorphism.
-/
theorem exists_isNilpotent_isSemisimple [PerfectField K] :
    ∃ᵉ (n ∈ adjoin K {f}) (s ∈ adjoin K {f}), IsNilpotent n ∧ IsSemisimple s ∧ f = n + s 
goal: ∃ n ∈ Algebra.adjoin K {f}, ∃ s ∈ Algebra.adjoin K {f}, IsNilpotent n ∧ s.IsSemisimple ∧ f = n + s
File: Mathlib/LinearAlgebra/FreeAlgebra.lean

full_name: FreeAlgebra.basisFreeMonoid
code: /-- The `FreeMonoid X` basis on the `FreeAlgebra R X`,
mapping `[x₁, x₂, ..., xₙ]` to the "monomial" `1 • x₁ * x₂ * ⋯ * xₙ` -/
-- @[simps]
noncomputable def basisFreeMonoid : Basis (FreeMonoid X) R (FreeAlgebra R X) 
goal: Basis (FreeMonoid X) R (FreeAlgebra R X)

full_name: FreeAlgebra.instFree
code: instance : Module.Free R (FreeAlgebra R X) 
goal: Module.Free R (FreeAlgebra R X)

full_name: FreeAlgebra.rank_eq
code: theorem rank_eq [CommRing R] [Nontrivial R] :
    Module.rank R (FreeAlgebra R X) = Cardinal.lift.{u} (Cardinal.mk (List X)) 
goal: Module.rank R (FreeAlgebra R X) = Cardinal.lift.{u, v} (Cardinal.mk (List X))
File: Mathlib/LinearAlgebra/Dimension/Localization.lean

full_name: IsLocalizedModule.linearIndependent_lift
code: lemma IsLocalizedModule.linearIndependent_lift {ι} {v : ι → N} (hf : LinearIndependent S v) :
    ∃ w : ι → M, LinearIndependent R w 
goal: ∃ w, LinearIndependent R w

full_name: IsLocalizedModule.lift_rank_eq
code: lemma IsLocalizedModule.lift_rank_eq :
    Cardinal.lift.{v} (Module.rank S N) = Cardinal.lift.{v'} (Module.rank R M) 
goal: Cardinal.lift.{v, v'} (Module.rank S N) = Cardinal.lift.{v', v} (Module.rank R M)

full_name: IsLocalizedModule.rank_eq
code: lemma IsLocalizedModule.rank_eq {N : Type v} [AddCommGroup N]
    [Module R N] [Module S N] [IsScalarTower R S N] (f : M →ₗ[R] N) [IsLocalizedModule p f] :
    Module.rank S N = Module.rank R M 
goal: Module.rank S N = Module.rank R M

full_name: exists_set_linearIndependent_of_isDomain
code: theorem exists_set_linearIndependent_of_isDomain [IsDomain R] :
    ∃ s : Set M, #s = Module.rank R M ∧ LinearIndependent (ι := s) R Subtype.val 
goal: ∃ s, #↑s = Module.rank R M ∧ LinearIndependent (ι := ↑s) R Subtype.val

full_name: rank_quotient_add_rank_of_isDomain
code: /-- The **rank-nullity theorem** for commutative domains. Also see `rank_quotient_add_rank`. -/
theorem rank_quotient_add_rank_of_isDomain [IsDomain R] (M' : Submodule R M) :
    Module.rank R (M ⧸ M') + Module.rank R M' = Module.rank R M 
goal: Module.rank R (M ⧸ M') + Module.rank R ↥M' = Module.rank R M

full_name: IsDomain.hasRankNullity
code: instance IsDomain.hasRankNullity [IsDomain R] : HasRankNullity.{w} R 
goal: HasRankNullity.{w, u} R

full_name: aleph0_le_rank_of_isEmpty_oreSet
code: /-- A domain that is not (left) Ore is of infinite rank.
See [cohn_1995] Proposition 1.3.6 -/
lemma aleph0_le_rank_of_isEmpty_oreSet (hS : IsEmpty (OreLocalization.OreSet R⁰)) :
    ℵ₀ ≤ Module.rank R R 
goal: ℵ₀ ≤ Module.rank R R

full_name: nonempty_oreSet_of_strongRankCondition
code: lemma nonempty_oreSet_of_strongRankCondition [StrongRankCondition R] :
    Nonempty (OreLocalization.OreSet R⁰) 
goal: Nonempty (OreLocalization.OreSet R⁰)
File: Mathlib/LinearAlgebra/TensorAlgebra/Basis.lean

full_name: TensorAlgebra.equivFreeAlgebra
code: /-- A basis provides an algebra isomorphism with the free algebra, replacing each basis vector
with its index. -/
noncomputable def equivFreeAlgebra (b : Basis κ R M) :
    TensorAlgebra R M ≃ₐ[R] FreeAlgebra R κ 
goal: TensorAlgebra R M ≃ₐ[R] FreeAlgebra R κ

full_name: TensorAlgebra.equivFreeAlgebra_ι_apply
code: @[simp]
lemma equivFreeAlgebra_ι_apply (b : Basis κ R M) (i : κ) :
    equivFreeAlgebra b (ι R (b i)) = FreeAlgebra.ι R i 
goal: (TensorAlgebra.equivFreeAlgebra b) ((TensorAlgebra.ι R) (b i)) = FreeAlgebra.ι R i

full_name: TensorAlgebra.equivFreeAlgebra_symm_ι
code: @[simp]
lemma equivFreeAlgebra_symm_ι (b : Basis κ R M) (i : κ) :
    (equivFreeAlgebra b).symm (FreeAlgebra.ι R i) = ι R (b i) 
goal: (TensorAlgebra.equivFreeAlgebra b).symm (FreeAlgebra.ι R i) = (TensorAlgebra.ι R) (b i)

full_name: Basis.tensorAlgebra
code: /-- A basis on `M` can be lifted to a basis on `TensorAlgebra R M` -/
@[simps! repr_apply]
noncomputable def _root_.Basis.tensorAlgebra (b : Basis κ R M) :
    Basis (FreeMonoid κ) R (TensorAlgebra R M) 
goal: Basis (FreeMonoid κ) R (TensorAlgebra R M)

full_name: Basis.tensorAlgebra_repr_apply
code: /-- A basis on `M` can be lifted to a basis on `TensorAlgebra R M` -/
@[simps! repr_apply]
noncomputable def _root_.Basis.tensorAlgebra (b : Basis κ R M) :
    Basis (FreeMonoid κ) R (TensorAlgebra R M) 
goal: ∀ (a : TensorAlgebra R M),
  b.tensorAlgebra.repr a = (FreeAlgebra.basisFreeMonoid R κ).repr ((TensorAlgebra.equivFreeAlgebra b) a)

full_name: TensorAlgebra.instModuleFree
code: /-- `TensorAlgebra R M` is free when `M` is. -/
instance instModuleFree [Module.Free R M] : Module.Free R (TensorAlgebra R M) 
goal: Module.Free R (TensorAlgebra R M)

full_name: TensorAlgebra.instNoZeroDivisors
code: /-- The `TensorAlgebra` of a free module over a commutative semiring with no zero-divisors has
no zero-divisors. -/
instance instNoZeroDivisors [NoZeroDivisors R] [Module.Free R M] :
    NoZeroDivisors (TensorAlgebra R M) 
goal: NoZeroDivisors (TensorAlgebra R M)

full_name: TensorAlgebra.instIsDomain
code: /-- The `TensorAlgebra` of a free module over an integral domain is a domain. -/
instance instIsDomain [IsDomain R] [Module.Free R M] : IsDomain (TensorAlgebra R M) 
goal: IsDomain (TensorAlgebra R M)

full_name: TensorAlgebra.rank_eq
code: lemma rank_eq [Nontrivial R] [Module.Free R M] :
    Module.rank R (TensorAlgebra R M) = Cardinal.lift.{uR} (sum fun n ↦ Module.rank R M ^ n) 
goal: Module.rank R (TensorAlgebra R M) = Cardinal.lift.{uR, uM} (Cardinal.sum fun n => Module.rank R M ^ n)
File: Mathlib/LinearAlgebra/TensorAlgebra/Grading.lean

full_name: TensorAlgebra.GradedAlgebra.ι
code: /-- A version of `TensorAlgebra.ι` that maps directly into the graded structure. This is
primarily an auxiliary construction used to provide `TensorAlgebra.gradedAlgebra`. -/
nonrec def GradedAlgebra.ι : M →ₗ[R] ⨁ i : ℕ, ↥(LinearMap.range (ι R : M →ₗ[_] _) ^ i) 
goal: M →ₗ[R] DirectSum ℕ fun i => ↥(LinearMap.range (TensorAlgebra.ι R) ^ i)

full_name: TensorAlgebra.GradedAlgebra.ι_apply
code: theorem GradedAlgebra.ι_apply (m : M) :
    GradedAlgebra.ι R M m =
      DirectSum.of (fun (i : ℕ) => ↥(LinearMap.range (TensorAlgebra.ι R : M →ₗ[_] _) ^ i)) 1
        ⟨TensorAlgebra.ι R m, by simpa only [pow_one] using LinearMap.mem_range_self _ m⟩ 
goal: (TensorAlgebra.GradedAlgebra.ι R M) m =
  (DirectSum.of (fun i => ↥(LinearMap.range (TensorAlgebra.ι R) ^ i)) 1) ⟨(TensorAlgebra.ι R) m, ⋯⟩

full_name: TensorAlgebra.gradedAlgebra
code: /-- The tensor algebra is graded by the powers of the submodule `(TensorAlgebra.ι R).range`. -/
instance gradedAlgebra :
    GradedAlgebra ((LinearMap.range (ι R : M →ₗ[R] TensorAlgebra R M) ^ ·) : ℕ → Submodule R _) 
goal: GradedAlgebra fun x => LinearMap.range (TensorAlgebra.ι R) ^ x
File: Mathlib/LinearAlgebra/Eigenspace/Matrix.lean

full_name: hasEigenvector_toLin_diagonal
code: /-- Basis vectors are eigenvectors of associated diagonal linear operator. -/
lemma hasEigenvector_toLin_diagonal (d : n → R) (i : n) (b : Basis n R M) :
    HasEigenvector (toLin b b (diagonal d)) (d i) (b i) 
goal: Module.End.HasEigenvector ((Matrix.toLin b b) (Matrix.diagonal d)) (d i) (b i)

full_name: hasEigenvector_toLin'_diagonal
code: /--  Standard basis vectors are eigenvectors of any associated diagonal linear operator. -/
lemma hasEigenvector_toLin'_diagonal (d : n → R) (i : n) :
    HasEigenvector (toLin' (diagonal d)) (d i) (Pi.basisFun R n i)  
goal: Module.End.HasEigenvector (Matrix.toLin' (Matrix.diagonal d)) (d i) ((Pi.basisFun R n) i)

full_name: hasEigenvalue_toLin_diagonal_iff
code: /-- Eigenvalues of a diagonal linear operator are the diagonal entries. -/
lemma hasEigenvalue_toLin_diagonal_iff (d : n → R) {μ : R} [NoZeroSMulDivisors R M]
    (b : Basis n R M) : HasEigenvalue (toLin b b (diagonal d)) μ ↔ ∃ i, d i = μ 
goal: Module.End.HasEigenvalue ((Matrix.toLin b b) (Matrix.diagonal d)) μ ↔ ∃ i, d i = μ

full_name: hasEigenvalue_toLin'_diagonal_iff
code: /-- Eigenvalues of a diagonal linear operator with respect to standard basis
    are the diagonal entries. -/
lemma hasEigenvalue_toLin'_diagonal_iff [NoZeroDivisors R] (d : n → R) {μ : R} :
    HasEigenvalue (toLin' (diagonal d)) μ ↔ (∃ i, d i = μ) 
goal: Module.End.HasEigenvalue (Matrix.toLin' (Matrix.diagonal d)) μ ↔ ∃ i, d i = μ

full_name: spectrum_diagonal
code: /-- The spectrum of the diagonal operator is the range of the diagonal viewed as a function. -/
lemma spectrum_diagonal [Field R] (d : n → R) :
    spectrum R (diagonal d) = Set.range d 
goal: spectrum R (Matrix.diagonal d) = Set.range d
File: Mathlib/LinearAlgebra/Eigenspace/Semisimple.lean

full_name: Module.End.apply_eq_of_mem_genEigenspace_of_comm_of_isSemisimple_of_isNilpotent_sub
code: lemma apply_eq_of_mem_genEigenspace_of_comm_of_isSemisimple_of_isNilpotent_sub
    {μ : R} {k : ℕ} {m : M} (hm : m ∈ f.genEigenspace μ k)
    (hfg : Commute f g) (hss : g.IsSemisimple) (hnil : IsNilpotent (f - g)) :
    g m = μ • m 
goal: g m = μ • m

full_name: Module.End.IsSemisimple.genEigenspace_eq_eigenspace
code: lemma IsSemisimple.genEigenspace_eq_eigenspace
    (hf : f.IsSemisimple) (μ : R) {k : ℕ} (hk : 0 < k) :
    f.genEigenspace μ k = f.eigenspace μ 
goal: (f.genEigenspace μ) k = f.eigenspace μ

full_name: Module.End.IsSemisimple.maxGenEigenspace_eq_eigenspace
code: lemma IsSemisimple.maxGenEigenspace_eq_eigenspace
    (hf : f.IsSemisimple) (μ : R) :
    f.maxGenEigenspace μ = f.eigenspace μ 
goal: f.maxGenEigenspace μ = f.eigenspace μ
File: Mathlib/LinearAlgebra/Basis/Bilinear.lean

full_name: LinearMap.ext_basis
code: /-- Two bilinear maps are equal when they are equal on all basis vectors. -/
theorem ext_basis {B B' : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} (h : ∀ i j, B (b₁ i) (b₂ j) = B' (b₁ i) (b₂ j)) :
    B = B' 
goal: B = B'

full_name: LinearMap.sum_repr_mul_repr_mulₛₗ
code: /-- Write out `B x y` as a sum over `B (b i) (b j)` if `b` is a basis.

Version for semi-bilinear maps, see `sum_repr_mul_repr_mul` for the bilinear version. -/
theorem sum_repr_mul_repr_mulₛₗ {B : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} (x y) :
    ((b₁.repr x).sum fun i xi => (b₂.repr y).sum fun j yj => ρ₁₂ xi • σ₁₂ yj • B (b₁ i) (b₂ j)) =
      B x y 
goal: ((b₁.repr x).sum fun i xi => (b₂.repr y).sum fun j yj => ρ₁₂ xi • σ₁₂ yj • (B (b₁ i)) (b₂ j)) = (B x) y

full_name: LinearMap.sum_repr_mul_repr_mul
code: /-- Write out `B x y` as a sum over `B (b i) (b j)` if `b` is a basis.

Version for bilinear maps, see `sum_repr_mul_repr_mulₛₗ` for the semi-bilinear version. -/
theorem sum_repr_mul_repr_mul {B : Mₗ →ₗ[Rₗ] Nₗ →ₗ[Rₗ] Pₗ} (x y) :
    ((b₁'.repr x).sum fun i xi => (b₂'.repr y).sum fun j yj => xi • yj • B (b₁' i) (b₂' j)) =
      B x y 
goal: ((b₁'.repr x).sum fun i xi => (b₂'.repr y).sum fun j yj => xi • yj • (B (b₁' i)) (b₂' j)) = (B x) y
File: Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean

full_name: Module.End.eigenspace_aeval_polynomial_degree_1
code: theorem eigenspace_aeval_polynomial_degree_1 (f : End K V) (q : K[X]) (hq : degree q = 1) :
    eigenspace f (-q.coeff 0 / q.leadingCoeff) = LinearMap.ker (aeval f q) 
goal: f.eigenspace (-q.coeff 0 / q.leadingCoeff) = LinearMap.ker ((Polynomial.aeval f) q)

full_name: Module.End.ker_aeval_ring_hom'_unit_polynomial
code: theorem ker_aeval_ring_hom'_unit_polynomial (f : End K V) (c : K[X]ˣ) :
    LinearMap.ker (aeval f (c : K[X])) = ⊥ 
goal: LinearMap.ker ((Polynomial.aeval f) ↑c) = ⊥

full_name: Module.End.aeval_apply_of_hasEigenvector
code: theorem aeval_apply_of_hasEigenvector {f : End K V} {p : K[X]} {μ : K} {x : V}
    (h : f.HasEigenvector μ x) : aeval f p x = p.eval μ • x 
goal: ((Polynomial.aeval f) p) x = Polynomial.eval μ p • x

full_name: Module.End.isRoot_of_hasEigenvalue
code: theorem isRoot_of_hasEigenvalue {f : End K V} {μ : K} (h : f.HasEigenvalue μ) :
    (minpoly K f).IsRoot μ 
goal: (minpoly K f).IsRoot μ

full_name: Module.End.hasEigenvalue_of_isRoot
code: theorem hasEigenvalue_of_isRoot (h : (minpoly K f).IsRoot μ) : f.HasEigenvalue μ 
goal: f.HasEigenvalue μ

full_name: Module.End.hasEigenvalue_iff_isRoot
code: theorem hasEigenvalue_iff_isRoot : f.HasEigenvalue μ ↔ (minpoly K f).IsRoot μ 
goal: f.HasEigenvalue μ ↔ (minpoly K f).IsRoot μ

full_name: Module.End.finite_hasEigenvalue
code: lemma finite_hasEigenvalue : Set.Finite f.HasEigenvalue 
goal: Set.Finite f.HasEigenvalue

full_name: Module.End.instFintypeEigenvalues
code: /-- An endomorphism of a finite-dimensional vector space has finitely many eigenvalues. -/
noncomputable instance : Fintype f.Eigenvalues 
goal: Fintype f.Eigenvalues

full_name: Module.End.finite_spectrum
code: /-- An endomorphism of a finite-dimensional vector space has a finite spectrum. -/
theorem Module.End.finite_spectrum {K : Type v} {V : Type w} [Field K] [AddCommGroup V]
    [Module K V] [FiniteDimensional K V] (f : Module.End K V) :
    Set.Finite (spectrum K f) 
goal: (spectrum K f).Finite

full_name: Matrix.finite_spectrum
code: /-- An n x n matrix over a field has a finite spectrum. -/
theorem Matrix.finite_spectrum (A : Matrix n n R) : Set.Finite (spectrum R A) 
goal: (spectrum R A).Finite

full_name: Matrix.instFiniteSpectrum
code: instance Matrix.instFiniteSpectrum (A : Matrix n n R) : Finite (spectrum R A) 
goal: Finite ↑(spectrum R A)
File: Mathlib/FieldTheory/Tower.lean

full_name: FiniteDimensional.left
code: /-- In a tower of field extensions `A / K / F`, if `A / F` is finite, so is `K / F`.

(In fact, it suffices that `A` is a nontrivial ring.)

Note this cannot be an instance as Lean cannot infer `A`.
-/
theorem left [Nontrivial A] [FiniteDimensional F A] : FiniteDimensional F K 
goal: FiniteDimensional F K

full_name: FiniteDimensional.right
code: theorem right [hf : FiniteDimensional F A] : FiniteDimensional K A 
goal: FiniteDimensional K A

full_name: FiniteDimensional.Subalgebra.isSimpleOrder_of_finrank_prime
code: theorem Subalgebra.isSimpleOrder_of_finrank_prime (F A) [Field F] [Ring A] [IsDomain A]
    [Algebra F A] (hp : (finrank F A).Prime) : IsSimpleOrder (Subalgebra F A) 
goal: IsSimpleOrder (Subalgebra F A)
File: Mathlib/FieldTheory/AxGrothendieck.lean

full_name: ax_grothendieck_of_locally_finite
code: /-- Any injective polynomial map over an algebraic extension of a finite field is surjective. -/
theorem ax_grothendieck_of_locally_finite {ι K R : Type*} [Field K] [Finite K] [CommRing R]
    [Finite ι] [Algebra K R] [Algebra.IsAlgebraic K R] (ps : ι → MvPolynomial ι R)
    (hinj : Injective fun v i => MvPolynomial.eval v (ps i)) :
    Surjective fun v i => MvPolynomial.eval v (ps i) 
goal: Function.Surjective fun v i => (MvPolynomial.eval v) (ps i)
File: Mathlib/FieldTheory/RatFunc/Degree.lean

full_name: RatFunc.intDegree
code: /-- `intDegree x` is the degree of the rational function `x`, defined as the difference between
the `natDegree` of its numerator and the `natDegree` of its denominator. In particular,
`intDegree 0 = 0`. -/
def intDegree (x : RatFunc K) : ℤ 
goal: ℤ

full_name: RatFunc.intDegree_zero
code: @[simp]
theorem intDegree_zero : intDegree (0 : RatFunc K) = 0 
goal: RatFunc.intDegree 0 = 0

full_name: RatFunc.intDegree_one
code: @[simp]
theorem intDegree_one : intDegree (1 : RatFunc K) = 0 
goal: RatFunc.intDegree 1 = 0

full_name: RatFunc.intDegree_C
code: @[simp]
theorem intDegree_C (k : K) : intDegree (C k) = 0 
goal: (RatFunc.C k).intDegree = 0

full_name: RatFunc.intDegree_X
code: @[simp]
theorem intDegree_X : intDegree (X : RatFunc K) = 1 
goal: RatFunc.X.intDegree = 1

full_name: RatFunc.intDegree_polynomial
code: @[simp]
theorem intDegree_polynomial {p : K[X]} :
    intDegree (algebraMap K[X] (RatFunc K) p) = natDegree p 
goal: ((algebraMap (Polynomial K) (RatFunc K)) p).intDegree = ↑p.natDegree

full_name: RatFunc.intDegree_mul
code: theorem intDegree_mul {x y : RatFunc K} (hx : x ≠ 0) (hy : y ≠ 0) :
    intDegree (x * y) = intDegree x + intDegree y 
goal: (x * y).intDegree = x.intDegree + y.intDegree

full_name: RatFunc.intDegree_neg
code: @[simp]
theorem intDegree_neg (x : RatFunc K) : intDegree (-x) = intDegree x 
goal: (-x).intDegree = x.intDegree

full_name: RatFunc.intDegree_add
code: theorem intDegree_add {x y : RatFunc K} (hxy : x + y ≠ 0) :
    (x + y).intDegree =
      (x.num * y.denom + x.denom * y.num).natDegree - (x.denom * y.denom).natDegree 
goal: (x + y).intDegree = ↑(x.num * y.denom + x.denom * y.num).natDegree - ↑(x.denom * y.denom).natDegree

full_name: RatFunc.natDegree_num_mul_right_sub_natDegree_denom_mul_left_eq_intDegree
code: theorem natDegree_num_mul_right_sub_natDegree_denom_mul_left_eq_intDegree {x : RatFunc K}
    (hx : x ≠ 0) {s : K[X]} (hs : s ≠ 0) :
    ((x.num * s).natDegree : ℤ) - (s * x.denom).natDegree = x.intDegree 
goal: ↑(x.num * s).natDegree - ↑(s * x.denom).natDegree = x.intDegree

full_name: RatFunc.intDegree_add_le
code: theorem intDegree_add_le {x y : RatFunc K} (hy : y ≠ 0) (hxy : x + y ≠ 0) :
    intDegree (x + y) ≤ max (intDegree x) (intDegree y) 
goal: (x + y).intDegree ≤ max x.intDegree y.intDegree
File: Mathlib/FieldTheory/IsAlgClosed/Classification.lean

full_name: Algebra.IsAlgebraic.cardinal_mk_le_sigma_polynomial
code: theorem cardinal_mk_le_sigma_polynomial :
    #L ≤ #(Σ p : R[X], { x : L // x ∈ p.aroots L }) 
goal: #L ≤ #((p : R[X]) × { x // x ∈ p.aroots L })

full_name: Algebra.IsAlgebraic.cardinal_mk_le_max
code: /-- The cardinality of an algebraic extension is at most the maximum of the cardinality
of the base ring or `ℵ₀` -/
theorem cardinal_mk_le_max : #L ≤ max #R ℵ₀ 
goal: #L ≤ max #R ℵ₀

full_name: IsAlgClosed.isAlgClosure_of_transcendence_basis
code: theorem isAlgClosure_of_transcendence_basis [IsAlgClosed K] (hv : IsTranscendenceBasis R v) :
    IsAlgClosure (Algebra.adjoin R (Set.range v)) K 
goal: IsAlgClosure (↥(Algebra.adjoin R (Set.range v))) K

full_name: IsAlgClosed.equivOfTranscendenceBasis
code: /-- setting `R` to be `ZMod (ringChar R)` this result shows that if two algebraically
closed fields have equipotent transcendence bases and the same characteristic then they are
isomorphic. -/
def equivOfTranscendenceBasis [IsAlgClosed K] [IsAlgClosed L] (e : ι ≃ κ)
    (hv : IsTranscendenceBasis R v) (hw : IsTranscendenceBasis R w) : K ≃+* L 
goal: K ≃+* L

full_name: IsAlgClosed.cardinal_le_max_transcendence_basis
code: theorem cardinal_le_max_transcendence_basis (hv : IsTranscendenceBasis R v) :
    #K ≤ max (max #R #ι) ℵ₀ 
goal: #K ≤ max (max #R #ι) ℵ₀

full_name: IsAlgClosed.cardinal_eq_cardinal_transcendence_basis_of_aleph0_lt
code: /-- If `K` is an uncountable algebraically closed field, then its
cardinality is the same as that of a transcendence basis. -/
theorem cardinal_eq_cardinal_transcendence_basis_of_aleph0_lt [Nontrivial R]
    (hv : IsTranscendenceBasis R v) (hR : #R ≤ ℵ₀) (hK : ℵ₀ < #K) : #K = #ι 
goal: #K = #ι

full_name: IsAlgClosed.ringEquivOfCardinalEqOfCharZero
code: /-- Two uncountable algebraically closed fields of characteristic zero are isomorphic
if they have the same cardinality. -/
theorem ringEquivOfCardinalEqOfCharZero [CharZero K] [CharZero L] (hK : ℵ₀ < #K)
    (hKL : #K = #L) : Nonempty (K ≃+* L) 
goal: Nonempty (K ≃+* L)

full_name: _private.Mathlib.FieldTheory.IsAlgClosed.Classification.0.IsAlgClosed.ringEquivOfCardinalEqOfCharP
code: private theorem ringEquivOfCardinalEqOfCharP (p : ℕ) [Fact p.Prime] [CharP K p] [CharP L p]
    (hK : ℵ₀ < #K) (hKL : #K = #L) : Nonempty (K ≃+* L) 
goal: Nonempty (K ≃+* L)

full_name: IsAlgClosed.ringEquivOfCardinalEqOfCharEq
code: /-- Two uncountable algebraically closed fields are isomorphic
if they have the same cardinality and the same characteristic. -/
theorem ringEquivOfCardinalEqOfCharEq (p : ℕ) [CharP K p] [CharP L p] (hK : ℵ₀ < #K)
    (hKL : #K = #L) : Nonempty (K ≃+* L) 
goal: Nonempty (K ≃+* L)