File: Mathlib/NumberTheory/ClassNumber/Finite.lean

full_name: ClassGroup.normBound
code: /-- If `b` is an `R`-basis of `S` of cardinality `n`, then `normBound abv b` is an integer
such that for every `R`-integral element `a : S` with coordinates `≤ y`,
we have algebra.norm a ≤ norm_bound abv b * y ^ n`. (See also `norm_le` and `norm_lt`). -/
noncomputable def normBound : ℤ 
goal: ℤ

full_name: ClassGroup.normBound_pos
code: theorem normBound_pos : 0 < normBound abv bS 
goal: 0 < ClassGroup.normBound abv bS

full_name: ClassGroup.norm_le
code: /-- If the `R`-integral element `a : S` has coordinates `≤ y` with respect to some basis `b`,
its norm is less than `normBound abv b * y ^ dim S`. -/
theorem norm_le (a : S) {y : ℤ} (hy : ∀ k, abv (bS.repr a k) ≤ y) :
    abv (Algebra.norm R a) ≤ normBound abv bS * y ^ Fintype.card ι 
goal: abv ((Algebra.norm R) a) ≤ ClassGroup.normBound abv bS * y ^ Fintype.card ι

full_name: ClassGroup.norm_lt
code: /-- If the `R`-integral element `a : S` has coordinates `< y` with respect to some basis `b`,
its norm is strictly less than `normBound abv b * y ^ dim S`. -/
theorem norm_lt {T : Type*} [LinearOrderedRing T] (a : S) {y : T}
    (hy : ∀ k, (abv (bS.repr a k) : T) < y) :
    (abv (Algebra.norm R a) : T) < normBound abv bS * y ^ Fintype.card ι 
goal: ↑(abv ((Algebra.norm R) a)) < ↑(ClassGroup.normBound abv bS) * y ^ Fintype.card ι

full_name: ClassGroup.exists_min
code: /-- A nonzero ideal has an element of minimal norm. -/
theorem exists_min (I : (Ideal S)⁰) :
    ∃ b ∈ (I : Ideal S),
      b ≠ 0 ∧ ∀ c ∈ (I : Ideal S), abv (Algebra.norm R c) < abv (Algebra.norm R b) → c =
      (0 : S) 
goal: ∃ b ∈ ↑I, b ≠ 0 ∧ ∀ c ∈ ↑I, abv ((Algebra.norm R) c) < abv ((Algebra.norm R) b) → c = 0

full_name: ClassGroup.cardM
code: /-- If we have a large enough set of elements in `R^ι`, then there will be a pair
whose remainders are close together. We'll show that all sets of cardinality
at least `cardM bS adm` elements satisfy this condition.

The value of `cardM` is not at all optimal: for specific choices of `R`,
the minimum cardinality can be exponentially smaller.
-/
noncomputable def cardM : ℕ 
goal: ℕ

full_name: ClassGroup.distinctElems
code: /-- In the following results, we need a large set of distinct elements of `R`. -/
noncomputable def distinctElems : Fin (cardM bS adm).succ ↪ R 
goal: Fin (ClassGroup.cardM bS adm).succ ↪ R

full_name: ClassGroup.finsetApprox
code: /-- `finsetApprox` is a finite set such that each fractional ideal in the integral closure
contains an element close to `finsetApprox`. -/
noncomputable def finsetApprox : Finset R 
goal: Finset R

full_name: ClassGroup.finsetApprox.zero_not_mem
code: theorem finsetApprox.zero_not_mem : (0 : R) ∉ finsetApprox bS adm 
goal: 0 ∉ ClassGroup.finsetApprox bS adm

full_name: ClassGroup.mem_finsetApprox
code: @[simp]
theorem mem_finsetApprox {x : R} :
    x ∈ finsetApprox bS adm ↔ ∃ i j, i ≠ j ∧ distinctElems bS adm i - distinctElems bS adm j =
    x 
goal: x ∈ ClassGroup.finsetApprox bS adm ↔
  ∃ i j, i ≠ j ∧ (ClassGroup.distinctElems bS adm) i - (ClassGroup.distinctElems bS adm) j = x

full_name: ClassGroup.exists_mem_finsetApprox
code: /-- We can approximate `a / b : L` with `q / r`, where `r` has finitely many options for `L`. -/
theorem exists_mem_finsetApprox (a : S) {b} (hb : b ≠ (0 : R)) :
    ∃ q : S,
      ∃ r ∈ finsetApprox bS adm, abv (Algebra.norm R (r • a - b • q)) <
      abv (Algebra.norm R (algebraMap R S b)) 
goal: ∃ q,
  ∃ r ∈ ClassGroup.finsetApprox bS adm,
    abv ((Algebra.norm R) (r • a - b • q)) < abv ((Algebra.norm R) ((algebraMap R S) b))

full_name: ClassGroup.exists_mem_finset_approx'
code: /-- We can approximate `a / b : L` with `q / r`, where `r` has finitely many options for `L`. -/
theorem exists_mem_finset_approx' [Algebra.IsAlgebraic R L] (a : S) {b : S} (hb : b ≠ 0) :
    ∃ q : S,
      ∃ r ∈ finsetApprox bS adm, abv (Algebra.norm R (r • a - q * b)) < abv (Algebra.norm R b) 
goal: ∃ q, ∃ r ∈ ClassGroup.finsetApprox bS adm, abv ((Algebra.norm R) (r • a - q * b)) < abv ((Algebra.norm R) b)

full_name: ClassGroup.prod_finsetApprox_ne_zero
code: theorem prod_finsetApprox_ne_zero : algebraMap R S (∏ m ∈ finsetApprox bS adm, m) ≠ 0 
goal: (algebraMap R S) (∏ m ∈ ClassGroup.finsetApprox bS adm, m) ≠ 0

full_name: ClassGroup.ne_bot_of_prod_finsetApprox_mem
code: theorem ne_bot_of_prod_finsetApprox_mem (J : Ideal S)
    (h : algebraMap _ _ (∏ m ∈ finsetApprox bS adm, m) ∈ J) : J ≠ ⊥ 
goal: J ≠ ⊥

full_name: ClassGroup.exists_mk0_eq_mk0
code: /-- Each class in the class group contains an ideal `J`
such that `M := Π m ∈ finsetApprox` is in `J`. -/
theorem exists_mk0_eq_mk0 [IsDedekindDomain S] [Algebra.IsAlgebraic R L] (I : (Ideal S)⁰) :
    ∃ J : (Ideal S)⁰,
      ClassGroup.mk0 I = ClassGroup.mk0 J ∧
        algebraMap _ _ (∏ m ∈ finsetApprox bS adm, m) ∈ (J : Ideal S) 
goal: ∃ J, ClassGroup.mk0 I = ClassGroup.mk0 J ∧ (algebraMap R S) (∏ m ∈ ClassGroup.finsetApprox bS adm, m) ∈ ↑J

full_name: ClassGroup.mkMMem
code: /-- `ClassGroup.mkMMem` is a specialization of `ClassGroup.mk0` to (the finite set of)
ideals that contain `M := ∏ m ∈ finsetApprox L f abs, m`.
By showing this function is surjective, we prove that the class group is finite. -/
noncomputable def mkMMem [IsDedekindDomain S]
    (J : { J : Ideal S // algebraMap _ _ (∏ m ∈ finsetApprox bS adm, m) ∈ J }) : ClassGroup S 
goal: ClassGroup S

full_name: ClassGroup.mkMMem_surjective
code: theorem mkMMem_surjective [IsDedekindDomain S] [Algebra.IsAlgebraic R L] :
    Function.Surjective (ClassGroup.mkMMem bS adm) 
goal: Function.Surjective (ClassGroup.mkMMem bS adm)

full_name: ClassGroup.fintypeOfAdmissibleOfAlgebraic
code: /-- The **class number theorem**: the class group of an integral closure `S` of `R` in an
algebraic extension `L` is finite if there is an admissible absolute value.

See also `ClassGroup.fintypeOfAdmissibleOfFinite` where `L` is a finite
extension of `K = Frac(R)`, supplying most of the required assumptions automatically.
-/
noncomputable def fintypeOfAdmissibleOfAlgebraic [IsDedekindDomain S]
    [Algebra.IsAlgebraic R L] : Fintype (ClassGroup S) 
goal: Fintype (ClassGroup S)

full_name: ClassGroup.fintypeOfAdmissibleOfFinite
code: /-- The main theorem: the class group of an integral closure `S` of `R` in a
finite extension `L` of `K = Frac(R)` is finite if there is an admissible
absolute value.

See also `ClassGroup.fintypeOfAdmissibleOfAlgebraic` where `L` is an
algebraic extension of `R`, that includes some extra assumptions.
-/
noncomputable def fintypeOfAdmissibleOfFinite : Fintype (ClassGroup S) 
goal: Fintype (ClassGroup S)