name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EReal.div_pos | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, 0 < a → 0 < b → b ≠ ⊤ → 0 < a / b | null | true |
MeasureTheory.Measure.instIsLocallyFiniteMeasureForallVolumeOfSigmaFinite | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} [inst : Fintype ι] {X : ι → Type u_4} [inst_1 : (i : ι) → TopologicalSpace (X i)]
[inst_2 : (i : ι) → MeasureTheory.MeasureSpace (X i)] [∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume]
[∀ (i : ι), MeasureTheory.IsLocallyFiniteMeasure MeasureTheory.volume],
MeasureTheory.IsLocallyFinite... | null | true |
Std.DTreeMap.Internal.Impl.WF.below.empty | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{x : α → Type v}, Std.DTreeMap.Internal.Impl.WF.below ⋯ | null | true |
DifferentiableWithinAt.add_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 (fun y => f... | **Alias** of the reverse direction of `differentiableWithinAt_add_const_iff`. | true |
ConjRootClass.mk_def | Mathlib.FieldTheory.Minpoly.ConjRootClass | ∀ (K : Type u_1) {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {x : L},
⟦x⟧ = ConjRootClass.mk K x | null | true |
Int32.minValue_le._simp_1 | Init.Data.SInt.Lemmas | ∀ (a : Int32), (Int32.minValue ≤ a) = True | null | false |
Function.Bijective.finset_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid M]
(e : ι → κ), Function.Bijective e → ∀ (f : ι → M) (g : κ → M), (∀ (x : ι), f x = g (e x)) → ∑ x, f x = ∑ x, g x | **Alias** of `Function.Bijective.finsetSum`. | true |
_private.Mathlib.SetTheory.Lists.0.Lists.mem.decidable.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : Lists α → Lists' α true → Sort u_2) (a : Lists α) (b : Bool) (b_1 : Lists' α b)
(l₂ : Lists' α true) (h_1 : (a : Lists α) → motive a Lists'.nil)
(h_2 : (a : Lists α) → (b : Bool) → (b_2 : Lists' α b) → (l₂ : Lists' α true) → motive a (b_2.cons' l₂)),
(match a, b_1.cons' l₂ with
| a,... | null | true |
CategoryTheory.Retract.ofIso._proof_2 | Mathlib.CategoryTheory.Retract | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y),
CategoryTheory.CategoryStruct.comp e.hom e.inv = CategoryTheory.CategoryStruct.id X | null | false |
Submodule.eq_of_le_of_finrank_le | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{S₁ S₂ : Submodule K V} [FiniteDimensional K ↥S₂], S₁ ≤ S₂ → Module.finrank K ↥S₂ ≤ Module.finrank K ↥S₁ → S₁ = S₂ | If a submodule is contained in a finite-dimensional
submodule with the same or smaller dimension, they are equal. | true |
AlgebraicGeometry.Scheme.Pullback.openCoverOfRight._proof_3 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z) (i : 𝒰.I₀),
CategoryTheory.Limits.HasPullback f (CategoryTheory.CategoryStruct.comp (𝒰.f i) g) | null | false |
Aesop.newNodeEmoji | Aesop.Tracing | String | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.signExtend_extractLsb_setWidth._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} (i : ℕ), n + i < w → ¬n + i < w + n → False | null | false |
HomologicalComplex.XIsoOfEq_hom_comp_d | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ p₂ : ι}
(h : p₁ = p₂) (p₃ : ι), CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).hom (K.d p₂ p₃) = K.d p₁ p₃ | null | true |
Int.Linear.orOver_cases | Init.Data.Int.Linear | ∀ {n : ℕ} {p : ℕ → Prop}, Int.Linear.OrOver (n + 1) p → Int.Linear.OrOver_cases_type n p | null | true |
_private.Mathlib.CategoryTheory.Abelian.Injective.Dimension.0.CategoryTheory.injectiveDimension_lt_iff._simp_1_1 | Mathlib.CategoryTheory.Abelian.Injective.Dimension | ∀ {n : WithBot ℕ∞} {m : ℕ}, (n < ↑m + 1) = (n ≤ ↑m) | null | false |
TensorProduct.uniqueLeft._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Subsingleton M] (z : TensorProduct R M N),
z = 0 | null | false |
closedBall_add_singleton | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x y : E),
Metric.closedBall x δ + {y} = Metric.closedBall (x + y) δ | null | true |
enorm_eq_zero'._simp_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedMonoid E] {a : E}, (‖a‖ₑ = 0) = (a = 1) | null | false |
Sbtw.left_mem_image_Ioi | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {x y z : P},
Sbtw R x y z → x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ioi 1 | null | true |
Aesop.SafeRuleResult | Aesop.Search.Expansion | Type | null | true |
FractionalIdeal.coeIdeal_span_singleton | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (x : R), ↑(Ideal.span {x}) = FractionalIdeal.spanSingleton S ((algebraMap R P) x) | null | true |
sSupHom.cancel_left._simp_2 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
{g : sSupHom β γ} {f₁ f₂ : sSupHom α β}, Function.Injective ⇑g → (g.comp f₁ = g.comp f₂) = (f₁ = f₂) | null | false |
IsTopologicalAddGroup.rightUniformSpace._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G],
Filter.Tendsto Prod.swap (Filter.comap (fun p => p.2 + -p.1) (nhds 0)) (Filter.comap (fun p => p.2 + -p.1) (nhds 0)) | null | false |
div_lt_div_right_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b c : α},
c < 0 → (a / c < b / c ↔ b < a) | null | true |
SemilatInfCat._sizeOf_inst | Mathlib.Order.Category.Semilat | SizeOf SemilatInfCat | null | false |
Vector.swap_comm | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (hi : i < n) (hj : j < n), xs.swap i j hi hj = xs.swap j i hj hi | null | true |
LinearEquiv.smul_id_of_finrank_eq_one.eq_1 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_2} [inst : CommSemiring R] [inst_1 : StrongRankCondition R] {M : Type u_3} [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module.Free R M] (d1 : Module.finrank R M = 1),
LinearEquiv.smul_id_of_finrank_eq_one d1 =
{ toFun := fun c => c • LinearMap.id, map_add' := ⋯, map_smul' := ⋯, invF... | null | true |
MagmaCat.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : MagmaCat}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | null | true |
Subgroup.IsSubnormal.below.rec | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {motive : (a : Subgroup G) → a.IsSubnormal → Prop}
{motive_1 : {a : Subgroup G} → (t : a.IsSubnormal) → Subgroup.IsSubnormal.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ (H K : Subgroup G) (h_le : H ≤ K) (hSubn : K.IsSubnormal) (hN : (H.subgroupOf K).Normal)
(ih : Subgroup.IsSubn... | null | false |
HasFDerivAt.comp_hasDerivAt_of_eq | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f : 𝕜 → F}
{f' : F} (x : 𝕜) {l : F → E} {l' : F →L[𝕜] E} {y : F},
HasFDerivAt l l' y → HasDerivAt f f' x → y = f... | The composition `l ∘ f` where `l : F → E` and `f : 𝕜 → F`, has a derivative equal to the
Fréchet derivative of `l` applied to the derivative of `f`. | true |
_private.Mathlib.Algebra.Polynomial.EraseLead.0.Polynomial.card_support_eq'._simp_1_1 | Mathlib.Algebra.Polynomial.EraseLead | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
MeasureTheory.Measure.MutuallySingular.restrict_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν),
μ.restrict h.nullSet = 0 | null | true |
CategoryTheory.Functor.mapCommMonCompIso._proof_6 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_6} [inst_3 : CategoryTheory.Category.{u_5, u_6} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] {E : Type u_... | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeNegAssignment.eq_3 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment.both.removeNegAssignment = Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos | null | true |
Set.eqOn_mulIndicator | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] {s : Set α} {f : α → M}, Set.EqOn (s.mulIndicator f) f s | See `Set.eqOn_mulIndicator'` for the version with `sᶜ`. | true |
HVertexOperator.coeff_inj_iff | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_1} [inst : PartialOrder Γ] {R : Type u_2} {V : Type u_3} {W : Type u_4} [inst_1 : CommRing R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
{a₁ a₂ : HVertexOperator Γ R V W}, a₁ = a₂ ↔ HVertexOperator.coeff a₁ = HVertexOperator.coeff a₂ | null | true |
Lean.Elab.Term.Do.ToTerm.Kind.forIn.elim | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Kind → Sort u} →
(t : Lean.Elab.Term.Do.ToTerm.Kind) → t.ctorIdx = 1 → motive Lean.Elab.Term.Do.ToTerm.Kind.forIn → motive t | null | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.variance_fun_id_gaussianReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True | null | false |
Lean.Import.mk.injEq | Lean.Setup | ∀ (module : Lean.Name) (importAll isExported isMeta : Bool) (module_1 : Lean.Name)
(importAll_1 isExported_1 isMeta_1 : Bool),
({ module := module, importAll := importAll, isExported := isExported, isMeta := isMeta } =
{ module := module_1, importAll := importAll_1, isExported := isExported_1, isMeta := isMet... | null | true |
CategoryTheory.Limits.colimit.toCostructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F (Categor... | If `F` has a colimit, then the colimit inclusions can be interpreted as costructured arrows
`F.obj - ⟶ colimit F`. | true |
Lean.JsonRpc.MessageMetaData.responseError.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageMetaData → Sort u} →
(t : Lean.JsonRpc.MessageMetaData) →
t.ctorIdx = 3 →
((id : Lean.JsonRpc.RequestID) →
(code : Lean.JsonRpc.ErrorCode) →
(message : String) →
(data? : Option Lean.Json) → motive (Lean.JsonRpc.MessageMetaData.responseError ... | null | false |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.part_mem._simp_1_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a),
(Finset.choose p l hp ∈ l) = True | null | false |
DirichletCharacter.conductor_mul_dvd_lcm_conductor | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} (χ ψ : DirichletCharacter R n),
(χ * ψ).conductor ∣ χ.conductor.lcm ψ.conductor | The conductor of `χ * ψ` divides the lcm of the conductors of `χ` and `ψ`. | true |
Lean.Meta.Grind.SplitSource._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.SplitSource | null | false |
Mathlib.Tactic.Linarith.CompSource.noConfusionType | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | Sort u → Mathlib.Tactic.Linarith.CompSource → Mathlib.Tactic.Linarith.CompSource → Sort u | null | false |
CategoryTheory.Comma.coconeOfPreserves_ι_app_left | Mathlib.CategoryTheory.Limits.Comma | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] {A : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
{B : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃}
[inst_3 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T}
(F : Categ... | null | true |
_private.Std.Tactic.Do.Syntax.0.Lean.Parser.Tactic.instReprMCasesPat.repr.match_1 | Std.Tactic.Do.Syntax | (motive : Lean.Parser.Tactic.MCasesPat → Sort u_1) →
(x : Lean.Parser.Tactic.MCasesPat) →
((a : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MCasesPat.one a)) →
(Unit → motive Lean.Parser.Tactic.MCasesPat.clear) →
((a : List Lean.Parser.Tactic.MCasesPat) → motive (Lean.Parser.Tactic.... | null | false |
_private.Init.Data.Char.Ordinal.0.Char.succ?_eq._simp_1_4 | Init.Data.Char.Ordinal | ∀ {a b : UInt32}, (a = a + b) = (b = 0) | null | false |
_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.mkCasesHint | Lean.Elab.Tactic.Split | Lean.Expr → Lean.MessageData | null | true |
PointedCone.dual_zero | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R}, PointedCone.dual p 0 = ⊤ | null | true |
Qq.Impl.MVarSynth.term.elim | Qq.Macro | {motive : Qq.Impl.MVarSynth → Sort u} →
(t : Qq.Impl.MVarSynth) →
t.ctorIdx = 0 →
((quotedType : Lean.Expr) →
(unquotedMVar : Lean.MVarId) → motive (Qq.Impl.MVarSynth.term quotedType unquotedMVar)) →
motive t | null | false |
Antitone.partMap | Mathlib.Order.Part | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] {f : β → γ} {g : α → Part β},
Antitone g → Antitone fun x => Part.map f (g x) | null | true |
CategoryTheory.Subobject.Classifier.ofIso_χ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (𝒞 : CategoryTheory.Subobject.Classifier C) {Ω₀ Ω : C}
(eΩ : 𝒞.Ω ≅ Ω) (eΩ₀ : 𝒞.Ω₀ ≅ Ω₀) (from' : (C_1 : C) → C_1 ⟶ Ω₀) (t : Ω₀ ⟶ Ω)
(ht :
autoParam (t = CategoryTheory.CategoryStruct.comp eΩ₀.inv (CategoryTheory.CategoryStruct.comp 𝒞.truth eΩ.hom))
... | null | true |
Filter.map_add_atTop_eq_nat | Mathlib.Order.Filter.AtTopBot.Basic | ∀ (k : ℕ), Filter.map (fun a => a + k) Filter.atTop = Filter.atTop | null | true |
IsLUB.inter_Ici_of_mem | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : LinearOrder γ] {s : Set γ} {a b : γ}, IsLUB s a → b ∈ s → IsLUB (s ∩ Set.Ici b) a | null | true |
Std.ExtDTreeMap.maxKey! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → [Inhabited α] → Std.ExtDTreeMap α β cmp → α | Tries to retrieve the largest key in the tree map, panicking if the map is empty.
| true |
Setoid.mapOfSurjective_eq_map | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : Setoid α} {f : α → β} (h : Setoid.ker f ≤ r) (hf : Function.Surjective f),
r.map f = r.mapOfSurjective f h hf | A special case of the equivalence closure of an equivalence relation r equaling r. | true |
Hyperreal.archimedeanClassMk_omega_neg._simp_1 | Mathlib.Analysis.Real.Hyperreal | (ArchimedeanClass.mk Hyperreal.omega < 0) = True | null | false |
CategoryTheory.Sieve.mk | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(arrows : CategoryTheory.Presieve X) →
(∀ {Y Z : C} {f : Y ⟶ X}, arrows f → ∀ (g : Z ⟶ Y), arrows (CategoryTheory.CategoryStruct.comp g f)) →
CategoryTheory.Sieve X | null | true |
Std.Iterators.ProductivenessRelation.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{P : Sort u} →
{Rel : Std.IterM m β → Std.IterM m β → Prop} →
{wf : WellFounded Rel} →
{subrelation : ∀ {it it' : Std.IterM m β}, it'.IsPlausibleSkipSuccessorOf it → Rel it' it} →... | null | false |
Filter.Germ.liftPred_coe | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {f : α → β},
Filter.Germ.LiftPred p ↑f ↔ ∀ᶠ (x : α) in l, p (f x) | null | true |
ZeroAtInftyContinuousMap.instIsCentralScalar | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β] {R : Type u_2}
[inst_3 : Zero R] [inst_4 : SMulWithZero R β] [inst_5 : SMulWithZero Rᵐᵒᵖ β] [inst_6 : ContinuousConstSMul R β]
[inst_7 : IsCentralScalar R β], IsCentralScalar R (ZeroAtInftyContinuousMap α β) | null | true |
_private.Mathlib.Data.Finset.Union.0.Finset.mem_disjiUnion._simp_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ s.val) | null | false |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_revPerm_Ico._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
Multiset.sum_induction_nonempty | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_3} [inst : AddCommMonoid M] {s : Multiset M} (p : M → Prop),
(∀ (a b : M), p a → p b → p (a + b)) → s ≠ ∅ → (∀ a ∈ s, p a) → p s.sum | null | true |
CategoryTheory.instAbelianOpposite._proof_4 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels Cᵒᵖ | null | false |
NonUnitalSubsemiring.toSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | {R : Type u} → [inst : NonAssocSemiring R] → (S : NonUnitalSubsemiring R) → 1 ∈ S → Subsemiring R | Turn a non-unital subsemiring containing `1` into a subsemiring. | true |
StandardEtalePair.lift._proof_3 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
RingHomClass (Polynomial (Polynomial R) →ₐ[R] S) (Polynomial (Polynomial R)) S | null | false |
exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {K : Type u_1} {L : Type u_2} [inst : NormedField K] [inst_1 : Field L] [inst_2 : Algebra K L],
FiniteDimensional K L →
IsNonarchimedean norm → ∃ f, IsPowMul ⇑f ∧ (∀ (x : K), f ((algebraMap K L) x) = ‖x‖) ∧ IsNonarchimedean ⇑f | If `K` is a nonarchimedean normed field `L/K` is a finite extension, then there exists a
power-multiplicative nonarchimedean `K`-algebra norm on `L` extending the norm on `K`. | true |
Lean.Server.References.ParentDecl.selectionRange | Lean.Server.References | Lean.Server.References.ParentDecl → Lean.Lsp.Range | Selection range of the parent declaration. | true |
CategoryTheory.CosimplicialObject.δ_comp_σ_self'_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ}
{j : Fin (n + 2)} {i : Fin (n + 1)},
j = i.castSucc →
∀ {Z : C} (h : X.obj { len := n } ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.δ j) (CategoryTheory.CategoryStruct.comp (X.σ i) h) = h | null | true |
Std.Time.Internal.UnitVal.recOn | Std.Time.Internal.UnitVal | {α : ℚ} →
{motive : Std.Time.Internal.UnitVal α → Sort u} →
(t : Std.Time.Internal.UnitVal α) → ((val : ℤ) → motive { val := val }) → motive t | null | false |
CategoryTheory.ObjectProperty.InheritedFromSource.of_hom_of_source | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {P : CategoryTheory.ObjectProperty C}
{Q : CategoryTheory.MorphismProperty C} [self : P.InheritedFromSource Q] {X Y : C} (f : X ⟶ Y), Q f → P X → P Y | null | true |
IntCast.recOn | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → (t : IntCast R) → ((intCast : ℤ → R) → motive { intCast := intCast }) → motive t | null | false |
CategoryTheory.Adjunction.compYonedaIso_hom_app_app_hom_apply | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : D) (X_1 : Cᵒᵖ)
(x : Opposite.unop X_1 ⟶ G.obj X),
(CategoryTheory.ConcreteCategory.hom ((adj.compYonedaIso.ho... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isRevMatch_iff_isRevMatch_beq._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {p : Char → Bool} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch p pos =
∃ (h : s.endPos ≠ s.startPos), pos = s.endPos.prev h ∧ p ((s.endPos.prev h).get ⋯) = true | null | false |
CategoryTheory.Limits.Cocone.extendId._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cocone F)
(j : J),
(s.extend (CategoryTheory.CategoryStruct.id s.pt)).ι.app j =
CategoryTheory.CategoryStruct.comp (s.ι.app ... | null | false |
Vector.isNone_finIdxOf? | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] [PartialEquivBEq α] {v : Vector α n} {a : α},
(v.finIdxOf? a).isNone = !v.contains a | null | true |
TypeCat.hom_ofHom | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X → Y), TypeCat.Hom.hom (TypeCat.ofHom f) = { toFun := f } | null | true |
SetLike.exists_of_lt | Mathlib.Data.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : PartialOrder A] [IsConcreteLE A B] {p q : A},
p < q → ∃ x ∈ q, x ∉ p | null | true |
ConjAct.Subgroup.val_conj_smul | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {G : Type u_3} [inst : Group G] {H : Subgroup G} [inst_1 : H.Normal] (g : ConjAct G) (h : ↥H), ↑(g • h) = g • ↑h | null | true |
OpenPartialHomeomorph.MDifferentiable | Mathlib.Geometry.Manifold.MFDeriv.Defs | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H →
{M : Type u_4} →
[... | Prop registering if an open partial homeomorphism is a local diffeomorphism on its source | true |
HasFibers.Fib.isoMk | Mathlib.CategoryTheory.FiberedCategory.HasFibers | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
{p : CategoryTheory.Functor 𝒳 𝒮} →
[inst_2 : HasFibers p] →
{S : 𝒮} →
{a b : HasFibers.Fib p S} →
(Φ : (HasFibers.ι... | The lift of an isomorphism `Φ : (ι S).obj a ≅ (ι S).obj b` lying over `𝟙 S` to an isomorphism
in `Fib S`. | true |
_private.Mathlib.Combinatorics.Graph.Subgraph.0.Graph.vertexSet_not_nonempty_iff._simp_1_1 | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β}, (G.vertexSet = ∅) = (G = ⊥) | null | false |
Aesop.PhaseName.safe.sizeOf_spec | Aesop.Rule.Name | sizeOf Aesop.PhaseName.safe = 1 | null | true |
groupCohomology.isoCocycles₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → groupCohomology.cocycles A 1 ≅ ModuleCat.of k ↥(groupCohomology.cocycles₁ A) | The 1-cocycles of the complex of inhomogeneous cochains of `A` are isomorphic to
`cocycles₁ A`, which is a simpler type. | true |
MeasurableSpace.separatesPoints_of_measurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α], MeasurableSpace.SeparatesPoints α | null | true |
IO.FS.Stream.noConfusionType | Init.System.IO | Sort u → IO.FS.Stream → IO.FS.Stream → Sort u | null | false |
Lean.Lsp.instToJsonDeleteFile | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.DeleteFile | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.edgeDensity_star_not_uniform._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} {hU : U ∈ P.parts} {hV : V ∈ P.parts},
U ≠ V →
|↑(G.edgeDensity ((SzemerediRegularity.star hP G ε hU V).biUnion id)
... | null | false |
_private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.poly_binom_aux3 | Mathlib.Algebra.Polynomial.Identities | ∀ {R : Type u} [inst : CommRing R] (f : Polynomial R) (x y : R),
Polynomial.eval (x + y) f =
((f.sum fun e a => a * x ^ e) + f.sum fun e a => a * ↑e * x ^ (e - 1) * y) +
f.sum fun e a => a * ↑(Polynomial.polyBinomAux1✝ x y e a) * y ^ 2 | null | true |
_private.Aesop.Index.RulePattern.0.Aesop.RulePatternIndex.getSingle.match_1 | Aesop.Index.RulePattern | (motive : Option Aesop.Substitution → Sort u_1) →
(__discr : Option Aesop.Substitution) →
((subst : Aesop.Substitution) → motive (some subst)) → ((x : Option Aesop.Substitution) → motive x) → motive __discr | null | false |
RightCancelSemigroup.ctorIdx | Mathlib.Algebra.Group.Defs | {G : Type u} → RightCancelSemigroup G → ℕ | null | false |
Set.inter_eq_right | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ∩ t = t ↔ t ⊆ s | null | true |
Metric.unitSphere.instCommMonoid._proof_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedCommRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜]
(a b : ↑(Metric.sphere 0 1)), a * b = b * a | null | false |
CategoryTheory.Bicategory.LeftAdjoint.noConfusion | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {P : Sort u_1} →
{B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : B} →
{right : b ⟶ a} →
{t : CategoryTheory.Bicategory.LeftAdjoint right} →
{B' : Type u} →
{inst' : CategoryTheory.Bicategory B'} →
{a' b' : B'} →
{righ... | null | false |
CategoryTheory.NatIso.ofComponents'_inv_app | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
autoParam
(∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) ... | null | true |
LieSubmodule.instLieRingModuleSubtypeMem | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → [inst_4 : LieRingModule L M] → (N : LieSubmodule R L M) → LieRingModule L ↥N | null | true |
AddCancelMonoid.toIsCancelAdd | Mathlib.Algebra.Group.Defs | ∀ (M : Type u) [inst : AddCancelMonoid M], IsCancelAdd M | Any `AddCancelMonoid G` satisfies `IsCancelAdd G`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.