statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
dvd_of_mem_factors' {a : α} {p : associates α} {hp : irreducible p} {hz : a ≠ 0}
(h_mem : subtype.mk p hp ∈ factors' a) : p ∣ associates.mk a | by { haveI := classical.dec_eq (associates α),
apply @dvd_of_mem_factors _ _ _ _ _ _ _ _ hp,
rw factors_mk _ hz,
apply mem_factor_set_some.2 h_mem } | lemma | associates.dvd_of_mem_factors' | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.mk",
"classical.dec_eq",
"irreducible"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_factors'_of_dvd {a p : α} (ha0 : a ≠ 0) (hp : irreducible p) (hd : p ∣ a) :
subtype.mk (associates.mk p) ((irreducible_mk _).2 hp) ∈ factors' a | begin
obtain ⟨q, hq, hpq⟩ := exists_mem_factors_of_dvd ha0 hp hd,
apply multiset.mem_pmap.mpr, use q, use hq,
exact subtype.eq (eq.symm (mk_eq_mk_iff_associated.mpr hpq))
end | lemma | associates.mem_factors'_of_dvd | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.mk",
"irreducible"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_factors'_iff_dvd {a p : α} (ha0 : a ≠ 0) (hp : irreducible p) :
subtype.mk (associates.mk p) ((irreducible_mk _).2 hp) ∈ factors' a ↔ p ∣ a | begin
split,
{ rw ← mk_dvd_mk, apply dvd_of_mem_factors', apply ha0 },
{ apply mem_factors'_of_dvd ha0 }
end | lemma | associates.mem_factors'_iff_dvd | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.mk",
"irreducible"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_factors_of_dvd {a p : α} (ha0 : a ≠ 0) (hp : irreducible p) (hd : p ∣ a) :
(associates.mk p) ∈ factors (associates.mk a) | begin
rw factors_mk _ ha0, exact mem_factor_set_some.mpr (mem_factors'_of_dvd ha0 hp hd)
end | lemma | associates.mem_factors_of_dvd | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.mk",
"irreducible"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_factors_iff_dvd {a p : α} (ha0 : a ≠ 0) (hp : irreducible p) :
(associates.mk p) ∈ factors (associates.mk a) ↔ p ∣ a | begin
split,
{ rw ← mk_dvd_mk, apply dvd_of_mem_factors, exact (irreducible_mk p).mpr hp },
{ apply mem_factors_of_dvd ha0 hp }
end | lemma | associates.mem_factors_iff_dvd | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.mk",
"irreducible"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exists_prime_dvd_of_not_inf_one {a b : α}
(ha : a ≠ 0) (hb : b ≠ 0) (h : (associates.mk a) ⊓ (associates.mk b) ≠ 1) :
∃ (p : α), prime p ∧ p ∣ a ∧ p ∣ b | begin
have hz : (factors (associates.mk a)) ⊓ (factors (associates.mk b)) ≠ 0,
{ contrapose! h with hf,
change ((factors (associates.mk a)) ⊓ (factors (associates.mk b))).prod = 1,
rw hf,
exact multiset.prod_zero },
rw [factors_mk a ha, factors_mk b hb, ← with_top.coe_inf] at hz,
obtain ⟨⟨p0, p0_irr... | lemma | associates.exists_prime_dvd_of_not_inf_one | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.mk",
"multiset.exists_mem_of_ne_zero",
"multiset.inf_eq_inter",
"multiset.prod_zero",
"prime",
"with_top.coe_inf"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coprime_iff_inf_one {a b : α} (ha0 : a ≠ 0) (hb0 : b ≠ 0) :
(associates.mk a) ⊓ (associates.mk b) = 1 ↔ ∀ {d : α}, d ∣ a → d ∣ b → ¬ prime d | begin
split,
{ intros hg p ha hb hp,
refine ((associates.prime_mk _).mpr hp).not_unit (is_unit_of_dvd_one _ _),
rw ← hg,
exact le_inf (mk_le_mk_of_dvd ha) (mk_le_mk_of_dvd hb) },
{ contrapose,
intros hg hc,
obtain ⟨p, hp, hpa, hpb⟩ := exists_prime_dvd_of_not_inf_one ha0 hb0 hg,
exact hc hp... | theorem | associates.coprime_iff_inf_one | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.mk",
"associates.prime_mk",
"is_unit_of_dvd_one",
"le_inf",
"prime"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
factors_self [nontrivial α] {p : associates α} (hp : irreducible p) :
p.factors = some ({⟨p, hp⟩}) | eq_of_prod_eq_prod (by rw [factors_prod, factor_set.prod, map_singleton, prod_singleton,
subtype.coe_mk]) | theorem | associates.factors_self | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"nontrivial",
"subtype.coe_mk"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
factors_prime_pow [nontrivial α] {p : associates α} (hp : irreducible p)
(k : ℕ) : factors (p ^ k) = some (multiset.replicate k ⟨p, hp⟩) | eq_of_prod_eq_prod (by rw [associates.factors_prod, factor_set.prod, multiset.map_replicate,
multiset.prod_replicate, subtype.coe_mk]) | theorem | associates.factors_prime_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.factors_prod",
"irreducible",
"multiset.map_replicate",
"multiset.prod_replicate",
"multiset.replicate",
"nontrivial",
"subtype.coe_mk"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prime_pow_dvd_iff_le [nontrivial α] {m p : associates α} (h₁ : m ≠ 0)
(h₂ : irreducible p) {k : ℕ} : p ^ k ≤ m ↔ k ≤ count p m.factors | begin
obtain ⟨a, nz, rfl⟩ := associates.exists_non_zero_rep h₁,
rw [factors_mk _ nz, ← with_top.some_eq_coe, count_some, multiset.le_count_iff_replicate_le,
← factors_le, factors_prime_pow h₂, factors_mk _ nz],
exact with_top.coe_le_coe
end | theorem | associates.prime_pow_dvd_iff_le | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.exists_non_zero_rep",
"irreducible",
"multiset.le_count_iff_replicate_le",
"nontrivial",
"with_top.coe_le_coe",
"with_top.some_eq_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_of_count_ne_zero {m p : associates α} (h0 : m ≠ 0)
(hp : irreducible p) : count p m.factors ≠ 0 → p ≤ m | begin
nontriviality α,
rw [← pos_iff_ne_zero],
intro h,
rw [← pow_one p],
apply (prime_pow_dvd_iff_le h0 hp).2,
simpa only
end | theorem | associates.le_of_count_ne_zero | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"pow_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_ne_zero_iff_dvd {a p : α} (ha0 : a ≠ 0) (hp : irreducible p) :
(associates.mk p).count (associates.mk a).factors ≠ 0 ↔ p ∣ a | begin
nontriviality α,
rw ← associates.mk_le_mk_iff_dvd_iff,
refine ⟨λ h, associates.le_of_count_ne_zero (associates.mk_ne_zero.mpr ha0)
((associates.irreducible_mk p).mpr hp) h, λ h, _⟩,
{ rw [← pow_one (associates.mk p), associates.prime_pow_dvd_iff_le
(associates.mk_ne_zero.mpr ha0) ((associates.ir... | theorem | associates.count_ne_zero_iff_dvd | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates.irreducible_mk",
"associates.le_of_count_ne_zero",
"associates.mk",
"associates.mk_le_mk_iff_dvd_iff",
"associates.prime_pow_dvd_iff_le",
"irreducible",
"pow_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_self [nontrivial α] {p : associates α} (hp : irreducible p) :
p.count p.factors = 1 | by simp [factors_self hp, associates.count_some hp] | theorem | associates.count_self | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.count_some",
"irreducible",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_eq_zero_of_ne {p q : associates α} (hp : irreducible p) (hq : irreducible q)
(h : p ≠ q) : p.count q.factors = 0 | not_ne_iff.mp $ λ h', h $ associated_iff_eq.mp $ hp.associated_of_dvd hq $
by { nontriviality α, exact le_of_count_ne_zero hq.ne_zero hp h' } | lemma | associates.count_eq_zero_of_ne | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_mul {a : associates α} (ha : a ≠ 0) {b : associates α} (hb : b ≠ 0)
{p : associates α} (hp : irreducible p) :
count p (factors (a * b)) = count p a.factors + count p b.factors | begin
obtain ⟨a0, nza, ha'⟩ := exists_non_zero_rep ha,
obtain ⟨b0, nzb, hb'⟩ := exists_non_zero_rep hb,
rw [factors_mul, ← ha', ← hb', factors_mk a0 nza, factors_mk b0 nzb, ← factor_set.coe_add,
← with_top.some_eq_coe, ← with_top.some_eq_coe, ← with_top.some_eq_coe, count_some hp,
multiset.count_add, ... | theorem | associates.count_mul | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"multiset.count_add",
"with_top.some_eq_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_of_coprime {a : associates α} (ha : a ≠ 0) {b : associates α}
(hb : b ≠ 0)
(hab : ∀ d, d ∣ a → d ∣ b → ¬ prime d) {p : associates α} (hp : irreducible p) :
count p a.factors = 0 ∨ count p b.factors = 0 | begin
rw [or_iff_not_imp_left, ← ne.def],
intro hca,
contrapose! hab with hcb,
exact ⟨p, le_of_count_ne_zero ha hp hca, le_of_count_ne_zero hb hp hcb,
(irreducible_iff_prime.mp hp)⟩,
end | theorem | associates.count_of_coprime | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"or_iff_not_imp_left",
"prime"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_mul_of_coprime {a : associates α} {b : associates α}
(hb : b ≠ 0)
{p : associates α} (hp : irreducible p) (hab : ∀ d, d ∣ a → d ∣ b → ¬ prime d) :
count p a.factors = 0 ∨ count p a.factors = count p (a * b).factors | begin
by_cases ha : a = 0,
{ simp [ha], },
cases count_of_coprime ha hb hab hp with hz hb0, { tauto },
apply or.intro_right,
rw [count_mul ha hb hp, hb0, add_zero]
end | theorem | associates.count_mul_of_coprime | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"prime"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_mul_of_coprime' {a b : associates α}
{p : associates α} (hp : irreducible p) (hab : ∀ d, d ∣ a → d ∣ b → ¬ prime d) :
count p (a * b).factors = count p a.factors
∨ count p (a * b).factors = count p b.factors | begin
by_cases ha : a = 0, { simp [ha], },
by_cases hb : b = 0, { simp [hb], },
rw [count_mul ha hb hp],
cases count_of_coprime ha hb hab hp with ha0 hb0,
{ apply or.intro_right, rw [ha0, zero_add] },
{ apply or.intro_left, rw [hb0, add_zero] }
end | theorem | associates.count_mul_of_coprime' | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"prime"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
dvd_count_of_dvd_count_mul {a b : associates α} (hb : b ≠ 0)
{p : associates α} (hp : irreducible p) (hab : ∀ d, d ∣ a → d ∣ b → ¬ prime d)
{k : ℕ} (habk : k ∣ count p (a * b).factors) : k ∣ count p a.factors | begin
by_cases ha : a = 0, { simpa [*] using habk, },
cases count_of_coprime ha hb hab hp with hz h,
{ rw hz, exact dvd_zero k },
{ rw [count_mul ha hb hp, h] at habk, exact habk }
end | theorem | associates.dvd_count_of_dvd_count_mul | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"dvd_zero",
"irreducible",
"prime"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
factors_one [nontrivial α] : factors (1 : associates α) = 0 | begin
apply eq_of_prod_eq_prod,
rw associates.factors_prod,
exact multiset.prod_zero,
end | lemma | associates.factors_one | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.factors_prod",
"multiset.prod_zero",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pow_factors [nontrivial α] {a : associates α} {k : ℕ} :
(a ^ k).factors = k • a.factors | begin
induction k with n h,
{ rw [zero_nsmul, pow_zero], exact factors_one },
{ rw [pow_succ, succ_nsmul, factors_mul, h] }
end | theorem | associates.pow_factors | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"nontrivial",
"pow_succ",
"pow_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_pow [nontrivial α] {a : associates α} (ha : a ≠ 0) {p : associates α}
(hp : irreducible p)
(k : ℕ) : count p (a ^ k).factors = k * count p a.factors | begin
induction k with n h,
{ rw [pow_zero, factors_one, zero_mul, count_zero hp] },
{ rw [pow_succ, count_mul ha (pow_ne_zero _ ha) hp, h, nat.succ_eq_add_one], ring }
end | lemma | associates.count_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"nontrivial",
"pow_ne_zero",
"pow_succ",
"pow_zero",
"ring",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
dvd_count_pow [nontrivial α] {a : associates α} (ha : a ≠ 0) {p : associates α}
(hp : irreducible p)
(k : ℕ) : k ∣ count p (a ^ k).factors | by { rw count_pow ha hp, apply dvd_mul_right } | theorem | associates.dvd_count_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"dvd_mul_right",
"irreducible",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pow_of_dvd_count [nontrivial α] {a : associates α} (ha : a ≠ 0) {k : ℕ}
(hk : ∀ (p : associates α) (hp : irreducible p), k ∣ count p a.factors) :
∃ (b : associates α), a = b ^ k | begin
obtain ⟨a0, hz, rfl⟩ := exists_non_zero_rep ha,
rw [factors_mk a0 hz] at hk,
have hk' : ∀ p, p ∈ (factors' a0) → k ∣ (factors' a0).count p,
{ rintros p -,
have pp : p = ⟨p.val, p.2⟩, { simp only [subtype.coe_eta, subtype.val_eq_coe] },
rw [pp, ← count_some p.2], exact hk p.val p.2 },
obtain ⟨u, ... | theorem | associates.is_pow_of_dvd_count | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"multiset.exists_smul_of_dvd_count",
"nontrivial",
"subtype.coe_eta",
"subtype.val_eq_coe",
"with_bot.coe_nsmul",
"with_top.some_eq_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_pow_count_factors_of_dvd_pow {p a : associates α} (hp : irreducible p)
{n : ℕ} (h : a ∣ p ^ n) : a = p ^ p.count a.factors | begin
nontriviality α,
have hph := pow_ne_zero n hp.ne_zero,
have ha := ne_zero_of_dvd_ne_zero hph h,
apply eq_of_eq_counts ha (pow_ne_zero _ hp.ne_zero),
have eq_zero_of_ne : ∀ (q : associates α), irreducible q → q ≠ p → _ = 0 :=
λ q hq h', nat.eq_zero_of_le_zero $ by
{ convert count_le_count_of_le hph h... | theorem | associates.eq_pow_count_factors_of_dvd_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"mul_one",
"mul_zero",
"ne_zero_of_dvd_ne_zero",
"pow_ne_zero"
] | The only divisors of prime powers are prime powers. See `eq_pow_find_of_dvd_irreducible_pow`
for an explicit expression as a p-power (without using `count`). | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
count_factors_eq_find_of_dvd_pow {a p : associates α} (hp : irreducible p)
[∀ n : ℕ, decidable (a ∣ p ^ n)] {n : ℕ} (h : a ∣ p ^ n) : nat.find ⟨n, h⟩ = p.count a.factors | begin
apply le_antisymm,
{ refine nat.find_le ⟨1, _⟩, rw mul_one, symmetry, exact eq_pow_count_factors_of_dvd_pow hp h },
{ have hph := pow_ne_zero (nat.find ⟨n, h⟩) hp.ne_zero,
casesI (subsingleton_or_nontrivial α) with hα hα,
{ simpa using hph, },
convert count_le_count_of_le hph hp (nat.find_spec ⟨... | lemma | associates.count_factors_eq_find_of_dvd_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible",
"mul_one",
"nat.find_le",
"pow_ne_zero",
"subsingleton_or_nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_pow_of_mul_eq_pow [nontrivial α] {a b c : associates α} (ha : a ≠ 0) (hb : b ≠ 0)
(hab : ∀ d, d ∣ a → d ∣ b → ¬ prime d) {k : ℕ} (h : a * b = c ^ k) :
∃ (d : associates α), a = d ^ k | begin
classical,
by_cases hk0 : k = 0,
{ use 1,
rw [hk0, pow_zero] at h ⊢,
apply (mul_eq_one_iff.1 h).1 },
{ refine is_pow_of_dvd_count ha _,
intros p hp,
apply dvd_count_of_dvd_count_mul hb hp hab,
rw h,
apply dvd_count_pow _ hp,
rintros rfl,
rw zero_pow' _ hk0 at h,
cases m... | theorem | associates.eq_pow_of_mul_eq_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"nontrivial",
"pow_zero",
"prime",
"zero_pow'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_pow_find_of_dvd_irreducible_pow {a p : associates α} (hp : irreducible p)
[∀ n : ℕ, decidable (a ∣ p ^ n)] {n : ℕ} (h : a ∣ p ^ n) : a = p ^ nat.find ⟨n, h⟩ | by { classical, rw [count_factors_eq_find_of_dvd_pow hp, ← eq_pow_count_factors_of_dvd_pow hp h] } | theorem | associates.eq_pow_find_of_dvd_irreducible_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"irreducible"
] | The only divisors of prime powers are prime powers. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
associates.quot_out {α : Type*} [comm_monoid α] (a : associates α):
associates.mk (quot.out (a)) = a | by rw [←quot_mk_eq_mk, quot.out_eq] | lemma | associates.quot_out | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.mk",
"comm_monoid",
"quot.out",
"quot.out_eq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
unique_factorization_monoid.to_gcd_monoid
(α : Type*) [cancel_comm_monoid_with_zero α] [unique_factorization_monoid α]
[decidable_eq (associates α)] [decidable_eq α] : gcd_monoid α | { gcd := λa b, quot.out (associates.mk a ⊓ associates.mk b : associates α),
lcm := λa b, quot.out (associates.mk a ⊔ associates.mk b : associates α),
gcd_dvd_left := λ a b, by
{ rw [←mk_dvd_mk, (associates.mk a ⊓ associates.mk b).quot_out, dvd_eq_le],
exact inf_le_left },
gcd_dvd_right := λ a b, by
{ rw [... | def | unique_factorization_monoid.to_gcd_monoid | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.mk",
"associates.mk_mul_mk",
"associates.quot_out",
"cancel_comm_monoid_with_zero",
"gcd_monoid",
"gcd_mul_lcm",
"inf_le_left",
"inf_le_right",
"le_inf_iff",
"mul_comm",
"quot.out",
"sup_top_eq",
"top_sup_eq",
"unique_factorization_monoid"
] | `to_gcd_monoid` constructs a GCD monoid out of a unique factorization domain. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
unique_factorization_monoid.to_normalized_gcd_monoid
(α : Type*) [cancel_comm_monoid_with_zero α] [unique_factorization_monoid α]
[normalization_monoid α] [decidable_eq (associates α)] [decidable_eq α] :
normalized_gcd_monoid α | { gcd := λa b, (associates.mk a ⊓ associates.mk b).out,
lcm := λa b, (associates.mk a ⊔ associates.mk b).out,
gcd_dvd_left := assume a b, (out_dvd_iff a (associates.mk a ⊓ associates.mk b)).2 $ inf_le_left,
gcd_dvd_right := assume a b, (out_dvd_iff b (associates.mk a ⊓ associates.mk b)).2 $ inf_le_right,
dvd_gc... | def | unique_factorization_monoid.to_normalized_gcd_monoid | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"associates.mk",
"cancel_comm_monoid_with_zero",
"gcd_mul_lcm",
"inf_le_left",
"inf_le_right",
"le_inf_iff",
"mul_comm",
"normalization_monoid",
"normalize_associated",
"normalize_gcd",
"normalize_lcm",
"normalized_gcd_monoid",
"unique_factorization_monoid"
] | `to_normalized_gcd_monoid` constructs a GCD monoid out of a normalization on a
unique factorization domain. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
fintype_subtype_dvd {M : Type*} [cancel_comm_monoid_with_zero M]
[unique_factorization_monoid M] [fintype Mˣ]
(y : M) (hy : y ≠ 0) :
fintype {x // x ∣ y} | begin
haveI : nontrivial M := ⟨⟨y, 0, hy⟩⟩,
haveI : normalization_monoid M := unique_factorization_monoid.normalization_monoid,
haveI := classical.dec_eq M,
haveI := classical.dec_eq (associates M),
-- We'll show `λ (u : Mˣ) (f ⊆ factors y) → u * Π f` is injective
-- and has image exactly the divisors of `y... | def | unique_factorization_monoid.fintype_subtype_dvd | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associates",
"cancel_comm_monoid_with_zero",
"classical.dec_eq",
"eq_zero_of_zero_dvd",
"exists_eq_right",
"exists_prop",
"finset",
"finset.mem_image",
"finset.mem_product",
"finset.mem_univ",
"finset.univ",
"fintype",
"fintype.of_finset",
"mul_comm",
"multiset.dvd_prod",
"multiset.me... | If `y` is a nonzero element of a unique factorization monoid with finitely
many units (e.g. `ℤ`, `ideal (ring_of_integers K)`), it has finitely many divisors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
factorization (n : α) : α →₀ ℕ | (normalized_factors n).to_finsupp | def | factorization | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [] | This returns the multiset of irreducible factors as a `finsupp` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
factorization_eq_count {n p : α} :
factorization n p = multiset.count p (normalized_factors n) | by simp [factorization] | lemma | factorization_eq_count | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"factorization",
"multiset.count"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
factorization_zero : factorization (0 : α) = 0 | by simp [factorization] | lemma | factorization_zero | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"factorization"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
factorization_one : factorization (1 : α) = 0 | by simp [factorization] | lemma | factorization_one | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"factorization"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
support_factorization {n : α} :
(factorization n).support = (normalized_factors n).to_finset | by simp [factorization, multiset.to_finsupp_support] | lemma | support_factorization | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"factorization",
"multiset.to_finsupp_support"
] | The support of `factorization n` is exactly the finset of normalized factors | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
factorization_mul {a b : α} (ha : a ≠ 0) (hb : b ≠ 0) :
factorization (a * b) = factorization a + factorization b | by simp [factorization, normalized_factors_mul ha hb] | lemma | factorization_mul | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"factorization"
] | For nonzero `a` and `b`, the power of `p` in `a * b` is the sum of the powers in `a` and `b` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
factorization_pow {x : α} {n : ℕ} :
factorization (x^n) = n • factorization x | by { ext, simp [factorization] } | lemma | factorization_pow | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"factorization"
] | For any `p`, the power of `p` in `x^n` is `n` times the power in `x` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
associated_of_factorization_eq (a b: α) (ha: a ≠ 0) (hb: b ≠ 0)
(h: factorization a = factorization b) : associated a b | begin
simp_rw [factorization, add_equiv.apply_eq_iff_eq] at h,
rwa [associated_iff_normalized_factors_eq_normalized_factors ha hb],
end | lemma | associated_of_factorization_eq | ring_theory | src/ring_theory/unique_factorization_domain.lean | [
"algebra.big_operators.associated",
"algebra.gcd_monoid.basic",
"data.finsupp.multiset",
"ring_theory.noetherian",
"ring_theory.multiplicity"
] | [
"associated",
"factorization"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_reduced_zmod {n : ℕ} : is_reduced (zmod n) ↔ squarefree n ∨ n = 0 | by rw [← ring_hom.ker_is_radical_iff_reduced_of_surjective
(zmod.ring_hom_surjective $ int.cast_ring_hom $ zmod n),
zmod.ker_int_cast_ring_hom, ← is_radical_iff_span_singleton,
is_radical_iff_squarefree_or_zero, int.squarefree_coe_nat, nat.cast_eq_zero] | lemma | is_reduced_zmod | ring_theory | src/ring_theory/zmod.lean | [
"algebra.squarefree",
"data.zmod.basic",
"ring_theory.int.basic"
] | [
"int.cast_ring_hom",
"int.squarefree_coe_nat",
"is_radical_iff_span_singleton",
"is_radical_iff_squarefree_or_zero",
"is_reduced",
"nat.cast_eq_zero",
"ring_hom.ker_is_radical_iff_reduced_of_surjective",
"squarefree",
"zmod",
"zmod.ker_int_cast_ring_hom",
"zmod.ring_hom_surjective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
subset_adjoin : s ⊆ adjoin R s | algebra.gc.le_u_l s | theorem | algebra.subset_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_le {S : subalgebra R A} (H : s ⊆ S) : adjoin R s ≤ S | algebra.gc.l_le H | theorem | algebra.adjoin_le | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_eq_Inf : adjoin R s = Inf {p | s ⊆ p} | le_antisymm (le_Inf (λ _ h, adjoin_le h)) (Inf_le subset_adjoin) | lemma | algebra.adjoin_eq_Inf | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"Inf_le",
"le_Inf"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_le_iff {S : subalgebra R A} : adjoin R s ≤ S ↔ s ⊆ S | algebra.gc _ _ | theorem | algebra.adjoin_le_iff | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.gc",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_mono (H : s ⊆ t) : adjoin R s ≤ adjoin R t | algebra.gc.monotone_l H | theorem | algebra.adjoin_mono | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_eq_of_le (S : subalgebra R A) (h₁ : s ⊆ S) (h₂ : S ≤ adjoin R s) : adjoin R s = S | le_antisymm (adjoin_le h₁) h₂ | theorem | algebra.adjoin_eq_of_le | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_eq (S : subalgebra R A) : adjoin R ↑S = S | adjoin_eq_of_le _ (set.subset.refl _) subset_adjoin | theorem | algebra.adjoin_eq | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"set.subset.refl",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_Union {α : Type*} (s : α → set A) :
adjoin R (set.Union s) = ⨆ (i : α), adjoin R (s i) | (@algebra.gc R A _ _ _).l_supr | lemma | algebra.adjoin_Union | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.gc",
"set.Union"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_attach_bUnion [decidable_eq A] {α : Type*} {s : finset α} (f : s → finset A) :
adjoin R (s.attach.bUnion f : set A) = ⨆ x, adjoin R (f x) | by simpa [adjoin_Union] | lemma | algebra.adjoin_attach_bUnion | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_induction {p : A → Prop} {x : A} (h : x ∈ adjoin R s)
(Hs : ∀ x ∈ s, p x)
(Halg : ∀ r, p (algebra_map R A r))
(Hadd : ∀ x y, p x → p y → p (x + y))
(Hmul : ∀ x y, p x → p y → p (x * y)) : p x | let S : subalgebra R A :=
{ carrier := p, mul_mem' := Hmul, add_mem' := Hadd, algebra_map_mem' := Halg } in
adjoin_le (show s ≤ S, from Hs) h | theorem | algebra.adjoin_induction | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra_map",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_induction₂ {p : A → A → Prop} {a b : A} (ha : a ∈ adjoin R s) (hb : b ∈ adjoin R s)
(Hs : ∀ (x ∈ s) (y ∈ s), p x y)
(Halg : ∀ r₁ r₂, p (algebra_map R A r₁) (algebra_map R A r₂))
(Halg_left : ∀ r (x ∈ s), p (algebra_map R A r) x)
(Halg_right : ∀ r (x ∈ s), p x (algebra_map R A r))
(Hadd_left : ∀ x₁ x₂ y... | begin
refine adjoin_induction hb _ (λ r, _) (Hadd_right a) (Hmul_right a),
{ exact adjoin_induction ha Hs Halg_left (λ x y Hx Hy z hz, Hadd_left x y z (Hx z hz) (Hy z hz))
(λ x y Hx Hy z hz, Hmul_left x y z (Hx z hz) (Hy z hz)) },
{ exact adjoin_induction ha (Halg_right r) (λ r', Halg r' r)
(λ x y, Ha... | lemma | algebra.adjoin_induction₂ | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra_map"
] | Induction principle for the algebra generated by a set `s`: show that `p x y` holds for any
`x y ∈ adjoin R s` given that that it holds for `x y ∈ s` and that it satisfies a number of
natural properties. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
adjoin_induction' {p : adjoin R s → Prop} (Hs : ∀ x (h : x ∈ s), p ⟨x, subset_adjoin h⟩)
(Halg : ∀ r, p (algebra_map R _ r)) (Hadd : ∀ x y, p x → p y → p (x + y))
(Hmul : ∀ x y, p x → p y → p (x * y)) (x : adjoin R s) : p x | subtype.rec_on x $ λ x hx, begin
refine exists.elim _ (λ (hx : x ∈ adjoin R s) (hc : p ⟨x, hx⟩), hc),
exact adjoin_induction hx (λ x hx, ⟨subset_adjoin hx, Hs x hx⟩)
(λ r, ⟨subalgebra.algebra_map_mem _ r, Halg r⟩)
(λ x y hx hy, exists.elim hx $ λ hx' hx, exists.elim hy $ λ hy' hy,
⟨subalgebra.add_mem _ ... | lemma | algebra.adjoin_induction' | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra_map"
] | The difference with `algebra.adjoin_induction` is that this acts on the subtype. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
adjoin_adjoin_coe_preimage {s : set A} :
adjoin R ((coe : adjoin R s → A) ⁻¹' s) = ⊤ | begin
refine eq_top_iff.2 (λ x, adjoin_induction' (λ a ha, _) (λ r, _) (λ _ _, _) (λ _ _, _) x),
{ exact subset_adjoin ha },
{ exact subalgebra.algebra_map_mem _ r },
{ exact subalgebra.add_mem _ },
{ exact subalgebra.mul_mem _ }
end | lemma | algebra.adjoin_adjoin_coe_preimage | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"subalgebra.add_mem",
"subalgebra.algebra_map_mem",
"subalgebra.mul_mem"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_union (s t : set A) : adjoin R (s ∪ t) = adjoin R s ⊔ adjoin R t | (algebra.gc : galois_connection _ (coe : subalgebra R A → set A)).l_sup | lemma | algebra.adjoin_union | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.gc",
"galois_connection",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_empty : adjoin R (∅ : set A) = ⊥ | show adjoin R ⊥ = ⊥, by { apply galois_connection.l_bot, exact algebra.gc } | theorem | algebra.adjoin_empty | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.gc",
"galois_connection.l_bot"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_univ : adjoin R (set.univ : set A) = ⊤ | eq_top_iff.2 $ λ x, subset_adjoin $ set.mem_univ _ | theorem | algebra.adjoin_univ | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"set.mem_univ"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_eq_span : (adjoin R s).to_submodule = span R (submonoid.closure s) | begin
apply le_antisymm,
{ intros r hr, rcases subsemiring.mem_closure_iff_exists_list.1 hr with ⟨L, HL, rfl⟩, clear hr,
induction L with hd tl ih, { exact zero_mem _ },
rw list.forall_mem_cons at HL,
rw [list.map_cons, list.sum_cons],
refine submodule.add_mem _ _ (ih HL.2),
replace HL := HL.1, ... | theorem | algebra.adjoin_eq_span | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.smul_def",
"algebra_map",
"ih",
"list.forall_mem_cons",
"list.prod",
"list.prod_cons",
"map_mul",
"mul_smul_comm",
"one_smul",
"submodule.add_mem",
"submonoid.closure",
"submonoid.mul_mem",
"submonoid.subset_closure"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
span_le_adjoin (s : set A) : span R s ≤ (adjoin R s).to_submodule | span_le.mpr subset_adjoin | lemma | algebra.span_le_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_to_submodule_le {s : set A} {t : submodule R A} :
(adjoin R s).to_submodule ≤ t ↔ ↑(submonoid.closure s) ⊆ (t : set A) | by rw [adjoin_eq_span, span_le] | lemma | algebra.adjoin_to_submodule_le | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"submodule",
"submonoid.closure"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_eq_span_of_subset {s : set A} (hs : ↑(submonoid.closure s) ⊆ (span R s : set A)) :
(adjoin R s).to_submodule = span R s | le_antisymm ((adjoin_to_submodule_le R).mpr hs) (span_le_adjoin R s) | lemma | algebra.adjoin_eq_span_of_subset | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"submonoid.closure"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_span {s : set A} :
adjoin R (submodule.span R s : set A) = adjoin R s | le_antisymm (adjoin_le (span_le_adjoin _ _)) (adjoin_mono submodule.subset_span) | lemma | algebra.adjoin_span | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"submodule.span",
"submodule.subset_span"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_image (f : A →ₐ[R] B) (s : set A) :
adjoin R (f '' s) = (adjoin R s).map f | le_antisymm (adjoin_le $ set.image_subset _ subset_adjoin) $
subalgebra.map_le.2 $ adjoin_le $ set.image_subset_iff.1 subset_adjoin | lemma | algebra.adjoin_image | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"set.image_subset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_insert_adjoin (x : A) :
adjoin R (insert x ↑(adjoin R s)) = adjoin R (insert x s) | le_antisymm
(adjoin_le (set.insert_subset.mpr
⟨subset_adjoin (set.mem_insert _ _), adjoin_mono (set.subset_insert _ _)⟩))
(algebra.adjoin_mono (set.insert_subset_insert algebra.subset_adjoin)) | lemma | algebra.adjoin_insert_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.adjoin_mono",
"algebra.subset_adjoin",
"set.insert_subset_insert",
"set.mem_insert",
"set.subset_insert"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_prod_le (s : set A) (t : set B) :
adjoin R (s ×ˢ t) ≤ (adjoin R s).prod (adjoin R t) | adjoin_le $ set.prod_mono subset_adjoin subset_adjoin | lemma | algebra.adjoin_prod_le | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"set.prod_mono"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_adjoin_of_map_mul {s} {x : A} {f : A →ₗ[R] B} (hf : ∀ a₁ a₂, f(a₁ * a₂) = f a₁ * f a₂)
(h : x ∈ adjoin R s) : f x ∈ adjoin R (f '' (s ∪ {1})) | begin
refine @adjoin_induction R A _ _ _ _ (λ a, f a ∈ adjoin R (f '' (s ∪ {1}))) x h
(λ a ha, subset_adjoin ⟨a, ⟨set.subset_union_left _ _ ha, rfl⟩⟩)
(λ r, _)
(λ y z hy hz, by simpa [hy, hz] using subalgebra.add_mem _ hy hz)
(λ y z hy hz, by simpa [hy, hz, hf y z] using subalgebra.mul_mem _ hy hz),
... | lemma | algebra.mem_adjoin_of_map_mul | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"set.mem_singleton",
"subalgebra.add_mem",
"subalgebra.mul_mem",
"subalgebra.smul_mem"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_inl_union_inr_eq_prod (s) (t) :
adjoin R (linear_map.inl R A B '' (s ∪ {1}) ∪ linear_map.inr R A B '' (t ∪ {1})) =
(adjoin R s).prod (adjoin R t) | begin
apply le_antisymm,
{ simp only [adjoin_le_iff, set.insert_subset, subalgebra.zero_mem, subalgebra.one_mem,
subset_adjoin, -- the rest comes from `squeeze_simp`
set.union_subset_iff, linear_map.coe_inl, set.mk_preimage_prod_right,
set.image_subset_iff, set_like.mem_coe, set.mk_preimage_prod_l... | lemma | algebra.adjoin_inl_union_inr_eq_prod | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"linear_map.coe_inl",
"linear_map.coe_inr",
"linear_map.inl",
"linear_map.inl_map_mul",
"linear_map.inr",
"linear_map.inr_map_mul",
"set.image_subset_iff",
"set.insert_subset",
"set.mk_preimage_prod_left",
"set.mk_preimage_prod_right",
"set.subset_union_left",
"set.subset_union_right",
"set.... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_comm_semiring_of_comm {s : set A} (hcomm : ∀ (a ∈ s) (b ∈ s), a * b = b * a) :
comm_semiring (adjoin R s) | { mul_comm := λ x y,
begin
ext,
simp only [subalgebra.coe_mul],
exact adjoin_induction₂ x.prop y.prop
hcomm
(λ _ _, by rw [commutes])
(λ r x hx, commutes r x) (λ r x hx, (commutes r x).symm)
(λ _ _ _ h₁ h₂, by simp only [add_mul, mul_add, h₁, h₂])
(λ _ _ _ h₁ h₂, by simp only... | def | algebra.adjoin_comm_semiring_of_comm | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"comm_semiring",
"mul_assoc",
"mul_comm",
"subalgebra.coe_mul"
] | If all elements of `s : set A` commute pairwise, then `adjoin R s` is a commutative
semiring. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
adjoin_singleton_one : adjoin R ({1} : set A) = ⊥ | eq_bot_iff.2 $ adjoin_le $ set.singleton_subset_iff.2 $ set_like.mem_coe.2 $ one_mem _ | lemma | algebra.adjoin_singleton_one | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
self_mem_adjoin_singleton (x : A) : x ∈ adjoin R ({x} : set A) | algebra.subset_adjoin (set.mem_singleton_iff.mpr rfl) | lemma | algebra.self_mem_adjoin_singleton | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra.subset_adjoin"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_union_eq_adjoin_adjoin :
adjoin R (s ∪ t) = (adjoin (adjoin R s) t).restrict_scalars R | le_antisymm
(closure_mono $ set.union_subset
(set.range_subset_iff.2 $ λ r, or.inl ⟨algebra_map R (adjoin R s) r, rfl⟩)
(set.union_subset_union_left _ $ λ x hxs, ⟨⟨_, subset_adjoin hxs⟩, rfl⟩))
(closure_le.2 $ set.union_subset
(set.range_subset_iff.2 $ λ x, adjoin_mono (set.subset_union_left _ _) x.2)
... | theorem | algebra.adjoin_union_eq_adjoin_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"closure_mono",
"restrict_scalars",
"set.subset.trans",
"set.subset_union_left",
"set.subset_union_right",
"set.union_subset",
"set.union_subset_union_left"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_union_coe_submodule : (adjoin R (s ∪ t)).to_submodule =
(adjoin R s).to_submodule * (adjoin R t).to_submodule | begin
rw [adjoin_eq_span, adjoin_eq_span, adjoin_eq_span, span_mul_span],
congr' 1 with z, simp [submonoid.closure_union, submonoid.mem_sup, set.mem_mul]
end | theorem | algebra.adjoin_union_coe_submodule | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"set.mem_mul",
"submonoid.closure_union",
"submonoid.mem_sup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_adjoin_of_tower [semiring B] [algebra R B] [algebra A B] [is_scalar_tower R A B]
(s : set B) : adjoin A (adjoin R s : set B) = adjoin A s | begin
apply le_antisymm (adjoin_le _),
{ exact adjoin_mono subset_adjoin },
{ change adjoin R s ≤ (adjoin A s).restrict_scalars R,
refine adjoin_le _,
exact subset_adjoin }
end | lemma | algebra.adjoin_adjoin_of_tower | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra",
"is_scalar_tower",
"restrict_scalars",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pow_smul_mem_of_smul_subset_of_mem_adjoin
[comm_semiring B] [algebra R B] [algebra A B] [is_scalar_tower R A B]
(r : A) (s : set B) (B' : subalgebra R B) (hs : r • s ⊆ B') {x : B} (hx : x ∈ adjoin R s)
(hr : algebra_map A B r ∈ B') :
∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ B' | begin
change x ∈ (adjoin R s).to_submodule at hx,
rw [adjoin_eq_span, finsupp.mem_span_iff_total] at hx,
rcases hx with ⟨l, rfl : l.sum (λ (i : submonoid.closure s) (c : R), c • ↑i) = x⟩,
choose n₁ n₂ using (λ x : submonoid.closure s, submonoid.pow_smul_mem_closure_smul r s x.prop),
use l.support.sup n₁,
in... | lemma | algebra.pow_smul_mem_of_smul_subset_of_mem_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"finset.le_sup",
"finsupp.mem_span_iff_total",
"finsupp.smul_sum",
"is_scalar_tower",
"is_scalar_tower.algebra_map_smul",
"map_pow",
"mul_comm",
"pow_add",
"smul_smul",
"subalgebra",
"subalgebra.mul_mem",
"subalgebra.pow_mem",
"subalgebra.smul... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pow_smul_mem_adjoin_smul (r : R) (s : set A) {x : A} (hx : x ∈ adjoin R s) :
∃ n₀ : ℕ, ∀ n ≥ n₀, r ^ n • x ∈ adjoin R (r • s) | pow_smul_mem_of_smul_subset_of_mem_adjoin r s _ subset_adjoin hx (subalgebra.algebra_map_mem _ _) | lemma | algebra.pow_smul_mem_adjoin_smul | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"subalgebra.algebra_map_mem"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_int (s : set R) : adjoin ℤ s = subalgebra_of_subring (subring.closure s) | le_antisymm (adjoin_le subring.subset_closure)
(subring.closure_le.2 subset_adjoin : subring.closure s ≤ (adjoin ℤ s).to_subring) | theorem | algebra.adjoin_int | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"subalgebra_of_subring",
"subring.closure",
"subring.subset_closure"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_adjoin_iff {s : set A} {x : A} :
x ∈ adjoin R s ↔ x ∈ subring.closure (set.range (algebra_map R A) ∪ s) | ⟨λ hx, subsemiring.closure_induction hx subring.subset_closure (subring.zero_mem _)
(subring.one_mem _) (λ _ _, subring.add_mem _) ( λ _ _, subring.mul_mem _),
suffices subring.closure (set.range ⇑(algebra_map R A) ∪ s) ≤ (adjoin R s).to_subring,
from @this x, subring.closure_le.2 subsemiring.subset_closure⟩ | theorem | algebra.mem_adjoin_iff | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra_map",
"set.range",
"subring.add_mem",
"subring.closure",
"subring.mul_mem",
"subring.one_mem",
"subring.subset_closure",
"subring.zero_mem",
"subsemiring.closure_induction"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_eq_ring_closure (s : set A) :
(adjoin R s).to_subring = subring.closure (set.range (algebra_map R A) ∪ s) | subring.ext $ λ x, mem_adjoin_iff | theorem | algebra.adjoin_eq_ring_closure | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"algebra_map",
"set.range",
"subring.closure",
"subring.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_comm_ring_of_comm {s : set A} (hcomm : ∀ (a ∈ s) (b ∈ s), a * b = b * a) :
comm_ring (adjoin R s) | { ..(adjoin R s).to_ring,
..adjoin_comm_semiring_of_comm R hcomm } | def | algebra.adjoin_comm_ring_of_comm | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [
"comm_ring"
] | If all elements of `s : set A` commute pairwise, then `adjoin R s` is a commutative
ring. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_adjoin (φ : A →ₐ[R] B) (s : set A) :
(adjoin R s).map φ = adjoin R (φ '' s) | (adjoin_image _ _ _).symm | lemma | alg_hom.map_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_le_equalizer (φ₁ φ₂ : A →ₐ[R] B) {s : set A} (h : s.eq_on φ₁ φ₂) :
adjoin R s ≤ φ₁.equalizer φ₂ | adjoin_le h | lemma | alg_hom.adjoin_le_equalizer | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext_of_adjoin_eq_top {s : set A} (h : adjoin R s = ⊤) ⦃φ₁ φ₂ : A →ₐ[R] B⦄
(hs : s.eq_on φ₁ φ₂) : φ₁ = φ₂ | ext $ λ x, adjoin_le_equalizer φ₁ φ₂ hs $ h.symm ▸ trivial | lemma | alg_hom.ext_of_adjoin_eq_top | ring_theory.adjoin | src/ring_theory/adjoin/basic.lean | [
"algebra.algebra.operations",
"algebra.algebra.subalgebra.tower",
"linear_algebra.prod",
"linear_algebra.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_trans (h1 : (adjoin R s).to_submodule.fg)
(h2 : (adjoin (adjoin R s) t).to_submodule.fg) :
(adjoin R (s ∪ t)).to_submodule.fg | begin
rcases fg_def.1 h1 with ⟨p, hp, hp'⟩,
rcases fg_def.1 h2 with ⟨q, hq, hq'⟩,
refine fg_def.2 ⟨p * q, hp.mul hq, le_antisymm _ _⟩,
{ rw [span_le],
rintros _ ⟨x, y, hx, hy, rfl⟩,
change x * y ∈ _,
refine subalgebra.mul_mem _ _ _,
{ have : x ∈ (adjoin R s).to_submodule,
{ rw ← hp', exact... | theorem | algebra.fg_trans | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"finsupp.mem_span_image_iff_total",
"finsupp.sum_mul",
"finsupp.total_apply",
"set.image_id",
"set.subset_union_left",
"smul_mul_assoc",
"subalgebra.mul_mem"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg (S : subalgebra R A) : Prop | ∃ t : finset A, algebra.adjoin R ↑t = S | def | subalgebra.fg | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin",
"finset",
"subalgebra"
] | A subalgebra `S` is finitely generated if there exists `t : finset A` such that
`algebra.adjoin R t = S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
fg_adjoin_finset (s : finset A) : (algebra.adjoin R (↑s : set A)).fg | ⟨s, rfl⟩ | lemma | subalgebra.fg_adjoin_finset | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_def {S : subalgebra R A} : S.fg ↔ ∃ t : set A, set.finite t ∧ algebra.adjoin R t = S | iff.symm set.exists_finite_iff_finset | theorem | subalgebra.fg_def | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin",
"set.exists_finite_iff_finset",
"set.finite",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_bot : (⊥ : subalgebra R A).fg | ⟨∅, algebra.adjoin_empty R A⟩ | theorem | subalgebra.fg_bot | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin_empty",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_of_fg_to_submodule {S : subalgebra R A} : S.to_submodule.fg → S.fg | λ ⟨t, ht⟩, ⟨t, le_antisymm
(algebra.adjoin_le (λ x hx, show x ∈ S.to_submodule, from ht ▸ subset_span hx)) $
show S.to_submodule ≤ (algebra.adjoin R ↑t).to_submodule,
from (λ x hx, span_le.mpr
(λ x hx, algebra.subset_adjoin hx)
(show x ∈ span R ↑t, by { rw ht, exact hx }))⟩ | theorem | subalgebra.fg_of_fg_to_submodule | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin",
"algebra.adjoin_le",
"algebra.subset_adjoin",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_of_noetherian [is_noetherian R A] (S : subalgebra R A) : S.fg | fg_of_fg_to_submodule (is_noetherian.noetherian S.to_submodule) | theorem | subalgebra.fg_of_noetherian | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"is_noetherian",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_of_submodule_fg (h : (⊤ : submodule R A).fg) : (⊤ : subalgebra R A).fg | let ⟨s, hs⟩ := h in ⟨s, to_submodule.injective $
by { rw [algebra.top_to_submodule, eq_top_iff, ← hs, span_le], exact algebra.subset_adjoin }⟩ | lemma | subalgebra.fg_of_submodule_fg | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.subset_adjoin",
"algebra.top_to_submodule",
"eq_top_iff",
"subalgebra",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg.prod {S : subalgebra R A} {T : subalgebra R B} (hS : S.fg) (hT : T.fg) : (S.prod T).fg | begin
obtain ⟨s, hs⟩ := fg_def.1 hS,
obtain ⟨t, ht⟩ := fg_def.1 hT,
rw [← hs.2, ← ht.2],
exact fg_def.2 ⟨(linear_map.inl R A B '' (s ∪ {1})) ∪ (linear_map.inr R A B '' (t ∪ {1})),
set.finite.union (set.finite.image _ (set.finite.union hs.1 (set.finite_singleton _)))
(set.finite.image _ (set.finite.union... | lemma | subalgebra.fg.prod | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin_inl_union_inr_eq_prod",
"linear_map.inl",
"linear_map.inr",
"set.finite.image",
"set.finite.union",
"set.finite_singleton",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg.map {S : subalgebra R A} (f : A →ₐ[R] B) (hs : S.fg) : (S.map f).fg | let ⟨s, hs⟩ := hs in ⟨s.image f, by rw [finset.coe_image, algebra.adjoin_image, hs]⟩ | lemma | subalgebra.fg.map | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin_image",
"finset.coe_image",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_of_fg_map (S : subalgebra R A) (f : A →ₐ[R] B) (hf : function.injective f)
(hs : (S.map f).fg) : S.fg | let ⟨s, hs⟩ := hs in ⟨s.preimage f $ λ _ _ _ _ h, hf h, map_injective hf $
by { rw [← algebra.adjoin_image, finset.coe_preimage, set.image_preimage_eq_of_subset, hs],
rw [← alg_hom.coe_range, ← algebra.adjoin_le_iff, hs, ← algebra.map_top], exact map_mono le_top }⟩ | lemma | subalgebra.fg_of_fg_map | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"alg_hom.coe_range",
"algebra.adjoin_image",
"algebra.adjoin_le_iff",
"algebra.map_top",
"finset.coe_preimage",
"le_top",
"set.image_preimage_eq_of_subset",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
fg_top (S : subalgebra R A) : (⊤ : subalgebra R S).fg ↔ S.fg | ⟨λ h, by { rw [← S.range_val, ← algebra.map_top], exact fg.map _ h },
λ h, fg_of_fg_map _ S.val subtype.val_injective $ by { rw [algebra.map_top, range_val], exact h }⟩ | lemma | subalgebra.fg_top | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.map_top",
"subalgebra",
"subtype.val_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
induction_on_adjoin [is_noetherian R A] (P : subalgebra R A → Prop)
(base : P ⊥) (ih : ∀ (S : subalgebra R A) (x : A), P S → P (algebra.adjoin R (insert x S)))
(S : subalgebra R A) : P S | begin
classical,
obtain ⟨t, rfl⟩ := S.fg_of_noetherian,
refine finset.induction_on t _ _,
{ simpa using base },
intros x t hxt h,
rw [finset.coe_insert],
simpa only [algebra.adjoin_insert_adjoin] using ih _ x h,
end | lemma | subalgebra.induction_on_adjoin | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin",
"algebra.adjoin_insert_adjoin",
"finset.coe_insert",
"finset.induction_on",
"ih",
"is_noetherian",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
alg_hom.is_noetherian_ring_range (f : A →ₐ[R] B) [is_noetherian_ring A] :
is_noetherian_ring f.range | is_noetherian_ring_range f.to_ring_hom | instance | alg_hom.is_noetherian_ring_range | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"is_noetherian_ring",
"is_noetherian_ring_range"
] | The image of a Noetherian R-algebra under an R-algebra map is a Noetherian ring. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_noetherian_ring_of_fg {S : subalgebra R A} (HS : S.fg)
[is_noetherian_ring R] : is_noetherian_ring S | let ⟨t, ht⟩ := HS in ht ▸ (algebra.adjoin_eq_range R (↑t : set A)).symm ▸
by haveI : is_noetherian_ring (mv_polynomial (↑t : set A) R) :=
mv_polynomial.is_noetherian_ring;
convert alg_hom.is_noetherian_ring_range _; apply_instance | theorem | is_noetherian_ring_of_fg | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"alg_hom.is_noetherian_ring_range",
"algebra.adjoin_eq_range",
"is_noetherian_ring",
"mv_polynomial",
"mv_polynomial.is_noetherian_ring",
"subalgebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_noetherian_subring_closure (s : set R) (hs : s.finite) :
is_noetherian_ring (subring.closure s) | show is_noetherian_ring (subalgebra_of_subring (subring.closure s)), from
algebra.adjoin_int s ▸ is_noetherian_ring_of_fg (subalgebra.fg_def.2 ⟨s, hs, rfl⟩) | theorem | is_noetherian_subring_closure | ring_theory.adjoin | src/ring_theory/adjoin/fg.lean | [
"ring_theory.polynomial.basic",
"ring_theory.principal_ideal_domain",
"data.mv_polynomial.basic"
] | [
"algebra.adjoin_int",
"is_noetherian_ring",
"is_noetherian_ring_of_fg",
"subalgebra_of_subring",
"subring.closure"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
alg_equiv.adjoin_singleton_equiv_adjoin_root_minpoly
{R : Type*} [comm_ring R] [algebra F R] (x : R) :
algebra.adjoin F ({x} : set R) ≃ₐ[F] adjoin_root (minpoly F x) | alg_equiv.symm $ alg_equiv.of_bijective
(alg_hom.cod_restrict
(adjoin_root.lift_hom _ x $ minpoly.aeval F x) _
(λ p, adjoin_root.induction_on _ p $ λ p,
(algebra.adjoin_singleton_eq_range_aeval F x).symm ▸
(polynomial.aeval _).mem_range.mpr ⟨p, rfl⟩))
⟨(alg_hom.injective_cod_restrict _ _ _).2 ... | def | alg_equiv.adjoin_singleton_equiv_adjoin_root_minpoly | ring_theory.adjoin | src/ring_theory/adjoin/field.lean | [
"data.polynomial.splits",
"ring_theory.adjoin.basic",
"ring_theory.adjoin_root"
] | [
"adjoin_root",
"adjoin_root.induction_on",
"adjoin_root.lift_hom",
"alg_equiv.of_bijective",
"alg_equiv.symm",
"alg_hom.cod_restrict",
"alg_hom.injective_cod_restrict",
"algebra",
"algebra.adjoin",
"algebra.adjoin_singleton_eq_range_aeval",
"comm_ring",
"minpoly",
"minpoly.aeval",
"minpoly... | If `p` is the minimal polynomial of `a` over `F` then `F[a] ≃ₐ[F] F[x]/(p)` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_of_splits {F K L : Type*} [field F] [field K] [field L]
[algebra F K] [algebra F L] (s : finset K) :
(∀ x ∈ s, is_integral F x ∧ polynomial.splits (algebra_map F L) (minpoly F x)) →
nonempty (algebra.adjoin F (↑s : set K) →ₐ[F] L) | begin
classical,
refine finset.induction_on s (λ H, _) (λ a s has ih H, _),
{ rw [coe_empty, algebra.adjoin_empty],
exact ⟨(algebra.of_id F L).comp (algebra.bot_equiv F K)⟩ },
rw forall_mem_insert at H, rcases H with ⟨⟨H1, H2⟩, H3⟩, cases ih H3 with f,
choose H3 H4 using H3,
rw [coe_insert, set.insert_e... | theorem | lift_of_splits | ring_theory.adjoin | src/ring_theory/adjoin/field.lean | [
"data.polynomial.splits",
"ring_theory.adjoin.basic",
"ring_theory.adjoin_root"
] | [
"adjoin_root.lift_hom",
"alg_equiv.adjoin_singleton_equiv_adjoin_root_minpoly",
"algebra",
"algebra.adjoin",
"algebra.adjoin_empty",
"algebra.adjoin_union_eq_adjoin_adjoin",
"algebra.bot_equiv",
"algebra.of_id",
"algebra_map",
"fg_adjoin_of_finite",
"field",
"field_of_finite_dimensional",
"f... | If `K` and `L` are field extensions of `F` and we have `s : finset K` such that
the minimal polynomial of each `x ∈ s` splits in `L` then `algebra.adjoin F s` embeds in `L`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.