ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/NumberTheory/LSeries/MellinEqDirichlet.lean

full_name: hasSum_mellin
code: /-- Most basic version of the "Mellin transform = Dirichlet series" argument. -/
lemma hasSum_mellin {a : ι → ℂ} {p : ι → ℝ} {F : ℝ → ℂ} {s : ℂ}
    (hp : ∀ i, a i = 0 ∨ 0 < p i) (hs : 0 < s.re)
    (hF : ∀ t ∈ Ioi 0, HasSum (fun i ↦ a i * rexp (-p i * t)) (F t))
    (h_sum : Summable fun i ↦ ‖a i‖ / (p i) ^ s.re) :
    HasSum (fun i ↦ Gamma s * a i / p i ^ s) (mellin F s) 
goal: HasSum (fun i => Complex.Gamma s * a i / ↑(p i) ^ s) (mellin F s)

full_name: hasSum_mellin_pi_mul
code: /-- Shortcut version for the commonly arising special case when `p i = π * q i` for some other
sequence `q`. -/
lemma hasSum_mellin_pi_mul {a : ι → ℂ} {q : ι → ℝ} {F : ℝ → ℂ} {s : ℂ}
    (hq : ∀ i, a i = 0 ∨ 0 < q i) (hs : 0 < s.re)
    (hF : ∀ t ∈ Ioi 0, HasSum (fun i ↦ a i * rexp (-π * q i * t)) (F t))
    (h_sum : Summable fun i ↦ ‖a i‖ / (q i) ^ s.re) :
    HasSum (fun i ↦ π ^ (-s) * Gamma s * a i / q i ^ s) (mellin F s) 
goal: HasSum (fun i => ↑π ^ (-s) * Complex.Gamma s * a i / ↑(q i) ^ s) (mellin F s)

full_name: hasSum_mellin_pi_mul₀
code: /-- Version allowing some constant terms (which are omitted from the sums). -/
lemma hasSum_mellin_pi_mul₀ {a : ι → ℂ} {p : ι → ℝ} {F : ℝ → ℂ} {s : ℂ}
    (hp : ∀ i, 0 ≤ p i) (hs : 0 < s.re)
    (hF : ∀ t ∈ Ioi 0, HasSum (fun i ↦ if p i = 0 then 0 else a i * rexp (-π * p i * t)) (F t))
    (h_sum : Summable fun i ↦ ‖a i‖ / (p i) ^ s.re) :
    HasSum (fun i ↦ π ^ (-s) * Gamma s * a i / p i ^ s) (mellin F s) 
goal: HasSum (fun i => ↑π ^ (-s) * Complex.Gamma s * a i / ↑(p i) ^ s) (mellin F s)

full_name: hasSum_mellin_pi_mul_sq
code: /-- Tailored version for even Jacobi theta functions. -/
lemma hasSum_mellin_pi_mul_sq {a : ι → ℂ} {r : ι → ℝ} {F : ℝ → ℂ} {s : ℂ} (hs : 0 < s.re)
    (hF : ∀ t ∈ Ioi 0, HasSum (fun i ↦ if r i = 0 then 0 else a i * rexp (-π * r i ^ 2 * t)) (F t))
    (h_sum : Summable fun i ↦ ‖a i‖ / |r i| ^ s.re) :
    HasSum (fun i ↦ Gammaℝ s * a i / |r i| ^ s) (mellin F (s / 2)) 
goal: HasSum (fun i => s.Gammaℝ * a i / ↑|r i| ^ s) (mellin F (s / 2))

full_name: hasSum_mellin_pi_mul_sq'
code: /-- Tailored version for odd Jacobi theta functions. -/
lemma hasSum_mellin_pi_mul_sq' {a : ι → ℂ} {r : ι → ℝ} {F : ℝ → ℂ} {s : ℂ} (hs : 0 < s.re)
    (hF : ∀ t ∈ Ioi 0, HasSum (fun i ↦ a i * r i * rexp (-π * r i ^ 2 * t)) (F t))
    (h_sum : Summable fun i ↦ ‖a i‖ / |r i| ^ s.re) :
    HasSum (fun i ↦ Gammaℝ (s + 1) * a i * SignType.sign (r i) / |r i| ^ s)
    (mellin F ((s + 1) / 2)) 
goal: HasSum (fun i => (s + 1).Gammaℝ * a i * ↑(SignType.sign (r i)) / ↑|r i| ^ s) (mellin F ((s + 1) / 2))
File: Mathlib/NumberTheory/Harmonic/Int.lean

full_name: padicValRat_two_harmonic
code: /-- The 2-adic valuation of the n-th harmonic number is the negative of the logarithm
    of n. -/
theorem padicValRat_two_harmonic (n : ℕ) : padicValRat 2 (harmonic n) = -Nat.log 2 n 
goal: padicValRat 2 (harmonic n) = -↑(Nat.log 2 n)

full_name: padicNorm_two_harmonic
code: /-- The 2-adic norm of the n-th harmonic number is 2 raised to the logarithm of n in base 2. -/
lemma padicNorm_two_harmonic {n : ℕ} (hn : n ≠ 0) :
    ‖(harmonic n : ℚ_[2])‖ = 2 ^ (Nat.log 2 n) 
goal: ‖↑(harmonic n)‖ = 2 ^ Nat.log 2 n

full_name: harmonic_not_int
code: /-- The n-th harmonic number is not an integer for n ≥ 2. -/
theorem harmonic_not_int {n : ℕ} (h : 2 ≤ n) : ¬ (harmonic n).isInt 
goal: ¬(harmonic n).isInt = true
File: Mathlib/NumberTheory/Harmonic/Defs.lean

full_name: harmonic
code: /-- The nth-harmonic number defined as a finset sum of consecutive reciprocals. -/
def harmonic : ℕ → ℚ 
goal: ℕ → ℚ

full_name: harmonic_zero
code: @[simp]
lemma harmonic_zero : harmonic 0 = 0 
goal: harmonic 0 = 0

full_name: harmonic_succ
code: @[simp]
lemma harmonic_succ (n : ℕ) : harmonic (n + 1) = harmonic n + (↑(n + 1))⁻¹ 
goal: harmonic (n + 1) = harmonic n + (↑(n + 1))⁻¹

full_name: harmonic_pos
code: lemma harmonic_pos {n : ℕ} (Hn : n ≠ 0) : 0 < harmonic n 
goal: 0 < harmonic n

full_name: harmonic_eq_sum_Icc
code: lemma harmonic_eq_sum_Icc {n : ℕ} :  harmonic n = ∑ i ∈ Finset.Icc 1 n, (↑i)⁻¹ 
goal: harmonic n = ∑ i ∈ Finset.Icc 1 n, (↑i)⁻¹
File: Mathlib/NumberTheory/Harmonic/Bounds.lean

full_name: log_add_one_le_harmonic
code: theorem log_add_one_le_harmonic (n : ℕ) :
    Real.log ↑(n+1) ≤ harmonic n 
goal: Real.log ↑(n + 1) ≤ ↑(harmonic n)

full_name: harmonic_le_one_add_log
code: theorem harmonic_le_one_add_log (n : ℕ) :
    harmonic n ≤ 1 + Real.log n 
goal: ↑(harmonic n) ≤ 1 + Real.log ↑n

full_name: log_le_harmonic_floor
code: theorem log_le_harmonic_floor (y : ℝ) (hy : 0 ≤ y) :
    Real.log y ≤ harmonic ⌊y⌋₊ 
goal: Real.log y ≤ ↑(harmonic ⌊y⌋₊)

full_name: harmonic_floor_le_one_add_log
code: theorem harmonic_floor_le_one_add_log (y : ℝ) (hy : 1 ≤ y) :
    harmonic ⌊y⌋₊ ≤ 1 + Real.log y 
goal: ↑(harmonic ⌊y⌋₊) ≤ 1 + Real.log y
File: Mathlib/NumberTheory/LucasPrimality.lean

full_name: lucas_primality
code: /-- If `a^(p-1) = 1 mod p`, but `a^((p-1)/q) ≠ 1 mod p` for all prime factors `q` of `p-1`, then `p`
is prime. This is true because `a` has order `p-1` in the multiplicative group mod `p`, so this
group must itself have order `p-1`, which only happens when `p` is prime.
-/
theorem lucas_primality (p : ℕ) (a : ZMod p) (ha : a ^ (p - 1) = 1)
    (hd : ∀ q : ℕ, q.Prime → q ∣ p - 1 → a ^ ((p - 1) / q) ≠ 1) : p.Prime 
goal: Nat.Prime p
File: Mathlib/NumberTheory/PrimesCongruentOne.lean

full_name: Nat.exists_prime_gt_modEq_one
code: /-- For any positive `k : ℕ` there exists an arbitrarily large prime `p` such that
`p ≡ 1 [MOD k]`. -/
theorem exists_prime_gt_modEq_one {k : ℕ} (n : ℕ) (hk0 : k ≠ 0) :
    ∃ p : ℕ, Nat.Prime p ∧ n < p ∧ p ≡ 1 [MOD k] 
goal: ∃ p, Nat.Prime p ∧ n < p ∧ p ≡ 1 [MOD k]

full_name: Nat.frequently_atTop_modEq_one
code: theorem frequently_atTop_modEq_one {k : ℕ} (hk0 : k ≠ 0) :
    ∃ᶠ p in atTop, Nat.Prime p ∧ p ≡ 1 [MOD k] 
goal: ∃ᶠ (p : ℕ) in Filter.atTop, Nat.Prime p ∧ p ≡ 1 [MOD k]

full_name: Nat.infinite_setOf_prime_modEq_one
code: /-- For any positive `k : ℕ` there are infinitely many primes `p` such that `p ≡ 1 [MOD k]`. -/
theorem infinite_setOf_prime_modEq_one {k : ℕ} (hk0 : k ≠ 0) :
    Set.Infinite {p : ℕ | Nat.Prime p ∧ p ≡ 1 [MOD k]} 
goal: {p | Nat.Prime p ∧ p ≡ 1 [MOD k]}.Infinite
File: Mathlib/NumberTheory/Zsqrtd/ToReal.lean

full_name: Zsqrtd.toReal
code: /-- The image of `Zsqrtd` in `ℝ`, using `Real.sqrt` which takes the positive root of `d`.

If the negative root is desired, use `toReal h (star a)`. -/
@[simps!]
noncomputable def toReal {d : ℤ} (h : 0 ≤ d) : ℤ√d →+* ℝ 
goal: ℤ√d →+* ℝ

full_name: Zsqrtd.toReal_apply
code: /-- The image of `Zsqrtd` in `ℝ`, using `Real.sqrt` which takes the positive root of `d`.

If the negative root is desired, use `toReal h (star a)`. -/
@[simps!]
noncomputable def toReal {d : ℤ} (h : 0 ≤ d) : ℤ√d →+* ℝ 
goal: (Zsqrtd.toReal h) a = ↑a.re + ↑a.im * √↑d

full_name: Zsqrtd.toReal_injective
code: theorem toReal_injective {d : ℤ} (h0d : 0 ≤ d) (hd : ∀ n : ℤ, d ≠ n * n) :
    Function.Injective (toReal h0d) 
goal: Function.Injective ⇑(Zsqrtd.toReal h0d)
File: Mathlib/NumberTheory/Zsqrtd/QuadraticReciprocity.lean

full_name: «_aux_Mathlib_NumberTheory_Zsqrtd_QuadraticReciprocity___macroRules_termℤ[i]_1»
code: local notation "ℤ[i]" => GaussianInt
goal: Lean.Macro

full_name: _aux_Mathlib_NumberTheory_Zsqrtd_QuadraticReciprocity___unexpand_GaussianInt_1
code: local notation "ℤ[i]" => GaussianInt
goal: Lean.PrettyPrinter.Unexpander

full_name: GaussianInt.mod_four_eq_three_of_nat_prime_of_prime
code: theorem mod_four_eq_three_of_nat_prime_of_prime (p : ℕ) [hp : Fact p.Prime]
    (hpi : Prime (p : ℤ[i])) : p % 4 = 3 
goal: p % 4 = 3

full_name: GaussianInt.prime_of_nat_prime_of_mod_four_eq_three
code: theorem prime_of_nat_prime_of_mod_four_eq_three (p : ℕ) [hp : Fact p.Prime] (hp3 : p % 4 = 3) :
    Prime (p : ℤ[i]) 
goal: Prime ↑p

full_name: GaussianInt.prime_iff_mod_four_eq_three_of_nat_prime
code: /-- A prime natural number is prime in `ℤ[i]` if and only if it is `3` mod `4` -/
theorem prime_iff_mod_four_eq_three_of_nat_prime (p : ℕ) [Fact p.Prime] :
    Prime (p : ℤ[i]) ↔ p % 4 = 3 
goal: Prime ↑p ↔ p % 4 = 3
File: Mathlib/NumberTheory/Cyclotomic/PID.lean

full_name: IsCyclotomicExtension.Rat.three_pid
code: /-- If `IsCyclotomicExtension {3} ℚ K` then `𝓞 K` is a principal ideal domain. -/
theorem three_pid [IsCyclotomicExtension {3} ℚ K] : IsPrincipalIdealRing (𝓞 K) 
goal: IsPrincipalIdealRing (NumberField.RingOfIntegers K)

full_name: IsCyclotomicExtension.Rat.five_pid
code: /-- If `IsCyclotomicExtension {5} ℚ K` then `𝓞 K` is a principal ideal domain. -/
theorem five_pid [IsCyclotomicExtension {5} ℚ K] : IsPrincipalIdealRing (𝓞 K) 
goal: IsPrincipalIdealRing (NumberField.RingOfIntegers K)
File: Mathlib/NumberTheory/Cyclotomic/Embeddings.lean

full_name: IsCyclotomicExtension.Rat.nrRealPlaces_eq_zero
code: /-- If `K` is a `n`-th cyclotomic extension of `ℚ`, where `2 < n`, then there are no real places
of `K`. -/
theorem nrRealPlaces_eq_zero [IsCyclotomicExtension {n} ℚ K]
    (hn : 2 < n) :
    haveI := IsCyclotomicExtension.numberField {n} ℚ K
    NrRealPlaces K = 0 
goal: NumberField.InfinitePlace.NrRealPlaces K = 0

full_name: IsCyclotomicExtension.Rat.nrComplexPlaces_eq_totient_div_two
code: /-- If `K` is a `n`-th cyclotomic extension of `ℚ`, then there are `φ n / n` complex places
of `K`. Note that this uses `1 / 2 = 0` in the cases `n = 1, 2`. -/
theorem nrComplexPlaces_eq_totient_div_two [h : IsCyclotomicExtension {n} ℚ K] :
    haveI := IsCyclotomicExtension.numberField {n} ℚ K
    NrComplexPlaces K = φ n / 2 
goal: NumberField.InfinitePlace.NrComplexPlaces K = (↑n).totient / 2
File: Mathlib/NumberTheory/Cyclotomic/Gal.lean

full_name: IsPrimitiveRoot.autToPow_injective
code: /-- `IsPrimitiveRoot.autToPow` is injective in the case that it's considered over a cyclotomic
field extension. -/
theorem autToPow_injective : Function.Injective <| hμ.autToPow K 
goal: Function.Injective ⇑(IsPrimitiveRoot.autToPow K hμ)

full_name: IsCyclotomicExtension.Aut.commGroup
code: /-- Cyclotomic extensions are abelian. -/
noncomputable def Aut.commGroup : CommGroup (L ≃ₐ[K] L) 
goal: CommGroup (L ≃ₐ[K] L)

full_name: IsCyclotomicExtension.autEquivPow_apply
code: /-- The `MulEquiv` that takes an automorphism `f` to the element `k : (ZMod n)ˣ` such that
  `f μ = μ ^ k` for any root of unity `μ`. A strengthening of `IsPrimitiveRoot.autToPow`. -/
@[simps]
noncomputable def autEquivPow : (L ≃ₐ[K] L) ≃* (ZMod n)ˣ 
goal: ∀ (a : L ≃ₐ[K] L), (IsCyclotomicExtension.autEquivPow L h) a = (↑(IsPrimitiveRoot.autToPow K ⋯)).toFun a

full_name: IsCyclotomicExtension.autEquivPow_symm_apply
code: /-- The `MulEquiv` that takes an automorphism `f` to the element `k : (ZMod n)ˣ` such that
  `f μ = μ ^ k` for any root of unity `μ`. A strengthening of `IsPrimitiveRoot.autToPow`. -/
@[simps]
noncomputable def autEquivPow : (L ≃ₐ[K] L) ≃* (ZMod n)ˣ 
goal: (IsCyclotomicExtension.autEquivPow L h).symm t =
  (IsPrimitiveRoot.powerBasis K ⋯).equivOfMinpoly (IsPrimitiveRoot.powerBasis K ⋯) ⋯

full_name: IsCyclotomicExtension.autEquivPow
code: /-- The `MulEquiv` that takes an automorphism `f` to the element `k : (ZMod n)ˣ` such that
  `f μ = μ ^ k` for any root of unity `μ`. A strengthening of `IsPrimitiveRoot.autToPow`. -/
@[simps]
noncomputable def autEquivPow : (L ≃ₐ[K] L) ≃* (ZMod n)ˣ 
goal: (L ≃ₐ[K] L) ≃* (ZMod ↑n)ˣ

full_name: IsCyclotomicExtension.fromZetaAut
code: /-- Maps `μ` to the `AlgEquiv` that sends `IsCyclotomicExtension.zeta` to `μ`. -/
noncomputable def fromZetaAut : L ≃ₐ[K] L 
goal: L ≃ₐ[K] L

full_name: IsCyclotomicExtension.fromZetaAut_spec
code: theorem fromZetaAut_spec : fromZetaAut hμ h (zeta n K L) = μ 
goal: (IsCyclotomicExtension.fromZetaAut hμ h) (IsCyclotomicExtension.zeta n K L) = μ

full_name: galCyclotomicEquivUnitsZMod
code: /-- `IsCyclotomicExtension.autEquivPow` repackaged in terms of `Gal`.
Asserts that the Galois group of `cyclotomic n K` is equivalent to `(ZMod n)ˣ`
if `cyclotomic n K` is irreducible in the base field. -/
noncomputable def galCyclotomicEquivUnitsZMod : (cyclotomic n K).Gal ≃* (ZMod n)ˣ 
goal: (Polynomial.cyclotomic (↑n) K).Gal ≃* (ZMod ↑n)ˣ

full_name: galXPowEquivUnitsZMod
code: /-- `IsCyclotomicExtension.autEquivPow` repackaged in terms of `Gal`.
Asserts that the Galois group of `X ^ n - 1` is equivalent to `(ZMod n)ˣ`
if `cyclotomic n K` is irreducible in the base field. -/
noncomputable def galXPowEquivUnitsZMod : (X ^ (n : ℕ) - 1 : K[X]).Gal ≃* (ZMod n)ˣ 
goal: (Polynomial.X ^ ↑n - 1).Gal ≃* (ZMod ↑n)ˣ
File: Mathlib/NumberTheory/ClassNumber/FunctionField.lean

full_name: FunctionField.RingOfIntegers.instFintypeClassGroupSubtypeMemSubalgebraPolynomialRingOfIntegers
code: noncomputable instance : Fintype (ClassGroup (ringOfIntegers Fq F)) 
goal: Fintype (ClassGroup ↥(FunctionField.ringOfIntegers Fq F))

full_name: FunctionField.classNumber
code: /-- The class number in a function field is the (finite) cardinality of the class group. -/
noncomputable def classNumber : ℕ 
goal: ℕ

full_name: FunctionField.classNumber_eq_one_iff
code: /-- The class number of a function field is `1` iff the ring of integers is a PID. -/
theorem classNumber_eq_one_iff :
    classNumber Fq F = 1 ↔ IsPrincipalIdealRing (ringOfIntegers Fq F) 
goal: FunctionField.classNumber Fq F = 1 ↔ IsPrincipalIdealRing ↥(FunctionField.ringOfIntegers Fq F)
File: Mathlib/NumberTheory/ClassNumber/AdmissibleAbs.lean

full_name: AbsoluteValue.exists_partition_int
code: /-- We can partition a finite family into `partition_card ε` sets, such that the remainders
in each set are close together. -/
theorem exists_partition_int (n : ℕ) {ε : ℝ} (hε : 0 < ε) {b : ℤ} (hb : b ≠ 0) (A : Fin n → ℤ) :
    ∃ t : Fin n → Fin ⌈1 / ε⌉₊,
    ∀ i₀ i₁, t i₀ = t i₁ → ↑(abs (A i₁ % b - A i₀ % b)) < abs b • ε 
goal: ∃ t, ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑|A i₁ % b - A i₀ % b| < |b| • ε

full_name: AbsoluteValue.absIsAdmissible
code: /-- `abs : ℤ → ℤ` is an admissible absolute value. -/
noncomputable def absIsAdmissible : IsAdmissible AbsoluteValue.abs 
goal: AbsoluteValue.abs.IsAdmissible

full_name: AbsoluteValue.instInhabitedIsAdmissibleIntAbs
code: noncomputable instance : Inhabited (IsAdmissible AbsoluteValue.abs) 
goal: Inhabited AbsoluteValue.abs.IsAdmissible
File: Mathlib/RepresentationTheory/Action/Continuous.lean

full_name: Action.instHasForget₂TopCat
code: instance : HasForget₂ (Action V G) TopCat 
goal: CategoryTheory.HasForget₂ (Action V G) TopCat

full_name: Action.instMulActionαMonoidTopologicalSpaceObjTopCatForget₂
code: instance (X : Action V G) : MulAction G ((CategoryTheory.forget₂ _ TopCat).obj X) 
goal: MulAction ↑G ↑((CategoryTheory.forget₂ (Action V G) TopCat).obj X)

full_name: Action.IsContinuous
code: /-- For `HasForget₂ V TopCat` a predicate on an `X : Action V G` saying that the induced action on
the underlying topological space is continuous. -/
abbrev IsContinuous (X : Action V G) : Prop 
goal: Prop

full_name: ContAction
code: /-- For `HasForget₂ V TopCat`, this is the full subcategory of `Action V G` where the induced
action is continuous. -/
def ContAction : Type _ 
goal: Type (u + 1)

full_name: ContAction.instCategory
code: instance : Category (ContAction V G) 
goal: CategoryTheory.Category.{u, u + 1} (ContAction V G)

full_name: ContAction.instConcreteCategory
code: instance : ConcreteCategory (ContAction V G) 
goal: CategoryTheory.ConcreteCategory (ContAction V G)

full_name: ContAction.instHasForget₂Action
code: instance : HasForget₂ (ContAction V G) (Action V G) 
goal: CategoryTheory.HasForget₂ (ContAction V G) (Action V G)

full_name: ContAction.instHasForget₂
code: instance : HasForget₂ (ContAction V G) V 
goal: CategoryTheory.HasForget₂ (ContAction V G) V

full_name: ContAction.instHasForget₂TopCat
code: instance : HasForget₂ (ContAction V G) TopCat 
goal: CategoryTheory.HasForget₂ (ContAction V G) TopCat

full_name: ContAction.instCoeAction
code: instance : Coe (ContAction V G) (Action V G) 
goal: Coe (ContAction V G) (Action V G)

full_name: ContAction.IsDiscrete
code: /-- A predicate on an `X : ContAction V G` saying that the topology on the underlying type of `X`
is discrete. -/
abbrev IsDiscrete (X : ContAction V G) : Prop 
goal: Prop

full_name: DiscreteContAction
code: /-- The subcategory of `ContAction V G` where the topology is discrete. -/
def DiscreteContAction : Type _ 
goal: Type (u + 1)

full_name: DiscreteContAction.instCategory
code: instance : Category (DiscreteContAction V G) 
goal: CategoryTheory.Category.{u, u + 1} (DiscreteContAction V G)

full_name: DiscreteContAction.instConcreteCategory
code: instance : ConcreteCategory (DiscreteContAction V G) 
goal: CategoryTheory.ConcreteCategory (DiscreteContAction V G)

full_name: DiscreteContAction.instHasForget₂ContAction
code: instance : HasForget₂ (DiscreteContAction V G) (ContAction V G) 
goal: CategoryTheory.HasForget₂ (DiscreteContAction V G) (ContAction V G)

full_name: DiscreteContAction.instHasForget₂TopCat
code: instance : HasForget₂ (DiscreteContAction V G) TopCat 
goal: CategoryTheory.HasForget₂ (DiscreteContAction V G) TopCat

full_name: DiscreteContAction.instDiscreteTopologyαTopologicalSpaceObjTopCatForget₂
code: instance (X : DiscreteContAction V G) :
    DiscreteTopology ((CategoryTheory.forget₂ _ TopCat).obj X) 
goal: DiscreteTopology ↑((CategoryTheory.forget₂ (DiscreteContAction V G) TopCat).obj X)
File: Mathlib/RepresentationTheory/GroupCohomology/Hilbert90.lean

full_name: groupCohomology.Hilbert90.aux
code: /-- Given `f : Aut_K(L) → Lˣ`, the sum `∑ f(φ) • φ` for `φ ∈ Aut_K(L)`, as a function `L → L`. -/
noncomputable def aux (f : (L ≃ₐ[K] L) → Lˣ) : L → L 
goal: L → L

full_name: groupCohomology.Hilbert90.aux_ne_zero
code: theorem aux_ne_zero (f : (L ≃ₐ[K] L) → Lˣ) : aux f ≠ 0 
goal: groupCohomology.Hilbert90.aux f ≠ 0

full_name: groupCohomology.isMulOneCoboundary_of_isMulOneCocycle_of_aut_to_units
code: /-- Noether's generalization of Hilbert's Theorem 90: given a finite extension of fields and a
function `f : Aut_K(L) → Lˣ` satisfying `f(gh) = g(f(h)) * f(g)` for all `g, h : Aut_K(L)`, there
exists `β : Lˣ` such that `g(β)/β = f(g)` for all `g : Aut_K(L).` -/
theorem isMulOneCoboundary_of_isMulOneCocycle_of_aut_to_units
    (f : (L ≃ₐ[K] L) → Lˣ) (hf : IsMulOneCocycle f) :
    IsMulOneCoboundary f 
goal: groupCohomology.IsMulOneCoboundary f

full_name: groupCohomology.H1ofAutOnUnitsUnique
code: /-- Noether's generalization of Hilbert's Theorem 90: given a finite extension of fields `L/K`, the
first group cohomology `H¹(Aut_K(L), Lˣ)` is trivial. -/
noncomputable instance H1ofAutOnUnitsUnique : Unique (H1 (Rep.ofAlgebraAutOnUnits K L)) 
goal: Unique (groupCohomology.H1 (Rep.ofAlgebraAutOnUnits K L))
File: Mathlib/RepresentationTheory/Character.lean

full_name: FDRep.character
code: /-- The character of a representation `V : FDRep k G` is the function associating to `g : G` the
trace of the linear map `V.ρ g`. -/
def character (V : FDRep k G) (g : G) 
goal: k

full_name: FDRep.char_mul_comm
code: theorem char_mul_comm (V : FDRep k G) (g : G) (h : G) :
    V.character (h * g) = V.character (g * h) 
goal: V.character (h * g) = V.character (g * h)

full_name: FDRep.char_one
code: @[simp]
theorem char_one (V : FDRep k G) : V.character 1 = FiniteDimensional.finrank k V 
goal: V.character 1 = ↑(FiniteDimensional.finrank k (CoeSort.coe V))

full_name: FDRep.char_tensor
code: /-- The character is multiplicative under the tensor product. -/
theorem char_tensor (V W : FDRep k G) : (V ⊗ W).character = V.character * W.character 
goal: (V ⊗ W).character = V.character * W.character

full_name: FDRep.char_tensor'
code: @[simp]
theorem char_tensor' (V W : FDRep k G) :
    character (Action.FunctorCategoryEquivalence.inverse.obj
    (Action.FunctorCategoryEquivalence.functor.obj V ⊗
     Action.FunctorCategoryEquivalence.functor.obj W)) = V.character * W.character 
goal: FDRep.character
    (Action.FunctorCategoryEquivalence.inverse.obj
      (Action.FunctorCategoryEquivalence.functor.obj V ⊗ Action.FunctorCategoryEquivalence.functor.obj W)) =
  V.character * W.character

full_name: FDRep.char_iso
code: /-- The character of isomorphic representations is the same. -/
theorem char_iso {V W : FDRep k G} (i : V ≅ W) : V.character = W.character 
goal: V.character = W.character

full_name: FDRep.char_conj
code: /-- The character of a representation is constant on conjugacy classes. -/
@[simp]
theorem char_conj (V : FDRep k G) (g : G) (h : G) : V.character (h * g * h⁻¹) = V.character g 
goal: V.character (h * g * h⁻¹) = V.character g

full_name: FDRep.char_dual
code: @[simp]
theorem char_dual (V : FDRep k G) (g : G) : (of (dual V.ρ)).character g = V.character g⁻¹ 
goal: (FDRep.of (Representation.dual V.ρ)).character g = V.character g⁻¹

full_name: FDRep.char_linHom
code: @[simp]
theorem char_linHom (V W : FDRep k G) (g : G) :
    (of (linHom V.ρ W.ρ)).character g = V.character g⁻¹ * W.character g 
goal: (FDRep.of (Representation.linHom V.ρ W.ρ)).character g = V.character g⁻¹ * W.character g

full_name: FDRep.average_char_eq_finrank_invariants
code: theorem average_char_eq_finrank_invariants (V : FDRep k G) :
    ⅟ (Fintype.card G : k) • ∑ g : G, V.character g = finrank k (invariants V.ρ) 
goal: ⅟↑(Fintype.card G) • ∑ g : G, V.character g = ↑(FiniteDimensional.finrank k ↥(Representation.invariants V.ρ))

full_name: FDRep.char_orthonormal
code: /-- Orthogonality of characters for irreducible representations of finite group over an
algebraically closed field whose characteristic doesn't divide the order of the group. -/
theorem char_orthonormal (V W : FDRep k G) [Simple V] [Simple W] :
    ⅟ (Fintype.card G : k) • ∑ g : G, V.character g * W.character g⁻¹ =
      if Nonempty (V ≅ W) then ↑1 else ↑0 
goal: ⅟↑(Fintype.card ↑G) • ∑ g : ↑G, V.character g * W.character g⁻¹ = if Nonempty (V ≅ W) then 1 else 0
File: Mathlib/ModelTheory/Algebra/Field/CharP.lean

full_name: FirstOrder.Field.eqZero
code: /-- For a given natural number `n`, `eqZero n` is the sentence in the language of rings
saying that `n` is zero. -/
noncomputable def eqZero (n : ℕ) : Language.ring.Sentence 
goal: FirstOrder.Language.ring.Sentence

full_name: FirstOrder.Field.realize_eqZero
code: @[simp] theorem realize_eqZero [CommRing K] [CompatibleRing K] (n : ℕ)
    (v : Empty → K) : (Formula.Realize (eqZero n) v) ↔ ((n : K) = 0) 
goal: FirstOrder.Language.Formula.Realize (FirstOrder.Field.eqZero n) v ↔ ↑n = 0

full_name: FirstOrder.Language.Theory.fieldOfChar
code: /-- The first order theory of fields of characteristic `p` as a theory over the language of rings -/
def _root_.FirstOrder.Language.Theory.fieldOfChar (p : ℕ) : Language.ring.Theory 
goal: FirstOrder.Language.ring.Theory

full_name: FirstOrder.Field.model_hasChar_of_charP
code: instance model_hasChar_of_charP [Field K] [CompatibleRing K] [CharP K p] :
    (Theory.fieldOfChar p).Model K 
goal: K ⊨ FirstOrder.Language.Theory.fieldOfChar p

full_name: FirstOrder.Field.charP_iff_model_fieldOfChar
code: theorem charP_iff_model_fieldOfChar [Field K] [CompatibleRing K] :
    (Theory.fieldOfChar p).Model K ↔ CharP K p 
goal: K ⊨ FirstOrder.Language.Theory.fieldOfChar p ↔ CharP K p

full_name: FirstOrder.Field.model_fieldOfChar_of_charP
code: instance model_fieldOfChar_of_charP [Field K] [CompatibleRing K]
    [CharP K p] : (Theory.fieldOfChar p).Model K 
goal: K ⊨ FirstOrder.Language.Theory.fieldOfChar p

full_name: FirstOrder.Field.charP_of_model_fieldOfChar
code: theorem charP_of_model_fieldOfChar [Field K] [CompatibleRing K]
    [h : (Theory.fieldOfChar p).Model K] : CharP K p 
goal: CharP K p