name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
SimpleGraph.maximumIndepSet_exists | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} [inst : Finite α], ∃ s, G.IsMaximumIndepSet s |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_529 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w)) []).length →
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card <
(List.findIdxs (fun x => decide (x = w)) []).length |
VitaliFamily.ae_eventually_measure_zero_of_singular | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [SecondCountableTopology α] [BorelSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ]
{ρ : MeasureTheory.Measure α} [MeasureTheory.IsLocallyFiniteMeasure ρ],
ρ.MutuallySingular μ → ∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun a => ρ a / μ a) (v.filterAt x) (nhds 0) |
PosMulReflectLE.toPosMulStrictMono | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLE α], PosMulStrictMono α |
Lean.Parser.Term.unsafe._regBuiltin.Lean.Parser.Term.unsafe_1 | Lean.Parser.Term | IO Unit |
Int16.or_self | Init.Data.SInt.Bitwise | ∀ {a : Int16}, a ||| a = a |
List.zip_eq_nil_iff._simp_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β}, (l₁.zip l₂ = []) = (l₁ = [] ∨ l₂ = []) |
Set.OrdConnected.predOrder._proof_10 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Set α} [inst_1 : PredOrder α] (x : α) (hx : x ∈ s),
(if h : Order.pred ↑⟨x, hx⟩ ∈ s then ⟨Order.pred ↑⟨x, hx⟩, h⟩ else ⟨x, hx⟩) ≤ ⟨x, hx⟩ |
Nat.factorial_coe_dvd_prod | Mathlib.Data.Nat.Factorial.BigOperators | ∀ (k : ℕ) (n : ℤ), ↑k.factorial ∣ ∏ i ∈ Finset.range k, (n + ↑i) |
Finset.coe_insert | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑(insert a s) = insert a ↑s |
_private.Mathlib.Data.List.SplitBy.0.List.getLast?.match_1.eq_2 | Mathlib.Data.List.SplitBy | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as |
ContinuousMap.notMem_idealOfSet | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {s : Set X} {f : C(X, R)}, f ∉ ContinuousMap.idealOfSet R s ↔ ∃ x ∈ sᶜ, f x ≠ 0 |
List.dropSlice.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (x x_1 : ℕ), List.dropSlice x x_1 [] = [] |
_private.Mathlib.Logic.Equiv.List.0.Encodable.encodeList.match_1.splitter | Mathlib.Logic.Equiv.List | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (l : List α) → motive (a :: l)) → motive x |
Std.Sat.AIG.Decl.relabel.match_1 | Std.Sat.AIG.Relabel | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((a : α) → motive (Std.Sat.AIG.Decl.atom a)) →
((lhs rhs : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate lhs rhs)) → motive decl |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_34 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls_1 lls : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (lrl lrr : Std.DTreeMap.Internal.Impl α β),
3 * (ll.size + 1 + lr.size) < l.size + 1 + r.size + 1 + (lrl.size + 1 + lrr.size) →
ll.Balanced ∧
lr.Balanced ∧
(ll.size + lr.size ≤ 1 ∨ ll.size ≤ 3 * lr.size ∧ lr.size ≤ 3 * ll.size) ∧ ls = ll.size + 1 + lr.size →
(l.Balanced ∧
r.Balanced ∧
(l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ lls = l.size + 1 + r.size) ∧
(lrl.Balanced ∧
lrr.Balanced ∧
(lrl.size + lrr.size ≤ 1 ∨ lrl.size ≤ 3 * lrr.size ∧ lrr.size ≤ 3 * lrl.size) ∧
lrs = lrl.size + 1 + lrr.size) ∧
(lls + lrs ≤ 1 ∨ lls ≤ 3 * lrs ∧ lrs ≤ 3 * lls) ∧ ls_1 = lls + 1 + lrs →
ll.size + 1 + lr.size + (l.size + 1 + r.size + 1 + (lrl.size + 1 + lrr.size)) ≤ 1 → False |
CategoryTheory.enrichedFunctorTypeEquivFunctor._proof_2 | Mathlib.CategoryTheory.Enriched.Basic | ∀ {C : Type u_2} [𝒞 : CategoryTheory.EnrichedCategory (Type u_1) C] {D : Type u_3}
[𝒟 : CategoryTheory.EnrichedCategory (Type u_1) D] (F : CategoryTheory.Functor C D) (X Y Z : C),
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp (Type u_1) X Y Z) fun f => F.map f) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (fun f => F.map f) fun f => F.map f)
(CategoryTheory.eComp (Type u_1) (F.obj X) (F.obj Y) (F.obj Z)) |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_3.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
Sort u_3)
(x : Std.DTreeMap.Internal.Impl α β)
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced)
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size)
(h_1 :
(lls : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(lrs : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(lrl lrr : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr) hlb hlr)
(h_2 :
(size : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1)
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1)
Std.DTreeMap.Internal.Impl.leaf).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1) Std.DTreeMap.Internal.Impl.leaf hlb hlr)
(h_3 :
(x : Std.DTreeMap.Internal.Impl α β) →
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive Std.DTreeMap.Internal.Impl.leaf x hlb hlr),
(match Std.DTreeMap.Internal.Impl.leaf, x, hlb, hlr with
| Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1, Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr, hlb,
hlr => h_1 lls k_1 v_1 l_1 r_1 lrs lrk lrv lrl lrr hlb hlr
| Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1, Std.DTreeMap.Internal.Impl.leaf, hlb, hlr =>
h_2 size k_1 v_1 l_1 r_1 hlb hlr
| Std.DTreeMap.Internal.Impl.leaf, x, hlb, hlr => h_3 x hlb hlr) =
h_3 x hlb hlr |
Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convIntro____1 | Init.Conv | Lean.Macro |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.glued | Mathlib.AlgebraicGeometry.RelativeGluing | {S : AlgebraicGeometry.Scheme} →
{𝒰 : S.OpenCover} →
[inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀] →
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] →
AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰 →
[Small.{u, u_1} 𝒰.I₀] → [Quiver.IsThin 𝒰.I₀] → AlgebraicGeometry.Scheme |
ArchimedeanClass.liftOrderHom_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {α : Type u_2}
[inst_3 : PartialOrder α] (f : M → α) (h : ∀ (a b : M), ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → f a ≤ f b)
(a : M), (ArchimedeanClass.liftOrderHom f h) (ArchimedeanClass.mk a) = f a |
Subsemiring.closure_singleton_one | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} [inst : NonAssocSemiring R], Subsemiring.closure {1} = ⊥ |
CategoryTheory.GrothendieckTopology.diagramPullback._proof_1 | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
{D : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functor Cᵒᵖ D) {X Y : C} (f : X ⟶ Y) (S T : (J.Cover Y)ᵒᵖ) (f_1 : S ⟶ T)
(I : (Opposite.unop ((J.pullback f).op.obj T)).shape.L),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp ((J.diagram P Y).map f_1)
(CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop ((J.pullback f).op.obj T)).index P)
((J.diagram P Y).obj T)
(fun I =>
CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop T).index P)
(CategoryTheory.GrothendieckTopology.Cover.Arrow.base I))
⋯))
(CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop ((J.pullback f).op.obj T)).index P) I) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop ((J.pullback f).op.obj S)).index P)
((J.diagram P Y).obj S)
(fun I =>
CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop S).index P)
(CategoryTheory.GrothendieckTopology.Cover.Arrow.base I))
⋯)
(((J.pullback f).op.comp (J.diagram P X)).map f_1))
(CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop ((J.pullback f).op.obj T)).index P) I) |
Std.ExtHashMap.getD_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β},
(m₁ ∩ m₂).getD k fallback = if k ∈ m₂ then m₁.getD k fallback else fallback |
Submonoid.LocalizationMap.map_surjective_of_surjOn | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : CommMonoid Q] {k : T.LocalizationMap Q},
Set.SurjOn ⇑g ↑S ↑T → Function.Surjective ⇑g → Function.Surjective ⇑(f.map hy k) |
Lean.Meta.Grind.AC.EqCnstrProof.ctorIdx | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.EqCnstrProof → ℕ |
Lean.Compiler.LCNF.FloatLetIn.BaseFloatContext.mk | Lean.Compiler.LCNF.FloatLetIn | List (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.FloatLetIn.BaseFloatContext |
Subfield.rank_comap | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A : Subfield E) {L : Type v} [inst_1 : Field L] (f : L →+* E),
Module.rank (↥(Subfield.comap f A)) L = A.relrank f.fieldRange |
ContinuousLinearMap.ebound | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : E →SL[σ₁₂] F),
∃ C, 0 < C ∧ ∀ (x : E), ‖f x‖ₑ ≤ ↑C * ‖x‖ₑ |
List.rotate_eq_nil_iff | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {n : ℕ}, l.rotate n = [] ↔ l = [] |
SubMulAction.ofFixingSubgroup_equivariantMap.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (s : Set α),
SubMulAction.ofFixingSubgroup_equivariantMap M s = { toFun := fun x => ↑x, map_smul' := ⋯ } |
Int64.toInt_maxValue | Init.Data.SInt.Lemmas | Int64.maxValue.toInt = 2 ^ 63 - 1 |
Ideal.comap._proof_6 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) (c x : R), x ∈ ⇑f ⁻¹' ↑I → c • x ∈ ⇑f ⁻¹' ↑I |
CategoryTheory.IsFilteredOrEmpty | Mathlib.CategoryTheory.Filtered.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop |
Std.TreeMap.isEmpty_inter_iff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
(t₁ ∩ t₂).isEmpty = true ↔ ∀ k ∈ t₁, k ∉ t₂ |
_private.Init.Meta.Defs.0.Lean.Name.hasNum._sunfold | Init.Meta.Defs | Lean.Name → Bool |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.mkMulEqProof.go | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Option Lean.Expr →
Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
Lean.Expr → Lean.Meta.Grind.Arith.Cutsat.ProofM✝ Lean.Meta.Grind.Arith.Cutsat.MulEqProof✝ |
ZeroHom.zero_comp | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P] (f : ZeroHom M N),
ZeroHom.comp 0 f = 0 |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_5 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) (X_1 : (CategoryTheory.FunctorToTypes.fromOverFunctor F x).Elements),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryOfElements.homMk
(CategoryTheory.Over.mk
(CategoryTheory.CategoryOfElements.homMk (F.elementsMk X_1.fst.left ↑X_1.snd) (F.elementsMk X x) X_1.fst.hom
⋯)).left
(CategoryTheory.Over.mk
(CategoryTheory.CategoryOfElements.homMk (F.elementsMk X_1.fst.left ↑X_1.snd) (F.elementsMk X x) X_1.fst.hom
⋯)).left
(↑(CategoryTheory.CategoryStruct.id X_1)).left ⋯)
(CategoryTheory.Over.mk
(CategoryTheory.CategoryOfElements.homMk (F.elementsMk X_1.fst.left ↑X_1.snd) (F.elementsMk X x) X_1.fst.hom
⋯)).hom =
(CategoryTheory.Over.mk
(CategoryTheory.CategoryOfElements.homMk (F.elementsMk X_1.fst.left ↑X_1.snd) (F.elementsMk X x) X_1.fst.hom
⋯)).hom |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_powerset._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y : PSet.{u_1}}, (y ∈ x.powerset) = (y ⊆ x) |
Lean.ProjectionFunctionInfo.mk | Lean.ProjFns | Lean.Name → ℕ → ℕ → Bool → Lean.ProjectionFunctionInfo |
CFC.rpow_sqrt_nnreal | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsTopologicalRing A] [T2Space A] {a : A} {x : NNReal},
autoParam (0 ≤ a) CFC.rpow_sqrt_nnreal._auto_1 → CFC.sqrt a ^ ↑x = a ^ (↑x / 2) |
Real.mk_add | Mathlib.Data.Real.Basic | ∀ {f g : CauSeq ℚ abs}, Real.mk (f + g) = Real.mk f + Real.mk g |
LieModule.isLieAbelian_of_ker_traceForm_eq_bot | Mathlib.Algebra.Lie.TraceForm | ∀ (R : Type u_1) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[LieRing.IsNilpotent L] [IsDomain R] [Module.Free R M] [Module.Finite R M],
LinearMap.ker (LieModule.traceForm R L M) = ⊥ → IsLieAbelian L |
SubMulAction.instOne | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | {R : Type u_1} → {M : Type u_2} → [inst : Monoid R] → [inst_1 : MulAction R M] → [One M] → One (SubMulAction R M) |
Function.const_inv | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {G : Type u_7} [inst : Inv G] (a : G), (Function.const ι a)⁻¹ = Function.const ι a⁻¹ |
instOrderBotSubtypeIsIdempotentElem._proof_1 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {M₀ : Type u_1} [inst : CommMonoidWithZero M₀], IsIdempotentElem 0 |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.denote_map._proof_1_1 | Std.Sat.AIG.RefVecOperator.Map | ∀ {len : ℕ} (idx : ℕ), ¬0 ≤ idx → False |
OpenSubgroup.instOrderTop._proof_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] (x : OpenSubgroup G), ↑x ⊆ Set.univ |
BddDistLat.Hom.Simps.hom | Mathlib.Order.Category.BddDistLat | (X Y : BddDistLat) → X.Hom Y → BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat |
Lean.Server.RequestContext | Lean.Server.Requests | Type |
AlgebraicGeometry.Scheme.Modules.Hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X : AlgebraicGeometry.Scheme} → X.Modules → X.Modules → Type u |
Quaternion.imJ_coe | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (x : R), (↑x).imJ = 0 |
LinearEquiv.extendScalarsOfSurjective | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring S] →
[inst_2 : Algebra R S] →
{M : Type u_3} →
{N : Type u_4} →
[inst_3 : AddCommMonoid M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R M] →
[inst_6 : Module S M] →
[IsScalarTower R S M] →
[inst_8 : Module R N] →
[inst_9 : Module S N] →
[IsScalarTower R S N] → Function.Surjective ⇑(algebraMap R S) → (M ≃ₗ[R] N) → M ≃ₗ[S] N |
Localization.AtPrime.mapPiEvalRingHom_comp_algebraMap | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {ι : Type u_4} {R : ι → Type u_5} [inst : (i : ι) → CommSemiring (R i)] {i : ι} (I : Ideal (R i))
[inst_1 : I.IsPrime],
(Localization.AtPrime.mapPiEvalRingHom I).comp
(algebraMap ((i : ι) → R i) (Localization.AtPrime (Ideal.comap (Pi.evalRingHom R i) I))) =
(algebraMap (R i) (Localization.AtPrime I)).comp (Pi.evalRingHom R i) |
notation_class | Mathlib.Tactic.Simps.NotationClass | Lean.ParserDescr |
FreeRing.coe_sub | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u} (x y : FreeRing α), ↑(x - y) = ↑x - ↑y |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isEtaUnassignedMVar._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.ShortComplex.homologyπ | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) → [inst_2 : S.HasHomology] → S.cycles ⟶ S.homology |
Topology.IsLowerSet.closure_eq_upperClosure | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {s : Set α},
closure s = ↑(upperClosure s) |
CategoryTheory.OplaxFunctor.PseudoCore | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.OplaxFunctor B C → Type (max (max u₁ v₁) w₂) |
Unitary.spectrum_subset_slitPlane_iff_norm_lt_two | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] {u : A}, u ∈ unitary A → (spectrum ℂ u ⊆ Complex.slitPlane ↔ ‖u - 1‖ < 2) |
Std.TreeSet.Raw.le_min! | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = false → ∀ {k : α}, (cmp k t.min!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true |
MeasureTheory.isMulLeftInvariant_map | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Mul G] {μ : MeasureTheory.Measure G} [MeasurableMul G]
{H : Type u_3} [inst_3 : MeasurableSpace H] [inst_4 : Mul H] [MeasurableMul H] [μ.IsMulLeftInvariant] (f : G →ₙ* H),
Measurable ⇑f → Function.Surjective ⇑f → (MeasureTheory.Measure.map (⇑f) μ).IsMulLeftInvariant |
CategoryTheory.Limits.binaryBiconeOfIsSplitEpiOfKernel._proof_7 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.IsSplitEpi f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.section_ f) f = CategoryTheory.CategoryStruct.id Y |
AlgebraicGeometry.IsAffineOpen.basicOpen_basicOpen_is_basicOpen | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : ↑(X.presheaf.obj (Opposite.op U))) (g : ↑(X.presheaf.obj (Opposite.op (X.basicOpen f)))),
∃ f', X.basicOpen f' = X.basicOpen g |
DistribLattice.ofInfSupLe | Mathlib.Order.Lattice | {α : Type u} → [inst : Lattice α] → (∀ (a b c : α), a ⊓ (b ⊔ c) ≤ a ⊓ b ⊔ a ⊓ c) → DistribLattice α |
KaehlerDifferential.moduleBaseChange._proof_3 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_3) (S : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing A] [inst_4 : Algebra R A] (r s : A) (x : TensorProduct R S Ω[A⁄R]), (r + s) • x = r • x + s • x |
instContinuousAddWeakSpace | Mathlib.Topology.Algebra.Module.WeakDual | ∀ (𝕜 : Type u_2) (E : Type u_1) [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E],
ContinuousAdd (WeakSpace 𝕜 E) |
nndist_inv_inv₀ | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_2} [inst : NormedDivisionRing α] {z w : α}, z ≠ 0 → w ≠ 0 → nndist z⁻¹ w⁻¹ = nndist z w / (‖z‖₊ * ‖w‖₊) |
Sum.isLeft_iff | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, x.isLeft = true ↔ ∃ y, x = Sum.inl y |
boolAlg_dual_comp_forget_to_bddDistLat | Mathlib.Order.Category.BoolAlg | BoolAlg.dual.comp (CategoryTheory.forget₂ BoolAlg BddDistLat) =
(CategoryTheory.forget₂ BoolAlg BddDistLat).comp BddDistLat.dual |
NumberField.InfinitePlace.mkReal._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (w : { w // w.IsReal }),
(fun φ => ⟨NumberField.InfinitePlace.mk ↑φ, ⋯⟩) ⟨(↑w).embedding, ⋯⟩ = w |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (head : α) (tail : List α) {i : ℕ} {h : i < (head :: tail).length}, ¬i = 0 → i - 1 < tail.length |
NonUnitalAlgHomClass | Mathlib.Algebra.Algebra.NonUnitalHom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : NonUnitalNonAssocSemiring B] →
[DistribMulAction R A] → [DistribMulAction R B] → [FunLike F A B] → Prop |
instAssociativeUInt32HMul | Init.Data.UInt.Lemmas | Std.Associative fun x1 x2 => x1 * x2 |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_11 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬(x.toNat ≤ y.toNat ↔ x.toNat + 2 ^ n ≤ y.toNat + 2 ^ n) → False |
Lean.Meta.Grind.MethodsRef | Lean.Meta.Tactic.Grind.Types | Type |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_3 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace γ]
(f : α × β → γ) {s : Set α} {t : Set β} (x : α) (y : β) (ε : ENNReal) (δ : NNReal) (x' a : α) (b : β)
(motive : (a, b) ∈ (s ∩ Metric.eball x ↑δ) ×ˢ (t ∩ {b | edist (f (x', b)) (f (x', y)) ≤ ε / 2}) → Prop)
(h : (a, b) ∈ (s ∩ Metric.eball x ↑δ) ×ˢ (t ∩ {b | edist (f (x', b)) (f (x', y)) ≤ ε / 2})),
(∀ (has : (a, b).1 ∈ s) (hax : (a, b).1 ∈ Metric.eball x ↑δ) (hbt : (a, b).2 ∈ t)
(hby : (a, b).2 ∈ {b | edist (f (x', b)) (f (x', y)) ≤ ε / 2}), motive ⋯) →
motive h |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_2 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_2 () |
isGδ_induced | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f → IsGδ s → IsGδ (f ⁻¹' s) |
_private.Mathlib.Analysis.BoxIntegral.Basic.0.BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt._simp_1_5 | Mathlib.Analysis.BoxIntegral.Basic | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t |
add_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (u v w : m → α),
(u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w |
WittVector.eval | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} →
{R : Type u_1} → [CommRing R] → {k : ℕ} → (ℕ → MvPolynomial (Fin k × ℕ) ℤ) → (Fin k → WittVector p R) → WittVector p R |
SSet.Subcomplex.PairingCore.RankFunction._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} → {h : A.PairingCore} → {α : Type v} → {inst : PartialOrder α} → [SizeOf α] → h.RankFunction α → ℕ |
Std.TreeMap.getEntryGT? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → Option (α × β) |
UniformSpace.Completion.ring._proof_11 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α],
Continuous (HMul.hMul 0) |
CentroidHom.coe_sub._simp_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocRing α] (f g : CentroidHom α), ⇑f - ⇑g = ⇑(f - g) |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unary._proof_2 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin as.size), ↑lo < as.size |
_private.Mathlib.Data.NNReal.Defs.0.NNReal.iSup_eq_zero._simp_1_2 | Mathlib.Data.NNReal.Defs | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a = ⊥) = (a ≤ ⊥) |
Semiring.toGrindSemiring._proof_15 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (a : α), a * 0 = 0 |
Filter.Tendsto.div_const | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [ContinuousMul G₀] {f : α → G₀}
{l : Filter α} {x : G₀}, Filter.Tendsto f l (nhds x) → ∀ (y : G₀), Filter.Tendsto (fun a => f a / y) l (nhds (x / y)) |
_private.Lean.LibrarySuggestions.Basic.0.Lean.LibrarySuggestions.Selector.intersperse._proof_5 | Lean.LibrarySuggestions.Basic | ∀ (c : Lean.LibrarySuggestions.Config) (suggestions₁ suggestions₂ : Array Lean.LibrarySuggestions.Suggestion)
(r : MProd Float (MProd Float (MProd ℕ (MProd ℕ (Array Lean.LibrarySuggestions.Suggestion))))),
r.snd.snd.fst < suggestions₁.size ∧
r.snd.snd.snd.fst < suggestions₂.size ∧ r.snd.snd.snd.snd.size < c.maxSuggestions →
¬r.snd.snd.fst < suggestions₁.size → False |
Lean.Doc.Inline.concat.sizeOf_spec | Lean.DocString.Types | ∀ {i : Type u} [inst : SizeOf i] (content : Array (Lean.Doc.Inline i)),
sizeOf (Lean.Doc.Inline.concat content) = 1 + sizeOf content |
Function.surjective_iff_hasRightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {f : α → β}, Function.Surjective f ↔ Function.HasRightInverse f |
Mathlib.Tactic.AtomM.RecurseM | Mathlib.Util.AtomM.Recurse | Type → Type |
SemidirectProduct.mulEquivSubgroup_symm_apply | Mathlib.GroupTheory.SemidirectProduct | ∀ {G : Type u_2} [inst : Group G] {H K : Subgroup G} [inst_1 : H.Normal] (h : H.IsComplement' K) (b : G),
(SemidirectProduct.mulEquivSubgroup h).symm b = Function.surjInv ⋯ b |
_private.Mathlib.RingTheory.Ideal.KrullsHeightTheorem.0.Ideal.mem_minimalPrimes_span_of_mem_minimalPrimes_span_insert.match_1_2 | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] (x : R) (t : Set R) (f : R →+* R ⧸ Ideal.span t) (r : Ideal (R ⧸ Ideal.span t))
(motive : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r → Prop) (x_1 : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r),
(∀ (hr : r.IsPrime) (hxr : Ideal.map f (Ideal.span {x}) ≤ r), motive ⋯) → motive x_1 |
AlgebraicGeometry.Scheme.IdealSheafData.range_glueDataObjι_ι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U : ↑X.affineOpens),
Set.range ⇑(CategoryTheory.CategoryStruct.comp (I.glueDataObjι U) (↑U).ι) = X.zeroLocus ↑(I.ideal U) ∩ ↑↑U |
m_Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b c : α),
|(a ⊔ c) / (b ⊔ c)|ₘ ⊔ |(a ⊓ c) / (b ⊓ c)|ₘ ≤ |a / b|ₘ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.