name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.Set.Lattice.Bounded.0.Set.iInter_eq_empty_iff._simp_1_1 | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
_private.Mathlib.MeasureTheory.Function.AbsolutelyContinuous.0.IntervalIntegrable.absolutelyContinuousOnInterval_intervalIntegral.match_1_1 | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ (motive : ℕ × (ℕ → ℝ × ℝ) → Prop) (h : ℕ × (ℕ → ℝ × ℝ)), (∀ (n : ℕ) (I : ℕ → ℝ × ℝ), motive (n, I)) → motive h | null | false |
exists₃_congr | Init.PropLemmas | ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {p q : (a : α) → (b : β a) → γ a b → Prop},
(∀ (a : α) (b : β a) (c : γ a b), p a b c ↔ q a b c) → ((∃ a b c, p a b c) ↔ ∃ a b c, q a b c) | null | true |
UInt8.ofNat_add | Init.Data.UInt.Lemmas | ∀ (a b : ℕ), UInt8.ofNat (a + b) = UInt8.ofNat a + UInt8.ofNat b | null | true |
instProperVAddOfIsTopologicalAddGroup | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G], ProperVAdd G G | The action `G ↷ G` by left translations is proper. | true |
CategoryTheory.IsGrothendieckAbelian.GabrielPopescu.preservesFiniteLimits | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.GabrielPopescu | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] (G : C),
CategoryTheory.IsSeparator G →
CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.IsGrothendieckAbelian.tensorObj G) | `tensorObj G` is left exact: it is additive and preserves monomorphisms and cokernels,
so it preserves homology and therefore finite limits. | true |
_private.Mathlib.Order.Lattice.0.exists_and_iff_of_antitone.match_1_1 | Mathlib.Order.Lattice | ∀ {α : Type u_1} {P Q : α → Prop} (motive : ((∃ x, P x) ∧ ∃ x, Q x) → Prop) (x : (∃ x, P x) ∧ ∃ x, Q x),
(∀ (x : α) (hPx : P x) (y : α) (hQx : Q y), motive ⋯) → motive x | null | false |
CategoryTheory.Mat_.additiveObjIsoBiproduct_naturality_assoc | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor (CategoryTheory.Mat_ C) D)
[ins... | null | true |
CategoryTheory.idLiftsCocone | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone (K.comp (CategoryTheory.Functor.id C))) →
CategoryTheory.LiftableCocone K (CategoryTh... | Any cocone lifts through the identity functor. | true |
MulArchimedeanOrder.instPreorder._proof_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] (a : MulArchimedeanOrder M),
|MulArchimedeanOrder.val a|ₘ ≤ |MulArchimedeanOrder.val a|ₘ ^ 1 | null | false |
monotone_of_deriv_nonneg | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {f : ℝ → ℝ}, Differentiable ℝ f → (∀ (x : ℝ), 0 ≤ deriv f x) → Monotone f | Let `f : ℝ → ℝ` be a differentiable function. If `f'` is nonnegative, then
`f` is a monotone function. | true |
Lake.ToolchainVer.casesOn._override | Lake.Util.Version | {motive : Lake.ToolchainVer → Sort u} →
(t : Lake.ToolchainVer) →
((ver : Lake.LeanVer) → motive (Lake.ToolchainVer.release ver)) →
((date : Lake.Date) → (rev : Option ℕ) → motive (Lake.ToolchainVer.nightly date rev)) →
((n : ℕ) → motive (Lake.ToolchainVer.pr n)) → ((v : String) → motive (Lake.Toolc... | null | false |
TestFunction.fderivCLM._proof_13 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | null | false |
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_4 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], SMulCommClass 𝕜 𝕜 F | null | false |
CategoryTheory.Pretopology.orderTop._proof_2 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
(x x_1 : C) (x_2 : x_1 ⟶ x), ∀ x_3 ∈ Set.univ, CategoryTheory.Presieve.pullbackArrows x_2 x_3 ∈ Set.univ | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.map.match_1.eq_3 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (X Y : CategoryTheory.WithTerminal C) → (X ⟶ Y) → Sort u_3)
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star)
(h_1 :
(a a_1 : C) →
(f : CategoryTheory.WithTerminal.of a ⟶ CategoryTheory.WithTerminal.of a_1) ... | null | true |
MeasureTheory.IsProjectiveLimit.isProbabilityMeasure | Mathlib.MeasureTheory.Constructions.Projective | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)]
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {μ : MeasureTheory.Measure ((i : ι) → α i)}
[∀ (i : Finset ι), MeasureTheory.IsProbabilityMeasure (P i)],
MeasureTheory.IsProjectiveLimit μ P → MeasureTheory.IsProbabilityMea... | null | true |
_private.Mathlib.Algebra.Group.Action.Defs.0.smul_pow.match_1_1 | Mathlib.Algebra.Group.Action.Defs | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Fin.instNontrivial | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} [n.AtLeastTwo], Nontrivial (Fin n) | null | true |
Std.DTreeMap.Raw.Const.get!_diff_of_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β], m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → Std.DTreeMap.Raw.Const.get! (m₁ \ m₂) k = default | null | true |
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidalObj.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.Mon C),
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidalObj A =
(CategoryTheory.Functor.const (CategoryTheory.Discrete PUnit.{w + 1})).obj A.X | null | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_of_mem_maximalAtlas._simp_1_2 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | null | false |
Std.HashMap.getElem?_insertMany_list.match_1 | Std.Data.HashMap.Lemmas | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | null | false |
List.interleave_perm_append._simp_1 | Batteries.Data.List.Interleave | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁.interleave l₂).Perm (l₁ ++ l₂) = True | null | false |
Homogenization.map_eq_id_iff._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Homogenization | ∀ {R : Type u_1} [inst : Ring R] {V : Type u_2} {P : Type u_3} [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] {f : P →ᵃ[R] P}, (Homogenization.map f = LinearMap.id) = (f = AffineMap.id R P) | null | false |
Ordinal.card_lt_aleph0 | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}}, o.card < Cardinal.aleph0 ↔ o < Ordinal.omega0 | null | true |
Lean.Parser.Tactic.MRefinePat.stateful.injEq | Std.Tactic.Do.Syntax | ∀ (h h_1 : Lean.TSyntax `Lean.binderIdent),
(Lean.Parser.Tactic.MRefinePat.stateful h = Lean.Parser.Tactic.MRefinePat.stateful h_1) = (h = h_1) | null | true |
_private.Mathlib.Tactic.Linter.DocString.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.DocString.48192442._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DocString | IO (Lean.Option Bool) | null | false |
CategoryTheory.Subobject.ofMkLE_comp_ofLE | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A₁ : C} (f : A₁ ⟶ B) [inst_1 : CategoryTheory.Mono f]
(X Y : CategoryTheory.Subobject B) (h₁ : CategoryTheory.Subobject.mk f ≤ X) (h₂ : X ≤ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.ofMkLE f X h₁) (X.ofLE Y h₂) =
CategoryTheor... | null | true |
BiheytingAlgebra.recOn | Mathlib.Order.Heyting.Basic | {α : Type u_4} →
{motive : BiheytingAlgebra α → Sort u} →
(t : BiheytingAlgebra α) →
([toHeytingAlgebra : HeytingAlgebra α] →
[toSDiff : SDiff α] →
(sdiff_le_iff : ∀ (a b c : α), a \ b ≤ c ↔ a ≤ b ⊔ c) →
[toHNot : HNot α] →
(top_sdiff : ∀ (a : α), ⊤ \ a = ... | null | false |
CategoryTheory.Limits.FormalCoproduct.objIsoOfEq_symm | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Limits.FormalCoproduct C) {i j : X.I}
(hij : i = j), (X.objIsoOfEq hij).symm = X.objIsoOfEq ⋯ | null | true |
CategoryTheory.Monoidal.transport._proof_3 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D) {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁)
(g : X₂ ⟶ Y₂),
e.inverse.map (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
CategoryTh... | null | false |
ContRepresentation.invariants._proof_1 | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_2} {G : Type u_3} {V : Type u_1} [inst : Monoid G] [inst_1 : Ring R] [inst_2 : AddCommGroup V]
[inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V] (π : ContRepresentation R G V)
{a b : V}, a ∈ {v | ∀ (g : G), (π g) v = v} → b ∈ {v | ∀ (g : G), (π g) v = v} → a + b ∈ ... | null | false |
Mathlib.Tactic.ByCases._aux_Mathlib_Tactic_ByCases___elabRules__private_Mathlib_Tactic_ByCases_0_Mathlib_Tactic_ByCases_tacticTry_push_neg_at___1 | Mathlib.Tactic.ByCases | Lean.Elab.Tactic.Tactic | null | false |
LatticeHom.dual._proof_3 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : Lattice β] (f : LatticeHom α β) (a b : α),
f.toFun (a ⊔ b) = f.toFun a ⊔ f.toFun b | null | false |
_private.Mathlib.Tactic.Inclusion.ExtensionAPI.Basic.0.Inclusion.checkIVarWellFormed.match_1 | Mathlib.Tactic.Inclusion.ExtensionAPI.Basic | (motive : Inclusion.IExpr → Sort u_1) →
(x : Inclusion.IExpr) →
((iType : Inclusion.IType) → (e : Lean.Expr) → motive { iType := iType, expr := e }) → motive x | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0.String.fromExpr? | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | Lean.Expr → Lean.Meta.SimpM (Option String) | null | true |
ImportGraph.Widget.RpcEncodablePacket.«_@».ImportGraph.Widget.Collapsible.439131168._hygCtx._hyg.1.recOn | ImportGraph.Widget.Collapsible | {motive : ImportGraph.Widget.RpcEncodablePacket✝ → Sort u} →
(t : ImportGraph.Widget.RpcEncodablePacket✝) →
((summary body initiallyOpen : Lean.Json) →
motive { summary := summary, body := body, initiallyOpen := initiallyOpen }) →
motive t | null | false |
Std.TreeSet.not_mem_diff_of_mem_right | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α}, k ∈ t₂ → k ∉ t₁ \ t₂ | null | true |
CategoryTheory.Over.mono_of_mono_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Over X} (k : f ⟶ g)
[hk : CategoryTheory.Mono (CategoryTheory.Over.Hom.left k)], CategoryTheory.Mono k | If `k.left` is a monomorphism, then `k` is a monomorphism. In other words, `Over.forget X` reflects
monomorphisms.
The converse of `CategoryTheory.Over.mono_left_of_mono`.
This lemma is not an instance, to avoid loops in type class inference.
| true |
Polynomial.leadingCoeff_det_X_one_add_C | Mathlib.LinearAlgebra.Matrix.Polynomial | ∀ {n : Type u_1} {α : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α),
(Polynomial.X • 1 + A.map ⇑Polynomial.C).det.leadingCoeff = 1 | null | true |
AddCircle.liftIoc_continuous | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} {B : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsOrderedAddMonoid 𝕜]
{p a : 𝕜} [hp : Fact (0 < p)] [inst_3 : Archimedean 𝕜] [inst_4 : TopologicalSpace 𝕜] [OrderTopology 𝕜]
[inst_6 : TopologicalSpace B] {f : 𝕜 → B},
f a = f (a + p) → ContinuousOn f (Set.Icc a (a... | null | true |
CancelCommMonoid.noConfusionType | Mathlib.Algebra.Group.Monoid | Sort u → {M : Type u_2} → CancelCommMonoid M → {M' : Type u_2} → CancelCommMonoid M' → Sort u | null | false |
Batteries.Tactic.CollectOpaques.State._sizeOf_inst | Batteries.Tactic.PrintOpaques | SizeOf Batteries.Tactic.CollectOpaques.State | null | false |
Batteries.Tactic.Lint.LintVerbosity.medium.sizeOf_spec | Batteries.Tactic.Lint.Frontend | sizeOf Batteries.Tactic.Lint.LintVerbosity.medium = 1 | null | true |
BoundedContinuousFunction.coe_toContinuousMapₐ | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} {γ : Type w} (𝕜 : Type u_1) [inst : NormedField 𝕜] [inst_1 : TopologicalSpace α] [inst_2 : NormedRing γ]
[inst_3 : NormedAlgebra 𝕜 γ] (f : BoundedContinuousFunction α γ),
⇑((BoundedContinuousFunction.toContinuousMapₐ 𝕜) f) = ⇑f | null | true |
WithCStarModule.instCStarModuleProd._proof_3 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {E : Type u_3} {F : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : Module ℂ E] [inst_4 : SMul A E] [inst_5 : NormedAddCommGroup F]
[inst_6 : Module ℂ F] [inst_7 : SMul A F] [inst_8 : CStarModule A E] [inst_9 : CStarModule A F] {a : A}
... | null | false |
OpenNormalSubgroup.instSetLike._proof_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] (x x_1 : OpenNormalSubgroup G),
↑x.toOpenSubgroup = ↑x_1.toOpenSubgroup → x = x_1 | null | false |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Mathlib.Linter.directoryDependencyCheck.match_1 | Mathlib.Tactic.Linter.DirectoryDependency | (motive : Option Lean.MessageData → Sort u_1) →
(x : Option Lean.MessageData) →
((msg : Lean.MessageData) → motive (some msg)) → ((x : Option Lean.MessageData) → motive x) → motive x | null | false |
CochainComplex.HomComplex.Triplet.q | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {n : ℤ} → CochainComplex.HomComplex.Triplet n → ℤ | a second integer | true |
ZFSet.vonNeumann_subset_vonNeumann_iff._simp_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, (ZFSet.vonNeumann a ⊆ ZFSet.vonNeumann b) = (a ≤ b) | null | false |
freeGroupEquivCoprodI | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} → FreeGroup ι ≃* Monoid.CoprodI fun x => FreeGroup Unit | A free group is a free product of copies of the `FreeGroup` over one generator. | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_3.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out))... | null | true |
_private.Mathlib.Topology.Algebra.Module.ModuleTopology.0.IsModuleTopology.continuous_bilinear_of_pi_fintype._simp_1_1 | Mathlib.Topology.Algebra.Module.ModuleTopology | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] [inst_1 : DecidableEq α] (a : α) (b : M), Pi.single a b = ⇑fun₀ | a => b | null | false |
MeasureTheory.ProgMeasurable.sub | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u v : ι → Ω → β} [inst_2 : MeasurableSpace ι] [inst_3 : AddGroup β]
[ContinuousSub β],
MeasureTheory.IsStronglyProgressive f u →
MeasureTheory.IsStrongly... | **Alias** of `MeasureTheory.IsStronglyProgressive.sub`. | true |
AddSubgroup.biSup_normal | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] {ι : Type u_5} (s : Set ι) (H : ι → AddSubgroup G),
(∀ i ∈ s, (H i).Normal) → (⨆ i ∈ s, H i).Normal | null | true |
IsLUB.of_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
(∀ {x y : α}, f y ≤ f x ↔ y ≤ x) → ∀ {s : Set α} {x : α}, IsLUB (f '' s) (f x) → IsLUB s x | null | true |
TopCat.Presheaf.SheafCondition.opensLeCoverCocone._proof_1 | Mathlib.Topology.Sheaves.SheafCondition.OpensLeCover | ∀ {X : TopCat} {ι : Type u_2} (U : ι → TopologicalSpace.Opens ↑X)
⦃X_1 Y : CategoryTheory.ObjectProperty.FullSubcategory fun V => ∃ i, V ≤ U i⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.ObjectProperty.ι fun V => ∃ i, V ≤ U i).map f)
(CategoryTheory.CategoryStruct.comp (TopCat.Presheaf... | null | false |
Rat.normalize._proof_4 | Init.Data.Rat.Basic | ∀ (num : ℤ) (den : ℕ), den ≠ 0 → (num / ↑(num.natAbs.gcd den)).natAbs.Coprime (den / num.natAbs.gcd den) | null | false |
Set.Icc.coe_iSup | Mathlib.Order.CompleteLatticeIntervals | ∀ {ι : Sort u_1} {α : Type u_2} [inst : ConditionallyCompleteLattice α] {a b : α} (h : a ≤ b) [Nonempty ι]
{S : ι → ↑(Set.Icc a b)},
have this := ⋯;
↑(iSup S) = ⨆ i, ↑(S i) | null | true |
AddAction.prodEquiv._proof_1 | Mathlib.Algebra.Group.Action.Prod | ∀ (M : Type u_2) (N : Type u_3) (α : Type u_1) [inst : AddMonoid M] [inst_1 : AddMonoid N] (x : AddAction (M × N) α)
(m : M) (n : N) (a : α), m +ᵥ n +ᵥ a = n +ᵥ m +ᵥ a | null | false |
ProbabilityTheory.iIndepFun.indepFun_div_right₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10}
{m : MeasurableSpace β} [inst : Div β] [MeasurableDiv₂ β] {f : ι → Ω → β},
ProbabilityTheory.iIndepFun f μ →
(∀ (i : ι), AEMeasurable (f i) μ) → ∀ (i j k : ι), i ≠ j → i ≠ k → ProbabilityTheory.IndepFun (f i)... | null | true |
Matrix.diagonal_mem_matrix_iff | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] {S : Set α},
0 ∈ S → ∀ {d : n → α}, Matrix.diagonal d ∈ S.matrix ↔ ∀ (i : n), d i ∈ S | null | true |
String.Slice.slice_startPos | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : s.Pos}, s.slice s.startPos p ⋯ = s.sliceTo p | null | true |
Std.Do.ExceptConds.imp._f | Std.Do.PostCond | {ps : Std.Do.PostShape} →
Std.Do.PostShape.below (motive := fun {ps} => Std.Do.ExceptConds ps → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps)
ps →
Std.Do.ExceptConds ps → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps | null | false |
_private.Mathlib.Topology.Semicontinuity.Basic.0.lowerSemicontinuousOn_iff_preimage_Ioi._simp_1_3 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {s : Set α} {f : α → β},
IsOpen s = ∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = s | null | false |
CategoryTheory.Limits.hasColimitsOfShape_discrete | Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteCoproducts C] (ι : Type w)
[Finite ι], CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ι) C | null | true |
Monoid.Foldl.ofFreeMonoid._proof_1 | Mathlib.Control.Fold | ∀ {α β : Type u_1} (f : β → α → β) (x y : FreeMonoid α),
MulOpposite.op { asHom := TypeCat.ofHom (flip (List.foldl f) (FreeMonoid.toList (x * y))) } =
MulOpposite.op { asHom := TypeCat.ofHom (flip (List.foldl f) (FreeMonoid.toList x)) } *
MulOpposite.op { asHom := TypeCat.ofHom (flip (List.foldl f) (FreeMon... | null | false |
instIdempotentOpInt64HOr | Init.Data.SInt.Bitwise | Std.IdempotentOp fun x1 x2 => x1 ||| x2 | null | true |
Set.decidableMemNSMul | Mathlib.Algebra.Group.Pointwise.Set.Finite | {α : Type u_1} →
[inst : AddMonoid α] →
{s : Set α} →
[Fintype α] → [DecidableEq α] → [DecidablePred fun x => x ∈ s] → (n : ℕ) → DecidablePred fun x => x ∈ n • s | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.real_inner_add_sub_eq_zero_iff._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
ByteArray.instGetElemNatUInt8LtSize | Init.Data.ByteArray.Basic | GetElem ByteArray ℕ UInt8 fun xs i => i < xs.size | null | true |
ApplicativeTransformation.ext | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
⦃η η' : ApplicativeTransformation F G⦄,
(∀ (α : Type u) (x : F α), (fun {α} => η.app α) x = (fun {α} => η'.app α) x) → η = η' | null | true |
String.Slice.posGE_eq_iff | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : p ≤ s.rawEndPos} {q : s.Pos},
s.posGE p h = q ↔ p ≤ q.offset ∧ ∀ (q' : s.Pos), p ≤ q'.offset → q ≤ q' | null | true |
CategoryTheory.preservesLimitIso_hom_π | Mathlib.CategoryTheory.Limits.Preserves.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J]
(F : CategoryTheory.Functor J C) [inst_3 : CategoryTheory.Limits.PreservesLimit F G]
[inst_4 : Category... | null | true |
Lean.Order.SeqRight.monotone_seqRight | Init.Internal.Order.Lemmas | ∀ {m : Type u → Type v} [inst : Monad m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m]
{α β : Type u} {γ : Type w} [inst_3 : Lean.Order.PartialOrder γ] [LawfulMonad m] (f : γ → m α) (g : γ → m β),
Lean.Order.monotone g → Lean.Order.monotone f → Lean.Order.monotone fun x => g x *> f... | null | true |
Std.Time.GenericFormat.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{awareness : Std.Time.Awareness} →
{t : Std.Time.GenericFormat awareness} →
{awareness' : Std.Time.Awareness} →
{t' : Std.Time.GenericFormat awareness'} →
awareness = awareness' → t ≍ t' → Std.Time.GenericFormat.noConfusionType P t t' | null | false |
DFinsupp.Lex.partialOrder._proof_3 | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : (i : ι) → Zero (α i)] [inst_1 : LinearOrder ι]
[inst_2 : (i : ι) → PartialOrder (α i)] (a b c : Lex (Π₀ (i : ι), α i)), a ≤ b → b ≤ c → a ≤ c | null | false |
AddCancelCommMonoid.toAddCancelMonoid.eq_1 | Mathlib.Algebra.Group.Monoid | ∀ (M : Type u_2) [inst : AddCancelCommMonoid M],
AddCancelCommMonoid.toAddCancelMonoid M =
{ toAddLeftCancelMonoid := inst.toAddLeftCancelMonoid, toIsRightCancelAdd := ⋯ } | null | true |
trdeg_eq_zero | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {R : Type u_3} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[Algebra.IsAlgebraic R A], Algebra.trdeg R A = 0 | null | true |
Filter.Tendsto.uniformity_add_iff_left | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {f g : ι → α × α}
{l : Filter ι},
Filter.Tendsto g l (uniformity α) → (Filter.Tendsto (f + g) l (uniformity α) ↔ Filter.Tendsto f l (uniformity α)) | If `g : ι → G × G` converges to the uniformity, then any `f : ι → G × G`
converges to the uniformity iff `f + g` does. This is often useful when `g` is valued in the
diagonal, in which case its convergence is automatic. | true |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure.eq_def | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.IsFilteredOrEmpty C] {α : Type w}
(f : α → C) (x : ℕ),
CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure✝ f x =
match x with
| 0 => ⟨ULift.{v, w} α, f ∘ ULift.down⟩
| n.succ =>
⟨CategoryTh... | null | true |
Unitization.starLift_symm_apply | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} {C : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : NonUnitalSemiring A] [inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A]
[inst_6 : IsScalarTower R A A] [inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : StarRing C]
[inst_10 : StarMo... | null | true |
CategoryTheory.Presheaf.uliftYonedaAdjunction._proof_2 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {ℰ : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} ℰ] {A : CategoryTheory.Functor C ℰ}
[inst_2 : CategoryTheory.uliftYoneda.{max u_5 u_1, u_4, u_3}.HasPointwiseLeftKanExtension A]
(L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type ... | null | false |
Matrix.sub_vecMulVec | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocRing α] (w₁ w₂ : m → α) (v : n → α),
Matrix.vecMulVec (w₁ - w₂) v = Matrix.vecMulVec w₁ v - Matrix.vecMulVec w₂ v | null | true |
CategoryTheory.OverPresheafAux.yonedaCollectionFunctor_obj | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (A : CategoryTheory.Functor Cᵒᵖ (Type v))
(F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)),
(CategoryTheory.OverPresheafAux.yonedaCollectionFunctor A).obj F =
CategoryTheory.OverPresheafAux.yonedaCollectio... | null | true |
LinearMap.trace_comp_cycle | Mathlib.LinearAlgebra.Trace | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
{P : Type u_4} [inst_3 : AddCommGroup N] [inst_4 : Module R N] [inst_5 : AddCommGroup P] [inst_6 : Module R P]
[Module.Free R N] [Module.Finite R N] [Module.Free R P] [Module.Finite R P] (f : M →ₗ[R] N... | null | true |
Matrix.colStochastic._proof_3 | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ (R : Type u_1) (n : Type u_2) [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [IsOrderedRing R], 1 ∈ {M | (∀ (i j : n), 0 ≤ M i j) ∧ Matrix.vecMul 1 M = 1} | null | false |
Group.conjugatesOfSet_union | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_4} [inst : Group G] (s t : Set G),
Group.conjugatesOfSet (s ∪ t) = Group.conjugatesOfSet s ∪ Group.conjugatesOfSet t | The set of conjugates of the union of two sets is the union of the conjugates | true |
CategoryTheory.Limits.PullbackCone.fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} → {f : X ⟶ Z} → {g : Y ⟶ Z} → (t : CategoryTheory.Limits.PullbackCone f g) → t.pt ⟶ X | The first projection of a pullback cone. | true |
AlgEquiv.coe_toAlgHom | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), ⇑↑e = ⇑e | null | true |
MvPolynomial.aeval_X_left_apply | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R), (MvPolynomial.aeval MvPolynomial.X) p = p | null | true |
IsClosed.isGreatest_inter_Icc_of_forall_exists_gt | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α] {a b : α}
{s : Set α},
IsClosed (s ∩ Set.Icc a b) →
a ∈ s → a ≤ b → (∀ x ∈ s ∩ Set.Ico a b, (s ∩ Set.Ioc x b).Nonempty) → IsGreatest (s ∩ Set.Icc a b) b | A "continuous induction principle" for a closed interval: if a set `s` meets `[a, b]`
on a closed subset, contains `a`, and the set `s ∩ [a, b)` has no maximal point, then `b` is the
greatest element of `s ∩ [a, b]`. | true |
TemperedDistribution | Mathlib.Analysis.Distribution.TemperedDistribution | (E : Type u_3) →
(F : Type u_4) →
[inst : NormedAddCommGroup E] →
[NormedSpace ℝ E] → [TopologicalSpace F] → [inst : AddCommGroup F] → [Module ℂ F] → Type (max u_3 u_4) | The space of tempered distribution is the space of continuous linear maps from the Schwartz to
a normed space, equipped with the topology of pointwise convergence. | true |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.evariance_def'._simp_1_1 | Mathlib.Probability.Moments.Variance | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a‖ₑ ^ n = ‖a ^ n‖ₑ | null | false |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.pushFormatError | Mathlib.Tactic.Linter.Whitespace | Array Mathlib.Linter.FormatError✝ → Mathlib.Linter.FormatError✝ → Array Mathlib.Linter.FormatError✝ | Add a new `FormatError` `f` to the array `fs`, trying, as much as possible, to merge the new
`FormatError` with the last entry of `fs`.
| true |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.HasMFDerivWithinAt.prod._proof_1_4 | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {F' : Type u_1} [inst_6 : NormedCommRing F'], ContinuousConstSMul F' F' | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.K | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option (Std.Time.Internal.Bounded.LE 0 11) | null | true |
CategoryTheory.ShortComplex.homologyIsoCokernelLift | 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] →
[inst_3 : CategoryTheory.Limits.HasKernel S.g] →
[inst_4 : CategoryTheory.Limits.HasCokernel (Catego... | The homology of a short complex `S` identifies to the cokernel of the induced morphism
`S.X₁ ⟶ kernel S.g`. | true |
ArchimedeanClass.mk_le_mk_of_abs | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M},
|a| ≤ |b| → ArchimedeanClass.mk b ≤ ArchimedeanClass.mk a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.