ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/LinearAlgebra/Eigenspace/Triangularizable.lean

full_name: Module.End.exists_hasEigenvalue_of_iSup_genEigenspace_eq_top
code: theorem exists_hasEigenvalue_of_iSup_genEigenspace_eq_top [Nontrivial M] {f : End R M}
    (hf : ⨆ μ, ⨆ k, f.genEigenspace μ k = ⊤) :
    ∃ μ, f.HasEigenvalue μ 
goal: ∃ μ, f.HasEigenvalue μ

full_name: Module.End.exists_eigenvalue
code: /-- In finite dimensions, over an algebraically closed field, every linear endomorphism has an
eigenvalue. -/
theorem exists_eigenvalue [IsAlgClosed K] [FiniteDimensional K V] [Nontrivial V] (f : End K V) :
    ∃ c : K, f.HasEigenvalue c 
goal: ∃ c, f.HasEigenvalue c

full_name: Module.End.instInhabitedEigenvaluesOfIsAlgClosedOfFiniteDimensionalOfNontrivial
code: noncomputable instance [IsAlgClosed K] [FiniteDimensional K V] [Nontrivial V] (f : End K V) :
    Inhabited f.Eigenvalues 
goal: Inhabited f.Eigenvalues

full_name: Module.End.iSup_genEigenspace_eq_top
code: /-- In finite dimensions, over an algebraically closed field, the generalized eigenspaces of any
linear endomorphism span the whole space. -/
theorem iSup_genEigenspace_eq_top [IsAlgClosed K] [FiniteDimensional K V] (f : End K V) :
    ⨆ (μ : K) (k : ℕ), f.genEigenspace μ k = ⊤ 
goal: ⨆ μ, ⨆ k, (f.genEigenspace μ) k = ⊤

full_name: Submodule.inf_iSup_genEigenspace
code: theorem inf_iSup_genEigenspace [FiniteDimensional K V] (h : ∀ x ∈ p, f x ∈ p) :
    p ⊓ ⨆ μ, ⨆ k, f.genEigenspace μ k = ⨆ μ, ⨆ k, p ⊓ f.genEigenspace μ k 
goal: p ⊓ ⨆ μ, ⨆ k, (f.genEigenspace μ) k = ⨆ μ, ⨆ k, p ⊓ (f.genEigenspace μ) k

full_name: Submodule.eq_iSup_inf_genEigenspace
code: theorem eq_iSup_inf_genEigenspace [FiniteDimensional K V]
    (h : ∀ x ∈ p, f x ∈ p) (h' : ⨆ μ, ⨆ k, f.genEigenspace μ k = ⊤) :
    p = ⨆ μ, ⨆ k, p ⊓ f.genEigenspace μ k 
goal: p = ⨆ μ, ⨆ k, p ⊓ (f.genEigenspace μ) k

full_name: Module.End.iSup_genEigenspace_restrict_eq_top
code: /-- In finite dimensions, if the generalized eigenspaces of a linear endomorphism span the whole
space then the same is true of its restriction to any invariant submodule. -/
theorem Module.End.iSup_genEigenspace_restrict_eq_top
    {p : Submodule K V} {f : Module.End K V} [FiniteDimensional K V]
    (h : ∀ x ∈ p, f x ∈ p) (h' : ⨆ μ, ⨆ k, f.genEigenspace μ k = ⊤) :
    ⨆ μ, ⨆ k, Module.End.genEigenspace (LinearMap.restrict f h) μ k = ⊤ 
goal: ⨆ μ, ⨆ k, (Module.End.genEigenspace (LinearMap.restrict f h) μ) k = ⊤
File: Mathlib/LinearAlgebra/Eigenspace/Zero.lean

full_name: IsNilpotent.charpoly_eq_X_pow_finrank
code: lemma IsNilpotent.charpoly_eq_X_pow_finrank (φ : Module.End R M) (h : IsNilpotent φ) :
    φ.charpoly = X ^ finrank R M 
goal: LinearMap.charpoly φ = Polynomial.X ^ FiniteDimensional.finrank R M

full_name: LinearMap.charpoly_nilpotent_tfae
code: lemma charpoly_nilpotent_tfae [IsNoetherian R M] (φ : Module.End R M) :
    List.TFAE [
      IsNilpotent φ,
      φ.charpoly = X ^ finrank R M,
      ∀ m : M, ∃ (n : ℕ), (φ ^ n) m = 0,
      natTrailingDegree φ.charpoly = finrank R M ] 
goal: [IsNilpotent φ, LinearMap.charpoly φ = Polynomial.X ^ FiniteDimensional.finrank R M, ∀ (m : M), ∃ n, (φ ^ n) m = 0,
    (LinearMap.charpoly φ).natTrailingDegree = FiniteDimensional.finrank R M].TFAE

full_name: LinearMap.charpoly_eq_X_pow_iff
code: lemma charpoly_eq_X_pow_iff [IsNoetherian R M] (φ : Module.End R M) :
    φ.charpoly = X ^ finrank R M ↔ ∀ m : M, ∃ (n : ℕ), (φ ^ n) m = 0 
goal: LinearMap.charpoly φ = Polynomial.X ^ FiniteDimensional.finrank R M ↔ ∀ (m : M), ∃ n, (φ ^ n) m = 0

full_name: LinearMap.hasEigenvalue_zero_tfae
code: lemma hasEigenvalue_zero_tfae (φ : Module.End K M) :
    List.TFAE [
      Module.End.HasEigenvalue φ 0,
      IsRoot (minpoly K φ) 0,
      constantCoeff φ.charpoly = 0,
      LinearMap.det φ = 0,
      ⊥ < ker φ,
      ∃ (m : M), m ≠ 0 ∧ φ m = 0 ] 
goal: [φ.HasEigenvalue 0, (minpoly K φ).IsRoot 0, Polynomial.constantCoeff (LinearMap.charpoly φ) = 0, LinearMap.det φ = 0,
    ⊥ < LinearMap.ker φ, ∃ m, m ≠ 0 ∧ φ m = 0].TFAE

full_name: LinearMap.charpoly_constantCoeff_eq_zero_iff
code: lemma charpoly_constantCoeff_eq_zero_iff (φ : Module.End K M) :
    constantCoeff φ.charpoly = 0 ↔ ∃ (m : M), m ≠ 0 ∧ φ m = 0 
goal: Polynomial.constantCoeff (LinearMap.charpoly φ) = 0 ↔ ∃ m, m ≠ 0 ∧ φ m = 0

full_name: LinearMap.not_hasEigenvalue_zero_tfae
code: lemma not_hasEigenvalue_zero_tfae (φ : Module.End K M) :
    List.TFAE [
      ¬ Module.End.HasEigenvalue φ 0,
      ¬ IsRoot (minpoly K φ) 0,
      constantCoeff φ.charpoly ≠ 0,
      LinearMap.det φ ≠ 0,
      ker φ = ⊥,
      ∀ (m : M), φ m = 0 → m = 0 ] 
goal: [¬φ.HasEigenvalue 0, ¬(minpoly K φ).IsRoot 0, Polynomial.constantCoeff (LinearMap.charpoly φ) ≠ 0, LinearMap.det φ ≠ 0,
    LinearMap.ker φ = ⊥, ∀ (m : M), φ m = 0 → m = 0].TFAE

full_name: LinearMap.finrank_maxGenEigenspace
code: lemma finrank_maxGenEigenspace (φ : Module.End K M) :
    finrank K (φ.maxGenEigenspace 0) = natTrailingDegree (φ.charpoly) 
goal: FiniteDimensional.finrank K ↥(φ.maxGenEigenspace 0) = (LinearMap.charpoly φ).natTrailingDegree
File: Mathlib/FieldTheory/Finiteness.lean

full_name: IsNoetherian.iff_rank_lt_aleph0
code: /-- A module over a division ring is noetherian if and only if
its dimension (as a cardinal) is strictly less than the first infinite cardinal `ℵ₀`.
-/
theorem iff_rank_lt_aleph0 : IsNoetherian K V ↔ Module.rank K V < ℵ₀ 
goal: IsNoetherian K V ↔ Module.rank K V < ℵ₀

full_name: IsNoetherian.fintypeBasisIndex
code: /-- In a noetherian module over a division ring, all bases are indexed by a finite type. -/
noncomputable def fintypeBasisIndex {ι : Type*} [IsNoetherian K V] (b : Basis ι K V) : Fintype ι 
goal: Fintype ι

full_name: IsNoetherian.instFintypeElemOfVectorSpaceIndex
code: /-- In a noetherian module over a division ring,
`Basis.ofVectorSpace` is indexed by a finite type. -/
noncomputable instance [IsNoetherian K V] : Fintype (Basis.ofVectorSpaceIndex K V) 
goal: Fintype ↑(Basis.ofVectorSpaceIndex K V)

full_name: IsNoetherian.finite_basis_index
code: /-- In a noetherian module over a division ring,
if a basis is indexed by a set, that set is finite. -/
theorem finite_basis_index {ι : Type*} {s : Set ι} [IsNoetherian K V] (b : Basis s K V) :
    s.Finite 
goal: s.Finite

full_name: IsNoetherian.finsetBasisIndex
code: /-- In a noetherian module over a division ring,
there exists a finite basis. This is the indexing `Finset`. -/
noncomputable def finsetBasisIndex [IsNoetherian K V] : Finset V 
goal: Finset V

full_name: IsNoetherian.coe_finsetBasisIndex
code: @[simp]
theorem coe_finsetBasisIndex [IsNoetherian K V] :
    (↑(finsetBasisIndex K V) : Set V) = Basis.ofVectorSpaceIndex K V 
goal: ↑(IsNoetherian.finsetBasisIndex K V) = Basis.ofVectorSpaceIndex K V

full_name: IsNoetherian.coeSort_finsetBasisIndex
code: @[simp]
theorem coeSort_finsetBasisIndex [IsNoetherian K V] :
    (finsetBasisIndex K V : Type _) = Basis.ofVectorSpaceIndex K V 
goal: { x // x ∈ IsNoetherian.finsetBasisIndex K V } = ↑(Basis.ofVectorSpaceIndex K V)

full_name: IsNoetherian.finsetBasis
code: /-- In a noetherian module over a division ring, there exists a finite basis.
This is indexed by the `Finset` `IsNoetherian.finsetBasisIndex`.
This is in contrast to the result `finite_basis_index (Basis.ofVectorSpace K V)`,
which provides a set and a `Set.finite`.
-/
noncomputable def finsetBasis [IsNoetherian K V] : Basis (finsetBasisIndex K V) K V 
goal: Basis { x // x ∈ IsNoetherian.finsetBasisIndex K V } K V

full_name: IsNoetherian.range_finsetBasis
code: @[simp]
theorem range_finsetBasis [IsNoetherian K V] :
    Set.range (finsetBasis K V) = Basis.ofVectorSpaceIndex K V 
goal: Set.range ⇑(IsNoetherian.finsetBasis K V) = Basis.ofVectorSpaceIndex K V

full_name: IsNoetherian.iff_fg
code: /-- A module over a division ring is noetherian if and only if it is finitely generated. -/
theorem iff_fg : IsNoetherian K V ↔ Module.Finite K V 
goal: IsNoetherian K V ↔ Module.Finite K V
File: Mathlib/FieldTheory/MvPolynomial.lean

full_name: MvPolynomial.quotient_mk_comp_C_injective
code: theorem quotient_mk_comp_C_injective (I : Ideal (MvPolynomial σ K)) (hI : I ≠ ⊤) :
    Function.Injective ((Ideal.Quotient.mk I).comp MvPolynomial.C) 
goal: Function.Injective ⇑((Ideal.Quotient.mk I).comp MvPolynomial.C)

full_name: MvPolynomial.rank_mvPolynomial
code: theorem rank_mvPolynomial : Module.rank K (MvPolynomial σ K) = Cardinal.mk (σ →₀ ℕ) 
goal: Module.rank K (MvPolynomial σ K) = Cardinal.mk (σ →₀ ℕ)
File: Mathlib/FieldTheory/Finite/Trace.lean

full_name: FiniteField.trace_to_zmod_nondegenerate
code: /-- The trace map from a finite field to its prime field is nongedenerate. -/
theorem trace_to_zmod_nondegenerate (F : Type*) [Field F] [Finite F]
    [Algebra (ZMod (ringChar F)) F] {a : F} (ha : a ≠ 0) :
    ∃ b : F, Algebra.trace (ZMod (ringChar F)) F (a * b) ≠ 0 
goal: ∃ b, (Algebra.trace (ZMod (ringChar F)) F) (a * b) ≠ 0
File: Mathlib/FieldTheory/AbsoluteGaloisGroup.lean

full_name: Field.absoluteGaloisGroup
code: /-- The absolute Galois group of `K`, defined as the Galois group of the field extension `K^al/K`,
  where `K^al` is an algebraic closure of `K`. -/
def absoluteGaloisGroup 
goal: Type u_1

full_name: Field._aux_Mathlib_FieldTheory_AbsoluteGaloisGroup___unexpand_Field_absoluteGaloisGroup_1
code: local notation "G_K" => absoluteGaloisGroup
goal: Lean.PrettyPrinter.Unexpander

full_name: Field._aux_Mathlib_FieldTheory_AbsoluteGaloisGroup___macroRules_Field_termG_K_1
code: local notation "G_K" => absoluteGaloisGroup
goal: Lean.Macro

full_name: Field.instGroupAbsoluteGaloisGroup
code: noncomputable instance : Group (G_K K) 
goal: Group (Field.absoluteGaloisGroup K)

full_name: Field.instTopologicalSpaceAbsoluteGaloisGroup
code: /-- `absoluteGaloisGroup` is a topological space with the Krull topology. -/
noncomputable instance : TopologicalSpace (G_K K) 
goal: TopologicalSpace (Field.absoluteGaloisGroup K)

full_name: Field.absoluteGaloisGroup.commutator_closure_isNormal
code: instance absoluteGaloisGroup.commutator_closure_isNormal :
    (commutator (G_K K)).topologicalClosure.Normal 
goal: (commutator (Field.absoluteGaloisGroup K)).topologicalClosure.Normal

full_name: Field.absoluteGaloisGroupAbelianization
code: /-- The topological abelianization of `absoluteGaloisGroup`, that is, the quotient of
  `absoluteGaloisGroup` by the topological closure of its commutator subgroup. -/
abbrev absoluteGaloisGroupAbelianization 
goal: Type u_1

full_name: Field._aux_Mathlib_FieldTheory_AbsoluteGaloisGroup___macroRules_Field_termG_K_ab_1
code: local notation "G_K_ab" => absoluteGaloisGroupAbelianization
goal: Lean.Macro

full_name: Field._aux_Mathlib_FieldTheory_AbsoluteGaloisGroup___unexpand_Field_absoluteGaloisGroupAbelianization_1
code: local notation "G_K_ab" => absoluteGaloisGroupAbelianization
goal: Lean.PrettyPrinter.Unexpander
File: Mathlib/Dynamics/BirkhoffSum/Basic.lean

full_name: birkhoffSum
code: /-- The sum of values of `g` on the first `n` points of the orbit of `x` under `f`. -/
def birkhoffSum (f : α → α) (g : α → M) (n : ℕ) (x : α) : M 
goal: M

full_name: birkhoffSum_zero
code: theorem birkhoffSum_zero (f : α → α) (g : α → M) (x : α) : birkhoffSum f g 0 x = 0 
goal: birkhoffSum f g 0 x = 0

full_name: birkhoffSum_zero'
code: @[simp]
theorem birkhoffSum_zero' (f : α → α) (g : α → M) : birkhoffSum f g 0 = 0 
goal: birkhoffSum f g 0 = 0

full_name: birkhoffSum_one
code: theorem birkhoffSum_one (f : α → α) (g : α → M) (x : α) : birkhoffSum f g 1 x = g x 
goal: birkhoffSum f g 1 x = g x

full_name: birkhoffSum_one'
code: @[simp]
theorem birkhoffSum_one' (f : α → α) (g : α → M) : birkhoffSum f g 1 = g 
goal: birkhoffSum f g 1 = g

full_name: birkhoffSum_succ
code: theorem birkhoffSum_succ (f : α → α) (g : α → M) (n : ℕ) (x : α) :
    birkhoffSum f g (n + 1) x = birkhoffSum f g n x + g (f^[n] x) 
goal: birkhoffSum f g (n + 1) x = birkhoffSum f g n x + g (f^[n] x)

full_name: birkhoffSum_succ'
code: theorem birkhoffSum_succ' (f : α → α) (g : α → M) (n : ℕ) (x : α) :
    birkhoffSum f g (n + 1) x = g x + birkhoffSum f g n (f x) 
goal: birkhoffSum f g (n + 1) x = g x + birkhoffSum f g n (f x)

full_name: birkhoffSum_add
code: theorem birkhoffSum_add (f : α → α) (g : α → M) (m n : ℕ) (x : α) :
    birkhoffSum f g (m + n) x = birkhoffSum f g m x + birkhoffSum f g n (f^[m] x) 
goal: birkhoffSum f g (m + n) x = birkhoffSum f g m x + birkhoffSum f g n (f^[m] x)

full_name: Function.IsFixedPt.birkhoffSum_eq
code: theorem Function.IsFixedPt.birkhoffSum_eq {f : α → α} {x : α} (h : IsFixedPt f x) (g : α → M)
    (n : ℕ) : birkhoffSum f g n x = n • g x 
goal: birkhoffSum f g n x = n • g x

full_name: map_birkhoffSum
code: theorem map_birkhoffSum {F N : Type*} [AddCommMonoid N] [FunLike F M N] [AddMonoidHomClass F M N]
    (g' : F) (f : α → α) (g : α → M) (n : ℕ) (x : α) :
    g' (birkhoffSum f g n x) = birkhoffSum f (g' ∘ g) n x 
goal: g' (birkhoffSum f g n x) = birkhoffSum f (⇑g' ∘ g) n x

full_name: birkhoffSum_apply_sub_birkhoffSum
code: /-- Birkhoff sum is "almost invariant" under `f`:
the difference between `birkhoffSum f g n (f x)` and `birkhoffSum f g n x`
is equal to `g (f^[n] x) - g x`. -/
theorem birkhoffSum_apply_sub_birkhoffSum (f : α → α) (g : α → G) (n : ℕ) (x : α) :
    birkhoffSum f g n (f x) - birkhoffSum f g n x = g (f^[n] x) - g x 
goal: birkhoffSum f g n (f x) - birkhoffSum f g n x = g (f^[n] x) - g x
File: Mathlib/Dynamics/BirkhoffSum/Average.lean

full_name: birkhoffAverage
code: /-- The average value of `g` on the first `n` points of the orbit of `x` under `f`,
i.e. the Birkhoff sum `∑ k ∈ Finset.range n, g (f^[k] x)` divided by `n`.

This average appears in many ergodic theorems
which say that `(birkhoffAverage R f g · x)`
converges to the "space average" `⨍ x, g x ∂μ` as `n → ∞`.

We use an auxiliary `[DivisionSemiring R]` to define division by `n`.
However, the definition does not depend on the choice of `R`,
see `birkhoffAverage_congr_ring`. -/
def birkhoffAverage (f : α → α) (g : α → M) (n : ℕ) (x : α) : M 
goal: M

full_name: birkhoffAverage_zero
code: theorem birkhoffAverage_zero (f : α → α) (g : α → M) (x : α) :
    birkhoffAverage R f g 0 x = 0 
goal: birkhoffAverage R f g 0 x = 0

full_name: birkhoffAverage_zero'
code: @[simp] theorem birkhoffAverage_zero' (f : α → α) (g : α → M) : birkhoffAverage R f g 0 = 0 
goal: birkhoffAverage R f g 0 = 0

full_name: birkhoffAverage_one
code: theorem birkhoffAverage_one (f : α → α) (g : α → M) (x : α) :
    birkhoffAverage R f g 1 x = g x 
goal: birkhoffAverage R f g 1 x = g x

full_name: birkhoffAverage_one'
code: @[simp]
theorem birkhoffAverage_one' (f : α → α) (g : α → M) : birkhoffAverage R f g 1 = g 
goal: birkhoffAverage R f g 1 = g

full_name: map_birkhoffAverage
code: theorem map_birkhoffAverage (S : Type*) {F N : Type*}
    [DivisionSemiring S] [AddCommMonoid N] [Module S N] [FunLike F M N]
    [AddMonoidHomClass F M N] (g' : F) (f : α → α) (g : α → M) (n : ℕ) (x : α) :
    g' (birkhoffAverage R f g n x) = birkhoffAverage S f (g' ∘ g) n x 
goal: g' (birkhoffAverage R f g n x) = birkhoffAverage S f (⇑g' ∘ g) n x

full_name: birkhoffAverage_congr_ring
code: theorem birkhoffAverage_congr_ring (S : Type*) [DivisionSemiring S] [Module S M]
    (f : α → α) (g : α → M) (n : ℕ) (x : α) :
    birkhoffAverage R f g n x = birkhoffAverage S f g n x 
goal: birkhoffAverage R f g n x = birkhoffAverage S f g n x

full_name: birkhoffAverage_congr_ring'
code: theorem birkhoffAverage_congr_ring' (S : Type*) [DivisionSemiring S] [Module S M] :
    birkhoffAverage (α := α) (M := M) R = birkhoffAverage S 
goal: birkhoffAverage R = birkhoffAverage S

full_name: Function.IsFixedPt.birkhoffAverage_eq
code: theorem Function.IsFixedPt.birkhoffAverage_eq [CharZero R] {f : α → α} {x : α} (h : IsFixedPt f x)
    (g : α → M) {n : ℕ} (hn : n ≠ 0) : birkhoffAverage R f g n x = g x 
goal: birkhoffAverage R f g n x = g x

full_name: birkhoffAverage_apply_sub_birkhoffAverage
code: /-- Birkhoff average is "almost invariant" under `f`:
the difference between `birkhoffAverage R f g n (f x)` and `birkhoffAverage R f g n x`
is equal to `(n : R)⁻¹ • (g (f^[n] x) - g x)`. -/
theorem birkhoffAverage_apply_sub_birkhoffAverage {α M : Type*} (R : Type*) [DivisionRing R]
    [AddCommGroup M] [Module R M] (f : α → α) (g : α → M) (n : ℕ) (x : α) :
    birkhoffAverage R f g n (f x) - birkhoffAverage R f g n x =
      (n : R)⁻¹ • (g (f^[n] x) - g x) 
goal: birkhoffAverage R f g n (f x) - birkhoffAverage R f g n x = (↑n)⁻¹ • (g (f^[n] x) - g x)
File: Mathlib/FieldTheory/Cardinality.lean

full_name: «_aux_Mathlib_FieldTheory_Cardinality___macroRules_term‖_‖_1»
code: local notation "‖" x "‖" => Fintype.card x
goal: Lean.Macro

full_name: _aux_Mathlib_FieldTheory_Cardinality___unexpand_Fintype_card_1
code: local notation "‖" x "‖" => Fintype.card x
goal: Lean.PrettyPrinter.Unexpander

full_name: Fintype.isPrimePow_card_of_field
code: /-- A finite field has prime power cardinality. -/
theorem Fintype.isPrimePow_card_of_field {α} [Fintype α] [Field α] : IsPrimePow ‖α‖ 
goal: IsPrimePow ‖α‖

full_name: Fintype.nonempty_field_iff
code: /-- A `Fintype` can be given a field structure iff its cardinality is a prime power. -/
theorem Fintype.nonempty_field_iff {α} [Fintype α] : Nonempty (Field α) ↔ IsPrimePow ‖α‖ 
goal: Nonempty (Field α) ↔ IsPrimePow ‖α‖

full_name: Fintype.not_isField_of_card_not_prime_pow
code: theorem Fintype.not_isField_of_card_not_prime_pow {α} [Fintype α] [Ring α] :
    ¬IsPrimePow ‖α‖ → ¬IsField α 
goal: ¬IsPrimePow ‖α‖ → ¬IsField α

full_name: Infinite.nonempty_field
code: /-- Any infinite type can be endowed a field structure. -/
theorem Infinite.nonempty_field {α : Type u} [Infinite α] : Nonempty (Field α) 
goal: Nonempty (Field α)

full_name: Field.nonempty_iff
code: /-- There is a field structure on type if and only if its cardinality is a prime power. -/
theorem Field.nonempty_iff {α : Type u} : Nonempty (Field α) ↔ IsPrimePow #α 
goal: Nonempty (Field α) ↔ IsPrimePow #α
File: Mathlib/Dynamics/FixedPoints/Topology.lean

full_name: isFixedPt_of_tendsto_iterate
code: /-- If the iterates `f^[n] x` converge to `y` and `f` is continuous at `y`,
then `y` is a fixed point for `f`. -/
theorem isFixedPt_of_tendsto_iterate {x y : α} (hy : Tendsto (fun n => f^[n] x) atTop (𝓝 y))
    (hf : ContinuousAt f y) : IsFixedPt f y 
goal: Function.IsFixedPt f y

full_name: isClosed_fixedPoints
code: /-- The set of fixed points of a continuous map is a closed set. -/
theorem isClosed_fixedPoints (hf : Continuous f) : IsClosed (fixedPoints f) 
goal: IsClosed (Function.fixedPoints f)
File: Mathlib/CategoryTheory/Subobject/WellPowered.lean

full_name: CategoryTheory.WellPowered
code: /--
A category (with morphisms in `Type v`) is well-powered if `Subobject X` is `v`-small for every `X`.

We show in `wellPowered_of_essentiallySmall_monoOver` and `essentiallySmall_monoOver`
that this is the case if and only if `MonoOver X` is `v`-essentially small for every `X`.
-/
class WellPowered : Prop where
  subobject_small : ∀ X : C, Small.{v} (Subobject X) := by infer_instance
goal: Prop

full_name: CategoryTheory.WellPowered.subobject_small
code: /--
A category (with morphisms in `Type v`) is well-powered if `Subobject X` is `v`-small for every `X`.

We show in `wellPowered_of_essentiallySmall_monoOver` and `essentiallySmall_monoOver`
that this is the case if and only if `MonoOver X` is `v`-essentially small for every `X`.
-/
class WellPowered : Prop where
  subobject_small : ∀ X : C, Small.{v} (Subobject X) := by infer_instance
goal: Small.{v, max u₁ v} (CategoryTheory.Subobject X)

full_name: CategoryTheory.small_subobject
code: instance small_subobject [WellPowered C] (X : C) : Small.{v} (Subobject X) 
goal: Small.{v, max u₁ v} (CategoryTheory.Subobject X)

full_name: CategoryTheory.wellPowered_of_smallCategory
code: instance (priority := 100) wellPowered_of_smallCategory (C : Type u₁) [SmallCategory C] :
    WellPowered C 
goal: CategoryTheory.WellPowered C

full_name: CategoryTheory.essentiallySmall_monoOver_iff_small_subobject
code: theorem essentiallySmall_monoOver_iff_small_subobject (X : C) :
    EssentiallySmall.{v} (MonoOver X) ↔ Small.{v} (Subobject X) 
goal: CategoryTheory.EssentiallySmall.{v, v, max u₁ v} (CategoryTheory.MonoOver X) ↔
  Small.{v, max u₁ v} (CategoryTheory.Subobject X)

full_name: CategoryTheory.wellPowered_of_essentiallySmall_monoOver
code: theorem wellPowered_of_essentiallySmall_monoOver (h : ∀ X : C, EssentiallySmall.{v} (MonoOver X)) :
    WellPowered C 
goal: CategoryTheory.WellPowered C

full_name: CategoryTheory.essentiallySmall_monoOver
code: instance essentiallySmall_monoOver (X : C) : EssentiallySmall.{v} (MonoOver X) 
goal: CategoryTheory.EssentiallySmall.{v, v, max u₁ v} (CategoryTheory.MonoOver X)

full_name: CategoryTheory.wellPowered_of_equiv
code: theorem wellPowered_of_equiv (e : C ≌ D) [WellPowered C] : WellPowered D 
goal: CategoryTheory.WellPowered D

full_name: CategoryTheory.wellPowered_congr
code: /-- Being well-powered is preserved by equivalences, as long as the two categories involved have
    their morphisms in the same universe. -/
theorem wellPowered_congr (e : C ≌ D) : WellPowered C ↔ WellPowered D 
goal: CategoryTheory.WellPowered C ↔ CategoryTheory.WellPowered D
File: Mathlib/Dynamics/Newton.lean

full_name: Polynomial.newtonMap
code: /-- Given a single-variable polynomial `P` with derivative `P'`, this is the map:
`x ↦ x - P(x) / P'(x)`. When `P'(x)` is not a unit we use a junk-value pattern and send `x ↦ x`. -/
def newtonMap (x : S) : S 
goal: S

full_name: Polynomial.newtonMap_apply
code: theorem newtonMap_apply :
    P.newtonMap x = x - (Ring.inverse <| aeval x (derivative P)) * (aeval x P) 
goal: P.newtonMap x = x - Ring.inverse ((Polynomial.aeval x) (Polynomial.derivative P)) * (Polynomial.aeval x) P

full_name: Polynomial.newtonMap_apply_of_isUnit
code: theorem newtonMap_apply_of_isUnit (h : IsUnit <| aeval x (derivative P)) :
    P.newtonMap x = x - h.unit⁻¹ * aeval x P 
goal: P.newtonMap x = x - ↑h.unit⁻¹ * (Polynomial.aeval x) P

full_name: Polynomial.newtonMap_apply_of_not_isUnit
code: theorem newtonMap_apply_of_not_isUnit (h : ¬ (IsUnit <| aeval x (derivative P))) :
    P.newtonMap x = x 
goal: P.newtonMap x = x

full_name: Polynomial.isNilpotent_iterate_newtonMap_sub_of_isNilpotent
code: theorem isNilpotent_iterate_newtonMap_sub_of_isNilpotent (h : IsNilpotent <| aeval x P) (n : ℕ) :
    IsNilpotent <| P.newtonMap^[n] x - x 
goal: IsNilpotent (P.newtonMap^[n] x - x)

full_name: Polynomial.isFixedPt_newtonMap_of_aeval_eq_zero
code: theorem isFixedPt_newtonMap_of_aeval_eq_zero (h : aeval x P = 0) :
    IsFixedPt P.newtonMap x 
goal: Function.IsFixedPt P.newtonMap x

full_name: Polynomial.isFixedPt_newtonMap_of_isUnit_iff
code: theorem isFixedPt_newtonMap_of_isUnit_iff (h : IsUnit <| aeval x (derivative P)) :
    IsFixedPt P.newtonMap x ↔ aeval x P = 0 
goal: Function.IsFixedPt P.newtonMap x ↔ (Polynomial.aeval x) P = 0

full_name: Polynomial.aeval_pow_two_pow_dvd_aeval_iterate_newtonMap
code: /-- This is really an auxiliary result, en route to
`Polynomial.exists_unique_nilpotent_sub_and_aeval_eq_zero`. -/
theorem aeval_pow_two_pow_dvd_aeval_iterate_newtonMap
    (h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) (n : ℕ) :
    (aeval x P) ^ (2 ^ n) ∣ aeval (P.newtonMap^[n] x) P 
goal: (Polynomial.aeval x) P ^ 2 ^ n ∣ (Polynomial.aeval (P.newtonMap^[n] x)) P

full_name: Polynomial.exists_unique_nilpotent_sub_and_aeval_eq_zero
code: /-- If `x` is almost a root of `P` in the sense that `P(x)` is nilpotent (and `P'(x)` is a
unit) then we may write `x` as a sum `x = n + r` where `n` is nilpotent and `r` is a root of `P`.
Moreover, `n` and `r` are unique.

This can be used to prove the Jordan-Chevalley decomposition of linear endomorphims. -/
theorem exists_unique_nilpotent_sub_and_aeval_eq_zero
    (h : IsNilpotent (aeval x P)) (h' : IsUnit (aeval x <| derivative P)) :
    ∃! r, IsNilpotent (x - r) ∧ aeval r P = 0 
goal: ∃! r, IsNilpotent (x - r) ∧ (Polynomial.aeval r) P = 0