Context stringlengths 57 92.3k | file_name stringlengths 21 79 | start int64 14 3.67k | end int64 18 3.69k | theorem stringlengths 25 2.71k | proof stringlengths 5 10.6k |
|---|---|---|---|---|---|
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]
|
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Constructions.Prod.Integral
import Mathlib.MeasureTheory.Function.LocallyIntegrable
import Mathlib.MeasureTheory.Group.Integral
import Mathlib.MeasureTheory.Group.Prod
import Mathlib.Measure... | Mathlib/Analysis/Convolution.lean | 500 | 503 | theorem ConvolutionExists.distrib_add (hfg : ConvolutionExists f g L ΞΌ)
(hfg' : ConvolutionExists f g' L ΞΌ) : f β[L, ΞΌ] (g + g') = f β[L, ΞΌ] g + f β[L, ΞΌ] g' := by |
ext x
exact (hfg x).distrib_add (hfg' x)
|
import Mathlib.LinearAlgebra.AffineSpace.AffineEquiv
#align_import linear_algebra.affine_space.affine_subspace from "leanprover-community/mathlib"@"e96bdfbd1e8c98a09ff75f7ac6204d142debc840"
noncomputable section
open Affine
open Set
section
variable (k : Type*) {V : Type*} {P : Type*} [Ring k] [AddCommGroup V]... | Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean | 653 | 655 | theorem lt_iff_le_and_exists (s1 s2 : AffineSubspace k P) :
s1 < s2 β s1 β€ s2 β§ β p β s2, p β s1 := by |
rw [lt_iff_le_not_le, not_le_iff_exists]
|
import Mathlib.Logic.Equiv.Fin
import Mathlib.Topology.DenseEmbedding
import Mathlib.Topology.Support
import Mathlib.Topology.Connected.LocallyConnected
#align_import topology.homeomorph from "leanprover-community/mathlib"@"4c3e1721c58ef9087bbc2c8c38b540f70eda2e53"
open Set Filter
open Topology
variable {X : Typ... | Mathlib/Topology/Homeomorph.lean | 425 | 426 | theorem image_frontier (h : X ββ Y) (s : Set X) : h '' frontier s = frontier (h '' s) := by |
rw [β preimage_symm, preimage_frontier]
|
import Mathlib.Algebra.Group.Pi.Basic
import Mathlib.Data.FunLike.Basic
import Mathlib.Logic.Function.Iterate
#align_import algebra.hom.group from "leanprover-community/mathlib"@"a148d797a1094ab554ad4183a4ad6f130358ef64"
variable {ΞΉ Ξ± Ξ² M N P : Type*}
-- monoids
variable {G : Type*} {H : Type*}
-- groups
variab... | Mathlib/Algebra/Group/Hom/Defs.lean | 1,172 | 1,175 | theorem comp_one [MulOneClass M] [MulOneClass N] [MulOneClass P] (f : N β* P) :
f.comp (1 : M β* N) = 1 := by |
ext
simp only [map_one, coe_comp, Function.comp_apply, one_apply]
|
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]
|
import Mathlib.Algebra.Ring.Prod
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Tactic.FinCases
#align_import data.zmod.basic from "leanprover-community/mathlib"@"74ad1c88c77e799d2fea62801d1dbbd698cff1b7"
assert_not_exists Submodule
open Function
namespace ZMod
instance charZero : CharZero (ZMod 0) :=... | Mathlib/Data/ZMod/Basic.lean | 676 | 678 | theorem intCast_mod (a : β€) (b : β) : ((a % b : β€) : ZMod b) = (a : ZMod b) := by |
rw [ZMod.intCast_eq_intCast_iff]
apply Int.mod_modEq
|
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... |
import Mathlib.NumberTheory.Padics.PadicNumbers
import Mathlib.RingTheory.DiscreteValuationRing.Basic
#align_import number_theory.padics.padic_integers from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open Padic Metric LocalRing
noncomputable section
open scoped Classical
def Pad... | Mathlib/NumberTheory/Padics/PadicIntegers.lean | 577 | 581 | theorem norm_lt_one_iff_dvd (x : β€_[p]) : βxβ < 1 β βp β£ x := by |
have := norm_le_pow_iff_mem_span_pow x 1
rw [Ideal.mem_span_singleton, pow_one] at this
rw [β this, norm_le_pow_iff_norm_lt_pow_add_one]
simp only [zpow_zero, Int.ofNat_zero, Int.ofNat_succ, add_left_neg, zero_add]
|
import Mathlib.Data.Prod.PProd
import Mathlib.Data.Set.Countable
import Mathlib.Order.Filter.Prod
import Mathlib.Order.Filter.Ker
#align_import order.filter.bases from "leanprover-community/mathlib"@"996b0ff959da753a555053a480f36e5f264d4207"
set_option autoImplicit true
open Set Filter
open scoped Classical
ope... | Mathlib/Order/Filter/Bases.lean | 672 | 678 | theorem _root_.Pairwise.exists_mem_filter_basis_of_disjoint {I} [Finite I] {l : I β Filter Ξ±}
{ΞΉ : I β Sort*} {p : β i, ΞΉ i β Prop} {s : β i, ΞΉ i β Set Ξ±} (hd : Pairwise (Disjoint on l))
(h : β i, (l i).HasBasis (p i) (s i)) :
β ind : β i, ΞΉ i, (β i, p i (ind i)) β§ Pairwise (Disjoint on fun i => s i (ind i)... |
rcases hd.exists_mem_filter_of_disjoint with β¨t, htl, hdβ©
choose ind hp ht using fun i => (h i).mem_iff.1 (htl i)
exact β¨ind, hp, hd.mono fun i j hij => hij.mono (ht _) (ht _)β©
|
import Mathlib.Algebra.Order.CauSeq.BigOperators
import Mathlib.Data.Complex.Abs
import Mathlib.Data.Complex.BigOperators
import Mathlib.Data.Nat.Choose.Sum
#align_import data.complex.exponential from "leanprover-community/mathlib"@"a8b2226cfb0a79f5986492053fc49b1a0c6aeffb"
open CauSeq Finset IsAbsoluteValue
open ... | Mathlib/Data/Complex/Exponential.lean | 1,744 | 1,745 | theorem abs_exp_ofReal_mul_I (x : β) : abs (exp (x * I)) = 1 := by |
rw [exp_mul_I, abs_cos_add_sin_mul_I]
|
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β]
|
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]
|
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 | 1,710 | 1,717 | theorem IsBigOWith.inv_rev {f : Ξ± β π} {g : Ξ± β π'} (h : IsBigOWith c l f g)
(hβ : βαΆ x in l, f x = 0 β g x = 0) : IsBigOWith c l (fun x => (g x)β»ΒΉ) fun x => (f x)β»ΒΉ := by |
refine IsBigOWith.of_bound (h.bound.mp (hβ.mono fun x hβ hle => ?_))
rcases eq_or_ne (f x) 0 with hx | hx
Β· simp only [hx, hβ hx, inv_zero, norm_zero, mul_zero, le_rfl]
Β· have hc : 0 < c := pos_of_mul_pos_left ((norm_pos_iff.2 hx).trans_le hle) (norm_nonneg _)
replace hle := inv_le_inv_of_le (norm_pos_iff.... |
import Mathlib.Algebra.BigOperators.Group.List
import Mathlib.Data.Vector.Defs
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.OfFn
import Mathlib.Data.List.InsertNth
import Mathlib.Control.Applicative
import Mathlib.Control.Traversable.Basic
#align_import data.vector.basic from "leanprover-community/mathlib"... | Mathlib/Data/Vector/Basic.lean | 280 | 281 | theorem get_cons_succ (a : Ξ±) (v : Vector Ξ± n) (i : Fin n) : get (a ::α΅₯ v) i.succ = get v i := by |
rw [β get_tail_succ, tail_cons]
|
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.Analysis.Fourier.AddCircle
import Mathlib.Analysis.Fourier.FourierTransform
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts
import Mathlib.Analysis.Calculus.ContDiff.Bounds
noncomputable... | Mathlib/Analysis/Fourier/FourierTransformDeriv.lean | 769 | 779 | theorem fourierIntegral_deriv
{f : β β E} (hf : Integrable f) (h'f : Differentiable β f) (hf' : Integrable (deriv f)) :
π (deriv f) = fun (x : β) β¦ (2 * Ο * I * x) β’ (π f x) := by |
ext x
have I : Integrable (fun x β¦ fderiv β f x) := by
simpa only [β deriv_fderiv] using (ContinuousLinearMap.smulRightL β β E 1).integrable_comp hf'
have : π (deriv f) x = π (fderiv β f) x 1 := by
simp only [fourierIntegral_continuousLinearMap_apply I, fderiv_deriv]
rw [this, fourierIntegral_fderiv ... |
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff
import Mathlib.FieldTheory.Minpoly.Field
#align_import linear_algebra.charpoly.basic from "leanprover-community/mathlib"@"d3e8e0a0237c10c2627bf52c246b15ff8e7df4c0"
universe u v w
variable {R : Type u} {M : Typ... | Mathlib/LinearAlgebra/Charpoly/Basic.lean | 71 | 75 | theorem aeval_self_charpoly : aeval f f.charpoly = 0 := by |
apply (LinearEquiv.map_eq_zero_iff (algEquivMatrix (chooseBasis R M)).toLinearEquiv).1
rw [AlgEquiv.toLinearEquiv_apply, β AlgEquiv.coe_algHom, β Polynomial.aeval_algHom_apply _ _ _,
charpoly_def]
exact Matrix.aeval_self_charpoly _
|
import Mathlib.AlgebraicTopology.SimplexCategory
import Mathlib.CategoryTheory.Comma.Arrow
import Mathlib.CategoryTheory.Limits.FunctorCategory
import Mathlib.CategoryTheory.Opposites
#align_import algebraic_topology.simplicial_object from "leanprover-community/mathlib"@"5ed51dc37c6b891b79314ee11a50adc2b1df6fd6"
o... | Mathlib/AlgebraicTopology/SimplicialObject.lean | 400 | 401 | theorem augment_hom_zero (X : SimplicialObject C) (Xβ : C) (f : X _[0] βΆ Xβ) (w) :
(X.augment Xβ f w).hom.app (op [0]) = f := by | simp
|
import Mathlib.LinearAlgebra.Matrix.Symmetric
import Mathlib.LinearAlgebra.Matrix.Orthogonal
import Mathlib.Data.Matrix.Kronecker
#align_import linear_algebra.matrix.is_diag from "leanprover-community/mathlib"@"55e2dfde0cff928ce5c70926a3f2c7dee3e2dd99"
namespace Matrix
variable {Ξ± Ξ² R n m : Type*}
open Function... | Mathlib/LinearAlgebra/Matrix/IsDiag.lean | 184 | 188 | theorem IsDiag.fromBlocks_of_isSymm [Zero Ξ±] {A : Matrix m m Ξ±} {C : Matrix n m Ξ±}
{D : Matrix n n Ξ±} (h : (A.fromBlocks 0 C D).IsSymm) (ha : A.IsDiag) (hd : D.IsDiag) :
(A.fromBlocks 0 C D).IsDiag := by |
rw [β (isSymm_fromBlocks_iff.1 h).2.1]
exact ha.fromBlocks hd
|
import Mathlib.Data.Sigma.Basic
import Mathlib.Algebra.Order.Ring.Nat
#align_import set_theory.lists from "leanprover-community/mathlib"@"497d1e06409995dd8ec95301fa8d8f3480187f4c"
variable {Ξ± : Type*}
inductive Lists'.{u} (Ξ± : Type u) : Bool β Type u
| atom : Ξ± β Lists' Ξ± false
| nil : Lists' Ξ± true
| con... | Mathlib/SetTheory/Lists.lean | 313 | 349 | theorem Equiv.trans : β {lβ lβ lβ : Lists Ξ±}, lβ ~ lβ β lβ ~ lβ β lβ ~ lβ := by |
let trans := fun lβ : Lists Ξ± => β β¦lβ lββ¦, lβ ~ lβ β lβ ~ lβ β lβ ~ lβ
suffices PProd (β lβ, trans lβ) (β (l : Lists' Ξ± true), β l' β l.toList, trans l') by exact this.1
apply inductionMut
Β· intro a lβ lβ hβ hβ
rwa [β equiv_atom.1 hβ] at hβ
Β· intro lβ IH lβ lβ hβ hβ
-- Porting note: Two 'have's are ... |
import Mathlib.Data.Set.Function
import Mathlib.Logic.Equiv.Defs
import Mathlib.Tactic.Says
#align_import logic.equiv.set from "leanprover-community/mathlib"@"aba57d4d3dae35460225919dcd82fe91355162f9"
open Function Set
universe u v w z
variable {Ξ± : Sort u} {Ξ² : Sort v} {Ξ³ : Sort w}
namespace Equiv
@[simp]
th... | Mathlib/Logic/Equiv/Set.lean | 642 | 648 | theorem ofLeftInverse_eq_ofInjective {Ξ± Ξ² : Type*} (f : Ξ± β Ξ²) (f_inv : Nonempty Ξ± β Ξ² β Ξ±)
(hf : β h : Nonempty Ξ±, LeftInverse (f_inv h) f) :
ofLeftInverse f f_inv hf =
ofInjective f ((isEmpty_or_nonempty Ξ±).elim (fun h _ _ _ => Subsingleton.elim _ _)
(fun h => (hf h).injective)) := by |
ext
simp
|
import Mathlib.CategoryTheory.NatIso
#align_import category_theory.bicategory.basic from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
namespace CategoryTheory
universe w v u
open Category Iso
-- intended to be used with explicit universe parameters
@[nolint checkUnivs]
class Bicate... | Mathlib/CategoryTheory/Bicategory/Basic.lean | 364 | 365 | theorem whisker_assoc_symm (f : a βΆ b) {g g' : b βΆ c} (Ξ· : g βΆ g') (h : c βΆ d) :
f β Ξ· β· h = (Ξ±_ f g h).inv β« (f β Ξ·) β· h β« (Ξ±_ f g' h).hom := by | simp
|
import Mathlib.Data.Nat.Factorial.Basic
import Mathlib.Order.Monotone.Basic
#align_import data.nat.choose.basic from "leanprover-community/mathlib"@"2f3994e1b117b1e1da49bcfb67334f33460c3ce4"
open Nat
namespace Nat
def choose : β β β β β
| _, 0 => 1
| 0, _ + 1 => 0
| n + 1, k + 1 => choose n k + choose n ... | Mathlib/Data/Nat/Choose/Basic.lean | 235 | 240 | theorem ascFactorial_eq_factorial_mul_choose (n k : β) :
(n + 1).ascFactorial k = k ! * (n + k).choose k := by |
rw [Nat.mul_comm]
apply Nat.mul_right_cancel (n + k - k).factorial_pos
rw [choose_mul_factorial_mul_factorial <| Nat.le_add_left k n, Nat.add_sub_cancel_right,
β factorial_mul_ascFactorial, Nat.mul_comm]
|
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]
|
import Mathlib.RingTheory.WittVector.Truncated
import Mathlib.RingTheory.WittVector.Identities
import Mathlib.NumberTheory.Padics.RingHoms
#align_import ring_theory.witt_vector.compare from "leanprover-community/mathlib"@"168ad7fc5d8173ad38be9767a22d50b8ecf1cd00"
noncomputable section
variable {p : β} [hp : Fact... | Mathlib/RingTheory/WittVector/Compare.lean | 183 | 189 | theorem toPadicInt_comp_fromPadicInt : (toPadicInt p).comp (fromPadicInt p) = RingHom.id β€_[p] := by |
rw [β PadicInt.toZModPow_eq_iff_ext]
intro n
rw [β RingHom.comp_assoc, toPadicInt, PadicInt.lift_spec]
simp only [fromPadicInt, toZModPow, RingHom.comp_id]
rw [RingHom.comp_assoc, truncate_comp_lift, β RingHom.comp_assoc]
simp only [RingEquiv.symm_toRingHom_comp_toRingHom, RingHom.id_comp]
|
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β)
|
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SumOverResidueClass
#align_import analysis.p_series from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
def SuccDiffBounded (C : β) (u : β β β) : Prop :=... | Mathlib/Analysis/PSeries.lean | 161 | 171 | theorem tsum_schlomilch_le {C : β} (hf : β β¦m nβ¦, 1 < m β m β€ n β f n β€ f m) (h_pos : β n, 0 < u n)
(h_nonneg : β n, 0 β€ f n) (hu : Monotone u) (h_succ_diff : SuccDiffBounded C u) :
β' k : β, (u (k + 1) - u k) * f (u k) β€ (u 1 - u 0) * f (u 0) + C * β' k, f k := by |
rw [ENNReal.tsum_eq_iSup_nat' (tendsto_atTop_mono Nat.le_succ tendsto_id)]
refine
iSup_le fun n =>
le_trans ?_
(add_le_add_left
(mul_le_mul_of_nonneg_left (ENNReal.sum_le_tsum <| Finset.Ico (u 0 + 1) (u n + 1)) ?_) _)
simpa using Finset.sum_schlomilch_le hf h_pos h_nonneg hu h_succ_di... |
import Mathlib.RingTheory.Ideal.Maps
#align_import ring_theory.ideal.prod from "leanprover-community/mathlib"@"052f6013363326d50cb99c6939814a4b8eb7b301"
universe u v
variable {R : Type u} {S : Type v} [Semiring R] [Semiring S] (I I' : Ideal R) (J J' : Ideal S)
namespace Ideal
def prod : Ideal (R Γ S) where
... | Mathlib/RingTheory/Ideal/Prod.lean | 157 | 173 | theorem ideal_prod_prime (I : Ideal (R Γ S)) :
I.IsPrime β
(β p : Ideal R, p.IsPrime β§ I = Ideal.prod p β€) β¨
β p : Ideal S, p.IsPrime β§ I = Ideal.prod β€ p := by |
constructor
Β· rw [ideal_prod_eq I]
intro hI
rcases ideal_prod_prime_aux hI with (h | h)
Β· right
rw [h] at hI β’
exact β¨_, β¨isPrime_of_isPrime_prod_top' hI, rflβ©β©
Β· left
rw [h] at hI β’
exact β¨_, β¨isPrime_of_isPrime_prod_top hI, rflβ©β©
Β· rintro (β¨p, β¨h, rflβ©β© | β¨p, β¨h, rflβ©β©)
... |
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... |
import Mathlib.Algebra.Algebra.Operations
import Mathlib.Data.Fintype.Lattice
import Mathlib.RingTheory.Coprime.Lemmas
#align_import ring_theory.ideal.operations from "leanprover-community/mathlib"@"e7f0ddbf65bd7181a85edb74b64bdc35ba4bdc74"
assert_not_exists Basis -- See `RingTheory.Ideal.Basis`
assert_not_exists ... | Mathlib/RingTheory/Ideal/Operations.lean | 569 | 571 | theorem span_singleton_mul_left_inj [IsDomain R] {x : R} (hx : x β 0) :
I * span {x} = J * span {x} β I = J := by |
simp only [le_antisymm_iff, span_singleton_mul_left_mono hx]
|
import Mathlib.SetTheory.Cardinal.Ordinal
import Mathlib.SetTheory.Ordinal.FixedPoint
#align_import set_theory.cardinal.cofinality from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Cardinal Set Order
open scoped Classical
open Cardinal Ordinal
un... | Mathlib/SetTheory/Cardinal/Cofinality.lean | 262 | 282 | theorem lift_cof (o) : Cardinal.lift.{u, v} (cof o) = cof (Ordinal.lift.{u, v} o) := by |
refine inductionOn o ?_
intro Ξ± r _
apply le_antisymm
Β· refine le_cof_type.2 fun S H => ?_
have : Cardinal.lift.{u, v} #(ULift.up β»ΒΉ' S) β€ #(S : Type (max u v)) := by
rw [β Cardinal.lift_umax.{v, u}, β Cardinal.lift_id'.{v, u} #S]
exact mk_preimage_of_injective_lift.{v, max u v} ULift.up S (ULi... |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.Prod
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.FinCases
import Mathlib.Tactic.LinearCombination
import Mathlib.Lean.Expr.ExtraRecognizers
import Mathlib.Data.Set.Subsingleton
#align_import lin... | Mathlib/LinearAlgebra/LinearIndependent.lean | 319 | 324 | theorem LinearIndependent.of_comp (f : M ββ[R] M') (hfv : LinearIndependent R (f β v)) :
LinearIndependent R v :=
linearIndependent_iff'.2 fun s g hg i his =>
have : (β i β s, g i β’ f (v i)) = 0 := by |
simp_rw [β map_smul, β map_sum, hg, f.map_zero]
linearIndependent_iff'.1 hfv s g this i his
|
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)]
|
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]
|
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 | 850 | 854 | theorem size_balanceL {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
(H : (β l', Raised l' (size l) β§ BalancedSz l' (size r)) β¨
β r', Raised (size r) r' β§ BalancedSz (size l) r') :
size (@balanceL Ξ± l x r) = size l + size r + 1 := by |
rw [balanceL_eq_balance' hl hr sl sr H, size_balance' sl sr]
|
import Mathlib.Data.Bool.Basic
import Mathlib.Data.Option.Defs
import Mathlib.Data.Prod.Basic
import Mathlib.Data.Sigma.Basic
import Mathlib.Data.Subtype
import Mathlib.Data.Sum.Basic
import Mathlib.Init.Data.Sigma.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Logic.Function.Conjugate
import Mathlib.Tactic.Lift... | Mathlib/Logic/Equiv/Basic.lean | 1,624 | 1,628 | theorem swapCore_comm (r a b : Ξ±) : swapCore a b r = swapCore b a r := by |
unfold swapCore
-- Porting note: whatever solution works for `swapCore_swapCore` will work here too.
split_ifs with hβ hβ hβ <;> try simp
Β· cases hβ; cases hβ; rfl
|
import Mathlib.Algebra.GCDMonoid.Multiset
import Mathlib.Combinatorics.Enumerative.Partition
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Cycle.Factors
import Mathlib.GroupTheory.Perm.Closure
import Mathlib.Algebra.GCDMonoid.Nat
import Mathlib.Tactic.NormNum.GCD
#align_import group_theory.perm.cycl... | Mathlib/GroupTheory/Perm/Cycle/Type.lean | 593 | 605 | theorem _root_.card_support_eq_three_iff : Ο.support.card = 3 β Ο.IsThreeCycle := by |
refine β¨fun h => ?_, IsThreeCycle.card_supportβ©
by_cases h0 : Ο.cycleType = 0
Β· rw [β sum_cycleType, h0, sum_zero] at h
exact (ne_of_lt zero_lt_three h).elim
obtain β¨n, hnβ© := exists_mem_of_ne_zero h0
by_cases h1 : Ο.cycleType.erase n = 0
Β· rw [β sum_cycleType, β cons_erase hn, h1, cons_zero, Multiset.... |
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... |
import Mathlib.Algebra.Ring.Defs
import Mathlib.Algebra.Group.Ext
local macro:max "local_hAdd[" type:term ", " inst:term "]" : term =>
`(term| (letI := $inst; HAdd.hAdd : $type β $type β $type))
local macro:max "local_hMul[" type:term ", " inst:term "]" : term =>
`(term| (letI := $inst; HMul.hMul : $type β $typ... | Mathlib/Algebra/Ring/Ext.lean | 231 | 234 | theorem toNonUnitalNonAssocring_injective :
Function.Injective (@toNonUnitalNonAssocRing R) := by |
intro _ _ _
ext <;> congr
|
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Support
#align_import group_theory.perm.list from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
namespace List
variable {Ξ± Ξ² : Type*}
section FormPerm
variable [DecidableEq Ξ±] (l :... | Mathlib/GroupTheory/Perm/List.lean | 379 | 382 | theorem formPerm_apply_mem_ne_self_iff (hl : Nodup l) (x : Ξ±) (hx : x β l) :
formPerm l x β x β 2 β€ l.length := by |
rw [Ne, formPerm_apply_mem_eq_self_iff _ hl x hx, not_le]
exact β¨Nat.succ_le_of_lt, Nat.lt_of_succ_leβ©
|
import Batteries.Data.Rat.Basic
import Batteries.Tactic.SeqFocus
namespace Rat
theorem ext : {p q : Rat} β p.num = q.num β p.den = q.den β p = q
| β¨_,_,_,_β©, β¨_,_,_,_β©, rfl, rfl => rfl
@[simp] theorem mk_den_one {r : Int} :
β¨r, 1, Nat.one_ne_zero, (Nat.coprime_one_right _)β© = (r : Rat) := rfl
@[simp] theor... | .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean | 110 | 111 | theorem mk_eq_mkRat (num den nz c) : β¨num, den, nz, cβ© = mkRat num den := by |
simp [mk_eq_normalize, normalize_eq_mkRat]
|
import Mathlib.Analysis.Convex.Basic
import Mathlib.Order.Filter.Extr
import Mathlib.Tactic.GCongr
#align_import analysis.convex.function from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open scoped Classical
open LinearMap Set Convex Pointwise
variable {π E F Ξ± Ξ² ΞΉ : Type*}
secti... | Mathlib/Analysis/Convex/Function.lean | 745 | 748 | theorem ConvexOn.le_left_of_right_le (hf : ConvexOn π s f) {x y z : E} (hx : x β s) (hy : y β s)
(hz : z β openSegment π x y) (hyz : f y β€ f z) : f z β€ f x := by |
obtain β¨a, b, ha, hb, hab, rflβ© := hz
exact hf.le_left_of_right_le' hx hy ha hb.le hab hyz
|
import Mathlib.Order.Filter.Basic
import Mathlib.Topology.Bases
import Mathlib.Data.Set.Accumulate
import Mathlib.Topology.Bornology.Basic
import Mathlib.Topology.LocallyFinite
open Set Filter Topology TopologicalSpace Classical Function
universe u v
variable {X : Type u} {Y : Type v} {ΞΉ : Type*}
variable [Topolog... | Mathlib/Topology/Compactness/Compact.lean | 430 | 432 | theorem IsCompact.inf_nhdsSet_eq_biSup {K : Set X} (hK : IsCompact K) (l : Filter X) :
l β (πΛ’ K) = β¨ x β K, l β π x := by |
simp only [inf_comm l, hK.nhdsSet_inf_eq_biSup]
|
import Mathlib.Data.Matrix.Basis
import Mathlib.Data.Matrix.DMatrix
import Mathlib.Algebra.Lie.Abelian
import Mathlib.LinearAlgebra.Matrix.Trace
import Mathlib.Algebra.Lie.SkewAdjoint
import Mathlib.LinearAlgebra.SymplecticGroup
#align_import algebra.lie.classical from "leanprover-community/mathlib"@"3e068ece210655b7... | Mathlib/Algebra/Lie/Classical.lean | 341 | 344 | theorem pb_inv [Invertible (2 : R)] : PB l R * Matrix.fromBlocks 1 0 0 (β
(PD l R)) = 1 := by |
rw [PB, Matrix.fromBlocks_multiply, mul_invOf_self]
simp only [Matrix.mul_zero, Matrix.mul_one, Matrix.zero_mul, zero_add, add_zero,
Matrix.fromBlocks_one]
|
import Mathlib.Topology.EMetricSpace.Basic
import Mathlib.Topology.Bornology.Constructions
import Mathlib.Data.Set.Pointwise.Interval
import Mathlib.Topology.Order.DenselyOrdered
open Set Filter TopologicalSpace Bornology
open scoped ENNReal NNReal Uniformity Topology
universe u v w
variable {Ξ± : Type u} {Ξ² : Typ... | Mathlib/Topology/MetricSpace/PseudoMetric.lean | 392 | 393 | theorem dist_edist (x y : Ξ±) : dist x y = (edist x y).toReal := by |
rw [edist_dist, ENNReal.toReal_ofReal dist_nonneg]
|
import Mathlib.Topology.Algebra.InfiniteSum.Order
import Mathlib.Topology.Algebra.InfiniteSum.Ring
import Mathlib.Topology.Instances.Real
import Mathlib.Topology.MetricSpace.Isometry
#align_import topology.instances.nnreal from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
noncomputabl... | Mathlib/Topology/Instances/NNReal.lean | 274 | 277 | theorem _root_.Real.tendsto_of_bddAbove_monotone {f : β β β} (h_bdd : BddAbove (Set.range f))
(h_mon : Monotone f) : β r : β, Tendsto f atTop (π r) := by |
obtain β¨B, hBβ© := Real.exists_isLUB (Set.range_nonempty f) h_bdd
exact β¨B, tendsto_atTop_isLUB h_mon hBβ©
|
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]
|
import Mathlib.LinearAlgebra.Dimension.LinearMap
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
#align_import linear_algebra.free_module.finite.matrix from "leanprover-community/mathlib"@"b1c23399f01266afe392a0d8f71f599a0dad4f7b"
universe u u' v w
variable (R : Type u) (S : Type u') (M : Type v) (N ... | Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean | 85 | 89 | theorem cardinal_mk_algHom_le_rank : #(M ββ[K] L) β€ lift.{v} (Module.rank K M) := by |
convert (linearIndependent_algHom_toLinearMap K M L).cardinal_lift_le_rank
Β· rw [lift_id]
Β· have := Module.nontrivial K L
rw [lift_id, FiniteDimensional.rank_linearMap_self]
|
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β)]
|
import Mathlib.Algebra.Algebra.Defs
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Fintype.Sort
import Mathlib.Data.List.FinRange
import Mathlib.LinearAlgebra.Pi
import Mathlib.Logic.Equiv.Fintype
#align_import linear_algebra.multilinear.basic from ... | Mathlib/LinearAlgebra/Multilinear/Basic.lean | 1,811 | 1,823 | theorem curryFinFinset_symm_apply_piecewise_const {k l n : β} {s : Finset (Fin n)} (hk : s.card = k)
(hl : sαΆ.card = l)
(f : MultilinearMap R (fun _ : Fin k => M') (MultilinearMap R (fun _ : Fin l => M') Mβ))
(x y : M') :
(curryFinFinset R Mβ M' hk hl).symm f (s.piecewise (fun _ => x) fun _ => y) =
... |
rw [curryFinFinset_symm_apply]; congr
Β· ext
rw [finSumEquivOfFinset_inl, Finset.piecewise_eq_of_mem]
apply Finset.orderEmbOfFin_mem
Β· ext
rw [finSumEquivOfFinset_inr, Finset.piecewise_eq_of_not_mem]
exact Finset.mem_compl.1 (Finset.orderEmbOfFin_mem _ _ _)
|
import Mathlib.Topology.MetricSpace.ProperSpace
import Mathlib.Topology.MetricSpace.Cauchy
open Set Filter Bornology
open scoped ENNReal Uniformity Topology Pointwise
universe u v w
variable {Ξ± : Type u} {Ξ² : Type v} {X ΞΉ : Type*}
variable [PseudoMetricSpace Ξ±]
namespace Metric
#align metric.bounded Bornology.I... | Mathlib/Topology/MetricSpace/Bounded.lean | 456 | 460 | theorem dist_le_diam_of_mem' (h : EMetric.diam s β β€) (hx : x β s) (hy : y β s) :
dist x y β€ diam s := by |
rw [diam, dist_edist]
rw [ENNReal.toReal_le_toReal (edist_ne_top _ _) h]
exact EMetric.edist_le_diam_of_mem hx hy
|
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.Combinatorics.Additive.AP.Three.Defs
import Mathlib.Combinatorics.Pigeonhole
import Mathlib.Data.Complex.ExponentialBounds
#align_import combinatorics.additive.behrend from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
open N... | Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean | 323 | 327 | theorem two_div_one_sub_two_div_e_le_eight : 2 / (1 - 2 / exp 1) β€ 8 := by |
rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
Β· have : 16 < 6 * (2.7182818283 : β) := by norm_num
linarith [exp_one_gt_d9]
rw [sub_pos, div_lt_one] <;> exact exp_one_gt_d9.trans' (by norm_num)
|
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Topology.MetricSpace.IsometricSMul
#align_import topology.metric_space.hausdorff_distance from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
noncomputable section
open NNReal ENNReal Topology Set Filter Pointwise Bornology
u... | Mathlib/Topology/MetricSpace/HausdorffDistance.lean | 571 | 574 | theorem dist_le_infDist_add_diam (hs : IsBounded s) (hy : y β s) :
dist x y β€ infDist x s + diam s := by |
rw [infDist, diam, dist_edist]
exact toReal_le_add (edist_le_infEdist_add_ediam hy) (infEdist_ne_top β¨y, hyβ©) hs.ediam_ne_top
|
import Mathlib.Algebra.Order.CauSeq.BigOperators
import Mathlib.Data.Complex.Abs
import Mathlib.Data.Complex.BigOperators
import Mathlib.Data.Nat.Choose.Sum
#align_import data.complex.exponential from "leanprover-community/mathlib"@"a8b2226cfb0a79f5986492053fc49b1a0c6aeffb"
open CauSeq Finset IsAbsoluteValue
open ... | Mathlib/Data/Complex/Exponential.lean | 761 | 767 | theorem sin_three_mul : sin (3 * x) = 3 * sin x - 4 * sin x ^ 3 := by |
have h1 : x + 2 * x = 3 * x := by ring
rw [β h1, sin_add x (2 * x)]
simp only [cos_two_mul, sin_two_mul, cos_sq']
have h2 : cos x * (2 * sin x * cos x) = 2 * sin x * cos x ^ 2 := by ring
rw [h2, cos_sq']
ring
|
import Mathlib.Topology.Algebra.Module.WeakDual
import Mathlib.MeasureTheory.Integral.BoundedContinuousFunction
import Mathlib.MeasureTheory.Measure.HasOuterApproxClosed
#align_import measure_theory.measure.finite_measure from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable... | Mathlib/MeasureTheory/Measure/FiniteMeasure.lean | 522 | 535 | theorem tendsto_zero_testAgainstNN_of_tendsto_zero_mass {Ξ³ : Type*} {F : Filter Ξ³}
{ΞΌs : Ξ³ β FiniteMeasure Ξ©} (mass_lim : Tendsto (fun i => (ΞΌs i).mass) F (π 0)) (f : Ξ© βα΅ ββ₯0) :
Tendsto (fun i => (ΞΌs i).testAgainstNN f) F (π 0) := by |
apply tendsto_iff_dist_tendsto_zero.mpr
have obs := fun i => (ΞΌs i).testAgainstNN_lipschitz_estimate f 0
simp_rw [testAgainstNN_zero, zero_add] at obs
simp_rw [show β i, dist ((ΞΌs i).testAgainstNN f) 0 = (ΞΌs i).testAgainstNN f by
simp only [dist_nndist, NNReal.nndist_zero_eq_val', eq_self_iff_true, imp_t... |
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.RingTheory.Ideal.Over
import Mathlib.RingTheory.Ideal.Prod
import Mathlib.RingTheory.Ideal.MinimalPrime
import Mathlib.RingTheory.Localization.Away.Basic
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.Topology.Sets.Closeds
import Mathlib.Topology.Sober
#a... | Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean | 653 | 660 | theorem localization_comap_injective [Algebra R S] (M : Submonoid R) [IsLocalization M S] :
Function.Injective (comap (algebraMap R S)) := by |
intro p q h
replace h := congr_arg (fun x : PrimeSpectrum R => Ideal.map (algebraMap R S) x.asIdeal) h
dsimp only [comap, ContinuousMap.coe_mk] at h
rw [IsLocalization.map_comap M S, IsLocalization.map_comap M S] at h
ext1
exact h
|
import Mathlib.Combinatorics.SimpleGraph.Finite
import Mathlib.Combinatorics.SimpleGraph.Maps
#align_import combinatorics.simple_graph.subgraph from "leanprover-community/mathlib"@"c6ef6387ede9983aee397d442974e61f89dfd87b"
universe u v
namespace SimpleGraph
@[ext]
structure Subgraph {V : Type u} (G : SimpleGra... | Mathlib/Combinatorics/SimpleGraph/Subgraph.lean | 686 | 695 | theorem comap_monotone {G' : SimpleGraph W} (f : G βg G') : Monotone (Subgraph.comap f) := by |
intro H H' h
constructor
Β· intro
simp only [comap_verts, Set.mem_preimage]
apply h.1
Β· intro v w
simp (config := { contextual := true }) only [comap_adj, and_imp, true_and_iff]
intro
apply h.2
|
import Mathlib.MeasureTheory.Integral.IntervalIntegral
import Mathlib.Data.Set.Function
#align_import analysis.sum_integral_comparisons from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Set MeasureTheory.MeasureSpace
variable {xβ : β} {a b : β} {f : β β β}
theorem AntitoneOn.in... | Mathlib/Analysis/SumIntegralComparisons.lean | 156 | 159 | theorem MonotoneOn.sum_le_integral_Ico (hab : a β€ b) (hf : MonotoneOn f (Set.Icc a b)) :
β x β Finset.Ico a b, f x β€ β« x in a..b, f x := by |
rw [β neg_le_neg_iff, β Finset.sum_neg_distrib, β intervalIntegral.integral_neg]
exact hf.neg.integral_le_sum_Ico hab
|
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)
|
import Mathlib.GroupTheory.QuotientGroup
import Mathlib.GroupTheory.Solvable
import Mathlib.GroupTheory.PGroup
import Mathlib.GroupTheory.Sylow
import Mathlib.Data.Nat.Factorization.Basic
import Mathlib.Tactic.TFAE
#align_import group_theory.nilpotent from "leanprover-community/mathlib"@"2bbc7e3884ba234309d2a43b19144... | Mathlib/GroupTheory/Nilpotent.lean | 638 | 645 | theorem nilpotencyClass_eq_quotient_center_plus_one [hH : IsNilpotent G] [Nontrivial G] :
Group.nilpotencyClass G = Group.nilpotencyClass (G β§Έ center G) + 1 := by |
rw [nilpotencyClass_quotient_center]
rcases h : Group.nilpotencyClass G with β¨β©
Β· exfalso
rw [nilpotencyClass_zero_iff_subsingleton] at h
apply false_of_nontrivial_of_subsingleton G
Β· simp
|
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.Normed.Order.Basic
import Mathlib.Topology.Algebra.Order.LiminfLimsup
#align_import analysis.asymptotics.superpolynomial_decay from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
... | Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean | 287 | 289 | theorem superpolynomialDecay_mul_param_iff (hk : Tendsto k l atTop) :
SuperpolynomialDecay l k (f * k) β SuperpolynomialDecay l k f := by |
simpa [mul_comm k] using superpolynomialDecay_param_mul_iff f hk
|
import Mathlib.Algebra.Order.Group.Basic
import Mathlib.Algebra.Order.Ring.Basic
import Mathlib.RingTheory.Ideal.Maps
import Mathlib.Tactic.TFAE
#align_import ring_theory.valuation.basic from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
open scoped Classical
open Function Ideal
nonco... | Mathlib/RingTheory/Valuation/Basic.lean | 337 | 339 | theorem map_one_add_of_lt (h : v x < 1) : v (1 + x) = 1 := by |
rw [β v.map_one] at h
simpa only [v.map_one] using v.map_add_eq_of_lt_left h
|
import Mathlib.Data.Fintype.Option
import Mathlib.Data.Fintype.Prod
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Vector.Basic
import Mathlib.Data.PFun
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.Basic
import Mathlib.Tactic.ApplyFun
#align_import computability.turing_machine from "leanprover-commu... | Mathlib/Computability/TuringMachine.lean | 587 | 590 | theorem Tape.move_left_mk' {Ξ} [Inhabited Ξ] (L R : ListBlank Ξ) :
(Tape.mk' L R).move Dir.left = Tape.mk' L.tail (R.cons L.head) := by |
simp only [Tape.move, Tape.mk', ListBlank.head_cons, eq_self_iff_true, ListBlank.cons_head_tail,
and_self_iff, ListBlank.tail_cons]
|
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
|
import Mathlib.Analysis.SpecialFunctions.Gamma.Beta
import Mathlib.NumberTheory.LSeries.HurwitzZeta
import Mathlib.Analysis.Complex.RemovableSingularity
import Mathlib.Analysis.PSeriesComplex
#align_import number_theory.zeta_function from "leanprover-community/mathlib"@"57f9349f2fe19d2de7207e99b0341808d977cdcf"
o... | Mathlib/NumberTheory/LSeries/RiemannZeta.lean | 203 | 208 | theorem zeta_eq_tsum_one_div_nat_add_one_cpow {s : β} (hs : 1 < re s) :
riemannZeta s = β' n : β, 1 / (n + 1 : β) ^ s := by |
have := zeta_eq_tsum_one_div_nat_cpow hs
rw [tsum_eq_zero_add] at this
Β· simpa [zero_cpow (Complex.ne_zero_of_one_lt_re hs)]
Β· rwa [Complex.summable_one_div_nat_cpow]
|
import Mathlib.Data.Stream.Init
import Mathlib.Tactic.Common
#align_import data.seq.computation from "leanprover-community/mathlib"@"1f0096e6caa61e9c849ec2adbd227e960e9dff58"
open Function
universe u v w
def Computation (Ξ± : Type u) : Type u :=
{ f : Stream' (Option Ξ±) // β β¦n aβ¦, f n = some a β f (n + 1) = ... | Mathlib/Data/Seq/Computation.lean | 759 | 773 | theorem bind_assoc (s : Computation Ξ±) (f : Ξ± β Computation Ξ²) (g : Ξ² β Computation Ξ³) :
bind (bind s f) g = bind s fun x : Ξ± => bind (f x) g := by |
apply
eq_of_bisim fun cβ cβ =>
cβ = cβ β¨ β s, cβ = bind (bind s f) g β§ cβ = bind s fun x : Ξ± => bind (f x) g
Β· intro cβ cβ h
match cβ, cβ, h with
| _, cβ, Or.inl (Eq.refl _) => cases' destruct cβ with b cb <;> simp
| _, _, Or.inr β¨s, rfl, rflβ© =>
apply recOn s <;> intro s <;> simp
... |
import Mathlib.Analysis.Normed.Group.Pointwise
import Mathlib.Analysis.NormedSpace.Real
#align_import analysis.normed_space.pointwise from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
open Metric Set
open Pointwise Topology
variable {π E : Type*}
variable [NormedField π]
sectio... | Mathlib/Analysis/NormedSpace/Pointwise.lean | 435 | 439 | theorem smul_sphere [Nontrivial E] (c : π) (x : E) {r : β} (hr : 0 β€ r) :
c β’ sphere x r = sphere (c β’ x) (βcβ * r) := by |
rcases eq_or_ne c 0 with (rfl | hc)
Β· simp [zero_smul_set, Set.singleton_zero, hr]
Β· exact smul_sphere' hc x r
|
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)]
|
import Mathlib.CategoryTheory.Functor.FullyFaithful
import Mathlib.CategoryTheory.FullSubcategory
import Mathlib.CategoryTheory.Whiskering
import Mathlib.CategoryTheory.EssentialImage
import Mathlib.Tactic.CategoryTheory.Slice
#align_import category_theory.equivalence from "leanprover-community/mathlib"@"9aba7801eeec... | Mathlib/CategoryTheory/Equivalence.lean | 159 | 163 | theorem counitInv_functor_comp (e : C β D) (X : C) :
e.counitInv.app (e.functor.obj X) β« e.functor.map (e.unitInv.app X) = π (e.functor.obj X) := by |
erw [Iso.inv_eq_inv (e.functor.mapIso (e.unitIso.app X) βͺβ« e.counitIso.app (e.functor.obj X))
(Iso.refl _)]
exact e.functor_unit_comp X
|
import Mathlib.Data.SetLike.Basic
import Mathlib.Order.Interval.Set.OrdConnected
import Mathlib.Order.Interval.Set.OrderIso
import Mathlib.Data.Set.Lattice
#align_import order.upper_lower.basic from "leanprover-community/mathlib"@"c0c52abb75074ed8b73a948341f50521fbf43b4c"
open Function OrderDual Set
variable {Ξ± Ξ²... | Mathlib/Order/UpperLower/Basic.lean | 1,417 | 1,419 | theorem coe_lowerClosure (s : Set Ξ±) : β(lowerClosure s) = β a β s, Iic a := by |
ext
simp
|
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]
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex
#align_import analysis.special_functions.trigonometric.arctan from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
namespace Real
open Set Filter
open scoped Topology Real
theorem tan_add {x y : β}
... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean | 247 | 256 | theorem arctan_add {x y : β} (h : x * y < 1) :
arctan x + arctan y = arctan ((x + y) / (1 - x * y)) := by |
rw [β arctan_tan (x := _ + _)]
Β· congr
conv_rhs => rw [β tan_arctan x, β tan_arctan y]
exact tan_add' β¨arctan_ne_mul_pi_div_two, arctan_ne_mul_pi_div_twoβ©
Β· rw [neg_lt, neg_add, β arctan_neg, β arctan_neg]
rw [β neg_mul_neg] at h
exact arctan_add_arctan_lt_pi_div_two h
Β· exact arctan_add_arctan... |
import Mathlib.Data.Fin.VecNotation
import Mathlib.Logic.Embedding.Set
#align_import logic.equiv.fin from "leanprover-community/mathlib"@"bd835ef554f37ef9b804f0903089211f89cb370b"
assert_not_exists MonoidWithZero
universe u
variable {m n : β}
def finZeroEquiv : Fin 0 β Empty :=
Equiv.equivEmpty _
#align fin_... | Mathlib/Logic/Equiv/Fin.lean | 445 | 449 | theorem coe_finRotate_of_ne_last {i : Fin n.succ} (h : i β Fin.last n) :
(finRotate (n + 1) i : β) = i + 1 := by |
rw [finRotate_succ_apply]
have : (i : β) < n := Fin.val_lt_last h
exact Fin.val_add_one_of_lt this
|
import Mathlib.Analysis.InnerProductSpace.Projection
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Unique
import Mathlib.MeasureTheory.Function.L2Space
#align_import measure_theory.function.conditional_expectation.condexp_L2 from "leanprover-community/mathlib"@"d8bbb04e2d2a44596798a9207ceefc0fb236e41e"... | Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean | 454 | 462 | theorem integrable_condexpIndSMul (hm : m β€ m0) [SigmaFinite (ΞΌ.trim hm)] (hs : MeasurableSet s)
(hΞΌs : ΞΌ s β β) (x : G) : Integrable (condexpIndSMul hm hs hΞΌs x) ΞΌ := by |
refine
integrable_of_forall_fin_meas_le' hm (ΞΌ s * βxββ) (ENNReal.mul_lt_top hΞΌs ENNReal.coe_ne_top) ?_
?_
Β· exact Lp.aestronglyMeasurable _
Β· refine fun t ht hΞΌt => (set_lintegral_nnnorm_condexpIndSMul_le hm hs hΞΌs x ht hΞΌt).trans ?_
gcongr
apply Set.inter_subset_left
|
import Mathlib.SetTheory.Ordinal.Arithmetic
import Mathlib.Tactic.Abel
#align_import set_theory.ordinal.natural_ops from "leanprover-community/mathlib"@"31b269b60935483943542d547a6dd83a66b37dc7"
set_option autoImplicit true
universe u v
open Function Order
noncomputable section
def NatOrdinal : Type _ :=
... | Mathlib/SetTheory/Ordinal/NaturalOps.lean | 799 | 799 | theorem nmul_succ (a b) : a ⨳ succ b = a ⨳ b β― a := by | rw [β nadd_one, nmul_nadd_one]
|
import Mathlib.MeasureTheory.Measure.MeasureSpace
open scoped ENNReal NNReal Topology
open Set MeasureTheory Measure Filter MeasurableSpace ENNReal Function
variable {R Ξ± Ξ² Ξ΄ Ξ³ ΞΉ : Type*}
namespace MeasureTheory
variable {m0 : MeasurableSpace Ξ±} [MeasurableSpace Ξ²] [MeasurableSpace Ξ³]
variable {ΞΌ ΞΌβ ΞΌβ ΞΌβ Ξ½ Ξ½' Ξ½... | Mathlib/MeasureTheory/Measure/Restrict.lean | 243 | 247 | theorem restrict_inter_add_diffβ (s : Set Ξ±) (ht : NullMeasurableSet t ΞΌ) :
ΞΌ.restrict (s β© t) + ΞΌ.restrict (s \ t) = ΞΌ.restrict s := by |
ext1 u hu
simp only [add_apply, restrict_apply hu, β inter_assoc, diff_eq]
exact measure_inter_add_diffβ (u β© s) ht
|
import Mathlib.Topology.UniformSpace.UniformConvergence
import Mathlib.Topology.UniformSpace.UniformEmbedding
import Mathlib.Topology.UniformSpace.CompleteSeparated
import Mathlib.Topology.UniformSpace.Compact
import Mathlib.Topology.Algebra.Group.Basic
import Mathlib.Topology.DiscreteSubset
import Mathlib.Tactic.Abel... | Mathlib/Topology/Algebra/UniformGroup.lean | 679 | 692 | theorem comm_topologicalGroup_is_uniform : UniformGroup G := by |
have :
Tendsto
((fun p : G Γ G => p.1 / p.2) β fun p : (G Γ G) Γ G Γ G => (p.1.2 / p.1.1, p.2.2 / p.2.1))
(comap (fun p : (G Γ G) Γ G Γ G => (p.1.2 / p.1.1, p.2.2 / p.2.1)) ((π 1).prod (π 1)))
(π (1 / 1)) :=
(tendsto_fst.div' tendsto_snd).comp tendsto_comap
constructor
rw [UniformCon... |
import Mathlib.SetTheory.Cardinal.Ordinal
import Mathlib.SetTheory.Ordinal.FixedPoint
#align_import set_theory.cardinal.cofinality from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputable section
open Function Cardinal Set Order
open scoped Classical
open Cardinal Ordinal
un... | Mathlib/SetTheory/Cardinal/Cofinality.lean | 826 | 839 | theorem infinite_pigeonhole_set {Ξ² Ξ± : Type u} {s : Set Ξ²} (f : s β Ξ±) (ΞΈ : Cardinal)
(hΞΈ : ΞΈ β€ #s) (hβ : β΅β β€ ΞΈ) (hβ : #Ξ± < ΞΈ.ord.cof) :
β (a : Ξ±) (t : Set Ξ²) (h : t β s), ΞΈ β€ #t β§ β β¦xβ¦ (hx : x β t), f β¨x, h hxβ© = a := by |
cases' infinite_pigeonhole_card f ΞΈ hΞΈ hβ hβ with a ha
refine β¨a, { x | β h, f β¨x, hβ© = a }, ?_, ?_, ?_β©
Β· rintro x β¨hx, _β©
exact hx
Β· refine
ha.trans
(ge_of_eq <|
Quotient.sound β¨Equiv.trans ?_ (Equiv.subtypeSubtypeEquivSubtypeExists _ _).symmβ©)
simp only [coe_eq_subtype, mem_s... |
import Mathlib.Algebra.Group.Indicator
import Mathlib.Algebra.Group.Submonoid.Basic
import Mathlib.Data.Set.Finite
#align_import data.finsupp.defs from "leanprover-community/mathlib"@"842328d9df7e96fd90fc424e115679c15fb23a71"
noncomputable section
open Finset Function
variable {Ξ± Ξ² Ξ³ ΞΉ M M' N P G H R S : Type*}... | Mathlib/Data/Finsupp/Defs.lean | 668 | 671 | theorem erase_single_ne {a a' : Ξ±} {b : M} (h : a β a') : erase a (single a' b) = single a' b := by |
ext s; by_cases hs : s = a
Β· rw [hs, erase_same, single_eq_of_ne h.symm]
Β· rw [erase_ne hs]
|
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.LinearAlgebra.Matrix.ZPow
#align_import linear_algebra.matrix.hermitian from "leanprover-community/mathlib"@"caa58cbf5bfb7f81ccbaca4e8b8ac4bc2b39cc1c"
namespace Matrix
variable {Ξ± Ξ² : Type*} {m n : Type*} {A : Matrix n n Ξ±}
open scoped Matrix
local ... | Mathlib/LinearAlgebra/Matrix/Hermitian.lean | 252 | 253 | theorem IsHermitian.inv [Fintype m] [DecidableEq m] {A : Matrix m m Ξ±} (hA : A.IsHermitian) :
Aβ»ΒΉ.IsHermitian := by | simp [IsHermitian, conjTranspose_nonsing_inv, hA.eq]
|
import Mathlib.Data.Bool.Basic
import Mathlib.Data.Option.Defs
import Mathlib.Data.Prod.Basic
import Mathlib.Data.Sigma.Basic
import Mathlib.Data.Subtype
import Mathlib.Data.Sum.Basic
import Mathlib.Init.Data.Sigma.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Logic.Function.Conjugate
import Mathlib.Tactic.Lift... | Mathlib/Logic/Equiv/Basic.lean | 2,075 | 2,078 | theorem update_comp_equiv [DecidableEq Ξ±'] [DecidableEq Ξ±] (f : Ξ± β Ξ²)
(g : Ξ±' β Ξ±) (a : Ξ±) (v : Ξ²) :
update f a v β g = update (f β g) (g.symm a) v := by |
rw [β update_comp_eq_of_injective _ g.injective, g.apply_symm_apply]
|
import Mathlib.Topology.UniformSpace.UniformConvergence
import Mathlib.Topology.UniformSpace.UniformEmbedding
import Mathlib.Topology.UniformSpace.CompleteSeparated
import Mathlib.Topology.UniformSpace.Compact
import Mathlib.Topology.Algebra.Group.Basic
import Mathlib.Topology.DiscreteSubset
import Mathlib.Tactic.Abel... | Mathlib/Topology/Algebra/UniformGroup.lean | 351 | 355 | theorem Filter.HasBasis.uniformity_of_nhds_one_inv_mul {ΞΉ} {p : ΞΉ β Prop} {U : ΞΉ β Set Ξ±}
(h : (π (1 : Ξ±)).HasBasis p U) :
(π€ Ξ±).HasBasis p fun i => { x : Ξ± Γ Ξ± | x.1β»ΒΉ * x.2 β U i } := by |
rw [uniformity_eq_comap_inv_mul_nhds_one]
exact h.comap _
|
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]
|
import Mathlib.Topology.Constructions
#align_import topology.continuous_on from "leanprover-community/mathlib"@"d4f691b9e5f94cfc64639973f3544c95f8d5d494"
open Set Filter Function Topology Filter
variable {Ξ± : Type*} {Ξ² : Type*} {Ξ³ : Type*} {Ξ΄ : Type*}
variable [TopologicalSpace Ξ±]
@[simp]
theorem nhds_bind_nhdsW... | Mathlib/Topology/ContinuousOn.lean | 1,318 | 1,324 | theorem IsOpen.ite' {s s' t : Set Ξ±} (hs : IsOpen s) (hs' : IsOpen s')
(ht : β x β frontier t, x β s β x β s') : IsOpen (t.ite s s') := by |
classical
simp only [isOpen_iff_continuous_mem, Set.ite] at *
convert continuous_piecewise (fun x hx => propext (ht x hx)) hs.continuousOn hs'.continuousOn
rename_i x
by_cases hx : x β t <;> simp [hx]
|
import Mathlib.Algebra.Algebra.Opposite
import Mathlib.Algebra.Algebra.Pi
import Mathlib.Algebra.BigOperators.Pi
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Algebra.BigOperators.RingEquiv
import Mathlib.Algebra.Module.LinearMap.Basic
import Mathlib.Algebra.Module.Pi
import Mathlib.Algebra.Star.BigOperators... | Mathlib/Data/Matrix/Basic.lean | 2,012 | 2,015 | theorem mulVec_smul_assoc [Fintype n] (A : Matrix m n Ξ±) (b : n β Ξ±) (a : Ξ±) :
A *α΅₯ (a β’ b) = a β’ A *α΅₯ b := by |
ext
apply dotProduct_smul
|
import Mathlib.Algebra.Category.ModuleCat.Free
import Mathlib.Topology.Category.Profinite.CofilteredLimit
import Mathlib.Topology.Category.Profinite.Product
import Mathlib.Topology.LocallyConstant.Algebra
import Mathlib.Init.Data.Bool.Lemmas
universe u
namespace Profinite
namespace NobelingProof
variable {I : Ty... | Mathlib/Topology/Category/Profinite/Nobeling.lean | 369 | 372 | theorem linearIndependent_iff_range : LinearIndependent β€ (GoodProducts.eval C) β
LinearIndependent β€ (fun (p : range C) β¦ p.1) := by |
rw [β @Set.rangeFactorization_eq _ _ (GoodProducts.eval C), β equiv_toFun_eq_eval C]
exact linearIndependent_equiv (equiv_range C)
|
import Mathlib.CategoryTheory.EpiMono
import Mathlib.CategoryTheory.Limits.HasLimits
#align_import category_theory.limits.shapes.equalizers from "leanprover-community/mathlib"@"4698e35ca56a0d4fa53aa5639c3364e0a77f4eba"
section
open CategoryTheory Opposite
namespace CategoryTheory.Limits
-- attribute [local tid... | Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean | 403 | 409 | theorem Fork.equalizer_ext (s : Fork f g) {W : C} {k l : W βΆ s.pt} (h : k β« s.ΞΉ = l β« s.ΞΉ) :
β j : WalkingParallelPair, k β« s.Ο.app j = l β« s.Ο.app j
| zero => h
| one => by
have : k β« ΞΉ s β« f = l β« ΞΉ s β« f := by |
simp only [β Category.assoc]; exact congrArg (Β· β« f) h
rw [s.app_one_eq_ΞΉ_comp_left, this]
|
import Mathlib.FieldTheory.IntermediateField
import Mathlib.RingTheory.Adjoin.Field
#align_import field_theory.splitting_field.is_splitting_field from "leanprover-community/mathlib"@"9fb8964792b4237dac6200193a0d533f1b3f7423"
noncomputable section
open scoped Classical Polynomial
universe u v w
variable {F : Ty... | Mathlib/FieldTheory/SplittingField/IsSplittingField.lean | 136 | 142 | theorem of_algEquiv [Algebra K F] (p : K[X]) (f : F ββ[K] L) [IsSplittingField K F p] :
IsSplittingField K L p := by |
constructor
Β· rw [β f.toAlgHom.comp_algebraMap]
exact splits_comp_of_splits _ _ (splits F p)
Β· rw [β (Algebra.range_top_iff_surjective f.toAlgHom).mpr f.surjective,
adjoin_rootSet_eq_range (splits F p), adjoin_rootSet F p]
|
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]
|
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 | 2,321 | 2,324 | theorem isBigO_congr (e : Ξ± ββ Ξ²) {b : Ξ²} {f : Ξ² β E} {g : Ξ² β F} :
f =O[π b] g β (f β e) =O[π (e.symm b)] (g β e) := by |
simp only [IsBigO_def]
exact exists_congr fun C => e.isBigOWith_congr
|
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]
|
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
|
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]
|
import Mathlib.Analysis.Normed.Group.Seminorm
import Mathlib.Order.LiminfLimsup
import Mathlib.Topology.Instances.Rat
import Mathlib.Topology.MetricSpace.Algebra
import Mathlib.Topology.MetricSpace.IsometricSMul
import Mathlib.Topology.Sequences
#align_import analysis.normed.group.basic from "leanprover-community/mat... | Mathlib/Analysis/Normed/Group/Basic.lean | 1,901 | 1,902 | theorem ennnorm_eq_ofReal_abs (r : β) : (βrββ : ββ₯0β) = ENNReal.ofReal |r| := by |
rw [β Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
|
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 | 349 | 350 | theorem toIocDiv_sub (a b : Ξ±) : toIocDiv hp a (b - p) = toIocDiv hp a b - 1 := by |
simpa only [one_zsmul] using toIocDiv_sub_zsmul hp a b 1
|
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Units.Hom
import Mathlib.Algebra.Opposites
import Mathlib.Algebra.Order.GroupWithZero.Synonym
import Mathlib.Algebra.Order.Ring.Nat
import Mathlib.Data.Set.Lattice
import Mathlib.Tactic.Common
#align_import data.set.pointwise.basic from "leanprover... | Mathlib/Data/Set/Pointwise/Basic.lean | 1,210 | 1,211 | theorem image_mul_right : (Β· * b) '' t = (Β· * bβ»ΒΉ) β»ΒΉ' t := by |
rw [image_eq_preimage_of_inverse] <;> intro c <;> simp
|
import Mathlib.MeasureTheory.Constructions.Prod.Basic
import Mathlib.MeasureTheory.Integral.DominatedConvergence
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.constructions.prod.integral from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
noncomputable s... | Mathlib/MeasureTheory/Constructions/Prod/Integral.lean | 280 | 285 | theorem integrable_prod_iff' [SigmaFinite ΞΌ] β¦f : Ξ± Γ Ξ² β Eβ¦
(h1f : AEStronglyMeasurable f (ΞΌ.prod Ξ½)) :
Integrable f (ΞΌ.prod Ξ½) β
(βα΅ y βΞ½, Integrable (fun x => f (x, y)) ΞΌ) β§ Integrable (fun y => β« x, βf (x, y)β βΞΌ) Ξ½ := by |
convert integrable_prod_iff h1f.prod_swap using 1
rw [funext fun _ => Function.comp_apply.symm, integrable_swap_iff]
|
import Mathlib.Algebra.BigOperators.GroupWithZero.Finset
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.Algebra.Module.LinearMap.Basic
import Mathlib.Data.Finset.Preimage
import Mathlib.Data.Set.Finite
import Mathlib.GroupTheory.GroupAction.BigOperators
#align_import data.dfinsupp.basic from "leanpr... | Mathlib/Data/DFinsupp/Basic.lean | 1,170 | 1,174 | theorem support_single_ne_zero {i : ΞΉ} {b : Ξ² i} (hb : b β 0) : (single i b).support = {i} := by |
ext j; by_cases h : i = j
Β· subst h
simp [hb]
simp [Ne.symm h, h]
|
import Mathlib.Algebra.Homology.Exact
import Mathlib.CategoryTheory.Limits.Shapes.Biproducts
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.CategoryTheory.Limits.Preserves.Finite
#align_import category_theory.preadditive.projective from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654... | Mathlib/CategoryTheory/Preadditive/Projective.lean | 217 | 223 | theorem projective_of_map_projective (adj : F β£ G) [F.Full] [F.Faithful] (P : C)
(hP : Projective (F.obj P)) : Projective P where
factors f g _ := by |
haveI := Adjunction.leftAdjointPreservesColimits.{0, 0} adj
rcases (@hP).1 (F.map f) (F.map g) with β¨f', hf'β©
use adj.unit.app _ β« G.map f' β« (inv <| adj.unit.app _)
exact F.map_injective (by simpa)
|
import Mathlib.RingTheory.IntegralClosure
import Mathlib.RingTheory.FractionalIdeal.Basic
#align_import ring_theory.fractional_ideal from "leanprover-community/mathlib"@"ed90a7d327c3a5caf65a6faf7e8a0d63c4605df7"
open IsLocalization Pointwise nonZeroDivisors
namespace FractionalIdeal
open Set Submodule
variable... | Mathlib/RingTheory/FractionalIdeal/Operations.lean | 128 | 130 | theorem map_symm_map (I : FractionalIdeal S P') (g : P ββ[R] P') :
(I.map (g.symm : P' ββ[R] P)).map (g : P ββ[R] P') = I := by |
rw [β map_comp, g.comp_symm, map_id]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.