fact stringlengths 19 5.66k | type stringclasses 8
values | library stringclasses 2
values | imports listlengths 1 14 | filename stringclasses 160
values | symbolic_name stringlengths 1 92 | docstring stringlengths 12 499 ⌀ |
|---|---|---|---|---|---|---|
zeroNeOne : (0 : ZHat) ≠ 1 := by intro h have h2 : (0 : ZHat) 2 = (1 : ZHat) 2 := by simp [h] rw [zero_val, one_val] at h2 revert h2 ; decide | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | zeroNeOne | null |
nontrivial : Nontrivial ZHat := ⟨0, 1, zeroNeOne⟩ | instance | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | nontrivial | null |
charZero : CharZero ZHat := ⟨ fun a b h ↦ by rw [ZHat.ext_iff] at h specialize h ⟨_, (max a b).succ_pos⟩ apply_fun ZMod.val at h rwa [natCast_val, ZMod.val_cast_of_lt, natCast_val, ZMod.val_cast_of_lt] at h · simp [Nat.succ_eq_add_one] · simp [Nat.succ_eq_add_one] ⟩ open BigOperators Nat Finset in /-- A nonarchimedean ... | instance | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | charZero | null |
e : ZHat := ⟨fun (n : ℕ+) ↦ ∑ i ∈ range (n : ℕ), i !, by intros D N hDN dsimp only obtain ⟨k, hk⟩ := exists_add_of_le <| le_of_dvd N.pos hDN simp_rw [map_sum, map_natCast, hk, sum_range_add, add_eq_left] refine sum_eq_zero (fun i _ => ?_) rw [ZMod.natCast_eq_zero_iff] exact Nat.dvd_factorial D.pos le_self_add ⟩ open Bi... | def | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | e | /-- A nonarchimedean analogue `0! + 1! + 2! + ⋯` of `e = 1/0! + 1/1! + 1/2! + ⋯`.
It is defined as the function whose value at `ZMod n` is the sum of `i!` for `0 ≤ i < n`. -/ |
e_def (n : ℕ+) : e n = ∑ i ∈ range (n : ℕ), (i ! : ZMod n) := rfl | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | e_def | null |
_root_.Nat.sum_factorial_lt_factorial_succ {j : ℕ} (hj : 1 < j) : ∑ i ∈ range (j + 1), i ! < (j + 1) ! := by calc ∑ i ∈ range (j + 1), i ! < ∑ _i ∈ range (j + 1), j ! := ?_ _ = (j + 1) * (j !) := by rw [sum_const, card_range, smul_eq_mul] _ = (j + 1)! := Nat.factorial_succ _ apply sum_lt_sum (fun i hi => factorial_le <... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | _root_.Nat.sum_factorial_lt_factorial_succ | null |
_root_.Nat.sum_factorial_lt_two_mul_factorial {j : ℕ} (hj : 3 ≤ j) : ∑ i ∈ range (j + 1), i ! < 2 * j ! := by induction j, hj using Nat.le_induction with | base => simp [sum_range_succ, factorial_succ] | succ j hj ih => rw [two_mul] at ih ⊢ rw [sum_range_succ] gcongr apply sum_factorial_lt_factorial_succ omega | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | _root_.Nat.sum_factorial_lt_two_mul_factorial | null |
e_factorial_succ (j : ℕ) : e ⟨(j + 1)!, by positivity⟩ = ∑ i ∈ range (j + 1), i ! := by simp_rw [e_def, PNat.mk_coe, cast_sum] obtain ⟨k, hk⟩ := exists_add_of_le <| self_le_factorial (j + 1) rw [hk, sum_range_add, add_eq_left] refine sum_eq_zero (fun i _ => ?_) rw [ZMod.natCast_eq_zero_iff, ← hk] exact factorial_dvd_fa... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | e_factorial_succ | null |
e_not_in_Int : ∀ a : ℤ, e ≠ a := by rintro (a|a) ha · obtain ⟨j, honelt, hj⟩ : ∃ j : ℕ, 1 < j ∧ a < ∑ i ∈ range (j + 1), i ! := by refine ⟨a + 2, ?_, ?_⟩ · simp only [lt_add_iff_pos_left, add_pos_iff, zero_lt_one, or_true] rw [sum_range_add] apply lt_add_of_nonneg_of_lt · positivity rw [range_one, sum_singleton, add_ze... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | e_not_in_Int | /-- Nonarchimedean $e$ is not an integer. -/ |
torsionfree_aux (a b : ℕ) [NeZero b] (h : a ∣ b) (x : ZMod b) (hx : a ∣ x.val) : ZMod.castHom h (ZMod a) x = 0 := by rw [ZMod.castHom_apply, ZMod.cast_eq_val] obtain ⟨y, hy⟩ := hx rw [hy] simp @[simp] | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | torsionfree_aux | null |
nat_mul_apply (N : ℕ) (z : ZHat) (k : ℕ+) : (N * z) k = N * (z k) := rfl @[simp] | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | nat_mul_apply | null |
pnat_mul_apply (N : ℕ+) (z : ZHat) (k : ℕ+) : (N * z) k = N * (z k) := rfl | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | pnat_mul_apply | null |
eq_zero_of_mul_eq_zero (N : ℕ+) (a : ZHat) (ha : N * a = 0) : a = 0 := by ext j rw [zero_val, ← a.prop j (N * j) (by simp)] apply torsionfree_aux apply Nat.dvd_of_mul_dvd_mul_left N.pos rw [← PNat.mul_coe] apply Nat.dvd_of_mod_eq_zero have : N * a (N * j) = 0 := by rw [← pnat_mul_apply] simp [ha] simpa only [ZMod.val_m... | theorem | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | eq_zero_of_mul_eq_zero | null |
torsionfree (N : ℕ+) : Function.Injective (fun z : ZHat ↦ N * z) := by rw [← AddMonoidHom.coe_mulLeft, injective_iff_map_eq_zero] intro a ha rw [AddMonoidHom.coe_mulLeft] at ha exact eq_zero_of_mul_eq_zero N a ha | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | torsionfree | null |
ZHat_flat : Module.Flat ℤ ZHat := by rw [IsDedekindDomain.flat_iff_torsion_eq_bot] rw [eq_bot_iff] intro x hx simp only [Submodule.mem_torsion'_iff, Subtype.exists, Submonoid.mk_smul, zsmul_eq_mul, exists_prop, Submodule.mem_bot, mem_nonZeroDivisors_iff_ne_zero] at hx ⊢ obtain ⟨N, hN⟩ := hx cases N case ofNat N => simp... | instance | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | ZHat_flat | null |
y_mul_N_eq_z (N : ℕ+) (z : ZHat) (hz : z N = 0) (j : ℕ+) : N * ((z (N * j)).val / (N : ℕ) : ZMod j) = z j := by have hhj := z.prop N (N * j) (by simp only [PNat.mul_coe, dvd_mul_right]) rw [hz, ZMod.castHom_apply, ZMod.cast_eq_val, ZMod.natCast_eq_zero_iff] at hhj rw [← Nat.cast_mul, mul_comm, Nat.div_mul_cancel hhj] h... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | y_mul_N_eq_z | null |
multiples (N : ℕ+) (z : ZHat) : (∃ (y : ZHat), N * y = z) ↔ z N = 0 := by constructor · intro ⟨y, hy⟩ rw [← hy] change N * (y N) = 0 simp · intro h let y : ZHat := { val := fun j ↦ (z (N * j)).val / (N : ℕ) property := by intro j k hjk have hj := z.prop N (N * j) (by simp only [PNat.mul_coe, dvd_mul_right]) have hk := ... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | multiples | null |
nat_dense (N : ℕ+) (z : ZHat) : ∃ (q : ZHat) (r : ℕ), z = N * q + r ∧ r < N := by let r : ℕ := (z N : ZMod N).val have h : (z - r) N = 0 := by change z N - r = 0; simp [r] rw [← multiples] at h obtain ⟨q, hq⟩ := h exact ⟨q, r, by linear_combination -hq, ZMod.val_lt (z N)⟩ | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | nat_dense | null |
QHat := ℚ ⊗[ℤ] ZHat | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | QHat | /-- The "profinite completion" of ℚ is defined to be `ℚ ⊗ ZHat`, with `ZHat` the profinite
completion of `ℤ`. -/ |
canonicalForm (z : QHat) : ∃ (N : ℕ+) (z' : ZHat), z = (1 / N : ℚ) ⊗ₜ z' := by induction z using TensorProduct.induction_on with | zero => refine ⟨1, 0, ?_⟩ simp | tmul q z => refine ⟨⟨q.den, q.den_pos ⟩, q.num * z, ?_⟩ simp_rw [← zsmul_eq_mul, TensorProduct.tmul_smul, TensorProduct.smul_tmul'] simp only [PNat.mk_coe, ... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | canonicalForm | /-- The "profinite completion" of ℚ is defined to be `ℚ ⊗ ZHat`, with `ZHat` the profinite
completion of `ℤ`. -/ |
IsCoprime (N : ℕ+) (z : ZHat) : Prop := IsUnit (z N) open ZMod in | def | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | IsCoprime | null |
isUnit_iff_coprime (n : ℕ) (m : ZMod n) : IsUnit m ↔ m.val.Coprime n := by refine ⟨fun H ↦ ?_, fun H ↦ ?_⟩ · have H' := val_coe_unit_coprime H.unit rwa [IsUnit.unit_spec] at H' let m' : (ZMod n)ˣ := { val := m inv := m⁻¹ val_inv := by rw [mul_inv_eq_gcd, H.gcd_eq_one, Nat.cast_one] inv_val := by rw [mul_comm, mul_inv_e... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | isUnit_iff_coprime | null |
isCoprime_iff_coprime (N : ℕ+) (z : ZHat) : IsCoprime N z ↔ Nat.Coprime N (z N).val := by unfold IsCoprime rw [isUnit_iff_coprime, Nat.coprime_comm] | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | isCoprime_iff_coprime | null |
i₂ : ZHat →ₐ[ℤ] QHat := Algebra.TensorProduct.includeRight | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | i₂ | null |
injective_zHat : Function.Injective i₂ := by intro a b h have h₁ := LinearMap.rTensor_tmul ZHat (f := Algebra.linearMap ℤ ℚ) a 1 have h₂ := LinearMap.rTensor_tmul ZHat (f := Algebra.linearMap ℤ ℚ) b 1 simp only [Algebra.linearMap_apply, map_one] at h₁ h₂ dsimp at h rw [← h₁, ← h₂] at h replace h := Module.Flat.rTensor_... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | injective_zHat | null |
nontrivial_QHat : Nontrivial QHat where exists_pair_ne := ⟨1 ⊗ₜ 0, 1 ⊗ₜ 1, injective_zHat.ne ZHat.zeroNeOne⟩ | instance | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | nontrivial_QHat | null |
i₁ : ℚ →ₐ[ℤ] QHat := Algebra.TensorProduct.includeLeft | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | i₁ | null |
injective_rat : Function.Injective i₁ := RingHom.injective i₁.toRingHom | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | injective_rat | null |
PNat.lcm_comm (m n : ℕ+) : PNat.lcm m n = PNat.lcm n m := PNat.eq <| by simp [Nat.lcm_comm] | theorem | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | PNat.lcm_comm | null |
lowestTerms (x : QHat) : (∃ N z, IsCoprime N z ∧ x = (1 / N : ℚ) ⊗ₜ z) ∧ (∀ N₁ N₂ z₁ z₂, IsCoprime N₁ z₁ ∧ IsCoprime N₂ z₂ ∧ (1 / N₁ : ℚ) ⊗ₜ z₁ = (1 / N₂ : ℚ) ⊗ₜ[ℤ] z₂ → N₁ = N₂ ∧ z₁ = z₂) := by constructor · -- Existence: by the previous lemma, an arbitrary element [x] can be written as z/N; obtain ⟨N, z, h⟩ := canoni... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | lowestTerms | null |
ratsub : AddSubgroup QHat := (i₁ : ℚ →+ QHat).range | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | ratsub | null |
zHatsub : AddSubgroup QHat := (i₂ : ZHat →+ QHat).range | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | zHatsub | null |
zsub : AddSubgroup QHat := (Int.castRingHom QHat : ℤ →+ QHat).range | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | zsub | null |
ZMod.isUnit_natAbs {z : ℤ} {N : ℕ} : IsUnit (z.natAbs : ZMod N) ↔ IsUnit (z : ZMod N) := by cases z.natAbs_eq with | inl h | inr h => rw [h]; simp @[simp] | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | ZMod.isUnit_natAbs | null |
_root_.Algebra.TensorProduct.one_tmul_intCast {R : Type*} {A : Type*} {B : Type*} [CommRing R] [Ring A] [Algebra R A] [Ring B] [Algebra R B] {z : ℤ} : (1 : A) ⊗ₜ[R] (z : B) = (z : TensorProduct R A B) := by rw [← map_intCast (F := B →ₐ[R] TensorProduct R A B), Algebra.TensorProduct.includeRight_apply] | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | _root_.Algebra.TensorProduct.one_tmul_intCast | null |
rat_meet_zHat : ratsub ⊓ zHatsub = zsub := by apply le_antisymm · intro x ⟨⟨l, hl⟩, ⟨r, hr⟩⟩ simp only [AddMonoidHom.coe_coe, Algebra.TensorProduct.includeLeft_apply, Algebra.TensorProduct.includeRight_apply] at hl hr rcases lowestTerms x with ⟨⟨N, z, hNz, hx⟩, unique⟩ have cop1 : IsCoprime l.den.toPNat' l.num := by si... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | rat_meet_zHat | null |
rat_join_zHat : ratsub ⊔ zHatsub = ⊤ := by rw [eq_top_iff] intro x _ rcases x.canonicalForm with ⟨N, z, hNz⟩ rcases ZHat.nat_dense N z with ⟨q, r, hz, _⟩ have h : z - r = N * q := sub_eq_of_eq_add hz rw [AddSubgroup.mem_sup] use ((r : ℤ) / N : ℚ) ⊗ₜ[ℤ] 1 constructor · simp use 1 ⊗ₜ[ℤ] q constructor · simp nth_rw 1 [← m... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | rat_join_zHat | null |
unitsratsub : Subgroup QHatˣ := (Units.map (i₁ : ℚ →* QHat)).range | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | unitsratsub | null |
unitszHatsub : Subgroup QHatˣ := (Units.map (i₂ : ZHat →* QHat)).range | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | unitszHatsub | null |
unitszsub : Subgroup QHatˣ := (Units.map (Int.castRingHom QHat : ℤ →* QHat)).range | abbrev | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | unitszsub | null |
unitsrat_meet_unitszHat : unitsratsub ⊓ unitszHatsub = unitszsub := by apply le_antisymm · intro x ⟨⟨q, hxq⟩, ⟨zHat, hxzHat⟩⟩ obtain ⟨z, (hz : (z : QHat) = x)⟩ : (x : QHat) ∈ zsub := by rw [← rat_meet_zHat] exact ⟨⟨q, by simp [← hxq]⟩, zHat, by simp [← hxzHat]⟩ have znez : z ≠ 0 := by rintro rfl simp [Eq.comm] at hz le... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | unitsrat_meet_unitszHat | null |
_root_.Algebra.TensorProduct.intCast_tmul_one {R : Type*} {A : Type*} {B : Type*} [CommRing R] [Ring A] [Algebra R A] [Ring B] [Algebra R B] {z : ℤ} : (z : A) ⊗ₜ[R] (1 : B) = (z : TensorProduct R A B) := by rw [← map_intCast (F := A →ₐ[R] TensorProduct R A B), Algebra.TensorProduct.includeLeft_apply] @[simp] | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | _root_.Algebra.TensorProduct.intCast_tmul_one | null |
_root_.Algebra.TensorProduct.one_tmul_natCast {R : Type*} {A : Type*} {B : Type*} [CommRing R] [Ring A] [Algebra R A] [Ring B] [Algebra R B] {n : ℕ} : (1 : A) ⊗ₜ[R] (n : B) = (n : TensorProduct R A B) := by rw [← map_natCast (F := B →ₐ[R] TensorProduct R A B), Algebra.TensorProduct.includeRight_apply] -- this needs tha... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | _root_.Algebra.TensorProduct.one_tmul_natCast | null |
unitsrat_join_unitszHat : unitsratsub ⊔ unitszHatsub = ⊤ := by rw [eq_top_iff] rintro y - rcases canonicalForm y.val with ⟨N, x, hy⟩ rcases canonicalForm (y⁻¹.val) with ⟨N2, x2, hy2⟩ set xinv := (1 / (N * N2) : ℚ) ⊗ₜ[ℤ] x2 with xinv_def have : (i₂ x) * xinv = 1 := by rw [xinv_def, Algebra.TensorProduct.includeRight_app... | lemma | FLT | [
"import Mathlib.Algebra.Order.Star.Basic",
"import Mathlib.Analysis.Normed.Field.Lemmas",
"import Mathlib.Data.PNat.Prime",
"import Mathlib.RingTheory.Flat.TorsionFree"
] | FLT/Data/QHat.lean | unitsrat_join_unitszHat | null |
exists_ofAdd_natCast_of_le_one {x : ℤᵐ⁰} (hx : x ≠ 0) (hx' : x ≤ 1) : ∃ (k : ℕ), (Multiplicative.ofAdd (-(k : ℤ))) = x := by lift x to Multiplicative ℤ using hx norm_cast at hx' obtain ⟨k, hk⟩ := Int.eq_ofNat_of_zero_le (Int.neg_nonneg_of_nonpos hx') use k rw [← hk, Int.neg_neg] rfl | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_ofAdd_natCast_of_le_one | null |
exists_ofAdd_natCast_lt {x : ℤᵐ⁰} (hx : x ≠ 0) : ∃ (k : ℕ), (Multiplicative.ofAdd (-(k : ℤ))) < x := by obtain ⟨y, hnz, hyx⟩ := WithZero.exists_ne_zero_and_lt hx lift y to Multiplicative ℤ using hnz use y.natAbs apply lt_of_le_of_lt _ hyx norm_cast exact inv_mabs_le y | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_ofAdd_natCast_lt | null |
ne_zero_of_some_le_intValuation {a : A} {m : Multiplicative ℤ} (h : m ≤ v.intValuation a) : a ≠ 0 := by rintro rfl simp at h | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | ne_zero_of_some_le_intValuation | null |
emultiplicity_eq_of_valuation_eq_ofAdd {a : A} {k : ℕ} (hv : v.intValuation a = (Multiplicative.ofAdd (-(k : ℤ)))) : emultiplicity v.asIdeal (Ideal.span {a}) = k := by classical have hnz : a ≠ 0 := ne_zero_of_some_le_intValuation _ (le_of_eq hv.symm) have hnb : Ideal.span {a} ≠ ⊥ := by rwa [ne_eq, Ideal.span_singleton_... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | emultiplicity_eq_of_valuation_eq_ofAdd | null |
exists_adicValued_mul_sub_le {a b : A} {γ : WithZero (Multiplicative ℤ)} (hγ : γ ≠ 0) (hle : γ ≤ v.intValuation a) (hle' : v.intValuation b ≤ v.intValuation a) : ∃ y, v.intValuation (y * a - b) ≤ γ := by -- Find `n` such that `γ = Multiplicative.ofAdd (-(n : ℤ))` have hγ' : γ ≤ 1 := by apply hle.trans apply intValuatio... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_adicValued_mul_sub_le | /-- Given `a, b ∈ A` and `v b ≤ v a` we can find `y in A` such that `y` is close to `a / b` by
the valuation v. -/ |
exists_adicValued_sub_lt_of_adicValued_le_one {x : (WithVal (v.valuation K))} (γ : (WithZero (Multiplicative ℤ))ˣ) (hx : Valued.v x ≤ 1) : ∃a, Valued.v ((algebraMap A K a) - (x : v.adicCompletion K)) < γ.val := by -- Write `x = n / d` obtain ⟨⟨n, d, hd⟩, hnd⟩ := IsLocalization.surj (nonZeroDivisors A) x dsimp only at h... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_adicValued_sub_lt_of_adicValued_le_one | null |
closureAlgebraMapIntegers_eq_integers : closure (algebraMap A (v.adicCompletion K)).range = SetLike.coe (v.adicCompletionIntegers K) := by apply subset_antisymm -- We know `closure A ⊆ 𝒪_v` because `𝒪_v` is closed and `A ⊆ 𝒪_v` · apply closure_minimal _ (Valued.isClosed_valuationSubring _) rintro b ⟨a, rfl⟩ exact co... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | closureAlgebraMapIntegers_eq_integers | /-- The closure of `A` in `K_v` is `𝒪_v`. -/ |
denseRange_of_integerAlgebraMap : DenseRange (algebraMap A (v.adicCompletionIntegers K)) := by rw [denseRange_iff_closure_range, Set.eq_univ_iff_forall] intro x rw [closure_subtype] suffices h : Subtype.val '' Set.range ((algebraMap A ↥(adicCompletionIntegers K v))) = (algebraMap A (v.adicCompletion K)).range by rw [h,... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | denseRange_of_integerAlgebraMap | /-- `A` is dense in `𝒪_v`. -/ |
exists_adicValued_sub_lt_of_adicCompletionInteger (x : v.adicCompletionIntegers K) (γ : (WithZero (Multiplicative ℤ))ˣ) : ∃a, Valued.v ((algebraMap A K a) - (x : v.adicCompletion K)) < γ.val := by have h := closureAlgebraMapIntegers_eq_integers K v rw [Set.ext_iff] at h specialize h x simp_rw [RingHom.coe_range, Subtyp... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_adicValued_sub_lt_of_adicCompletionInteger | /-- An element of `𝒪_v` can be approximated by an element of `A`. -/ |
completionIdeal : Ideal (v.adicCompletionIntegers K) := IsLocalRing.maximalIdeal (adicCompletionIntegers K v) | abbrev | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | completionIdeal | /-- The maximal ideal of the integers of the completion of `v`. -/ |
mem_completionIdeal_iff (x : v.adicCompletionIntegers K) : x ∈ completionIdeal K v ↔ Valued.v x.val < 1 := Valuation.mem_maximalIdeal_iff _ _ | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | mem_completionIdeal_iff | /-- The maximal ideal of the integers of the completion of `v`. -/ |
algebraMap_completionIntegers (x : A) : (algebraMap A (v.adicCompletionIntegers K) x) = (algebraMap A (v.adicCompletion K) x) := rfl | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | algebraMap_completionIntegers | /-- The maximal ideal of the integers of the completion of `v`. -/ |
ResidueFieldToCompletionResidueField : A ⧸ v.asIdeal →+* ResidueField (v.adicCompletionIntegers K) := Ideal.quotientMap _ (algebraMap _ _) <| le_of_eq Ideal.LiesOver.over open IsLocalRing in /-- The canonical isomorphism from A / v to 𝓞ᵥ / v, where 𝓞ᵥ is the integers of the completion Kᵥ of the field of fractions K o... | def | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | ResidueFieldToCompletionResidueField | /-- The canonical ring homomorphism from A / v to 𝓞ᵥ / v, where 𝓞ᵥ is the integers of the
completion Kᵥ of the field of fractions of A. -/ |
ResidueFieldEquivCompletionResidueField : A ⧸ v.asIdeal ≃+* ResidueField (v.adicCompletionIntegers K) := by apply RingEquiv.ofBijective (ResidueFieldToCompletionResidueField K v) ⟨Ideal.quotientMap_injective' <| ge_of_eq Ideal.LiesOver.over, ?_⟩ intro z obtain ⟨x, hx⟩ := Submodule.Quotient.mk_surjective (p := maximalId... | def | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | ResidueFieldEquivCompletionResidueField | /-- The canonical isomorphism from A / v to 𝓞ᵥ / v, where 𝓞ᵥ is the integers of the
completion Kᵥ of the field of fractions K of A. -/ |
inertiaDeg_asIdeal_completionIdeal : Ideal.inertiaDeg v.asIdeal (v.completionIdeal K) = 1 := by rw [Ideal.inertiaDeg_algebraMap] have f : (A ⧸ v.asIdeal) ≃ₗ[A ⧸ v.asIdeal] ((adicCompletionIntegers K v) ⧸ completionIdeal K v) := { __ := ResidueFieldEquivCompletionResidueField K v map_smul' := by intro x y rw [Algebra.sm... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | inertiaDeg_asIdeal_completionIdeal | null |
exists_forall_adicValued_sub_lt {ι : Type*} (s : Finset ι) (e : ι → (WithZero (Multiplicative ℤ))ˣ) (valuation : ι → HeightOneSpectrum A) (injective : Function.Injective valuation) (x : (i : ι) → (valuation i).adicCompletionIntegers K) : ∃ a, ∀ i ∈ s, Valued.v ((algebraMap A K a) - (x i).val) < (e i).val := by -- Appro... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_forall_adicValued_sub_lt | /-- An element of `∏_{v ∈ s} 𝒪_v`, with `s` finite, can be approximated by an element of `A`.
-/ |
closureAlgebraMapIntegers_eq_prodIntegers {ι : Type*} (valuation : ι → HeightOneSpectrum A) (injective : Function.Injective valuation) : closure (SetLike.coe (algebraMap A ((i : ι) → (valuation i).adicCompletion K)).range) = (Set.pi Set.univ (fun (i : ι) ↦ ((valuation i).adicCompletionIntegers K).carrier)) := by apply ... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | closureAlgebraMapIntegers_eq_prodIntegers | /-- The closure of `A` in `∏_{v ∈ s} K_v` is `∏_{v ∈ s} 𝒪_v`. `s` may be infinite. -/ |
adicCompletion.eq_mul_nonZeroDivisor_inv_adicCompletionIntegers (v : HeightOneSpectrum A) (x : v.adicCompletion K) : ∃a ∈ nonZeroDivisors A, ∃b ∈ v.adicCompletionIntegers K, x = (algebraMap A K a)⁻¹ • b := by obtain ⟨a, hz, ha⟩ := adicCompletion.mul_nonZeroDivisor_mem_adicCompletionIntegers v x use a, hz, (algebraMap A... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | adicCompletion.eq_mul_nonZeroDivisor_inv_adicCompletionIntegers | null |
adicCompletion.eq_mul_pi_adicCompletionIntegers {ι : Type*} [Fintype ι] (valuation : ι → HeightOneSpectrum A) (x : (i : ι) → (valuation i).adicCompletion K) : ∃k : K, ∃y ∈ Set.pi Set.univ (fun (i : ι) ↦ ((valuation i).adicCompletionIntegers K).carrier), x = k • y := by classical choose f hf using fun (i : ι) => eq_mul_... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | adicCompletion.eq_mul_pi_adicCompletionIntegers | null |
denseRange_of_prodAlgebraMap {ι : Type*} [Fintype ι] {valuation : ι → HeightOneSpectrum A} (injective : Function.Injective valuation) : DenseRange (algebraMap K ((i : ι) → (valuation i).adicCompletion K)) := by rw [denseRange_iff_closure_range, Set.eq_univ_iff_forall] let S := Set.range (algebraMap K ((i : ι) → (valuat... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | denseRange_of_prodAlgebraMap | /-- If `s` is finite then `K` in dense in `∏_{v ∈ s} K_v`. -/ |
exists_uniformizer (v : HeightOneSpectrum A) : ∃ π : v.adicCompletionIntegers K, Valued.v π.1 = Multiplicative.ofAdd (- 1 : ℤ) := by obtain ⟨π, hπ⟩ := v.intValuation_exists_uniformizer use π rw [← WithZero.exp, ← hπ, ← ValuationSubring.algebraMap_apply, ← IsScalarTower.algebraMap_apply, v.valuedAdicCompletion_eq_valuat... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | exists_uniformizer | null |
uniformizer_ne_zero {v : HeightOneSpectrum A} {π : v.adicCompletionIntegers K} (hπ : Valued.v π.1 = Multiplicative.ofAdd (-1 : ℤ)) : π ≠ 0 := by contrapose! hπ simp [hπ] variable {K} in open scoped Multiplicative in | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | uniformizer_ne_zero | null |
uniformizer_not_isUnit {π : v.adicCompletionIntegers K} (hπ : Valued.v π.1 = Multiplicative.ofAdd (-1 : ℤ)) : ¬IsUnit (π : v.adicCompletionIntegers K) := by rw [ValuationSubring.isUnit_iff_valued_eq_one, ← WithZero.coe_one, ← ofAdd_zero, hπ] apply ne_of_lt rw [WithZero.coe_lt_coe, Multiplicative.ofAdd_lt] omega | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | uniformizer_not_isUnit | null |
eq_pow_uniformizer_mul_unit {x : v.adicCompletionIntegers K} (hx : x ≠ 0) {π : v.adicCompletionIntegers K} (hπ : Valued.v π.1 = Multiplicative.ofAdd (-1 : ℤ)) : ∃ (n : ℕ) (u : (v.adicCompletionIntegers K)ˣ), x = π ^ n * u := by have hx' : Valued.v x.1 ≠ 0 := by simp [hx] let m := - Multiplicative.toAdd (WithZero.unzero... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | eq_pow_uniformizer_mul_unit | null |
maximalIdeal_eq_span_uniformizer {π : v.adicCompletionIntegers K} (hπ : Valued.v π.1 = Multiplicative.ofAdd (-1 : ℤ)) : IsLocalRing.maximalIdeal (v.adicCompletionIntegers K) = Ideal.span {(π : v.adicCompletionIntegers K)} := by refine (IsLocalRing.maximalIdeal.isMaximal _).eq_of_le (Ideal.span_singleton_ne_top (uniform... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | maximalIdeal_eq_span_uniformizer | null |
mem_completionIdeal_pow {n : ℕ} (x : v.adicCompletionIntegers K) : x ∈ (v.completionIdeal K) ^ n ↔ Valued.v x.val ≤ ↑(Multiplicative.ofAdd (-(n : ℤ))) := by obtain ⟨π, hπ⟩ := exists_uniformizer K v unfold completionIdeal rw [maximalIdeal_eq_span_uniformizer K v hπ, Ideal.span_singleton_pow, Ideal.mem_span_singleton'] h... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | mem_completionIdeal_pow | null |
mem_completionIdeal_iff' (x : v.adicCompletionIntegers K) : x ∈ v.completionIdeal K ↔ Valued.v x.val ≤ ↑(Multiplicative.ofAdd (-(1 : ℤ))) := by rw [← Submodule.pow_one (v.completionIdeal K), adicCompletion.mem_completionIdeal_pow, Int.natCast_one] | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | mem_completionIdeal_iff' | null |
completionIdeal_ne_bot : completionIdeal K v ≠ ⊥ := IsDiscreteValuationRing.not_a_field _ | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Valuation.ValuationSubring",
"import FLT.Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"import FLT.Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.Algebra.Order.GroupWithZero.Canonical",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.Numbe... | FLT/DedekindDomain/AdicValuation.lean | completionIdeal_ne_bot | null |
comap (w : HeightOneSpectrum B) : HeightOneSpectrum A where asIdeal := w.asIdeal.comap (algebraMap A B) isPrime := Ideal.comap_isPrime (algebraMap A B) w.asIdeal ne_bot := mt Ideal.eq_bot_of_comap_eq_bot w.ne_bot variable {A} in /-- If `B` is an `A`-algebra and `v : HeightOneSpectrum A` is a nonzero prime, then `v.Exte... | def | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | comap | /-- If B/A is an integral extension of Dedekind domains, `comap w` is the pullback
of the nonzero prime `w` to `A`. -/ |
Extension (v : HeightOneSpectrum A) := {w : HeightOneSpectrum B // w.comap A = v} | def | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | Extension | /-- If `B` is an `A`-algebra and `v : HeightOneSpectrum A` is a nonzero prime,
then `v.Extension B` is the subtype of `HeightOneSpeectrum B` consisting of valuations of `B`
which restrict to `v`. -/ |
mk_count_factors_map (hAB : Function.Injective (algebraMap A B)) (w : HeightOneSpectrum B) (I : Ideal A) [DecidableEq (Associates (Ideal A))] [DecidableEq (Associates (Ideal B))] [∀ p : Associates (Ideal A), Decidable (Irreducible p)] [∀ p : Associates (Ideal B), Decidable (Irreducible p)] : (Associates.mk w.asIdeal).c... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | mk_count_factors_map | /-- If `B` is an `A`-algebra and `v : HeightOneSpectrum A` is a nonzero prime,
then `v.Extension B` is the subtype of `HeightOneSpeectrum B` consisting of valuations of `B`
which restrict to `v`. -/ |
ramificationIdx_ne_zero (hAB : Function.Injective (algebraMap A B)) (w : HeightOneSpectrum B) : Ideal.ramificationIdx (algebraMap A B) (comap A w).asIdeal w.asIdeal ≠ 0 := Ideal.IsDedekindDomain.ramificationIdx_ne_zero ((Ideal.map_eq_bot_iff_of_injective hAB).not.mpr (comap A w).3) w.2 Ideal.map_comap_le /-- If w | v t... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | ramificationIdx_ne_zero | null |
intValuation_comap (hAB : Function.Injective (algebraMap A B)) (w : HeightOneSpectrum B) (x : A) : (comap A w).intValuation x ^ (Ideal.ramificationIdx (algebraMap A B) (comap A w).asIdeal w.asIdeal) = w.intValuation (algebraMap A B x) := by classical have h_ne_zero := ramificationIdx_ne_zero A B hAB w by_cases hx : x =... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | intValuation_comap | /-- If w | v then for a ∈ A we have w(a)=v(a)^e where e is the ramification index. -/ |
valuation_comap (w : HeightOneSpectrum B) (x : K) : (comap A w).valuation K x ^ (Ideal.ramificationIdx (algebraMap A B) (comap A w).asIdeal w.asIdeal) = w.valuation L (algebraMap K L x) := by obtain ⟨x, y, hy, rfl⟩ := IsFractionRing.div_surjective (A := A) x simp [valuation, ← IsScalarTower.algebraMap_apply A K L, IsSc... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | valuation_comap | /-- If w | v then for x ∈ K we have w(x)=v(x)^e where e is the ramification index. -/ |
noZeroSMulDivisors [IsDomain B] : NoZeroSMulDivisors A B := by have := FaithfulSMul.of_field_isFractionRing A B K L infer_instance include K L in omit [IsIntegralClosure B A L] [IsFractionRing B L] in /-- There are only finitely many nonzero primes of B above a nonzero prime of A. -/ | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | noZeroSMulDivisors | null |
Extension.finite (v : HeightOneSpectrum A) : Finite (v.Extension B) := by have := noZeroSMulDivisors A K L B rw [Extension, ← Set.coe_setOf] rw [@Set.finite_coe_iff] have := primesOver_finite v.asIdeal B refine Set.Finite.of_finite_image (f := HeightOneSpectrum.asIdeal) ?_ ?_ · refine Set.Finite.subset this ?_ simp onl... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | Extension.finite | /-- There are only finitely many nonzero primes of B above a nonzero prime of A. -/ |
Extension.fintype : Fintype (Extension B v) := have := Extension.finite A K L B v Fintype.ofFinite <| Extension B v include K L in omit [IsIntegralClosure B A L] [IsFractionRing B L] in | def | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | Extension.fintype | /-- There are only finitely many nonzero primes of B above a nonzero prime of A. -/ |
preimage_comap_finite (S : Set (HeightOneSpectrum A)) (hS : S.Finite) : ((comap A : HeightOneSpectrum B → HeightOneSpectrum A) ⁻¹' S).Finite := by rw [← Set.biUnion_preimage_singleton (comap A) S] exact Set.Finite.biUnion' hS <| fun v _ ↦ Extension.finite A K L B v /-- Given an inclusion of Dedekind domains A → B, maki... | theorem | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | preimage_comap_finite | /-- There are only finitely many nonzero primes of B above a nonzero prime of A. -/ |
preimageComapFinset (S : Finset (HeightOneSpectrum A)) : Finset (HeightOneSpectrum B) := Set.Finite.toFinset <| preimage_comap_finite A K L B S S.finite_toSet omit [IsIntegralClosure B A L] in /-- `Ideal.sum_ramification_inertia`, rewritten as a sum over extensions. -/ | def | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | preimageComapFinset | /-- Given an inclusion of Dedekind domains A → B, making B finite over A,
this is the preimage of a Finset of finite places of A, as a Finset of
finite places of B. -/ |
_root_.Ideal.sum_ramification_inertia_extensions [Module.Finite A B] : letI := Extension.fintype A K L B v ∑ (w : Extension B v), Ideal.ramificationIdx (algebraMap A B) (v.asIdeal) (w.val.asIdeal) * (v.asIdeal).inertiaDeg (w.val.asIdeal) = Module.finrank K L := by have := v.isMaximal have := noZeroSMulDivisors A K L B ... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | _root_.Ideal.sum_ramification_inertia_extensions | /-- `Ideal.sum_ramification_inertia`, rewritten as a sum over extensions. -/ |
LinearEquivTensorProduct : L ≃ₗ[K] K ⊗[A] B := let f := LocalizedModule.equivTensorProduct (nonZeroDivisors A) B have := IsIntegralClosure.isLocalization A K L B have : IsLocalizedModule (nonZeroDivisors A) (IsScalarTower.toAlgHom A B L).toLinearMap := inferInstance let g : LocalizedModule (nonZeroDivisors A) B ≃ₗ[A] L... | def | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | LinearEquivTensorProduct | /-- The canonical `K`-linear isomorphism `L ≅ K ⊗ B`. -/ |
LinearEquivTensorProduct_symm_one_tmul (b : B) : (LinearEquivTensorProduct A K L B).symm (1 ⊗ₜ b) = (algebraMap _ _ b) := by have : (SemilinearEquivClass.semilinearEquiv (Localization.algEquiv (nonZeroDivisors A) K)).symm 1 = 1 := map_one (Localization.algEquiv (nonZeroDivisors A) K).symm simp [LinearEquivTensorProduct... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | LinearEquivTensorProduct_symm_one_tmul | null |
LinearEquivTensorProduct_symm_tmul (k : K) (b : B) : (LinearEquivTensorProduct A K L B).symm (k ⊗ₜ b) = k • (algebraMap _ _ b) := by have : k ⊗ₜ b = k • (1 ⊗ₜ b : K ⊗[A] B) := by simp [TensorProduct.smul_tmul'] rw [this, LinearEquiv.map_smul, LinearEquivTensorProduct_symm_one_tmul] variable (M : Type*) [AddCommGroup M]... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | LinearEquivTensorProduct_symm_tmul | null |
linearEquivTensorProductModule : L ⊗[K] M ≃ₗ[A] B ⊗[A] M := let f₁ : L ⊗[K] M ≃ₗ[A] L ⊗[A] M := IsLocalization.moduleTensorEquiv (nonZeroDivisors A) K L M |>.restrictScalars A let f₂ : L ≃ₗ[A] B ⊗[A] K := LinearEquivTensorProduct A K L B |>.restrictScalars A |>.trans (TensorProduct.comm A K B) let f₃ : L ⊗[A] M ≃ₗ[A] (... | def | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | linearEquivTensorProductModule | /-- The canonical `A`-linear isomorphism `L ⊗ M ≅ B ⊗ M` for any `K`-module `M`. -/ |
linearEquivTensorProductModule_symm_tmul (b : B) (m : M) : (linearEquivTensorProductModule A K L B M).symm (b ⊗ₜ m) = (algebraMap B L b) ⊗ₜ m := by simp [linearEquivTensorProductModule, LinearEquivTensorProduct_symm_one_tmul] -- this proof breaks until someone PRs the simp lemmas in the import | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | linearEquivTensorProductModule_symm_tmul | null |
linearEquivTensorProductModule_tmul (b : B) (m : M) : (linearEquivTensorProductModule A K L B M) ((algebraMap B L b) ⊗ₜ m) = b ⊗ₜ m := by rw [← LinearEquiv.eq_symm_apply, linearEquivTensorProductModule_symm_tmul] | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | linearEquivTensorProductModule_tmul | null |
_root_.IsIntegralClosure.isLocalizedModule : IsLocalizedModule (nonZeroDivisors A) ((Algebra.linearMap B L).restrictScalars A) := by have hlocal := IsIntegralClosure.isLocalization A K L B rw [← isLocalizedModule_iff_isLocalization'] at hlocal exact { map_units x := by obtain ⟨x, hx⟩ := x simpa only [← IsScalarTower.al... | lemma | FLT | [
"import FLT.Mathlib.RingTheory.Localization.BaseChange -- removing this breaks a simp proof",
"import Mathlib.Algebra.Group.Int.TypeTags",
"import Mathlib.NumberTheory.RamificationInertia.Basic",
"import Mathlib.RingTheory.DedekindDomain.AdicValuation",
"import Mathlib.RingTheory.DedekindDomain.IntegralClos... | FLT/DedekindDomain/IntegralClosure.lean | _root_.IsIntegralClosure.isLocalizedModule | null |
IsLocalProartinianAlgebra (R : Type u) [CommRing R] [TopologicalSpace R] [Algebra 𝓞 R] : Prop extends IsTopologicalRing R, IsLocalRing R, IsProartinian R, IsLocalHom (algebraMap 𝓞 R), IsResidueAlgebra 𝓞 R section 𝓞_is_local -- if 𝓞 admits a local proartinian algebra then 𝓞 is itself local. | class | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | IsLocalProartinianAlgebra | /-- A local proartinian algebra is a topological ring that is local and proartinian,
and that the induced map on the residue fields is bijective. -/ |
ProartinianCat where /-- Underlying set of a `ProartinianCat` -/ carrier : Type u /-- ring structure of a `ProartinianCat` -/ [commRing : CommRing carrier] /-- topological space structure of a `ProartinianCat` -/ [topologicalSpace : TopologicalSpace carrier] /-- algebra structure of a `ProartinianCat` -/ [algebra : Alg... | structure | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | ProartinianCat | /-- The category of local proartinian algebras over `𝓞` with fixed residue field `𝕜`. -/ |
of (X : Type u) [CommRing X] [Algebra 𝓞 X] [TopologicalSpace X] [IsLocalProartinianAlgebra 𝓞 X] : ProartinianCat 𝓞 := ⟨X⟩ | abbrev | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | of | /-- Make a `ProartinianCat` from an unbundled algebra. -/ |
coe_of (X : Type u) [CommRing X] [Algebra 𝓞 X] [TopologicalSpace X] [IsLocalProartinianAlgebra 𝓞 X] : of 𝓞 X = X := rfl variable {𝓞} in /-- The type of morphisms in `ProartinianCat 𝓞`. -/ @[ext] | lemma | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | coe_of | /-- Make a `ProartinianCat` from an unbundled algebra. -/ |
Hom (A B : ProartinianCat 𝓞) where /-- The underlying algebra map. -/ hom : A →A[𝓞] B | structure | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | Hom | /-- The type of morphisms in `ProartinianCat 𝓞`. -/ |
ofHom {A B : Type u} [CommRing A] [Algebra 𝓞 A] [TopologicalSpace A] [IsLocalProartinianAlgebra 𝓞 A] [CommRing B] [Algebra 𝓞 B] [TopologicalSpace B] [IsLocalProartinianAlgebra 𝓞 B] (f : A →A[𝓞] B) : of 𝓞 A ⟶ of 𝓞 B := ⟨f⟩ variable {𝓞} variable {X Y Z : Type u} [CommRing X] [Algebra 𝓞 X] [TopologicalSpace X] [I... | abbrev | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | ofHom | /-- Typecheck an `ContinuousAlgHom` as a morphism in `ProartinianCat`. -/ |
hom_id : (𝟙 A :).hom = ContinuousAlgHom.id 𝓞 A := rfl | lemma | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | hom_id | null |
id_apply (x) : (𝟙 A :).hom x = x := rfl @[simp] | lemma | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | id_apply | null |
hom_comp (f : A ⟶ B) (g : B ⟶ C) : (f ≫ g).hom = g.hom.comp f.hom := rfl | lemma | FLT | [
"import FLT.Deformations.IsProartinian",
"import FLT.Deformations.IsResidueAlgebra",
"import Mathlib.Topology.Algebra.Algebra.Equiv"
] | FLT/Deformations/Categories.lean | hom_comp | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.