Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | goals listlengths 0 224 | goals_before listlengths 0 220 |
|---|---|---|---|---|---|---|---|
import Mathlib.RingTheory.Ideal.Cotangent
import Mathlib.RingTheory.QuotientNilpotent
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.FinitePresentation
import Mathlib.RingTheory.Localization.Away.Basic
import Mathlib.RingTheory.Localization.Away.AdjoinRoot
#align_import ring_theory.etale from ... | Mathlib/RingTheory/Smooth/Basic.lean | 188 | 196 | theorem comp [FormallySmooth R A] [FormallySmooth A B] : FormallySmooth R B := by |
constructor
intro C _ _ I hI f
obtain ⟨f', e⟩ := FormallySmooth.comp_surjective I hI (f.comp (IsScalarTower.toAlgHom R A B))
letI := f'.toRingHom.toAlgebra
obtain ⟨f'', e'⟩ :=
FormallySmooth.comp_surjective I hI { f.toRingHom with commutes' := AlgHom.congr_fun e.symm }
apply_fun AlgHom.restrictScalars ... | [
" ∃ f, (Ideal.Quotient.mkₐ R I).comp f = g",
" ∀ (g : A →ₐ[R] B ⧸ I), ∃ f, (Ideal.Quotient.mkₐ R I).comp f = g",
" Function.Surjective (Ideal.Quotient.mkₐ R I).comp",
" ∀ [_RB : Algebra R B], Function.Surjective (Ideal.Quotient.mkₐ R I).comp",
" ∀ ⦃S : Type u⦄ [inst : CommRing S] (I : Ideal S),\n I ^ 2 =... | [
" ∃ f, (Ideal.Quotient.mkₐ R I).comp f = g",
" ∀ (g : A →ₐ[R] B ⧸ I), ∃ f, (Ideal.Quotient.mkₐ R I).comp f = g",
" Function.Surjective (Ideal.Quotient.mkₐ R I).comp",
" ∀ [_RB : Algebra R B], Function.Surjective (Ideal.Quotient.mkₐ R I).comp",
" ∀ ⦃S : Type u⦄ [inst : CommRing S] (I : Ideal S),\n I ^ 2 =... |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ι : Type*} {α : ι → Type*} {f f₁ f₂ : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)}
... | Mathlib/Order/Filter/Pi.lean | 233 | 235 | theorem compl_mem_coprodᵢ {s : Set (∀ i, α i)} :
sᶜ ∈ Filter.coprodᵢ f ↔ ∀ i, (eval i '' s)ᶜ ∈ f i := by |
simp only [Filter.coprodᵢ, mem_iSup, compl_mem_comap]
| [
" s ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ s",
" sᶜ ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), (eval i '' s)ᶜ ∈ f i"
] | [
" s ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ s"
] |
import Mathlib.MeasureTheory.Integral.IntervalIntegral
import Mathlib.MeasureTheory.Integral.Average
#align_import measure_theory.integral.interval_average from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open MeasureTheory Set TopologicalSpace
open scoped Interval
variable {E : Ty... | Mathlib/MeasureTheory/Integral/IntervalAverage.lean | 39 | 40 | theorem interval_average_symm (f : ℝ → E) (a b : ℝ) : (⨍ x in a..b, f x) = ⨍ x in b..a, f x := by |
rw [setAverage_eq, setAverage_eq, uIoc_comm]
| [
" ⨍ (x : ℝ) in a..b, f x = ⨍ (x : ℝ) in b..a, f x"
] | [] |
import Mathlib.Algebra.Algebra.Subalgebra.Unitization
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Topology.Algebra.StarSubalgebra
import Mathlib.Topology.ContinuousFunction.ContinuousMapZero
import Mathlib.Topology.ContinuousFunction.Weierstrass
#align_import topology.continuous_function.stone_weierstrass fro... | Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean | 94 | 113 | theorem comp_attachBound_mem_closure (A : Subalgebra ℝ C(X, ℝ)) (f : A)
(p : C(Set.Icc (-‖f‖) ‖f‖, ℝ)) : p.comp (attachBound (f : C(X, ℝ))) ∈ A.topologicalClosure := by |
-- `p` itself is in the closure of polynomials, by the Weierstrass theorem,
have mem_closure : p ∈ (polynomialFunctions (Set.Icc (-‖f‖) ‖f‖)).topologicalClosure :=
continuousMap_mem_polynomialFunctions_closure _ _ p
-- and so there are polynomials arbitrarily close.
have frequently_mem_polynomials := mem_c... | [
" (g.toContinuousMapOn (Set.Icc (-‖f‖) ‖f‖)).comp (↑f).attachBound = ↑((Polynomial.aeval f) g)",
" ((g.toContinuousMapOn (Set.Icc (-‖f‖) ‖f‖)).comp (↑f).attachBound) a✝ = ↑((Polynomial.aeval f) g) a✝",
" Polynomial.eval (↑((↑f).attachBound a✝)) g = Polynomial.eval (↑f a✝) g",
" (g.toContinuousMapOn (Set.Icc (... | [
" (g.toContinuousMapOn (Set.Icc (-‖f‖) ‖f‖)).comp (↑f).attachBound = ↑((Polynomial.aeval f) g)",
" ((g.toContinuousMapOn (Set.Icc (-‖f‖) ‖f‖)).comp (↑f).attachBound) a✝ = ↑((Polynomial.aeval f) g) a✝",
" Polynomial.eval (↑((↑f).attachBound a✝)) g = Polynomial.eval (↑f a✝) g",
" (g.toContinuousMapOn (Set.Icc (... |
import Mathlib.Algebra.Order.Monoid.Defs
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
open Function
universe u
variable {α : Type u}
class OrderedAddCommGroup (α : Ty... | Mathlib/Algebra/Order/Group/Defs.lean | 71 | 73 | theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
ContravariantClass α α (· * ·) (· ≤ ·) where
elim a b c bc := by | simpa using mul_le_mul_left' bc a⁻¹
| [
" b ≤ c"
] | [] |
import Mathlib.Algebra.NeZero
import Mathlib.Algebra.Polynomial.BigOperators
import Mathlib.Algebra.Polynomial.Lifts
import Mathlib.Algebra.Polynomial.Splits
import Mathlib.RingTheory.RootsOfUnity.Complex
import Mathlib.NumberTheory.ArithmeticFunction
import Mathlib.RingTheory.RootsOfUnity.Basic
import Mathlib.FieldTh... | Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean | 107 | 114 | theorem natDegree_cyclotomic' {ζ : R} {n : ℕ} (h : IsPrimitiveRoot ζ n) :
(cyclotomic' n R).natDegree = Nat.totient n := by |
rw [cyclotomic']
rw [natDegree_prod (primitiveRoots n R) fun z : R => X - C z]
· simp only [IsPrimitiveRoot.card_primitiveRoots h, mul_one, natDegree_X_sub_C, Nat.cast_id,
Finset.sum_const, nsmul_eq_mul]
intro z _
exact X_sub_C_ne_zero z
| [
" cyclotomic' 0 R = 1",
" cyclotomic' 1 R = X - 1",
" cyclotomic' 2 R = X + 1",
" ∏ μ ∈ primitiveRoots 2 R, (X - C μ) = X + 1",
" primitiveRoots 2 R = {-1}",
" IsPrimitiveRoot (-1) 2 ∧ ∀ (x : R), IsPrimitiveRoot x 2 → x = -1",
" (cyclotomic' n R).natDegree = n.totient",
" (∏ μ ∈ primitiveRoots n R, (X... | [
" cyclotomic' 0 R = 1",
" cyclotomic' 1 R = X - 1",
" cyclotomic' 2 R = X + 1",
" ∏ μ ∈ primitiveRoots 2 R, (X - C μ) = X + 1",
" primitiveRoots 2 R = {-1}",
" IsPrimitiveRoot (-1) 2 ∧ ∀ (x : R), IsPrimitiveRoot x 2 → x = -1"
] |
import Mathlib.Algebra.ModEq
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Periodic
import Mathlib.Data.Int.SuccPred
import Mathlib.GroupTheory.QuotientGroup
import Mathlib.Order.Circular
import Mathlib.Data.List.TFAE
import Mathlib.Data.Set.Lattice
#align_import a... | Mathlib/Algebra/Order/ToIntervalMod.lean | 138 | 139 | theorem toIocMod_sub_self (a b : α) : toIocMod hp a b - b = -toIocDiv hp a b • p := by |
rw [toIocMod, sub_sub_cancel_left, neg_smul]
| [
" toIcoMod hp 0 b ∈ Set.Ico 0 p",
" p = 0 + p",
" toIcoDiv hp a b • p - b = -toIcoMod hp a b",
" toIocDiv hp a b • p - b = -toIocMod hp a b",
" toIcoMod hp a b - b = -toIcoDiv hp a b • p",
" toIocMod hp a b - b = -toIocDiv hp a b • p"
] | [
" toIcoMod hp 0 b ∈ Set.Ico 0 p",
" p = 0 + p",
" toIcoDiv hp a b • p - b = -toIcoMod hp a b",
" toIocDiv hp a b • p - b = -toIocMod hp a b",
" toIcoMod hp a b - b = -toIcoDiv hp a b • p"
] |
set_option autoImplicit true
namespace Array
@[simp]
theorem extract_eq_nil_of_start_eq_end {a : Array α} :
a.extract i i = #[] := by
refine extract_empty_of_stop_le_start a ?h
exact Nat.le_refl i
theorem extract_append_left {a b : Array α} {i j : Nat} (h : j ≤ a.size) :
(a ++ b).extract i j = a.extrac... | Mathlib/Data/Array/ExtractLemmas.lean | 40 | 42 | theorem extract_eq_of_size_le_end {a : Array α} (h : a.size ≤ l) :
a.extract p l = a.extract p a.size := by |
simp only [extract, Nat.min_eq_right h, Nat.sub_eq, mkEmpty_eq, Nat.min_self]
| [
" a.extract i i = #[]",
" i ≤ i",
" (a ++ b).extract i j = a.extract i j",
" ((a ++ b).extract i j).size = (a.extract i j).size",
" min j (a.size + b.size) - i = min j a.size - i",
" ∀ (i_1 : Nat) (hi₁ : i_1 < ((a ++ b).extract i j).size) (hi₂ : i_1 < (a.extract i j).size),\n ((a ++ b).extract i j)[i_1... | [
" a.extract i i = #[]",
" i ≤ i",
" (a ++ b).extract i j = a.extract i j",
" ((a ++ b).extract i j).size = (a.extract i j).size",
" min j (a.size + b.size) - i = min j a.size - i",
" ∀ (i_1 : Nat) (hi₁ : i_1 < ((a ++ b).extract i j).size) (hi₂ : i_1 < (a.extract i j).size),\n ((a ++ b).extract i j)[i_1... |
import Mathlib.Analysis.InnerProductSpace.Dual
import Mathlib.Analysis.InnerProductSpace.Orientation
import Mathlib.Data.Complex.Orientation
import Mathlib.Tactic.LinearCombination
#align_import analysis.inner_product_space.two_dim from "leanprover-community/mathlib"@"cd8fafa2fac98e1a67097e8a91ad9901cfde48af"
non... | Mathlib/Analysis/InnerProductSpace/TwoDim.lean | 161 | 168 | theorem areaForm_map {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
[hF : Fact (finrank ℝ F = 2)] (φ : E ≃ₗᵢ[ℝ] F) (x y : F) :
(Orientation.map (Fin 2) φ.toLinearEquiv o).areaForm x y =
o.areaForm (φ.symm x) (φ.symm y) := by |
have : φ.symm ∘ ![x, y] = ![φ.symm x, φ.symm y] := by
ext i
fin_cases i <;> rfl
simp [areaForm_to_volumeForm, volumeForm_map, this]
| [
" E →ₗ[ℝ] E →ₗ[ℝ] ℝ",
" (o.areaForm x) y = o.volumeForm ![x, y]",
" (o.areaForm x) x = 0",
" o.volumeForm ![x, x] = 0",
" ![x, x] 0 = ![x, x] 1",
" 0 ≠ 1",
" (o.areaForm x) y = -(o.areaForm y) x",
" o.volumeForm ![x, y] = -o.volumeForm ![y, x]",
" ![x, y] = ![y, x] ∘ ⇑(Equiv.swap 0 1)",
" ![x, y] ... | [
" E →ₗ[ℝ] E →ₗ[ℝ] ℝ",
" (o.areaForm x) y = o.volumeForm ![x, y]",
" (o.areaForm x) x = 0",
" o.volumeForm ![x, x] = 0",
" ![x, x] 0 = ![x, x] 1",
" 0 ≠ 1",
" (o.areaForm x) y = -(o.areaForm y) x",
" o.volumeForm ![x, y] = -o.volumeForm ![y, x]",
" ![x, y] = ![y, x] ∘ ⇑(Equiv.swap 0 1)",
" ![x, y] ... |
import Mathlib.Order.SuccPred.Basic
import Mathlib.Order.BoundedOrder
#align_import order.succ_pred.limit from "leanprover-community/mathlib"@"1e05171a5e8cf18d98d9cf7b207540acb044acae"
variable {α : Type*}
namespace Order
open Function Set OrderDual
section LT
variable [LT α]
def IsSuccLimit (a : α) : Pr... | Mathlib/Order/SuccPred/Limit.lean | 46 | 47 | theorem not_isSuccLimit_iff_exists_covBy (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a := by |
simp [IsSuccLimit]
| [
" ¬IsSuccLimit a ↔ ∃ b, b ⋖ a"
] | [] |
import Mathlib.Algebra.BigOperators.Group.Finset
#align_import data.nat.gcd.big_operators from "leanprover-community/mathlib"@"008205aa645b3f194c1da47025c5f110c8406eab"
namespace Nat
variable {ι : Type*}
theorem coprime_list_prod_left_iff {l : List ℕ} {k : ℕ} :
Coprime l.prod k ↔ ∀ n ∈ l, Coprime n k := by
... | Mathlib/Data/Nat/GCD/BigOperators.lean | 56 | 58 | theorem coprime_fintype_prod_right_iff [Fintype ι] {x : ℕ} {s : ι → ℕ} :
Coprime x (∏ i, s i) ↔ ∀ i, Coprime x (s i) := by |
simp [coprime_prod_right_iff]
| [
" l.prod.Coprime k ↔ ∀ n ∈ l, n.Coprime k",
" [].prod.Coprime k ↔ ∀ n ∈ [], n.Coprime k",
" (head✝ :: tail✝).prod.Coprime k ↔ ∀ n ∈ head✝ :: tail✝, n.Coprime k",
" k.Coprime l.prod ↔ ∀ n ∈ l, k.Coprime n",
" m.prod.Coprime k ↔ ∀ n ∈ m, n.Coprime k",
" (Multiset.prod ⟦a✝⟧).Coprime k ↔ ∀ n ∈ ⟦a✝⟧, n.Coprime... | [
" l.prod.Coprime k ↔ ∀ n ∈ l, n.Coprime k",
" [].prod.Coprime k ↔ ∀ n ∈ [], n.Coprime k",
" (head✝ :: tail✝).prod.Coprime k ↔ ∀ n ∈ head✝ :: tail✝, n.Coprime k",
" k.Coprime l.prod ↔ ∀ n ∈ l, k.Coprime n",
" m.prod.Coprime k ↔ ∀ n ∈ m, n.Coprime k",
" (Multiset.prod ⟦a✝⟧).Coprime k ↔ ∀ n ∈ ⟦a✝⟧, n.Coprime... |
import Mathlib.Algebra.Algebra.Tower
import Mathlib.Algebra.GroupWithZero.NonZeroDivisors
import Mathlib.GroupTheory.MonoidLocalization
import Mathlib.RingTheory.Ideal.Basic
import Mathlib.GroupTheory.GroupAction.Ring
#align_import ring_theory.localization.basic from "leanprover-community/mathlib"@"b69c9a770ecf37eb21... | Mathlib/RingTheory/Localization/Basic.lean | 135 | 144 | theorem of_le (N : Submonoid R) (h₁ : M ≤ N) (h₂ : ∀ r ∈ N, IsUnit (algebraMap R S r)) :
IsLocalization N S where
map_units' r := h₂ r r.2
surj' s :=
have ⟨⟨x, y, hy⟩, H⟩ := IsLocalization.surj M s
⟨⟨x, y, h₁ hy⟩, H⟩
exists_of_eq {x y} := by |
rw [IsLocalization.eq_iff_exists M]
rintro ⟨c, hc⟩
exact ⟨⟨c, h₁ c.2⟩, hc⟩
| [
" (algebraMap R S) x = (algebraMap R S) y",
" (algebraMap R S) x = (algebraMap R S) y → ∃ c, ↑c * x = ↑c * y",
" (∃ c, ↑c * x = ↑c * y) → ∃ c, ↑c * x = ↑c * y",
" ∃ c, ↑c * x = ↑c * y"
] | [
" (algebraMap R S) x = (algebraMap R S) y"
] |
import Mathlib.MeasureTheory.Measure.VectorMeasure
import Mathlib.MeasureTheory.Function.AEEqOfIntegral
#align_import measure_theory.measure.with_density_vector_measure from "leanprover-community/mathlib"@"d1bd9c5df2867c1cb463bc6364446d57bdd9f7f1"
noncomputable section
open scoped Classical MeasureTheory NNReal ... | Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean | 64 | 65 | theorem withDensityᵥ_zero : μ.withDensityᵥ (0 : α → E) = 0 := by |
ext1 s hs; erw [withDensityᵥ_apply (integrable_zero α E μ) hs]; simp
| [
" (fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) ∅ = 0",
" HasSum (fun i => (fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) (s i))\n ((fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) (⋃ i, s i))",
" HasSum (fun i => if MeasurableSet (s i) then ∫ (x : α) in s... | [
" (fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) ∅ = 0",
" HasSum (fun i => (fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) (s i))\n ((fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) (⋃ i, s i))",
" HasSum (fun i => if MeasurableSet (s i) then ∫ (x : α) in s... |
import Mathlib.ModelTheory.Satisfiability
import Mathlib.Combinatorics.SimpleGraph.Basic
#align_import model_theory.graph from "leanprover-community/mathlib"@"e56b8fea84d60fe434632b9d3b829ee685fb0c8f"
set_option linter.uppercaseLean3 false
universe u v w w'
namespace FirstOrder
namespace Language
open FirstOr... | Mathlib/ModelTheory/Graph.lean | 107 | 110 | theorem _root_.SimpleGraph.simpleGraphOfStructure (G : SimpleGraph V) :
@simpleGraphOfStructure V G.structure _ = G := by |
ext
rfl
| [
" V ⊨ Theory.simpleGraph ↔ (Irreflexive fun x y => RelMap adj ![x, y]) ∧ Symmetric fun x y => RelMap adj ![x, y]",
" V ⊨ Theory.simpleGraph",
" (Irreflexive fun x y => G.Adj x y) ∧ Symmetric fun x y => G.Adj x y",
" FirstOrder.Language.simpleGraphOfStructure V = G",
" (FirstOrder.Language.simpleGraphOfStruc... | [
" V ⊨ Theory.simpleGraph ↔ (Irreflexive fun x y => RelMap adj ![x, y]) ∧ Symmetric fun x y => RelMap adj ![x, y]",
" V ⊨ Theory.simpleGraph",
" (Irreflexive fun x y => G.Adj x y) ∧ Symmetric fun x y => G.Adj x y"
] |
import Mathlib.Analysis.Seminorm
import Mathlib.Topology.Algebra.Equicontinuity
import Mathlib.Topology.MetricSpace.Equicontinuity
import Mathlib.Topology.Algebra.FilterBasis
import Mathlib.Topology.Algebra.Module.LocallyConvex
#align_import analysis.locally_convex.with_seminorms from "leanprover-community/mathlib"@"... | Mathlib/Analysis/LocallyConvex/WithSeminorms.lean | 143 | 153 | theorem basisSets_smul_right (v : E) (U : Set E) (hU : U ∈ p.basisSets) :
∀ᶠ x : 𝕜 in 𝓝 0, x • v ∈ U := by |
rcases p.basisSets_iff.mp hU with ⟨s, r, hr, hU⟩
rw [hU, Filter.eventually_iff]
simp_rw [(s.sup p).mem_ball_zero, map_smul_eq_mul]
by_cases h : 0 < (s.sup p) v
· simp_rw [(lt_div_iff h).symm]
rw [← _root_.ball_zero_eq]
exact Metric.ball_mem_nhds 0 (div_pos hr h)
simp_rw [le_antisymm (not_lt.mp h) (... | [
" U ∈ p.basisSets ↔ ∃ i r, 0 < r ∧ U = (i.sup p).ball 0 r",
" (p i).ball 0 r = ({i}.sup p).ball 0 r",
" p.basisSets.Nonempty",
" (p i).ball 0 1 ∈ p.basisSets",
" ∃ z ∈ p.basisSets, z ⊆ U ∩ V",
" ((s ∪ t).sup p).ball 0 (min r₁ r₂) ∈ p.basisSets ∧ ((s ∪ t).sup p).ball 0 (min r₁ r₂) ⊆ U ∩ V",
" ((s ∪ t).su... | [
" U ∈ p.basisSets ↔ ∃ i r, 0 < r ∧ U = (i.sup p).ball 0 r",
" (p i).ball 0 r = ({i}.sup p).ball 0 r",
" p.basisSets.Nonempty",
" (p i).ball 0 1 ∈ p.basisSets",
" ∃ z ∈ p.basisSets, z ⊆ U ∩ V",
" ((s ∪ t).sup p).ball 0 (min r₁ r₂) ∈ p.basisSets ∧ ((s ∪ t).sup p).ball 0 (min r₁ r₂) ⊆ U ∩ V",
" ((s ∪ t).su... |
import Mathlib.Analysis.NormedSpace.ContinuousAffineMap
import Mathlib.Analysis.Calculus.ContDiff.Basic
#align_import analysis.calculus.affine_map from "leanprover-community/mathlib"@"839b92fedff9981cf3fe1c1f623e04b0d127f57c"
namespace ContinuousAffineMap
variable {𝕜 V W : Type*} [NontriviallyNormedField 𝕜]
va... | Mathlib/Analysis/Calculus/AffineMap.lean | 30 | 33 | theorem contDiff {n : ℕ∞} (f : V →ᴬ[𝕜] W) : ContDiff 𝕜 n f := by |
rw [f.decomp]
apply f.contLinear.contDiff.add
exact contDiff_const
| [
" ContDiff 𝕜 n ⇑f",
" ContDiff 𝕜 n (⇑f.contLinear + Function.const V (f 0))",
" ContDiff 𝕜 n fun x => Function.const V (f 0) x"
] | [] |
import Mathlib.MeasureTheory.Constructions.BorelSpace.Order
import Mathlib.Topology.Order.LeftRightLim
#align_import measure_theory.measure.stieltjes from "leanprover-community/mathlib"@"20d5763051978e9bc6428578ed070445df6a18b3"
noncomputable section
open scoped Classical
open Set Filter Function ENNReal NNReal T... | Mathlib/MeasureTheory/Measure/Stieltjes.lean | 76 | 80 | theorem iInf_Ioi_eq (f : StieltjesFunction) (x : ℝ) : ⨅ r : Ioi x, f r = f x := by |
suffices Function.rightLim f x = ⨅ r : Ioi x, f r by rw [← this, f.rightLim_eq]
rw [f.mono.rightLim_eq_sInf, sInf_image']
rw [← neBot_iff]
infer_instance
| [
" f = g",
" ∀ (x : ℝ), ↑f x = ↑g x",
" rightLim (↑f) x = ↑f x",
" ContinuousWithinAt (↑f) (Ici x) x",
" ⨅ r, ↑f ↑r = ↑f x",
" rightLim (↑f) x = ⨅ r, ↑f ↑r",
" 𝓝[>] x ≠ ⊥",
" (𝓝[>] x).NeBot"
] | [
" f = g",
" ∀ (x : ℝ), ↑f x = ↑g x",
" rightLim (↑f) x = ↑f x",
" ContinuousWithinAt (↑f) (Ici x) x"
] |
import Mathlib.Analysis.Calculus.Deriv.Inv
import Mathlib.Analysis.Calculus.Deriv.Polynomial
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.SpecialFunctions.PolynomialExp
#align_import analysis.calculus.bump_function_inner from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9... | Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean | 46 | 46 | theorem zero_of_nonpos {x : ℝ} (hx : x ≤ 0) : expNegInvGlue x = 0 := by | simp [expNegInvGlue, hx]
| [
" expNegInvGlue x = 0"
] | [] |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
#align_import analysis.calculus.iterated_deriv from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open scoped Classical Topology
open Filter Asymptotics Set
variable {𝕜... | Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean | 91 | 95 | theorem iteratedFDerivWithin_eq_equiv_comp :
iteratedFDerivWithin 𝕜 n f s =
ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F ∘ iteratedDerivWithin n f s := by |
rw [iteratedDerivWithin_eq_equiv_comp, ← Function.comp.assoc, LinearIsometryEquiv.self_comp_symm,
Function.id_comp]
| [
" iteratedDerivWithin n f univ = iteratedDeriv n f",
" iteratedDerivWithin n f univ x = iteratedDeriv n f x",
" iteratedDerivWithin n f s = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDerivWithin 𝕜 n f s",
" iteratedDerivWithin n f s x =\n (⇑(ContinuousMultilinearMap.piFieldEquiv... | [
" iteratedDerivWithin n f univ = iteratedDeriv n f",
" iteratedDerivWithin n f univ x = iteratedDeriv n f x",
" iteratedDerivWithin n f s = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDerivWithin 𝕜 n f s",
" iteratedDerivWithin n f s x =\n (⇑(ContinuousMultilinearMap.piFieldEquiv... |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.BigOperators
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.Algebra.Polynomial.Div
#align_import data.polynomial.ring_division from "leanprover-community/mathlib"@"8efcf8022aac8e01df8d302dcebdbc25d6a886c8"
noncomputable ... | Mathlib/Algebra/Polynomial/RingDivision.lean | 124 | 126 | theorem natDegree_mul (hp : p ≠ 0) (hq : q ≠ 0) : (p*q).natDegree = p.natDegree + q.natDegree := by |
rw [← Nat.cast_inj (R := WithBot ℕ), ← degree_eq_natDegree (mul_ne_zero hp hq),
Nat.cast_add, ← degree_eq_natDegree hp, ← degree_eq_natDegree hq, degree_mul]
| [
" a✝ = 0 ∨ b✝ = 0",
" a✝.leadingCoeff = 0 ∨ b✝.leadingCoeff = 0",
" a✝.leadingCoeff * b✝.leadingCoeff = 0",
" (p * q).natDegree = p.natDegree + q.natDegree"
] | [
" a✝ = 0 ∨ b✝ = 0",
" a✝.leadingCoeff = 0 ∨ b✝.leadingCoeff = 0",
" a✝.leadingCoeff * b✝.leadingCoeff = 0"
] |
import Mathlib.Algebra.IsPrimePow
import Mathlib.Algebra.Squarefree.Basic
import Mathlib.Order.Hom.Bounded
import Mathlib.Algebra.GCDMonoid.Basic
#align_import ring_theory.chain_of_divisors from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
variable {M : Type*} [CancelCommMonoidWithZero... | Mathlib/RingTheory/ChainOfDivisors.lean | 224 | 231 | theorem factor_orderIso_map_one_eq_bot {m : Associates M} {n : Associates N}
(d : { l : Associates M // l ≤ m } ≃o { l : Associates N // l ≤ n }) :
(d ⟨1, one_dvd m⟩ : Associates N) = 1 := by |
letI : OrderBot { l : Associates M // l ≤ m } := Subtype.orderBot bot_le
letI : OrderBot { l : Associates N // l ≤ n } := Subtype.orderBot bot_le
simp only [← Associates.bot_eq_one, Subtype.mk_bot, bot_le, Subtype.coe_eq_bot_iff]
letI : BotHomClass ({ l // l ≤ m } ≃o { l // l ≤ n }) _ _ := OrderIsoClass.toBotH... | [
" ¬IsUnit p",
" IsUnit b",
" Associated (p * b) p",
"M : Type u_1\ninst✝ : CancelCommMonoidWithZero M\np : Associates M\nh₁ : p ≠ 0\nhp : IsAtom p\na b : Associates M\nh : p = p * b\nha : a = p\n| p",
" p ≠ ⊥",
" b = ⊥",
" b = p * ↑ha.unit⁻¹",
" ↑(d ⟨1, ⋯⟩) = 1",
" d ⊥ = ⊥"
] | [
" ¬IsUnit p",
" IsUnit b",
" Associated (p * b) p",
"M : Type u_1\ninst✝ : CancelCommMonoidWithZero M\np : Associates M\nh₁ : p ≠ 0\nhp : IsAtom p\na b : Associates M\nh : p = p * b\nha : a = p\n| p",
" p ≠ ⊥",
" b = ⊥",
" b = p * ↑ha.unit⁻¹"
] |
import Mathlib.CategoryTheory.Equivalence
#align_import algebraic_topology.dold_kan.compatibility from "leanprover-community/mathlib"@"32a7e535287f9c73f2e4d2aef306a39190f0b504"
open CategoryTheory CategoryTheory.Category
namespace AlgebraicTopology
namespace DoldKan
namespace Compatibility
variable {A A' B B'... | Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean | 103 | 105 | theorem equivalence₁UnitIso_eq : (equivalence₁ hF).unitIso = equivalence₁UnitIso hF := by |
ext X
simp [equivalence₁]
| [
" (equivalence₁ hF).counitIso = equivalence₁CounitIso hF",
" (equivalence₁ hF).counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y",
" (equivalence₁ hF).unitIso = equivalence₁UnitIso hF",
" (equivalence₁ hF).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X"
] | [
" (equivalence₁ hF).counitIso = equivalence₁CounitIso hF",
" (equivalence₁ hF).counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y"
] |
import Mathlib.Data.PFunctor.Univariate.M
#align_import data.qpf.univariate.basic from "leanprover-community/mathlib"@"14b69e9f3c16630440a2cbd46f1ddad0d561dee7"
universe u
class QPF (F : Type u → Type u) [Functor F] where
P : PFunctor.{u}
abs : ∀ {α}, P α → F α
repr : ∀ {α}, F α → P α
abs_repr : ∀ {α} (... | Mathlib/Data/QPF/Univariate/Basic.lean | 377 | 379 | theorem corecF_eq {α : Type _} (g : α → F α) (x : α) :
PFunctor.M.dest (corecF g x) = q.P.map (corecF g) (repr (g x)) := by |
rw [corecF, PFunctor.M.dest_corec]
| [
" (corecF g x).dest = (P F).map (corecF g) (repr (g x))"
] | [] |
import Mathlib.FieldTheory.RatFunc.AsPolynomial
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
noncomputable section
universe u
variable {K : Type u}
namespace RatFunc
section IntDegree
open Polynomial
variable [Field... | Mathlib/FieldTheory/RatFunc/Degree.lean | 65 | 68 | theorem intDegree_polynomial {p : K[X]} :
intDegree (algebraMap K[X] (RatFunc K) p) = natDegree p := by |
rw [intDegree, RatFunc.num_algebraMap, RatFunc.denom_algebraMap, Polynomial.natDegree_one,
Int.ofNat_zero, sub_zero]
| [
" intDegree 0 = 0",
" intDegree 1 = 0",
" (C k).intDegree = 0",
" X.intDegree = 1",
" ((algebraMap K[X] (RatFunc K)) p).intDegree = ↑p.natDegree"
] | [
" intDegree 0 = 0",
" intDegree 1 = 0",
" (C k).intDegree = 0",
" X.intDegree = 1"
] |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_lim... | Mathlib/Analysis/SpecificLimits/Normed.lean | 111 | 114 | theorem isLittleO_pow_pow_of_abs_lt_left {r₁ r₂ : ℝ} (h : |r₁| < |r₂|) :
(fun n : ℕ ↦ r₁ ^ n) =o[atTop] fun n ↦ r₂ ^ n := by |
refine (IsLittleO.of_norm_left ?_).of_norm_right
exact (isLittleO_pow_pow_of_lt_left (abs_nonneg r₁) h).congr (pow_abs r₁) (pow_abs r₂)
| [
" Summable f",
" ∀ (i : ℕ), 0 ≤ ‖f i‖",
" Tendsto (fun n => ∑ i ∈ Finset.range n, ‖f i‖) atTop (𝓝 r)",
" (fun n => r₁ ^ n) =o[atTop] fun n => r₂ ^ n",
" (fun x => ‖r₁ ^ x‖) =o[atTop] fun x => ‖r₂ ^ x‖"
] | [
" Summable f",
" ∀ (i : ℕ), 0 ≤ ‖f i‖",
" Tendsto (fun n => ∑ i ∈ Finset.range n, ‖f i‖) atTop (𝓝 r)"
] |
import Mathlib.Analysis.SpecialFunctions.Pow.Complex
import Qq
#align_import analysis.special_functions.pow.real from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real ComplexConjugate
open Finset Set
namespace Real
variable {x y z... | Mathlib/Analysis/SpecialFunctions/Pow/Real.lean | 100 | 112 | theorem rpow_def_of_neg {x : ℝ} (hx : x < 0) (y : ℝ) : x ^ y = exp (log x * y) * cos (y * π) := by |
rw [rpow_def, Complex.cpow_def, if_neg]
· have : Complex.log x * y = ↑(log (-x) * y) + ↑(y * π) * Complex.I := by
simp only [Complex.log, abs_of_neg hx, Complex.arg_ofReal_of_neg hx, Complex.abs_ofReal,
Complex.ofReal_mul]
ring
rw [this, Complex.exp_add_mul_I, ← Complex.ofReal_exp, ← Comple... | [
" x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" (if ↑x = 0 then if ↑y = 0 then 1 else 0 else ((↑x).log * ↑y).exp).re =\n if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" Complex.re 1 = 1",
" Complex.re 1 = 0",
" Complex.re 1 = rexp (x.log * y)",
" Complex.re 0 = 1... | [
" x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" (if ↑x = 0 then if ↑y = 0 then 1 else 0 else ((↑x).log * ↑y).exp).re =\n if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" Complex.re 1 = 1",
" Complex.re 1 = 0",
" Complex.re 1 = rexp (x.log * y)",
" Complex.re 0 = 1... |
import Mathlib.Data.List.Basic
#align_import data.list.lattice from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
open Nat
namespace List
variable {α : Type*} {l l₁ l₂ : List α} {p : α → Prop} {a : α}
variable [DecidableEq α]
section BagInter
@[simp]
theorem nil_bagInt... | Mathlib/Data/List/Lattice.lean | 211 | 214 | theorem cons_bagInter_of_neg (l₁ : List α) (h : a ∉ l₂) :
(a :: l₁).bagInter l₂ = l₁.bagInter l₂ := by |
cases l₂; · simp only [bagInter_nil]
simp only [erase_of_not_mem h, List.bagInter, if_neg (mt mem_of_elem_eq_true h)]
| [
" [].bagInter l = []",
" [].bagInter [] = []",
" [].bagInter (head✝ :: tail✝) = []",
" l.bagInter [] = []",
" (head✝ :: tail✝).bagInter [] = []",
" (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)",
" (a :: l₁).bagInter [] = a :: l₁.bagInter ([].erase a)",
" (a :: l₁).bagInter (head✝ :: tail✝) = ... | [
" [].bagInter l = []",
" [].bagInter [] = []",
" [].bagInter (head✝ :: tail✝) = []",
" l.bagInter [] = []",
" (head✝ :: tail✝).bagInter [] = []",
" (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)",
" (a :: l₁).bagInter [] = a :: l₁.bagInter ([].erase a)",
" (a :: l₁).bagInter (head✝ :: tail✝) = ... |
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.Order.Ring.Nat
import Mathlib.Tactic.NthRewrite
#align_import data.nat.gcd.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
namespace Nat
theorem gcd_greatest {a b d : ℕ} (hda : d ∣ a) (hdb : d ∣ b) (hd ... | Mathlib/Data/Nat/GCD/Basic.lean | 68 | 69 | theorem gcd_mul_left_add_left (m n k : ℕ) : gcd (n * k + m) n = gcd m n := by |
rw [gcd_comm, gcd_mul_left_add_right, gcd_comm]
| [
" m.gcd (n + k * m) = m.gcd n",
" m.gcd (n + m * k) = m.gcd n",
" m.gcd (k * m + n) = m.gcd n",
" m.gcd (m * k + n) = m.gcd n",
" (m + k * n).gcd n = m.gcd n",
" (m + n * k).gcd n = m.gcd n",
" (k * n + m).gcd n = m.gcd n",
" (n * k + m).gcd n = m.gcd n"
] | [
" m.gcd (n + k * m) = m.gcd n",
" m.gcd (n + m * k) = m.gcd n",
" m.gcd (k * m + n) = m.gcd n",
" m.gcd (m * k + n) = m.gcd n",
" (m + k * n).gcd n = m.gcd n",
" (m + n * k).gcd n = m.gcd n",
" (k * n + m).gcd n = m.gcd n"
] |
import Mathlib.Analysis.Normed.Group.InfiniteSum
import Mathlib.Analysis.Normed.MulAction
import Mathlib.Topology.Algebra.Order.LiminfLimsup
import Mathlib.Topology.PartialHomeomorph
#align_import analysis.asymptotics.asymptotics from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open ... | Mathlib/Analysis/Asymptotics/Asymptotics.lean | 135 | 149 | theorem isBigO_iff'' {g : α → E'''} :
f =O[l] g ↔ ∃ c > 0, ∀ᶠ x in l, c * ‖f x‖ ≤ ‖g x‖ := by |
refine ⟨fun h => ?mp, fun h => ?mpr⟩
case mp =>
rw [isBigO_iff'] at h
obtain ⟨c, ⟨hc_pos, hc⟩⟩ := h
refine ⟨c⁻¹, ⟨by positivity, ?_⟩⟩
filter_upwards [hc] with x hx
rwa [inv_mul_le_iff (by positivity)]
case mpr =>
rw [isBigO_iff']
obtain ⟨c, ⟨hc_pos, hc⟩⟩ := h
refine ⟨c⁻¹, ⟨by posi... | [
" IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g ↔ ∃ c, IsBigOWith c l f g",
" f =O[l] g ↔ ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g ↔ ∃ c > 0, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g",
" ∃ c > 0, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" ∀ᶠ (x : α) in l, ‖f x‖ ≤... | [
" IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g ↔ ∃ c, IsBigOWith c l f g",
" f =O[l] g ↔ ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g ↔ ∃ c > 0, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g",
" ∃ c > 0, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" ∀ᶠ (x : α) in l, ‖f x‖ ≤... |
import Mathlib.RingTheory.IntegrallyClosed
import Mathlib.RingTheory.Trace
import Mathlib.RingTheory.Norm
#align_import ring_theory.discriminant from "leanprover-community/mathlib"@"3e068ece210655b7b9a9477c3aff38a492400aa1"
universe u v w z
open scoped Matrix
open Matrix FiniteDimensional Fintype Polynomial Fin... | Mathlib/RingTheory/Discriminant.lean | 113 | 116 | theorem discr_of_matrix_vecMul (b : ι → B) (P : Matrix ι ι A) :
discr A (b ᵥ* P.map (algebraMap A B)) = P.det ^ 2 * discr A b := by |
rw [discr_def, traceMatrix_of_matrix_vecMul, det_mul, det_mul, det_transpose, mul_comm, ←
mul_assoc, discr_def, pow_two]
| [
" discr A b = discr A (⇑f ∘ b)",
" (traceMatrix A b).det = discr A (⇑f ∘ b)",
" traceMatrix A b = traceMatrix A (⇑f ∘ b)",
" traceMatrix A b i✝ j✝ = traceMatrix A (⇑f ∘ b) i✝ j✝",
" discr A (⇑b ∘ ⇑f.symm) = discr A ⇑b",
" discr A b = 0",
" traceMatrix A b *ᵥ g = 0",
" (traceMatrix A b *ᵥ g) i = 0 i",
... | [
" discr A b = discr A (⇑f ∘ b)",
" (traceMatrix A b).det = discr A (⇑f ∘ b)",
" traceMatrix A b = traceMatrix A (⇑f ∘ b)",
" traceMatrix A b i✝ j✝ = traceMatrix A (⇑f ∘ b) i✝ j✝",
" discr A (⇑b ∘ ⇑f.symm) = discr A ⇑b",
" discr A b = 0",
" traceMatrix A b *ᵥ g = 0",
" (traceMatrix A b *ᵥ g) i = 0 i",
... |
import Batteries.Data.List.Count
import Batteries.Data.Fin.Lemmas
open Nat Function
namespace List
theorem rel_of_pairwise_cons (p : (a :: l).Pairwise R) : ∀ {a'}, a' ∈ l → R a a' :=
(pairwise_cons.1 p).1 _
theorem Pairwise.of_cons (p : (a :: l).Pairwise R) : Pairwise R l :=
(pairwise_cons.1 p).2
theorem... | .lake/packages/batteries/Batteries/Data/List/Pairwise.lean | 108 | 112 | theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {l₁ l₂ : List α} :
Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁) := by |
have (l₁ l₂ : List α) (H : ∀ x : α, x ∈ l₁ → ∀ y : α, y ∈ l₂ → R x y)
(x : α) (xm : x ∈ l₂) (y : α) (ym : y ∈ l₁) : R x y := s (H y ym x xm)
simp only [pairwise_append, and_left_comm]; rw [Iff.intro (this l₁ l₂) (this l₂ l₁)]
| [
" Pairwise S l",
" Pairwise S []",
" Pairwise S (a :: l)",
" ∀ (a' : α), a' ∈ l → S a a'",
" Pairwise (fun a b => R a b ∧ S a b) l",
" Pairwise (fun a b => R a b ∧ S a b) []",
" Pairwise (fun a b => R a b ∧ S a b) (a✝¹ :: l✝)",
" (∀ (a' : α✝), a' ∈ l✝ → R a✝¹ a' ∧ S a✝¹ a') ∧ Pairwise (fun a b => R a ... | [
" Pairwise S l",
" Pairwise S []",
" Pairwise S (a :: l)",
" ∀ (a' : α), a' ∈ l → S a a'",
" Pairwise (fun a b => R a b ∧ S a b) l",
" Pairwise (fun a b => R a b ∧ S a b) []",
" Pairwise (fun a b => R a b ∧ S a b) (a✝¹ :: l✝)",
" (∀ (a' : α✝), a' ∈ l✝ → R a✝¹ a' ∧ S a✝¹ a') ∧ Pairwise (fun a b => R a ... |
import Mathlib.Topology.UniformSpace.CompleteSeparated
import Mathlib.Topology.EMetricSpace.Lipschitz
import Mathlib.Topology.MetricSpace.Basic
import Mathlib.Topology.MetricSpace.Bounded
#align_import topology.metric_space.antilipschitz from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
... | Mathlib/Topology/MetricSpace/Antilipschitz.lean | 77 | 79 | theorem mul_le_nndist (hf : AntilipschitzWith K f) (x y : α) :
K⁻¹ * nndist x y ≤ nndist (f x) (f y) := by |
simpa only [div_eq_inv_mul] using NNReal.div_le_of_le_mul' (hf.le_mul_nndist x y)
| [
" AntilipschitzWith K f ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)",
" (∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))) ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)",
" AntilipschitzWith K f ↔ ∀ (x y : α), dist x y ≤ ↑K * dist (f x) (f y)",
" (∀ (x y : α), nndist x y ≤ K * nndist (f x) ... | [
" AntilipschitzWith K f ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)",
" (∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))) ↔ ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)",
" AntilipschitzWith K f ↔ ∀ (x y : α), dist x y ≤ ↑K * dist (f x) (f y)",
" (∀ (x y : α), nndist x y ≤ K * nndist (f x) ... |
import Mathlib.RepresentationTheory.Action.Limits
import Mathlib.RepresentationTheory.Action.Concrete
import Mathlib.CategoryTheory.Monoidal.FunctorCategory
import Mathlib.CategoryTheory.Monoidal.Transport
import Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence
import Mathlib.CategoryTheory.Monoidal.Rigid.FunctorCa... | Mathlib/RepresentationTheory/Action/Monoidal.lean | 98 | 100 | theorem leftUnitor_hom_hom {X : Action V G} : Hom.hom (λ_ X).hom = (λ_ X.V).hom := by |
dsimp
simp
| [
" (α_ X Y Z).hom.hom = (α_ X.V Y.V Z.V).hom",
" (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) ≫ (α_ X.V Y.V Z.V).hom ≫ (𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) = (α_ X.V Y.V Z.V).hom",
" (α_ X Y Z).inv.hom = (α_ X.V Y.V Z.V).inv",
" ((𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) ≫ (α_ X.V Y.V Z.V).inv) ≫ (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) = (α_ X.V Y.V Z.V).inv",
" (λ_ ... | [
" (α_ X Y Z).hom.hom = (α_ X.V Y.V Z.V).hom",
" (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) ≫ (α_ X.V Y.V Z.V).hom ≫ (𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) = (α_ X.V Y.V Z.V).hom",
" (α_ X Y Z).inv.hom = (α_ X.V Y.V Z.V).inv",
" ((𝟙 X.V ⊗ 𝟙 (Y.V ⊗ Z.V)) ≫ (α_ X.V Y.V Z.V).inv) ≫ (𝟙 (X.V ⊗ Y.V) ⊗ 𝟙 Z.V) = (α_ X.V Y.V Z.V).inv"
] |
import Mathlib.Data.Fintype.Basic
import Mathlib.ModelTheory.Substructures
#align_import model_theory.elementary_maps from "leanprover-community/mathlib"@"d11893b411025250c8e61ff2f12ccbd7ee35ab15"
open FirstOrder
namespace FirstOrder
namespace Language
open Structure
variable (L : Language) (M : Type*) (N : T... | Mathlib/ModelTheory/ElementaryMaps.lean | 98 | 100 | theorem map_formula (f : M ↪ₑ[L] N) {α : Type*} (φ : L.Formula α) (x : α → M) :
φ.Realize (f ∘ x) ↔ φ.Realize x := by |
rw [Formula.Realize, Formula.Realize, ← f.map_boundedFormula, Unique.eq_default (f ∘ default)]
| [
" f = g",
" { toFun := toFun✝, map_formula' := map_formula'✝ } = g",
" { toFun := toFun✝¹, map_formula' := map_formula'✝¹ } = { toFun := toFun✝, map_formula' := map_formula'✝ }",
" toFun✝¹ = toFun✝",
" toFun✝¹ x = toFun✝ x",
" φ.Realize (⇑f ∘ v) (⇑f ∘ xs) ↔ φ.Realize v xs",
" (φ.restrictFreeVar id).Real... | [
" f = g",
" { toFun := toFun✝, map_formula' := map_formula'✝ } = g",
" { toFun := toFun✝¹, map_formula' := map_formula'✝¹ } = { toFun := toFun✝, map_formula' := map_formula'✝ }",
" toFun✝¹ = toFun✝",
" toFun✝¹ x = toFun✝ x",
" φ.Realize (⇑f ∘ v) (⇑f ∘ xs) ↔ φ.Realize v xs",
" (φ.restrictFreeVar id).Real... |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ι α : T... | Mathlib/Order/Interval/Finset/Basic.lean | 149 | 149 | theorem right_mem_Ioc : b ∈ Ioc a b ↔ a < b := by | simp only [mem_Ioc, and_true_iff, le_rfl]
| [
" (Icc a b).Nonempty ↔ a ≤ b",
" (Ico a b).Nonempty ↔ a < b",
" (Ioc a b).Nonempty ↔ a < b",
" (Ioo a b).Nonempty ↔ a < b",
" Icc a b = ∅ ↔ ¬a ≤ b",
" Ico a b = ∅ ↔ ¬a < b",
" Ioc a b = ∅ ↔ ¬a < b",
" Ioo a b = ∅ ↔ ¬a < b",
" a ∈ Icc a b ↔ a ≤ b",
" a ∈ Ico a b ↔ a < b",
" b ∈ Icc a b ↔ a ≤ b",
... | [
" (Icc a b).Nonempty ↔ a ≤ b",
" (Ico a b).Nonempty ↔ a < b",
" (Ioc a b).Nonempty ↔ a < b",
" (Ioo a b).Nonempty ↔ a < b",
" Icc a b = ∅ ↔ ¬a ≤ b",
" Ico a b = ∅ ↔ ¬a < b",
" Ioc a b = ∅ ↔ ¬a < b",
" Ioo a b = ∅ ↔ ¬a < b",
" a ∈ Icc a b ↔ a ≤ b",
" a ∈ Ico a b ↔ a < b",
" b ∈ Icc a b ↔ a ≤ b"
] |
import Mathlib.Algebra.Order.Monoid.Defs
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
open Function
universe u
variable {α : Type u}
class OrderedAddCommGroup (α : Ty... | Mathlib/Algebra/Order/Group/Defs.lean | 165 | 166 | theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by |
rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
| [
" b ≤ c",
" 1 < a⁻¹ ↔ a < 1",
" a⁻¹ < 1 ↔ 1 < a"
] | [
" b ≤ c",
" 1 < a⁻¹ ↔ a < 1"
] |
import Mathlib.Algebra.GroupWithZero.NonZeroDivisors
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.RingTheory.Coprime.Basic
import Mathlib.Tactic.AdaptationNote
#align_import ring_theory.polynomial.scale_roots from "leanprover-community/mathlib"@"40ac1b258344e0c2b4568dc37bfad937ec35a727"
variable {R... | Mathlib/RingTheory/Polynomial/ScaleRoots.lean | 98 | 101 | theorem map_scaleRoots (p : R[X]) (x : R) (f : R →+* S) (h : f p.leadingCoeff ≠ 0) :
(p.scaleRoots x).map f = (p.map f).scaleRoots (f x) := by |
ext
simp [Polynomial.natDegree_map_of_leadingCoeff_ne_zero _ h]
| [
" (p.scaleRoots s).coeff i = p.coeff i * s ^ (p.natDegree - i)",
" (p.scaleRoots s).coeff p.natDegree = p.leadingCoeff",
" scaleRoots 0 s = 0",
" (scaleRoots 0 s).coeff n✝ = coeff 0 n✝",
" p.scaleRoots s ≠ 0",
" False",
" (p.scaleRoots s).support ≤ p.support",
" a✝ ∈ (p.scaleRoots s).support → a✝ ∈ p.... | [
" (p.scaleRoots s).coeff i = p.coeff i * s ^ (p.natDegree - i)",
" (p.scaleRoots s).coeff p.natDegree = p.leadingCoeff",
" scaleRoots 0 s = 0",
" (scaleRoots 0 s).coeff n✝ = coeff 0 n✝",
" p.scaleRoots s ≠ 0",
" False",
" (p.scaleRoots s).support ≤ p.support",
" a✝ ∈ (p.scaleRoots s).support → a✝ ∈ p.... |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
import Mathlib.LinearAlgebra.Projection
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.I... | Mathlib/LinearAlgebra/Dual.lean | 320 | 326 | theorem toDual_total_right (f : ι →₀ R) (i : ι) :
b.toDual (b i) (Finsupp.total ι M R b f) = f i := by |
rw [Finsupp.total_apply, Finsupp.sum, _root_.map_sum]
simp_rw [LinearMap.map_smul, toDual_apply, smul_eq_mul, mul_boole, Finset.sum_ite_eq]
split_ifs with h
· rfl
· rw [Finsupp.not_mem_support_iff.mp h]
| [
" (b.toDual (b i)) (b j) = if i = j then 1 else 0",
" (if j = i then 1 else 0) = if i = j then 1 else 0",
" (b.toDual ((Finsupp.total ι M R ⇑b) f)) (b i) = f i",
" ∑ d ∈ f.support, (b.toDual (f d • b d)) (b i) = f i",
" (if i ∈ f.support then f i else 0) = f i",
" f i = f i",
" 0 = f i",
" (b.toDual (... | [
" (b.toDual (b i)) (b j) = if i = j then 1 else 0",
" (if j = i then 1 else 0) = if i = j then 1 else 0",
" (b.toDual ((Finsupp.total ι M R ⇑b) f)) (b i) = f i",
" ∑ d ∈ f.support, (b.toDual (f d • b d)) (b i) = f i",
" (if i ∈ f.support then f i else 0) = f i",
" f i = f i",
" 0 = f i"
] |
import Mathlib.CategoryTheory.Sites.Plus
import Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory
#align_import category_theory.sites.sheafification from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
namespace CategoryTheory
open CategoryTheory.Limits Opposite
universe w v u
var... | Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean | 483 | 486 | theorem sheafifyMap_comp {P Q R : Cᵒᵖ ⥤ D} (η : P ⟶ Q) (γ : Q ⟶ R) :
J.sheafifyMap (η ≫ γ) = J.sheafifyMap η ≫ J.sheafifyMap γ := by |
dsimp [sheafifyMap, sheafify]
simp
| [
" J.sheafifyMap (𝟙 P) = 𝟙 (J.sheafify P)",
" J.plusMap (J.plusMap (𝟙 P)) = 𝟙 (J.plusObj (J.plusObj P))",
" J.sheafifyMap (η ≫ γ) = J.sheafifyMap η ≫ J.sheafifyMap γ",
" J.plusMap (J.plusMap (η ≫ γ)) = J.plusMap (J.plusMap η) ≫ J.plusMap (J.plusMap γ)"
] | [
" J.sheafifyMap (𝟙 P) = 𝟙 (J.sheafify P)",
" J.plusMap (J.plusMap (𝟙 P)) = 𝟙 (J.plusObj (J.plusObj P))"
] |
import Mathlib.RingTheory.WittVector.Frobenius
import Mathlib.RingTheory.WittVector.Verschiebung
import Mathlib.RingTheory.WittVector.MulP
#align_import ring_theory.witt_vector.identities from "leanprover-community/mathlib"@"0798037604b2d91748f9b43925fb7570a5f3256c"
namespace WittVector
variable {p : ℕ} {R : Typ... | Mathlib/RingTheory/WittVector/Identities.lean | 57 | 61 | theorem coeff_p_pow [CharP R p] (i : ℕ) : ((p : 𝕎 R) ^ i).coeff i = 1 := by |
induction' i with i h
· simp only [Nat.zero_eq, one_coeff_zero, Ne, pow_zero]
· rw [pow_succ, ← frobenius_verschiebung, coeff_frobenius_charP,
verschiebung_coeff_succ, h, one_pow]
| [
" frobenius (verschiebung x) = x * ↑p",
" ∀ (n : ℕ), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * ↑p)",
" verschiebung x = x * ↑p",
" (↑p ^ i).coeff i = 1",
" (↑p ^ 0).coeff 0 = 1",
" (↑p ^ (i + 1)).coeff (i + 1) = 1"
] | [
" frobenius (verschiebung x) = x * ↑p",
" ∀ (n : ℕ), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * ↑p)",
" verschiebung x = x * ↑p"
] |
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.Algebra.Polynomial.RingDivision
#align_import field_theory.ratfunc from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d010e417b10abb1b6"
noncomputable section
open scoped Classical
open scoped nonZeroDivisors Polynomial
universe u v
va... | Mathlib/FieldTheory/RatFunc/Defs.lean | 181 | 185 | theorem mk_eq_localization_mk (p : K[X]) {q : K[X]} (hq : q ≠ 0) :
RatFunc.mk p q =
ofFractionRing (Localization.mk p ⟨q, mem_nonZeroDivisors_iff_ne_zero.mpr hq⟩) := by |
-- Porting note: the original proof, did not need to pass `hq`
rw [mk_def_of_ne _ hq, Localization.mk_eq_mk']
| [
" { toFractionRing := x } = { toFractionRing := y }",
" { toFractionRing := x } = { toFractionRing := { toFractionRing := x }.toFractionRing }",
" P",
" ∀ {a c : K[X]} {b d : ↥K[X]⁰},\n (Localization.r K[X]⁰) (a, b) (c, d) → (fun p q => f p ↑q) a b = (fun p q => f p ↑q) c d",
" (fun p q => f p ↑q) p q = ... | [
" { toFractionRing := x } = { toFractionRing := y }",
" { toFractionRing := x } = { toFractionRing := { toFractionRing := x }.toFractionRing }",
" P",
" ∀ {a c : K[X]} {b d : ↥K[X]⁰},\n (Localization.r K[X]⁰) (a, b) (c, d) → (fun p q => f p ↑q) a b = (fun p q => f p ↑q) c d",
" (fun p q => f p ↑q) p q = ... |
import Mathlib.Data.Matrix.Basic
import Mathlib.Data.PEquiv
#align_import data.matrix.pequiv from "leanprover-community/mathlib"@"3e068ece210655b7b9a9477c3aff38a492400aa1"
namespace PEquiv
open Matrix
universe u v
variable {k l m n : Type*}
variable {α : Type v}
open Matrix
def toMatrix [DecidableEq n] [Zer... | Mathlib/Data/Matrix/PEquiv.lean | 152 | 155 | theorem single_mul_single [Fintype n] [DecidableEq k] [DecidableEq m] [DecidableEq n] [Semiring α]
(a : m) (b : n) (c : k) :
((single a b).toMatrix : Matrix _ _ α) * (single b c).toMatrix = (single a c).toMatrix := by |
rw [← toMatrix_trans, single_trans_single]
| [
" (f.toMatrix * M) i j = Option.casesOn (f i) 0 fun fi => M fi j",
" ∑ j_1 : m, (if j_1 ∈ f i then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) (f i)",
" ∑ j_1 : m, (if j_1 ∈ none then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) none",
" ∑ j_1 : m, (if j_1 ∈ some fi then 1 else 0) * M j... | [
" (f.toMatrix * M) i j = Option.casesOn (f i) 0 fun fi => M fi j",
" ∑ j_1 : m, (if j_1 ∈ f i then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) (f i)",
" ∑ j_1 : m, (if j_1 ∈ none then 1 else 0) * M j_1 j = Option.rec 0 (fun val => M val j) none",
" ∑ j_1 : m, (if j_1 ∈ some fi then 1 else 0) * M j... |
import Mathlib.GroupTheory.GroupAction.BigOperators
import Mathlib.Logic.Equiv.Fin
import Mathlib.Algebra.BigOperators.Pi
import Mathlib.Algebra.Module.Prod
import Mathlib.Algebra.Module.Submodule.Ker
#align_import linear_algebra.pi from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
un... | Mathlib/LinearAlgebra/Pi.lean | 64 | 66 | theorem pi_eq_zero (f : (i : ι) → M₂ →ₗ[R] φ i) : pi f = 0 ↔ ∀ i, f i = 0 := by |
simp only [LinearMap.ext_iff, pi_apply, funext_iff];
exact ⟨fun h a b => h b a, fun h a b => h b a⟩
| [
" ker (pi f) = ⨅ i, ker (f i)",
" c ∈ ker (pi f) ↔ c ∈ ⨅ i, ker (f i)",
" pi f = 0 ↔ ∀ (i : ι), f i = 0",
" (∀ (x : M₂) (a : ι), (f a) x = 0 x a) ↔ ∀ (i : ι) (x : M₂), (f i) x = 0 x"
] | [
" ker (pi f) = ⨅ i, ker (f i)",
" c ∈ ker (pi f) ↔ c ∈ ⨅ i, ker (f i)"
] |
import Mathlib.Order.Interval.Set.OrdConnected
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.ord_connected_component from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open Interval Function OrderDual
namespace Set
variable {α : Type*} [LinearOrder α] {s t : Set α}... | Mathlib/Order/Interval/Set/OrdConnectedComponent.lean | 142 | 149 | theorem dual_ordConnectedSection (s : Set α) :
ordConnectedSection (ofDual ⁻¹' s) = ofDual ⁻¹' ordConnectedSection s := by |
simp only [ordConnectedSection]
simp (config := { unfoldPartialApp := true }) only [ordConnectedProj]
ext x
simp only [mem_range, Subtype.exists, mem_preimage, OrderDual.exists, dual_ordConnectedComponent,
ofDual_toDual]
tauto
| [
" toDual x ∈ (⇑ofDual ⁻¹' s).ordConnectedComponent (toDual x✝) ↔ toDual x ∈ ⇑ofDual ⁻¹' s.ordConnectedComponent x✝",
" ⇑ofDual ⁻¹' [[x✝, x]] ⊆ ⇑ofDual ⁻¹' s ↔ toDual x ∈ ⇑ofDual ⁻¹' s.ordConnectedComponent x✝",
" x ∈ s.ordConnectedComponent x ↔ x ∈ s",
" s.ordConnectedComponent x = ∅ ↔ x ∉ s",
" univ.ordCon... | [
" toDual x ∈ (⇑ofDual ⁻¹' s).ordConnectedComponent (toDual x✝) ↔ toDual x ∈ ⇑ofDual ⁻¹' s.ordConnectedComponent x✝",
" ⇑ofDual ⁻¹' [[x✝, x]] ⊆ ⇑ofDual ⁻¹' s ↔ toDual x ∈ ⇑ofDual ⁻¹' s.ordConnectedComponent x✝",
" x ∈ s.ordConnectedComponent x ↔ x ∈ s",
" s.ordConnectedComponent x = ∅ ↔ x ∉ s",
" univ.ordCon... |
import Mathlib.Analysis.InnerProductSpace.Orthogonal
import Mathlib.Analysis.Normed.Group.AddTorsor
#align_import geometry.euclidean.basic from "leanprover-community/mathlib"@"2de9c37fa71dde2f1c6feff19876dd6a7b1519f0"
open Set
open scoped RealInnerProductSpace
variable {V P : Type*} [NormedAddCommGroup V] [InnerP... | Mathlib/Geometry/Euclidean/PerpBisector.lean | 92 | 95 | theorem mem_perpBisector_iff_dist_eq : c ∈ perpBisector p₁ p₂ ↔ dist c p₁ = dist c p₂ := by |
rw [dist_eq_norm_vsub V, dist_eq_norm_vsub V, ← real_inner_add_sub_eq_zero_iff,
vsub_sub_vsub_cancel_left, inner_add_left, add_eq_zero_iff_eq_neg, ← inner_neg_right,
neg_vsub_eq_vsub_rev, mem_perpBisector_iff_inner_eq_inner]
| [
" c ∈ perpBisector p₁ p₂ ↔ ⟪(Equiv.pointReflection c) p₁ -ᵥ p₂, p₂ -ᵥ p₁⟫_ℝ = 0",
" 2⁻¹ * ⟪c -ᵥ p₁ + (c -ᵥ p₂), p₂ -ᵥ p₁⟫_ℝ = 0 ↔ ⟪c -ᵥ p₁ + (c -ᵥ p₂), p₂ -ᵥ p₁⟫_ℝ = 0",
" c ∈ perpBisector p₁ ((Equiv.pointReflection p₂) p₁) ↔ ⟪c -ᵥ p₂, p₁ -ᵥ p₂⟫_ℝ = 0",
" midpoint ℝ p₁ p₂ ∈ perpBisector p₁ p₂",
" (perpBisec... | [
" c ∈ perpBisector p₁ p₂ ↔ ⟪(Equiv.pointReflection c) p₁ -ᵥ p₂, p₂ -ᵥ p₁⟫_ℝ = 0",
" 2⁻¹ * ⟪c -ᵥ p₁ + (c -ᵥ p₂), p₂ -ᵥ p₁⟫_ℝ = 0 ↔ ⟪c -ᵥ p₁ + (c -ᵥ p₂), p₂ -ᵥ p₁⟫_ℝ = 0",
" c ∈ perpBisector p₁ ((Equiv.pointReflection p₂) p₁) ↔ ⟪c -ᵥ p₂, p₁ -ᵥ p₂⟫_ℝ = 0",
" midpoint ℝ p₁ p₂ ∈ perpBisector p₁ p₂",
" (perpBisec... |
import Mathlib.Algebra.ModEq
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Periodic
import Mathlib.Data.Int.SuccPred
import Mathlib.GroupTheory.QuotientGroup
import Mathlib.Order.Circular
import Mathlib.Data.List.TFAE
import Mathlib.Data.Set.Lattice
#align_import a... | Mathlib/Algebra/Order/ToIntervalMod.lean | 123 | 124 | theorem toIcoDiv_zsmul_sub_self (a b : α) : toIcoDiv hp a b • p - b = -toIcoMod hp a b := by |
rw [toIcoMod, neg_sub]
| [
" toIcoMod hp 0 b ∈ Set.Ico 0 p",
" p = 0 + p",
" toIcoDiv hp a b • p - b = -toIcoMod hp a b"
] | [
" toIcoMod hp 0 b ∈ Set.Ico 0 p",
" p = 0 + p"
] |
import Mathlib.Algebra.Order.Ring.Defs
import Mathlib.Algebra.Group.Int
import Mathlib.Data.Nat.Dist
import Mathlib.Data.Ordmap.Ordnode
import Mathlib.Tactic.Abel
import Mathlib.Tactic.Linarith
#align_import data.ordmap.ordset from "leanprover-community/mathlib"@"47b51515e69f59bca5cf34ef456e6000fe205a69"
variable... | Mathlib/Data/Ordmap/Ordset.lean | 114 | 115 | theorem Sized.eq_node' {s l x r} (h : @Sized α (node s l x r)) : node s l x r = .node' l x r := by |
rw [h.1]
| [
" 0 < delta",
" a ≤ delta * (delta * a)",
" 1 ≤ delta * delta",
" node s l x r = l.node' x r"
] | [
" 0 < delta",
" a ≤ delta * (delta * a)",
" 1 ≤ delta * delta"
] |
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Zip
import Mathlib.Data.Nat.Defs
import Mathlib.Data.List.Infix
#align_import data.list.rotate from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
universe u
variable {α : Type u}
open Nat Function
namespace List
theorem rotate... | Mathlib/Data/List/Rotate.lean | 142 | 144 | theorem rotate_eq_drop_append_take {l : List α} {n : ℕ} :
n ≤ l.length → l.rotate n = l.drop n ++ l.take n := by |
rw [rotate_eq_rotate']; exact rotate'_eq_drop_append_take
| [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []",
" l.rotate 0 = l",
" [].rotate' n = []",
" [].rotate' 0 = []",
" [].rotate' (n✝ + 1) = []",
" l.rotate' 0 = l",
" (head✝ :: tail✝).rotate' 0 = head✝ :: tail✝",
" (a :: l).rotate' n.succ = (l ++ [a]).rotate' n",
" ([].rotate' x✝).length ... | [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []",
" l.rotate 0 = l",
" [].rotate' n = []",
" [].rotate' 0 = []",
" [].rotate' (n✝ + 1) = []",
" l.rotate' 0 = l",
" (head✝ :: tail✝).rotate' 0 = head✝ :: tail✝",
" (a :: l).rotate' n.succ = (l ++ [a]).rotate' n",
" ([].rotate' x✝).length ... |
import Mathlib.Topology.Order
import Mathlib.Topology.Sets.Opens
import Mathlib.Topology.ContinuousFunction.Basic
#align_import topology.continuous_function.t0_sierpinski from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
noncomputable section
namespace TopologicalSpace
theorem eq_in... | Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean | 55 | 58 | theorem productOfMemOpens_injective [T0Space X] : Function.Injective (productOfMemOpens X) := by |
intro x1 x2 h
apply Inseparable.eq
rw [← Inducing.inseparable_iff (productOfMemOpens_inducing X), h]
| [
" t = ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace",
" t ≤ ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace",
" ∀ (i : Opens X), t ≤ induced (fun x => x ∈ i) sierpinskiSpace",
" ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace ≤ t",
" IsOpen u",
" u ∈ ⋃ i, {s | IsOpen s}",
" ∃ i t_1, IsOpen t_1 ∧ (fun x => x... | [
" t = ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace",
" t ≤ ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace",
" ∀ (i : Opens X), t ≤ induced (fun x => x ∈ i) sierpinskiSpace",
" ⨅ u, induced (fun x => x ∈ u) sierpinskiSpace ≤ t",
" IsOpen u",
" u ∈ ⋃ i, {s | IsOpen s}",
" ∃ i t_1, IsOpen t_1 ∧ (fun x => x... |
import Mathlib.Algebra.Ring.InjSurj
import Mathlib.Algebra.Group.Units.Hom
import Mathlib.Algebra.Ring.Hom.Defs
#align_import algebra.ring.units from "leanprover-community/mathlib"@"2ed7e4aec72395b6a7c3ac4ac7873a7a43ead17c"
universe u v w x
variable {α : Type u} {β : Type v} {γ : Type w} {R : Type x}
open Funct... | Mathlib/Algebra/Ring/Units.lean | 50 | 50 | theorem neg_divp (a : α) (u : αˣ) : -(a /ₚ u) = -a /ₚ u := by | simp only [divp, neg_mul]
| [
" -↑u * -↑u⁻¹ = 1",
" -↑u⁻¹ * -↑u = 1",
" -(a /ₚ u) = -a /ₚ u"
] | [
" -↑u * -↑u⁻¹ = 1",
" -↑u⁻¹ * -↑u = 1"
] |
import Batteries.Data.Nat.Gcd
import Mathlib.Init.Data.Nat.Notation
import Mathlib.Mathport.Rename
#align_import init.data.nat.gcd from "leanprover-community/lean"@"855e5b74e3a52a40552e8f067169d747d48743fd"
open WellFounded
namespace Nat
#align nat.gcd Nat.gcd
#align nat.gcd_zero_left Nat.gcd_zero_left
#alig... | Mathlib/Init/Data/Nat/GCD.lean | 35 | 36 | theorem gcd_def (x y : ℕ) : gcd x y = if x = 0 then y else gcd (y % x) x := by |
cases x <;> simp [Nat.gcd_succ]
| [
" x.gcd y = if x = 0 then y else (y % x).gcd x",
" gcd 0 y = if 0 = 0 then y else (y % 0).gcd 0",
" (n✝ + 1).gcd y = if n✝ + 1 = 0 then y else (y % (n✝ + 1)).gcd (n✝ + 1)"
] | [] |
import Mathlib.Algebra.ContinuedFractions.Translations
#align_import algebra.continued_fractions.continuants_recurrence from "leanprover-community/mathlib"@"5f11361a98ae4acd77f5c1837686f6f0102cdc25"
namespace GeneralizedContinuedFraction
variable {K : Type*} {g : GeneralizedContinuedFraction K} {n : ℕ} [Division... | Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean | 33 | 38 | theorem continuants_recurrenceAux {gp ppred pred : Pair K} (nth_s_eq : g.s.get? n = some gp)
(nth_conts_aux_eq : g.continuantsAux n = ppred)
(succ_nth_conts_aux_eq : g.continuantsAux (n + 1) = pred) :
g.continuants (n + 1) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩ := by |
simp [nth_cont_eq_succ_nth_cont_aux,
continuantsAux_recurrence nth_s_eq nth_conts_aux_eq succ_nth_conts_aux_eq]
| [
" g.continuantsAux (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }",
" g.continuants (n + 1) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }"
] | [
" g.continuantsAux (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }"
] |
import Mathlib.SetTheory.Game.Ordinal
import Mathlib.SetTheory.Ordinal.NaturalOps
#align_import set_theory.game.birthday from "leanprover-community/mathlib"@"a347076985674932c0e91da09b9961ed0a79508c"
universe u
open Ordinal
namespace SetTheory
open scoped NaturalOps PGame
namespace PGame
noncomputable def b... | Mathlib/SetTheory/Game/Birthday.lean | 54 | 56 | theorem birthday_moveLeft_lt {x : PGame} (i : x.LeftMoves) :
(x.moveLeft i).birthday < x.birthday := by |
cases x; rw [birthday]; exact lt_max_of_lt_left (lt_lsub _ i)
| [
" x.birthday = max (lsub fun i => (x.moveLeft i).birthday) (lsub fun i => (x.moveRight i).birthday)",
" (mk α✝ β✝ a✝¹ a✝).birthday =\n max (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday) (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday)",
" max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (... | [
" x.birthday = max (lsub fun i => (x.moveLeft i).birthday) (lsub fun i => (x.moveRight i).birthday)",
" (mk α✝ β✝ a✝¹ a✝).birthday =\n max (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday) (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday)",
" max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (... |
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
import Mathlib.Analysis.Complex.CauchyIntegral
#align_import analysis.complex.removable_singularity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open TopologicalSpace Metric S... | Mathlib/Analysis/Complex/RemovableSingularity.lean | 71 | 87 | theorem differentiableOn_update_limUnder_of_isLittleO {f : ℂ → E} {s : Set ℂ} {c : ℂ} (hc : s ∈ 𝓝 c)
(hd : DifferentiableOn ℂ f (s \ {c}))
(ho : (fun z => f z - f c) =o[𝓝[≠] c] fun z => (z - c)⁻¹) :
DifferentiableOn ℂ (update f c (limUnder (𝓝[≠] c) f)) s := by |
set F : ℂ → E := fun z => (z - c) • f z
suffices DifferentiableOn ℂ F (s \ {c}) ∧ ContinuousAt F c by
rw [differentiableOn_compl_singleton_and_continuousAt_iff hc, ← differentiableOn_dslope hc,
dslope_sub_smul] at this
have hc : Tendsto f (𝓝[≠] c) (𝓝 (deriv F c)) :=
continuousAt_update_same.m... | [
" AnalyticAt ℂ f c",
" ContinuousOn f (closedBall c ↑R)",
" ContinuousAt f z",
" DifferentiableOn ℂ f (s \\ {c}) ∧ ContinuousAt f c ↔ DifferentiableOn ℂ f s",
" DifferentiableOn ℂ f (s \\ {c}) ∧ ContinuousAt f c → DifferentiableOn ℂ f s",
" DifferentiableWithinAt ℂ f s x",
" ∀ᶠ (z : ℂ) in 𝓝[≠] x, Diffe... | [
" AnalyticAt ℂ f c",
" ContinuousOn f (closedBall c ↑R)",
" ContinuousAt f z",
" DifferentiableOn ℂ f (s \\ {c}) ∧ ContinuousAt f c ↔ DifferentiableOn ℂ f s",
" DifferentiableOn ℂ f (s \\ {c}) ∧ ContinuousAt f c → DifferentiableOn ℂ f s",
" DifferentiableWithinAt ℂ f s x",
" ∀ᶠ (z : ℂ) in 𝓝[≠] x, Diffe... |
import Mathlib.Analysis.Normed.Group.InfiniteSum
import Mathlib.Analysis.Normed.MulAction
import Mathlib.Topology.Algebra.Order.LiminfLimsup
import Mathlib.Topology.PartialHomeomorph
#align_import analysis.asymptotics.asymptotics from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open ... | Mathlib/Analysis/Asymptotics/Asymptotics.lean | 109 | 109 | theorem isBigO_iff_isBigOWith : f =O[l] g ↔ ∃ c : ℝ, IsBigOWith c l f g := by | rw [IsBigO_def]
| [
" IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖",
" f =O[l] g ↔ ∃ c, IsBigOWith c l f g"
] | [
" IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖"
] |
import Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.measure.haar.normed_space from "leanprover-community/mathlib"@"b84aee748341da06a6d78491367e2c0e9f15e8a5"
noncomputable sect... | Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean | 163 | 177 | theorem integrable_comp_smul_iff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
[MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] (μ : Measure E) [IsAddHaarMeasure μ]
(f : E → F) {R : ℝ} (hR : R ≠ 0) : Integrable (fun x => f (R • x)) μ ↔ Integrable f μ := by |
-- reduce to one-way implication
suffices
∀ {g : E → F} (_ : Integrable g μ) {S : ℝ} (_ : S ≠ 0), Integrable (fun x => g (S • x)) μ by
refine ⟨fun hf => ?_, fun hf => this hf hR⟩
convert this hf (inv_ne_zero hR)
rw [← mul_smul, mul_inv_cancel hR, one_smul]
-- now prove
intro g hg S hS
let t :... | [
" NoAtoms μ",
" Integrable (fun x => f (R • x)) μ ↔ Integrable f μ",
" Integrable f μ",
" x✝ = R • R⁻¹ • x✝",
" ∀ {g : E → F}, Integrable g μ → ∀ {S : ℝ}, S ≠ 0 → Integrable (fun x => g (S • x)) μ",
" Integrable (fun x => g (S • x)) μ",
" Integrable g (map (fun x => S • x) μ)",
" ENNReal.ofReal |(S ^ ... | [
" NoAtoms μ"
] |
import Mathlib.Algebra.Field.Defs
import Mathlib.Algebra.GroupWithZero.Units.Lemmas
import Mathlib.Algebra.Ring.Commute
import Mathlib.Algebra.Ring.Invertible
import Mathlib.Order.Synonym
#align_import algebra.field.basic from "leanprover-community/mathlib"@"05101c3df9d9cfe9430edc205860c79b6d660102"
open Function ... | Mathlib/Algebra/Field/Basic.lean | 101 | 106 | theorem one_div_neg_eq_neg_one_div (a : K) : 1 / -a = -(1 / a) :=
calc
1 / -a = 1 / (-1 * a) := by | rw [neg_eq_neg_one_mul]
_ = 1 / a * (1 / -1) := by rw [one_div_mul_one_div_rev]
_ = 1 / a * -1 := by rw [one_div_neg_one_eq_neg_one]
_ = -(1 / a) := by rw [mul_neg, mul_one]
| [
" -1 * -1 = 1",
" 1 / -a = 1 / (-1 * a)",
" 1 / (-1 * a) = 1 / a * (1 / -1)",
" 1 / a * (1 / -1) = 1 / a * -1",
" 1 / a * -1 = -(1 / a)"
] | [
" -1 * -1 = 1"
] |
import Mathlib.Data.ENat.Lattice
import Mathlib.Order.OrderIsoNat
import Mathlib.Tactic.TFAE
#align_import order.height from "leanprover-community/mathlib"@"bf27744463e9620ca4e4ebe951fe83530ae6949b"
open List hiding le_antisymm
open OrderDual
universe u v
variable {α β : Type*}
namespace Set
section LT
varia... | Mathlib/Order/Height.lean | 109 | 114 | theorem le_chainHeight_TFAE (n : ℕ) :
TFAE [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, length l = n, ∃ l ∈ s.subchain, n ≤ length l] := by |
tfae_have 1 → 2; · exact s.exists_chain_of_le_chainHeight
tfae_have 2 → 3; · rintro ⟨l, hls, he⟩; exact ⟨l, hls, he.ge⟩
tfae_have 3 → 1; · rintro ⟨l, hs, hn⟩; exact le_iSup₂_of_le l hs (WithTop.coe_le_coe.2 hn)
tfae_finish
| [
" a :: l ∈ s.subchain ↔ a ∈ s ∧ l ∈ s.subchain ∧ ∀ b ∈ l.head?, a < b",
" [a] ∈ s.subchain ↔ a ∈ s",
" ∃ l ∈ s.subchain, l.length = n",
" n ≤ l.length",
" [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE",
" ↑n ≤ s.chainHeight → ∃ l ∈ s.subchain, l.length = n",
"... | [
" a :: l ∈ s.subchain ↔ a ∈ s ∧ l ∈ s.subchain ∧ ∀ b ∈ l.head?, a < b",
" [a] ∈ s.subchain ↔ a ∈ s",
" ∃ l ∈ s.subchain, l.length = n",
" n ≤ l.length"
] |
import Mathlib.Algebra.MvPolynomial.Derivation
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.pderiv from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
universe u v
namespace MvPolynomial
open Set Function Finsupp
variable {R : ... | Mathlib/Algebra/MvPolynomial/PDeriv.lean | 69 | 77 | theorem pderiv_monomial {i : σ} :
pderiv i (monomial s a) = monomial (s - single i 1) (a * s i) := by |
classical
simp only [pderiv_def, mkDerivation_monomial, Finsupp.smul_sum, smul_eq_mul, ← smul_mul_assoc,
← (monomial _).map_smul]
refine (Finset.sum_eq_single i (fun j _ hne => ?_) fun hi => ?_).trans ?_
· simp [Pi.single_eq_of_ne hne]
· rw [Finsupp.not_mem_support_iff] at hi; simp [hi]
· s... | [
" pderiv i = mkDerivation R (Pi.single i 1)",
" mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)",
" (pderiv i) ((monomial s) a) = (monomial (s - single i 1)) (a * ↑(s i))",
" (s.sum fun a_1 b => (monomial (s - single a_1 1)) (a * ↑b) * Pi.single i 1 a_1) =\n (monomial (s - single i 1)) (a *... | [
" pderiv i = mkDerivation R (Pi.single i 1)",
" mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)"
] |
import Mathlib.CategoryTheory.Equivalence
#align_import algebraic_topology.dold_kan.compatibility from "leanprover-community/mathlib"@"32a7e535287f9c73f2e4d2aef306a39190f0b504"
open CategoryTheory CategoryTheory.Category
namespace AlgebraicTopology
namespace DoldKan
namespace Compatibility
variable {A A' B B'... | Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean | 133 | 138 | theorem equivalence₂CounitIso_eq :
(equivalence₂ eB hF).counitIso = equivalence₂CounitIso eB hF := by |
ext Y'
dsimp [equivalence₂, Iso.refl]
simp only [equivalence₁CounitIso_eq, equivalence₂CounitIso_hom_app,
equivalence₁CounitIso_hom_app, Functor.map_comp, assoc]
| [
" (equivalence₁ hF).counitIso = equivalence₁CounitIso hF",
" (equivalence₁ hF).counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y",
" (equivalence₁ hF).unitIso = equivalence₁UnitIso hF",
" (equivalence₁ hF).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X",
" (equivalence₂ eB hF).counitIso = e... | [
" (equivalence₁ hF).counitIso = equivalence₁CounitIso hF",
" (equivalence₁ hF).counitIso.hom.app Y = (equivalence₁CounitIso hF).hom.app Y",
" (equivalence₁ hF).unitIso = equivalence₁UnitIso hF",
" (equivalence₁ hF).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X"
] |
import Mathlib.LinearAlgebra.Dimension.Free
import Mathlib.Algebra.Module.Torsion
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomputable section
universe u v v' u₁' w w'
variable {R S : Type u} {M : Type v} {M' : Type v'} {M₁ : Type v}... | Mathlib/LinearAlgebra/Dimension/Constructions.lean | 550 | 552 | theorem Subalgebra.rank_top : Module.rank F (⊤ : Subalgebra F E) = Module.rank F E := by |
rw [subalgebra_top_rank_eq_submodule_top_rank]
exact _root_.rank_top F E
| [
" Module.rank R (ι →₀ M) = lift.{v, w} #ι * lift.{w, v} (Module.rank R M)",
" Module.rank R (ι →₀ M) = #ι * Module.rank R M",
" Module.rank R (ι →₀ R) = lift.{u, w} #ι",
" Module.rank R (ι →₀ R) = #ι",
" Module.rank R (⨁ (i : ι), M i) = sum fun i => Module.rank R (M i)",
" Module.rank R (Matrix m n R) = l... | [
" Module.rank R (ι →₀ M) = lift.{v, w} #ι * lift.{w, v} (Module.rank R M)",
" Module.rank R (ι →₀ M) = #ι * Module.rank R M",
" Module.rank R (ι →₀ R) = lift.{u, w} #ι",
" Module.rank R (ι →₀ R) = #ι",
" Module.rank R (⨁ (i : ι), M i) = sum fun i => Module.rank R (M i)",
" Module.rank R (Matrix m n R) = l... |
import Mathlib.Data.Fintype.Card
import Mathlib.Order.UpperLower.Basic
#align_import combinatorics.set_family.intersecting from "leanprover-community/mathlib"@"d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46"
open Finset
variable {α : Type*}
namespace Set
section SemilatticeInf
variable [SemilatticeInf α] [OrderBot ... | Mathlib/Combinatorics/SetFamily/Intersecting.lean | 122 | 130 | theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
(h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by |
classical
rintro a b hab ha
rw [h (Insert.insert b s) _ (Finset.subset_insert _ _)]
· exact mem_insert_self _ _
rw [coe_insert]
exact
hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
| [
" {a}.Intersecting ↔ a ≠ ⊥",
" (insert a s).Intersecting",
" ¬Disjoint c c",
" ¬Disjoint b c",
" s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}",
" s ≠ {⊥}",
" False",
" s.Intersecting ↔ s = ∅",
" ⊥ ∈ s",
" s = ∅ → s ≠ {⊥}",
" ∅ ≠ {⊥}",
" IsUpperSet s",
" b ∈ s",
" b ∈ in... | [
" {a}.Intersecting ↔ a ≠ ⊥",
" (insert a s).Intersecting",
" ¬Disjoint c c",
" ¬Disjoint b c",
" s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}",
" s ≠ {⊥}",
" False",
" s.Intersecting ↔ s = ∅",
" ⊥ ∈ s",
" s = ∅ → s ≠ {⊥}",
" ∅ ≠ {⊥}",
" IsUpperSet s",
" b ∈ s",
" b ∈ in... |
import Mathlib.Topology.Algebra.InfiniteSum.Group
import Mathlib.Logic.Encodable.Lattice
noncomputable section
open Filter Finset Function Encodable
open scoped Topology
variable {M : Type*} [CommMonoid M] [TopologicalSpace M] {m m' : M}
variable {G : Type*} [CommGroup G] {g g' : G}
-- don't declare [Topologic... | Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean | 88 | 92 | theorem hasProd_iff_tendsto_nat [T2Space M] {f : ℕ → M} (hf : Multipliable f) :
HasProd f m ↔ Tendsto (fun n : ℕ ↦ ∏ i ∈ range n, f i) atTop (𝓝 m) := by |
refine ⟨fun h ↦ h.tendsto_prod_nat, fun h ↦ ?_⟩
rw [tendsto_nhds_unique h hf.hasProd.tendsto_prod_nat]
exact hf.hasProd
| [
" HasProd f m ↔ Tendsto (fun n => ∏ i ∈ range n, f i) atTop (𝓝 m)",
" HasProd f m",
" HasProd f (∏' (b : ℕ), f b)"
] | [] |
namespace Nat
@[reducible] def Coprime (m n : Nat) : Prop := gcd m n = 1
instance (m n : Nat) : Decidable (Coprime m n) := inferInstanceAs (Decidable (_ = 1))
theorem coprime_iff_gcd_eq_one : Coprime m n ↔ gcd m n = 1 := .rfl
theorem Coprime.gcd_eq_one : Coprime m n → gcd m n = 1 := id
theorem Coprime.symm ... | .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean | 108 | 118 | theorem Coprime.coprime_div_left (cmn : Coprime m n) (dvd : a ∣ m) : Coprime (m / a) n := by |
match eq_zero_or_pos a with
| .inl h0 =>
rw [h0] at dvd
rw [Nat.eq_zero_of_zero_dvd dvd] at cmn ⊢
simp; assumption
| .inr hpos =>
let ⟨k, hk⟩ := dvd
rw [hk, Nat.mul_div_cancel_left _ hpos]
rw [hk] at cmn
exact cmn.coprime_mul_left
| [
" k ∣ m",
" k ∣ n * m",
" ((k * m).gcd n).Coprime k",
" (m * k).gcd n = m.gcd n",
" m.gcd (k * n) = m.gcd n",
" m.gcd (n * k) = m.gcd n",
" (m / m.gcd n).Coprime (n / m.gcd n)",
" d ∣ 1",
" d ∣ m.gcd n",
" ∃ m' n', m'.Coprime n' ∧ m = m' * m.gcd n ∧ n = n' * m.gcd n",
" m = 1 * m.gcd n ∧ n = 1 *... | [
" k ∣ m",
" k ∣ n * m",
" ((k * m).gcd n).Coprime k",
" (m * k).gcd n = m.gcd n",
" m.gcd (k * n) = m.gcd n",
" m.gcd (n * k) = m.gcd n",
" (m / m.gcd n).Coprime (n / m.gcd n)",
" d ∣ 1",
" d ∣ m.gcd n",
" ∃ m' n', m'.Coprime n' ∧ m = m' * m.gcd n ∧ n = n' * m.gcd n",
" m = 1 * m.gcd n ∧ n = 1 *... |
import Mathlib.CategoryTheory.Preadditive.Yoneda.Basic
import Mathlib.CategoryTheory.Preadditive.Injective
import Mathlib.Algebra.Category.GroupCat.EpiMono
import Mathlib.Algebra.Category.ModuleCat.EpiMono
#align_import category_theory.preadditive.yoneda.injective from "leanprover-community/mathlib"@"f8d8465c3c392a93... | Mathlib/CategoryTheory/Preadditive/Yoneda/Injective.lean | 43 | 51 | theorem injective_iff_preservesEpimorphisms_preadditive_yoneda_obj' (J : C) :
Injective J ↔ (preadditiveYonedaObj J).PreservesEpimorphisms := by |
rw [injective_iff_preservesEpimorphisms_yoneda_obj]
refine ⟨fun h : (preadditiveYonedaObj J ⋙ (forget <| ModuleCat (End J))).PreservesEpimorphisms =>
?_, ?_⟩
· exact
Functor.preservesEpimorphisms_of_preserves_of_reflects (preadditiveYonedaObj J) (forget _)
· intro
exact (inferInstance : (preaddit... | [
" Injective J ↔ (preadditiveYoneda.obj J).PreservesEpimorphisms",
" (yoneda.obj J).PreservesEpimorphisms ↔ (preadditiveYoneda.obj J).PreservesEpimorphisms",
" (preadditiveYoneda.obj J).PreservesEpimorphisms",
" (preadditiveYoneda.obj J).PreservesEpimorphisms → (yoneda.obj J).PreservesEpimorphisms",
" (yoned... | [
" Injective J ↔ (preadditiveYoneda.obj J).PreservesEpimorphisms",
" (yoneda.obj J).PreservesEpimorphisms ↔ (preadditiveYoneda.obj J).PreservesEpimorphisms",
" (preadditiveYoneda.obj J).PreservesEpimorphisms",
" (preadditiveYoneda.obj J).PreservesEpimorphisms → (yoneda.obj J).PreservesEpimorphisms",
" (yoned... |
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
#align_import analysis.special_functions.trigonometric.inverse_deriv from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classic... | Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean | 66 | 71 | theorem hasDerivWithinAt_arcsin_Ici {x : ℝ} (h : x ≠ -1) :
HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x := by |
rcases eq_or_ne x 1 with (rfl | h')
· convert (hasDerivWithinAt_const (1 : ℝ) _ (π / 2)).congr _ _ <;>
simp (config := { contextual := true }) [arcsin_of_one_le]
· exact (hasDerivAt_arcsin h h').hasDerivWithinAt
| [
" HasStrictDerivAt arcsin (1 / √(1 - x ^ 2)) x ∧ ContDiffAt ℝ ⊤ arcsin x",
" 1 - x ^ 2 < 0",
" HasStrictDerivAt arcsin 0 x ∧ ContDiffAt ℝ ⊤ arcsin x",
" 0 < 1 - x ^ 2",
" HasStrictDerivAt arcsin x.arcsin.cos⁻¹ x ∧ ContDiffAt ℝ ⊤ arcsin x",
" HasDerivWithinAt arcsin (1 / √(1 - x ^ 2)) (Ici x) x",
" HasDe... | [
" HasStrictDerivAt arcsin (1 / √(1 - x ^ 2)) x ∧ ContDiffAt ℝ ⊤ arcsin x",
" 1 - x ^ 2 < 0",
" HasStrictDerivAt arcsin 0 x ∧ ContDiffAt ℝ ⊤ arcsin x",
" 0 < 1 - x ^ 2",
" HasStrictDerivAt arcsin x.arcsin.cos⁻¹ x ∧ ContDiffAt ℝ ⊤ arcsin x"
] |
import Mathlib.Data.PNat.Prime
import Mathlib.Algebra.IsPrimePow
import Mathlib.NumberTheory.Cyclotomic.Basic
import Mathlib.RingTheory.Adjoin.PowerBasis
import Mathlib.RingTheory.Polynomial.Cyclotomic.Eval
import Mathlib.RingTheory.Norm
import Mathlib.RingTheory.Polynomial.Cyclotomic.Expand
#align_import number_theo... | Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean | 98 | 100 | theorem zeta_isRoot [IsDomain B] [NeZero ((n : ℕ) : B)] : IsRoot (cyclotomic n B) (zeta n A B) := by |
convert aeval_zeta n A B using 0
rw [IsRoot.def, aeval_def, eval₂_eq_eval_map, map_cyclotomic]
| [
" (aeval (zeta n A B)) (cyclotomic (↑n) A) = 0",
" IsPrimitiveRoot (zeta n A B) ↑n",
" (cyclotomic (↑n) B).IsRoot (zeta n A B)",
" (cyclotomic (↑n) B).IsRoot (zeta n A B) ↔ (aeval (zeta n A B)) (cyclotomic (↑n) A) = 0"
] | [
" (aeval (zeta n A B)) (cyclotomic (↑n) A) = 0",
" IsPrimitiveRoot (zeta n A B) ↑n"
] |
import Mathlib.Analysis.Complex.Circle
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup
#align_import analysis.complex.isometry from "leanprover-community/mathlib"@"ae690b0c236e488a0043f6faa8ce3546e7f2f9c5"
noncomputable section
open Complex
open ComplexConjugate
... | Mathlib/Analysis/Complex/Isometry.lean | 65 | 71 | theorem rotation_ne_conjLIE (a : circle) : rotation a ≠ conjLIE := by |
intro h
have h1 : rotation a 1 = conj 1 := LinearIsometryEquiv.congr_fun h 1
have hI : rotation a I = conj I := LinearIsometryEquiv.congr_fun h I
rw [rotation_apply, RingHom.map_one, mul_one] at h1
rw [rotation_apply, conj_I, ← neg_one_mul, mul_left_inj' I_ne_zero, h1, eq_neg_self_iff] at hI
exact one_ne_z... | [
" Complex.abs (↑a * x) = Complex.abs x",
" (rotation a).trans (rotation b) = rotation (b * a)",
" ((rotation a).trans (rotation b)) x✝ = (rotation (b * a)) x✝",
" rotation a ≠ conjLIE",
" False"
] | [
" Complex.abs (↑a * x) = Complex.abs x",
" (rotation a).trans (rotation b) = rotation (b * a)",
" ((rotation a).trans (rotation b)) x✝ = (rotation (b * a)) x✝"
] |
import Mathlib.NumberTheory.NumberField.Basic
import Mathlib.RingTheory.Localization.NormTrace
#align_import number_theory.number_field.norm from "leanprover-community/mathlib"@"00f91228655eecdcd3ac97a7fd8dbcb139fe990a"
open scoped NumberField
open Finset NumberField Algebra FiniteDimensional
namespace RingOfIn... | Mathlib/NumberTheory/NumberField/Norm.lean | 90 | 99 | theorem dvd_norm [IsGalois K L] (x : 𝓞 L) : x ∣ algebraMap (𝓞 K) (𝓞 L) (norm K x) := by |
classical
have hint :
IsIntegral ℤ (∏ σ ∈ univ.erase (AlgEquiv.refl : L ≃ₐ[K] L), σ x) :=
IsIntegral.prod _ (fun σ _ =>
((RingOfIntegers.isIntegral_coe x).map σ))
refine ⟨⟨_, hint⟩, ?_⟩
ext
rw [coe_algebraMap_norm K x, norm_eq_prod_automorphisms]
simp [← Finset.mul_prod_erase _ _ (mem_univ Al... | [
" (norm K) ((algebraMap (𝓞 K) (𝓞 L)) x) = x ^ finrank K L",
" IsUnit ((norm K) x) ↔ IsUnit x",
" IsUnit x",
" IsUnit (⟨∏ σ ∈ univ \\ {AlgEquiv.refl}, σ ↑x, ⋯⟩ * x)",
" ⟨∏ σ ∈ univ \\ {AlgEquiv.refl}, σ ↑x, ⋯⟩ * x = (algebraMap (𝓞 K) (𝓞 L)) ((norm K) x)",
" ↑(⟨∏ σ ∈ univ \\ {AlgEquiv.refl}, σ ↑x, ⋯⟩ * ... | [
" (norm K) ((algebraMap (𝓞 K) (𝓞 L)) x) = x ^ finrank K L",
" IsUnit ((norm K) x) ↔ IsUnit x",
" IsUnit x",
" IsUnit (⟨∏ σ ∈ univ \\ {AlgEquiv.refl}, σ ↑x, ⋯⟩ * x)",
" ⟨∏ σ ∈ univ \\ {AlgEquiv.refl}, σ ↑x, ⋯⟩ * x = (algebraMap (𝓞 K) (𝓞 L)) ((norm K) x)",
" ↑(⟨∏ σ ∈ univ \\ {AlgEquiv.refl}, σ ↑x, ⋯⟩ * ... |
import Mathlib.Data.Nat.Factorization.Basic
import Mathlib.Data.SetLike.Fintype
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.GroupTheory.PGroup
import Mathlib.GroupTheory.NoncommPiCoprod
import Mathlib.Order.Atoms.Finite
import Mathlib.Data.Set.Lattice
#align_import group_theory.sylow from "leanprove... | Mathlib/GroupTheory/Sylow.lean | 548 | 556 | theorem card_normalizer_modEq_card [Fintype G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime] {H : Subgroup G}
(hH : Fintype.card H = p ^ n) : card (normalizer H) ≡ card G [MOD p ^ (n + 1)] := by |
have : H.subgroupOf (normalizer H) ≃ H := (subgroupOfEquivOfLe le_normalizer).toEquiv
simp only [← Nat.card_eq_fintype_card] at hH ⊢
rw [card_eq_card_quotient_mul_card_subgroup H,
card_eq_card_quotient_mul_card_subgroup (H.subgroupOf (normalizer H)), Nat.card_congr this,
hH, pow_succ']
simp only [Nat.c... | [
" Fintype.card ↑(mk ⁻¹' t) = Fintype.card ↥s * Fintype.card ↑t",
" x⁻¹ * n * x⁻¹⁻¹ ∈ H",
" x⁻¹⁻¹ = x",
" b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H",
" ∀ (x y : Subtype ↑H.normalizer), Setoid.r x y ↔ Setoid.r ↑x ↑y",
" Setoid.r x✝ y✝ ↔ Setoid.r ↑x✝ ↑y✝",
" x✝⁻¹ * y✝ ∈ comap H.normalizer.subtype H ↔ (↑x✝)⁻¹ * ↑y✝... | [
" Fintype.card ↑(mk ⁻¹' t) = Fintype.card ↥s * Fintype.card ↑t",
" x⁻¹ * n * x⁻¹⁻¹ ∈ H",
" x⁻¹⁻¹ = x",
" b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H",
" ∀ (x y : Subtype ↑H.normalizer), Setoid.r x y ↔ Setoid.r ↑x ↑y",
" Setoid.r x✝ y✝ ↔ Setoid.r ↑x✝ ↑y✝",
" x✝⁻¹ * y✝ ∈ comap H.normalizer.subtype H ↔ (↑x✝)⁻¹ * ↑y✝... |
import Mathlib.Data.Nat.Cast.WithTop
import Mathlib.RingTheory.Prime
import Mathlib.RingTheory.Polynomial.Content
import Mathlib.RingTheory.Ideal.Quotient
#align_import ring_theory.eisenstein_criterion from "leanprover-community/mathlib"@"da420a8c6dd5bdfb85c4ced85c34388f633bc6ff"
open Polynomial Ideal.Quotient
v... | Mathlib/RingTheory/EisensteinCriterion.lean | 72 | 78 | theorem isUnit_of_natDegree_eq_zero_of_isPrimitive {p q : R[X]}
-- Porting note: stated using `IsPrimitive` which is defeq to old statement.
(hu : IsPrimitive (p * q)) (hpm : p.natDegree = 0) : IsUnit p := by |
rw [eq_C_of_degree_le_zero (natDegree_eq_zero_iff_degree_le_zero.1 hpm), isUnit_C]
refine hu _ ?_
rw [← eq_C_of_degree_le_zero (natDegree_eq_zero_iff_degree_le_zero.1 hpm)]
exact dvd_mul_right _ _
| [
" (map (mk P) f).coeff n = (C ((mk P) f.leadingCoeff) * X ^ f.natDegree).coeff n",
" ¬n = f.natDegree",
" False",
" (C ((mk P) f.leadingCoeff) * X ^ f.natDegree).degree < ↑n",
" ↑f.natDegree < ↑n",
" (map (mk P) f).degree < ↑n",
" ↑n = (map (mk P) q).degree",
" eval 0 q ∈ P",
" IsUnit p",
" IsUnit... | [
" (map (mk P) f).coeff n = (C ((mk P) f.leadingCoeff) * X ^ f.natDegree).coeff n",
" ¬n = f.natDegree",
" False",
" (C ((mk P) f.leadingCoeff) * X ^ f.natDegree).degree < ↑n",
" ↑f.natDegree < ↑n",
" (map (mk P) f).degree < ↑n",
" ↑n = (map (mk P) q).degree",
" eval 0 q ∈ P"
] |
import Mathlib.Data.Finset.Pointwise
#align_import combinatorics.additive.e_transform from "leanprover-community/mathlib"@"207c92594599a06e7c134f8d00a030a83e6c7259"
open MulOpposite
open Pointwise
variable {α : Type*} [DecidableEq α]
namespace Finset
section CommGroup
variable [CommGroup α] (e : α) (x : F... | Mathlib/Combinatorics/Additive/ETransform.lean | 88 | 92 | theorem mulDysonETransform.smul_finset_snd_subset_fst :
e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 := by |
dsimp
rw [smul_finset_inter, smul_inv_smul, inter_comm]
exact inter_subset_union
| [
" (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2",
" e • x.2 * e⁻¹ • x.1 ⊆ x.1 * x.2",
" (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card",
" (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card",
" mulDysonETransform e (mulDysonETra... | [
" (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2",
" e • x.2 * e⁻¹ • x.1 ⊆ x.1 * x.2",
" (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card",
" (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card",
" mulDysonETransform e (mulDysonETra... |
import Mathlib.Logic.Relation
import Mathlib.Data.List.Forall2
import Mathlib.Data.List.Lex
import Mathlib.Data.List.Infix
#align_import data.list.chain from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSu... | Mathlib/Data/List/Chain.lean | 82 | 83 | theorem chain_append_singleton_iff_forall₂ :
Chain R a (l ++ [b]) ↔ Forall₂ R (a :: l) (l ++ [b]) := by | simp [chain_iff_forall₂]
| [
" Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l",
" Chain (fun x y => x ∈ [a✝] ∧ y ∈ [] ∧ R x y) a✝ []",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) a (b :: l)",
" a ∈ a :: b :: l ∧ b ∈ b :: l ∧ R a b",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) b l",
" Chain R a [b] ↔ R a... | [
" Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l",
" Chain (fun x y => x ∈ [a✝] ∧ y ∈ [] ∧ R x y) a✝ []",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) a (b :: l)",
" a ∈ a :: b :: l ∧ b ∈ b :: l ∧ R a b",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) b l",
" Chain R a [b] ↔ R a... |
import Mathlib.CategoryTheory.Monoidal.Braided.Basic
import Mathlib.CategoryTheory.Monoidal.Discrete
import Mathlib.CategoryTheory.Monoidal.CoherenceLemmas
import Mathlib.CategoryTheory.Limits.Shapes.Terminal
import Mathlib.Algebra.PUnitInstances
#align_import category_theory.monoidal.Mon_ from "leanprover-community/... | Mathlib/CategoryTheory/Monoidal/Mon_.lean | 84 | 85 | theorem assoc_flip :
(M.X ◁ M.mul) ≫ M.mul = (α_ M.X M.X M.X).inv ≫ (M.mul ▷ M.X) ≫ M.mul := by | simp
| [
" 𝟙_ C ◁ 𝟙 (𝟙_ C) ≫ (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom",
" (λ_ (𝟙_ C)).hom ▷ 𝟙_ C ≫ (λ_ (𝟙_ C)).hom = (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom ≫ 𝟙_ C ◁ (λ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom",
" (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f",
" (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f",
" M.X ◁ M.mul ≫ M.mul = (α_ M.X M.X ... | [
" 𝟙_ C ◁ 𝟙 (𝟙_ C) ≫ (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom",
" (λ_ (𝟙_ C)).hom ▷ 𝟙_ C ≫ (λ_ (𝟙_ C)).hom = (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom ≫ 𝟙_ C ◁ (λ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom",
" (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f",
" (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f"
] |
import Mathlib.CategoryTheory.Subobject.Limits
#align_import algebra.homology.image_to_kernel from "leanprover-community/mathlib"@"618ea3d5c99240cd7000d8376924906a148bf9ff"
universe v u w
open CategoryTheory CategoryTheory.Limits
variable {ι : Type*}
variable {V : Type u} [Category.{v} V] [HasZeroMorphisms V]
o... | Mathlib/Algebra/Homology/ImageToKernel.lean | 127 | 132 | theorem imageToKernel_comp_mono {D : V} (h : C ⟶ D) [Mono h] (w) :
imageToKernel f (g ≫ h) w =
imageToKernel f g ((cancel_mono h).mp (by simpa using w : (f ≫ g) ≫ h = 0 ≫ h)) ≫
(Subobject.isoOfEq _ _ (kernelSubobject_comp_mono g h)).inv := by |
ext
simp
| [
" kernel.lift g f w ≫ kernel.ι g = f",
" Mono (imageToKernel f g w)",
" Mono ((imageSubobject f).ofLE (kernelSubobject g) ⋯)",
" imageToKernel f g w ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow",
" (kernelSubobject g).arrow ((imageToKernel f g w) x) = (imageSubobject f).arrow x",
" factorThruIma... | [
" kernel.lift g f w ≫ kernel.ι g = f",
" Mono (imageToKernel f g w)",
" Mono ((imageSubobject f).ofLE (kernelSubobject g) ⋯)",
" imageToKernel f g w ≫ (kernelSubobject g).arrow = (imageSubobject f).arrow",
" (kernelSubobject g).arrow ((imageToKernel f g w) x) = (imageSubobject f).arrow x",
" factorThruIma... |
import Mathlib.MeasureTheory.Decomposition.RadonNikodym
import Mathlib.MeasureTheory.Measure.Haar.OfBasis
import Mathlib.Probability.Independence.Basic
#align_import probability.density from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open scoped Classical MeasureTheory NNReal ENNRea... | Mathlib/Probability/Density.lean | 122 | 128 | theorem hasPDF_of_map_eq_withDensity {X : Ω → E} {ℙ : Measure Ω} {μ : Measure E}
(hX : AEMeasurable X ℙ) (f : E → ℝ≥0∞) (hf : AEMeasurable f μ) (h : map X ℙ = μ.withDensity f) :
HasPDF X ℙ μ := by |
refine ⟨hX, ?_, ?_⟩ <;> rw [h]
· rw [withDensity_congr_ae hf.ae_eq_mk]
exact haveLebesgueDecomposition_withDensity μ hf.measurable_mk
· exact withDensity_absolutelyContinuous μ f
| [
" HasPDF X ℙ μ ↔ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ",
" AEMeasurable X ℙ ∧ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ ↔\n (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ",
" HasPDF X ℙ μ",
" (map X ℙ).HaveLebesgueDecomposition μ",
" map X ℙ ≪ μ",
" (μ.withDensity f).HaveLe... | [
" HasPDF X ℙ μ ↔ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ",
" AEMeasurable X ℙ ∧ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ ↔\n (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ"
] |
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Data.Nat.Factorial.DoubleFactorial
#align_import ring_theory.polynomial.hermite.basic from "leanprover-community/mathlib"@"938d3db9c278f8a52c0f964a405806f0f2b09b74"
noncomputable section
open Polynomial
namespace P... | Mathlib/RingTheory/Polynomial/Hermite/Basic.lean | 103 | 107 | theorem coeff_hermite_self (n : ℕ) : coeff (hermite n) n = 1 := by |
induction' n with n ih
· apply coeff_C
· rw [coeff_hermite_succ_succ, ih, coeff_hermite_of_lt, mul_zero, sub_zero]
simp
| [
" hermite (n + 1) = X * hermite n - derivative (hermite n)",
" hermite n = (fun p => X * p - derivative p)^[n] 1",
" hermite 0 = (fun p => X * p - derivative p)^[0] 1",
" hermite (n + 1) = (fun p => X * p - derivative p)^[n + 1] 1",
" hermite 1 = X",
" X * C 1 - derivative (C 1) = X",
" (hermite (n + 1)... | [
" hermite (n + 1) = X * hermite n - derivative (hermite n)",
" hermite n = (fun p => X * p - derivative p)^[n] 1",
" hermite 0 = (fun p => X * p - derivative p)^[0] 1",
" hermite (n + 1) = (fun p => X * p - derivative p)^[n + 1] 1",
" hermite 1 = X",
" X * C 1 - derivative (C 1) = X",
" (hermite (n + 1)... |
import Mathlib.Analysis.Convex.Gauge
import Mathlib.Analysis.Convex.Normed
open Metric Bornology Filter Set
open scoped NNReal Topology Pointwise
noncomputable section
section Module
variable {E : Type*} [AddCommGroup E] [Module ℝ E]
def gaugeRescale (s t : Set E) (x : E) : E := (gauge s x / gauge t x) • x
the... | Mathlib/Analysis/Convex/GaugeRescale.lean | 48 | 52 | theorem gaugeRescale_self_apply {s : Set E} (hsa : Absorbent ℝ s) (hsb : IsVonNBounded ℝ s)
(x : E) : gaugeRescale s s x = x := by |
rcases eq_or_ne x 0 with rfl | hx; · simp
rw [gaugeRescale, div_self, one_smul]
exact ((gauge_pos hsa hsb).2 hx).ne'
| [
" gaugeRescale s t (c • x) = c • gaugeRescale s t x",
" (c * gauge s x / (c * gauge t x) * c) • x = (c * (gauge s x / gauge t x)) • x",
" gaugeRescale s s x = x",
" gaugeRescale s s 0 = 0",
" gauge s x ≠ 0"
] | [
" gaugeRescale s t (c • x) = c • gaugeRescale s t x",
" (c * gauge s x / (c * gauge t x) * c) • x = (c * (gauge s x / gauge t x)) • x"
] |
import Mathlib.CategoryTheory.Sites.Sieves
#align_import category_theory.sites.sheaf_of_types from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe w v₁ v₂ u₁ u₂
namespace CategoryTheory
open Opposite CategoryTheory Category Limits Sieve
namespace Presieve
variable {C : Type ... | Mathlib/CategoryTheory/Sites/IsSheafFor.lean | 195 | 202 | theorem extend_agrees {x : FamilyOfElements P R} (t : x.Compatible) {f : Y ⟶ X} (hf : R f) :
x.sieveExtend f (le_generate R Y hf) = x f hf := by |
have h := (le_generate R Y hf).choose_spec
unfold FamilyOfElements.sieveExtend
rw [t h.choose (𝟙 _) _ hf _]
· simp
· rw [id_comp]
exact h.choose_spec.choose_spec.2
| [
" x.Compatible ↔ x.PullbackCompatible",
" x.Compatible → x.PullbackCompatible",
" P.map pullback.fst.op (x f₁ hf₁) = P.map pullback.snd.op (x f₂ hf₂)",
" pullback.fst ≫ f₁ = pullback.snd ≫ f₂",
" x.PullbackCompatible → x.Compatible",
" P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂)",
" x.sieveExtend.Co... | [
" x.Compatible ↔ x.PullbackCompatible",
" x.Compatible → x.PullbackCompatible",
" P.map pullback.fst.op (x f₁ hf₁) = P.map pullback.snd.op (x f₂ hf₂)",
" pullback.fst ≫ f₁ = pullback.snd ≫ f₂",
" x.PullbackCompatible → x.Compatible",
" P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂)",
" x.sieveExtend.Co... |
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Aut
import Mathlib.Data.ZMod.Defs
import Mathlib.Tactic.Ring
#align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"
open MulOpposite
universe u v
class Shelf (α : Type u) where
act : ... | Mathlib/Algebra/Quandle.lean | 232 | 236 | theorem left_cancel_inv (x : R) {y y' : R} : x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y' := by |
constructor
· apply (act' x).symm.injective
rintro rfl
rfl
| [
" x ◃ y = x ◃ y' ↔ y = y'",
" x ◃ y = x ◃ y' → y = y'",
" y = y' → x ◃ y = x ◃ y'",
" x ◃ y = x ◃ y",
" x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y'",
" x ◃⁻¹ y = x ◃⁻¹ y' → y = y'",
" y = y' → x ◃⁻¹ y = x ◃⁻¹ y'",
" x ◃⁻¹ y = x ◃⁻¹ y"
] | [
" x ◃ y = x ◃ y' ↔ y = y'",
" x ◃ y = x ◃ y' → y = y'",
" y = y' → x ◃ y = x ◃ y'",
" x ◃ y = x ◃ y"
] |
import Mathlib.Order.ConditionallyCompleteLattice.Basic
import Mathlib.Data.Set.Finite
#align_import order.conditionally_complete_lattice.finset from "leanprover-community/mathlib"@"2445c98ae4b87eabebdde552593519b9b6dc350c"
open Set
variable {ι α β γ : Type*}
section ConditionallyCompleteLinearOrder
variable [... | Mathlib/Order/ConditionallyCompleteLattice/Finset.lean | 33 | 35 | theorem Finset.Nonempty.csSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s := by |
rw [h.csSup_eq_max']
exact s.max'_mem _
| [
" sSup ↑s ∈ s",
" s.max' h ∈ s"
] | [] |
import Mathlib.Data.Nat.Lattice
import Mathlib.Logic.Denumerable
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.Hom.Basic
import Mathlib.Data.Set.Subsingleton
#align_import order.order_iso_nat from "leanprover-community/mathlib"@"210657c4ea4a4a7b234392f70a3a2a83346dfa90"
variable {α : Type*}
namespa... | Mathlib/Order/OrderIsoNat.lean | 58 | 62 | theorem exists_not_acc_lt_of_not_acc {a : α} {r} (h : ¬Acc r a) : ∃ b, ¬Acc r b ∧ r b a := by |
contrapose! h
refine ⟨_, fun b hr => ?_⟩
by_contra hb
exact h b hb hr
| [
" ∃ b, ¬Acc r b ∧ r b a",
" Acc r a",
" Acc r b",
" False"
] | [] |
import Mathlib.Init.Control.Combinators
import Mathlib.Init.Function
import Mathlib.Tactic.CasesM
import Mathlib.Tactic.Attr.Core
#align_import control.basic from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
universe u v w
variable {α β γ : Type u}
section Monad
variable {m : Type u... | Mathlib/Control/Basic.lean | 83 | 85 | theorem map_bind (x : m α) {g : α → m β} {f : β → γ} :
f <$> (x >>= g) = x >>= fun a => f <$> g a := by |
rw [← bind_pure_comp, bind_assoc]; simp [bind_pure_comp]
| [
" f <$> (x >>= g) = do\n let a ← x\n f <$> g a",
" (do\n let x ← x\n let a ← g x\n pure (f a)) =\n do\n let a ← x\n f <$> g a"
] | [] |
import Mathlib.Algebra.Group.Units.Hom
import Mathlib.Algebra.GroupWithZero.Commute
import Mathlib.Algebra.GroupWithZero.Hom
import Mathlib.GroupTheory.GroupAction.Units
#align_import algebra.group_with_zero.units.lemmas from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
assert_not_exis... | Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean | 49 | 52 | theorem eq_on_inv₀ (f g : F') (h : f a = g a) : f a⁻¹ = g a⁻¹ := by |
rcases eq_or_ne a 0 with (rfl | ha)
· rw [inv_zero, map_zero, map_zero]
· exact (IsUnit.mk0 a ha).eq_on_inv f g h
| [
" f a⁻¹ = g a⁻¹",
" f 0⁻¹ = g 0⁻¹"
] | [] |
import Mathlib.CategoryTheory.Sites.Subsheaf
import Mathlib.CategoryTheory.Sites.CompatibleSheafification
import Mathlib.CategoryTheory.Sites.LocallyInjective
#align_import category_theory.sites.surjective from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe v u w v' u' w'
open ... | Mathlib/CategoryTheory/Sites/LocallySurjective.lean | 101 | 105 | theorem isLocallySurjective_iff_imagePresheaf_sheafify_eq_top {F G : Cᵒᵖ ⥤ A} (f : F ⟶ G) :
IsLocallySurjective J f ↔ (imagePresheaf (whiskerRight f (forget A))).sheafify J = ⊤ := by |
simp only [Subpresheaf.ext_iff, Function.funext_iff, Set.ext_iff, top_subpresheaf_obj,
Set.top_eq_univ, Set.mem_univ, iff_true_iff]
exact ⟨fun H _ => H.imageSieve_mem, fun H => ⟨H _⟩⟩
| [
" ∀ {Y Z : C} {f_1 : Y ⟶ U},\n (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Y f_1 →\n ∀ (g : Z ⟶ Y), (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Z (g ≫ f_1)",
" ∃ t, (f.app { unop := W }) t = (G.map (j ≫ i).op) s",
" (f.app { unop := W }) ((F.map j.op) t) = (G.map (j ≫ i).op... | [
" ∀ {Y Z : C} {f_1 : Y ⟶ U},\n (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Y f_1 →\n ∀ (g : Z ⟶ Y), (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Z (g ≫ f_1)",
" ∃ t, (f.app { unop := W }) t = (G.map (j ≫ i).op) s",
" (f.app { unop := W }) ((F.map j.op) t) = (G.map (j ≫ i).op... |
import Mathlib.FieldTheory.Minpoly.Field
#align_import ring_theory.power_basis from "leanprover-community/mathlib"@"d1d69e99ed34c95266668af4e288fc1c598b9a7f"
open Polynomial
open Polynomial
variable {R S T : Type*} [CommRing R] [Ring S] [Algebra R S]
variable {A B : Type*} [CommRing A] [CommRing B] [IsDomain B]... | Mathlib/RingTheory/PowerBasis.lean | 132 | 135 | theorem exists_eq_aeval' (pb : PowerBasis R S) (y : S) : ∃ f : R[X], y = aeval pb.gen f := by |
nontriviality S
obtain ⟨f, _, hf⟩ := exists_eq_aeval pb y
exact ⟨f, hf⟩
| [
" FiniteDimensional.finrank R S = pb.dim",
" y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.degree < ↑d ∧ y = (aeval x) f",
" (Set.range fun i => x ^ ↑i) = (fun i => x ^ i) '' ↑(Finset.range d)",
" (n ∈ Set.range fun i => x ^ ↑i) ↔ n ∈ (fun i => x ^ i) '' ↑(Finset.range d)",
" (∃ y, x ^ ↑y = n) ↔... | [
" FiniteDimensional.finrank R S = pb.dim",
" y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.degree < ↑d ∧ y = (aeval x) f",
" (Set.range fun i => x ^ ↑i) = (fun i => x ^ i) '' ↑(Finset.range d)",
" (n ∈ Set.range fun i => x ^ ↑i) ↔ n ∈ (fun i => x ^ i) '' ↑(Finset.range d)",
" (∃ y, x ^ ↑y = n) ↔... |
import Mathlib.Algebra.Lie.OfAssociative
import Mathlib.Algebra.Lie.IdealOperations
#align_import algebra.lie.abelian from "leanprover-community/mathlib"@"8983bec7cdf6cb2dd1f21315c8a34ab00d7b2f6d"
universe u v w w₁ w₂
class LieModule.IsTrivial (L : Type v) (M : Type w) [Bracket L M] [Zero M] : Prop where
triv... | Mathlib/Algebra/Lie/Abelian.lean | 318 | 326 | theorem LieSubmodule.lie_abelian_iff_lie_self_eq_bot : IsLieAbelian I ↔ ⁅I, I⁆ = ⊥ := by |
simp only [_root_.eq_bot_iff, lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le,
LieSubmodule.bot_coe, Set.subset_singleton_iff, Set.mem_setOf_eq, exists_imp]
refine
⟨fun h z x y hz =>
hz.symm.trans
(((I : LieSubalgebra R L).coe_bracket x y).symm.trans
((coe_zero_iff_zero _ _).mpr (by ... | [
" ⁅x, m⁆ = 0",
" ⁅x, y⁆ = 0",
" ⁅f u, y⁆ = 0",
" ⁅f u, f v⁆ = 0",
" (Std.Commutative fun x x_1 => x * x_1) ↔ IsLieAbelian A",
" ⁅I, N⁆ = ⊥",
" ⁅I, N⁆ ≤ ⊥",
" {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑⊥",
" m ∈ ↑⊥",
" IsLieAbelian ↥↑I ↔ ⁅I, I⁆ = ⊥",
" IsLieAbelian ↥↑I ↔ ∀ (y : L) (x : ↥I) (x_1 : ↥I), ⁅↑x, ↑x_... | [
" ⁅x, m⁆ = 0",
" ⁅x, y⁆ = 0",
" ⁅f u, y⁆ = 0",
" ⁅f u, f v⁆ = 0",
" (Std.Commutative fun x x_1 => x * x_1) ↔ IsLieAbelian A",
" ⁅I, N⁆ = ⊥",
" ⁅I, N⁆ ≤ ⊥",
" {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑⊥",
" m ∈ ↑⊥"
] |
import Mathlib.Data.Option.NAry
import Mathlib.Data.Seq.Computation
#align_import data.seq.seq from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace Stream'
universe u v w
def IsSeq {α : Type u} (s : Stream' (Option α)) : Prop :=
∀ {n : ℕ}, s n = none → s (n + 1) = none
#al... | Mathlib/Data/Seq/Seq.lean | 174 | 178 | theorem ge_stable (s : Seq α) {aₙ : α} {n m : ℕ} (m_le_n : m ≤ n)
(s_nth_eq_some : s.get? n = some aₙ) : ∃ aₘ : α, s.get? m = some aₘ :=
have : s.get? n ≠ none := by | simp [s_nth_eq_some]
have : s.get? m ≠ none := mt (s.le_stable m_le_n) this
Option.ne_none_iff_exists'.mp this
| [
" (some a :: ↑s).IsSeq",
" (some a :: ↑s) (0 + 1) = none",
" (some a :: ↑s) (n✝ + 1 + 1) = none",
" x = y",
" s.get? n = t.get? n",
" s.TerminatedAt n ↔ (s.get? n).isNone = true",
" s.get? n = none ↔ (s.get? n).isNone = true",
" none = none ↔ none.isNone = true",
" some val✝ = none ↔ (some val✝).isN... | [
" (some a :: ↑s).IsSeq",
" (some a :: ↑s) (0 + 1) = none",
" (some a :: ↑s) (n✝ + 1 + 1) = none",
" x = y",
" s.get? n = t.get? n",
" s.TerminatedAt n ↔ (s.get? n).isNone = true",
" s.get? n = none ↔ (s.get? n).isNone = true",
" none = none ↔ none.isNone = true",
" some val✝ = none ↔ (some val✝).isN... |
import Mathlib.Order.Interval.Set.UnorderedInterval
import Mathlib.Algebra.Order.Interval.Set.Monoid
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Group.MinMax
#align_import data.set.pointwise.interval from "leanprover-community/mathlib"@"2196ab363eb097c... | Mathlib/Data/Set/Pointwise/Interval.lean | 624 | 625 | theorem preimage_mul_const_Ioc (a b : α) {c : α} (h : 0 < c) :
(fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c) := by | simp [← Ioi_inter_Iic, h]
| [
" (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c)"
] | [
" (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c)"
] |
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Algebra.Polynomial.RingDivision
#align_import data.polynomial.mirror from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
namespace Polynomial
open Polynomial
section Semiring
variable {R : Type*} [Semiring R] (p q : R... | Mathlib/Algebra/Polynomial/Mirror.lean | 82 | 97 | theorem coeff_mirror (n : ℕ) :
p.mirror.coeff n = p.coeff (revAt (p.natDegree + p.natTrailingDegree) n) := by |
by_cases h2 : p.natDegree < n
· rw [coeff_eq_zero_of_natDegree_lt (by rwa [mirror_natDegree])]
by_cases h1 : n ≤ p.natDegree + p.natTrailingDegree
· rw [revAt_le h1, coeff_eq_zero_of_lt_natTrailingDegree]
exact (tsub_lt_iff_left h1).mpr (Nat.add_lt_add_right h2 _)
· rw [← revAtFun_eq, revAtFun, i... | [
" mirror 0 = 0",
" ((monomial n) a).mirror = (monomial n) a",
" p.mirror.natDegree = p.natDegree",
" p.reverse.leadingCoeff * (X ^ p.natTrailingDegree).leadingCoeff ≠ 0",
" p.mirror.natTrailingDegree = p.natTrailingDegree",
" p.mirror.coeff n = p.coeff ((revAt (p.natDegree + p.natTrailingDegree)) n)",
"... | [
" mirror 0 = 0",
" ((monomial n) a).mirror = (monomial n) a",
" p.mirror.natDegree = p.natDegree",
" p.reverse.leadingCoeff * (X ^ p.natTrailingDegree).leadingCoeff ≠ 0",
" p.mirror.natTrailingDegree = p.natTrailingDegree"
] |
import Mathlib.Algebra.Algebra.Unitization
import Mathlib.Algebra.Star.NonUnitalSubalgebra
import Mathlib.Algebra.Star.Subalgebra
import Mathlib.GroupTheory.GroupAction.Ring
section Subalgebra
variable {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A]
def Subalgebra.toNonUnitalSubalgebra (S : Subalgebr... | Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean | 73 | 75 | theorem NonUnitalSubalgebra.toSubalgebra_toNonUnitalSubalgebra (S : NonUnitalSubalgebra R A)
(h1 : (1 : A) ∈ S) : (NonUnitalSubalgebra.toSubalgebra S h1).toNonUnitalSubalgebra = S := by |
cases S; rfl
| [
" S.toNonUnitalSubalgebra.toSubalgebra ⋯ = S",
" { toSubsemiring := toSubsemiring✝, algebraMap_mem' := algebraMap_mem'✝ }.toNonUnitalSubalgebra.toSubalgebra ⋯ =\n { toSubsemiring := toSubsemiring✝, algebraMap_mem' := algebraMap_mem'✝ }",
" (S.toSubalgebra h1).toNonUnitalSubalgebra = S",
" ({ toNonUnitalSub... | [
" S.toNonUnitalSubalgebra.toSubalgebra ⋯ = S",
" { toSubsemiring := toSubsemiring✝, algebraMap_mem' := algebraMap_mem'✝ }.toNonUnitalSubalgebra.toSubalgebra ⋯ =\n { toSubsemiring := toSubsemiring✝, algebraMap_mem' := algebraMap_mem'✝ }"
] |
import Mathlib.Data.Finset.Fold
import Mathlib.Algebra.GCDMonoid.Multiset
#align_import algebra.gcd_monoid.finset from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
#align_import algebra.gcd_monoid.div from "leanprover-community/mathlib"@"b537794f8409bc9598febb79cd510b1df5f4539d"
variab... | Mathlib/Algebra/GCDMonoid/Finset.lean | 77 | 82 | theorem lcm_insert [DecidableEq β] {b : β} :
(insert b s : Finset β).lcm f = GCDMonoid.lcm (f b) (s.lcm f) := by |
by_cases h : b ∈ s
· rw [insert_eq_of_mem h,
(lcm_eq_right_iff (f b) (s.lcm f) (Multiset.normalize_lcm (s.1.map f))).2 (dvd_lcm h)]
apply fold_insert h
| [
" s.lcm f ∣ a ↔ ∀ b ∈ s, f b ∣ a",
" (∀ b ∈ Multiset.map f s.val, b ∣ a) ↔ ∀ b ∈ s, f b ∣ a",
" (∀ (b : α), ∀ x ∈ s.val, f x = b → b ∣ a) ↔ ∀ b ∈ s, f b ∣ a",
" (insert b s).lcm f = GCDMonoid.lcm (f b) (s.lcm f)"
] | [
" s.lcm f ∣ a ↔ ∀ b ∈ s, f b ∣ a",
" (∀ b ∈ Multiset.map f s.val, b ∣ a) ↔ ∀ b ∈ s, f b ∣ a",
" (∀ (b : α), ∀ x ∈ s.val, f x = b → b ∣ a) ↔ ∀ b ∈ s, f b ∣ a"
] |
import Mathlib.FieldTheory.RatFunc.Defs
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
#align_import field_theory.ratfunc from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d010e417b10abb1b6"
universe u v
noncompu... | Mathlib/FieldTheory/RatFunc/Basic.lean | 177 | 179 | theorem ofFractionRing_inv (p : FractionRing K[X]) :
ofFractionRing p⁻¹ = (ofFractionRing p)⁻¹ := by |
simp only [Inv.inv, RatFunc.inv]
| [
" { toFractionRing := 0 } = 0",
" { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }",
" { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }",
" { toFractionRing := -p } = -{ toFractionRing := p }",
" { toFractionRing := 1 } = 1",
" { toFractionRing... | [
" { toFractionRing := 0 } = 0",
" { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }",
" { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }",
" { toFractionRing := -p } = -{ toFractionRing := p }",
" { toFractionRing := 1 } = 1",
" { toFractionRing... |
import Mathlib.Algebra.Homology.Single
#align_import algebra.homology.augment from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
open CategoryTheory Limits HomologicalComplex
universe v u
variable {V : Type u} [Category.{v} V]
namespace CochainComplex
@[simp... | Mathlib/Algebra/Homology/Augment.lean | 325 | 328 | theorem cochainComplex_d_succ_succ_zero (C : CochainComplex V ℕ) (i : ℕ) : C.d 0 (i + 2) = 0 := by |
rw [C.shape]
simp only [ComplexShape.up_Rel, zero_add]
exact (Nat.one_lt_succ_succ _).ne
| [
" (fun i j => C.d (i + 1) (j + 1)) i j = 0",
" ¬(ComplexShape.up ℕ).Rel (i + 1) (j + 1)",
" C.d 0 1 ≫ (truncate.obj C).d 0 1 = 0",
" (fun x x_1 =>\n match x, x_1 with\n | 0, 1 => f\n | i.succ, j.succ => C.d i j\n | x, x_2 => 0)\n i j =\n 0",
" (fun x x_1 =>\n match... | [
" (fun i j => C.d (i + 1) (j + 1)) i j = 0",
" ¬(ComplexShape.up ℕ).Rel (i + 1) (j + 1)",
" C.d 0 1 ≫ (truncate.obj C).d 0 1 = 0",
" (fun x x_1 =>\n match x, x_1 with\n | 0, 1 => f\n | i.succ, j.succ => C.d i j\n | x, x_2 => 0)\n i j =\n 0",
" (fun x x_1 =>\n match... |
import Mathlib.Algebra.Group.ConjFinite
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.GroupTheory.GroupAction.Quotient
import Mathlib.GroupTheory.Index
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Line... | Mathlib/GroupTheory/CommutingProbability.lean | 78 | 81 | theorem commProb_le_one : commProb M ≤ 1 := by |
refine div_le_one_of_le ?_ (sq_nonneg (Nat.card M : ℚ))
rw [← Nat.cast_pow, Nat.cast_le, sq, ← Nat.card_prod]
apply Finite.card_subtype_le
| [
" commProb (M × M') = commProb M * commProb M'",
" ↑(Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 ∧ (p.1 * p.2).2 = (p.2 * p.1).2 }) /\n (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ^ 2) =\n ↑(Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } × { p // p.1 * p.2 = p.2 * p.1 })) /\n (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ... | [
" commProb (M × M') = commProb M * commProb M'",
" ↑(Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 ∧ (p.1 * p.2).2 = (p.2 * p.1).2 }) /\n (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ^ 2) =\n ↑(Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } × { p // p.1 * p.2 = p.2 * p.1 })) /\n (↑(Nat.card M) ^ 2 * ↑(Nat.card M') ... |
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Data.Finset.Sort
#align_import data.polynomial.basic from "leanprover-community/mathlib"@"949dc57e616a621462062668c9f39e4e17b64b69"
set_option linter.uppercaseLean3 false
noncomputable section
structure ... | Mathlib/Algebra/Polynomial/Basic.lean | 178 | 180 | theorem ofFinsupp_sub {R : Type u} [Ring R] {a b} : (⟨a - b⟩ : R[X]) = ⟨a⟩ - ⟨b⟩ := by |
rw [sub_eq_add_neg, ofFinsupp_add, ofFinsupp_neg]
rfl
| [
" { toFinsupp := f.toFinsupp } = f",
" { toFinsupp := { toFinsupp := toFinsupp✝ }.toFinsupp } = { toFinsupp := toFinsupp✝ }",
" { toFinsupp := a + b } = Polynomial.add { toFinsupp := a } { toFinsupp := b }",
" { toFinsupp := -a } = Polynomial.neg { toFinsupp := a }",
" { toFinsupp := a - b } = { toFinsupp :... | [
" { toFinsupp := f.toFinsupp } = f",
" { toFinsupp := { toFinsupp := toFinsupp✝ }.toFinsupp } = { toFinsupp := toFinsupp✝ }",
" { toFinsupp := a + b } = Polynomial.add { toFinsupp := a } { toFinsupp := b }",
" { toFinsupp := -a } = Polynomial.neg { toFinsupp := a }"
] |
import Mathlib.Order.Filter.Basic
#align_import order.filter.prod from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
open Set
open Filter
namespace Filter
variable {α β γ δ : Type*} {ι : Sort*}
section Prod
variable {s : Set α} {t : Set β} {f : Filter α} {g : Filter β}
protected ... | Mathlib/Order/Filter/Prod.lean | 101 | 104 | theorem eventually_prod_principal_iff {p : α × β → Prop} {s : Set β} :
(∀ᶠ x : α × β in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ x : α in f, ∀ y : β, y ∈ s → p (x, y) := by |
rw [eventually_iff, eventually_iff, mem_prod_principal]
simp only [mem_setOf_eq]
| [
" s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s",
" s ∈ comap Prod.fst f ⊓ comap Prod.snd g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁.prod t₂ ⊆ s",
" s ∈ comap Prod.fst f ⊓ comap Prod.snd g → ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁.prod t₂ ⊆ s",
" ∃ t₁_1 ∈ f, ∃ t₂_1 ∈ g, t₁_1.prod t₂_1 ⊆ t₁ ∩ t₂",
" (∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁.prod t₂ ⊆ s) → s ... | [
" s ∈ f ×ˢ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s",
" s ∈ comap Prod.fst f ⊓ comap Prod.snd g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁.prod t₂ ⊆ s",
" s ∈ comap Prod.fst f ⊓ comap Prod.snd g → ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁.prod t₂ ⊆ s",
" ∃ t₁_1 ∈ f, ∃ t₂_1 ∈ g, t₁_1.prod t₂_1 ⊆ t₁ ∩ t₂",
" (∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁.prod t₂ ⊆ s) → s ... |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.GaloisConnection
import Mathlib.Data.Set.Lattice
import Mathlib.Tactic.AdaptationNote
#align_import data.rel from "leanprover-community/mathlib"@"706d88f2b8fdfeb0b22796433d7a6c1a010af9f2"
variable {α β γ : Type*}
def Rel (α β : Type*) :=
α → β → Prop --... | Mathlib/Data/Rel.lean | 156 | 158 | theorem inv_bot : (⊥ : Rel α β).inv = (⊥ : Rel β α) := by |
#adaptation_note /-- nightly-2024-03-16: simp was `simp [Bot.bot, inv, flip]` -/
simp [Bot.bot, inv, Function.flip_def]
| [
" r.inv.inv = r",
" r.inv.inv x y ↔ r x y",
" r.inv.codom = r.dom",
" x ∈ r.inv.codom ↔ x ∈ r.dom",
" r.inv.dom = r.codom",
" x ∈ r.inv.dom ↔ x ∈ r.codom",
" (r • s) • t = r • s • t",
" (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z",
" (∃ y, ... | [
" r.inv.inv = r",
" r.inv.inv x y ↔ r x y",
" r.inv.codom = r.dom",
" x ∈ r.inv.codom ↔ x ∈ r.dom",
" r.inv.dom = r.codom",
" x ∈ r.inv.dom ↔ x ∈ r.codom",
" (r • s) • t = r • s • t",
" (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z",
" (∃ y, ... |
import Mathlib.Data.Set.Basic
#align_import data.set.bool_indicator from "leanprover-community/mathlib"@"fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e"
open Bool
namespace Set
variable {α : Type*} (s : Set α)
noncomputable def boolIndicator (x : α) :=
@ite _ (x ∈ s) (Classical.propDecidable _) true false
#align s... | Mathlib/Data/Set/BoolIndicator.lean | 32 | 34 | theorem not_mem_iff_boolIndicator (x : α) : x ∉ s ↔ s.boolIndicator x = false := by |
unfold boolIndicator
split_ifs with h <;> simp [h]
| [
" x ∈ s ↔ s.boolIndicator x = true",
" x ∈ s ↔ (if x ∈ s then true else false) = true",
" x ∈ s ↔ true = true",
" x ∈ s ↔ False",
" x ∉ s ↔ s.boolIndicator x = false",
" x ∉ s ↔ (if x ∈ s then true else false) = false",
" x ∉ s ↔ False",
" x ∉ s ↔ false = false"
] | [
" x ∈ s ↔ s.boolIndicator x = true",
" x ∈ s ↔ (if x ∈ s then true else false) = true",
" x ∈ s ↔ true = true",
" x ∈ s ↔ False"
] |
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.RingTheory.PowerSeries.Basic
#align_import ring_theory.power_series.well_known from "leanprover-community/mathlib"@"8199f6717c150a7fe91c4534175f4cf99725978f"
namespace PowerS... | Mathlib/RingTheory/PowerSeries/WellKnown.lean | 181 | 182 | theorem coeff_sin_bit0 : coeff A (bit0 n) (sin A) = 0 := by |
rw [sin, coeff_mk, if_pos (even_bit0 n)]
| [
" (constantCoeff A) (exp A) = 1",
" (algebraMap ℚ A) (1 / ↑0!) = 1",
" (coeff A (bit0 n)) (sin A) = 0"
] | [
" (constantCoeff A) (exp A) = 1",
" (algebraMap ℚ A) (1 / ↑0!) = 1"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.