name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.ExtTreeMap.getKey!_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey! t.minKey! = t.minKey! | true |
MeasureTheory.quasiMeasurePreserving_sub_left | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ] [MeasurableNeg G] [μ.IsAddLeftInvariant] (g : G),
MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g - h) μ μ | true |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap! f t) = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal.Impl.... | true |
ProbabilityTheory.measure_condCDF_univ | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α),
(ProbabilityTheory.condCDF ρ a).measure Set.univ = 1 | true |
CategoryTheory.Limits.hasProducts_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasCoproducts C],
CategoryTheory.Limits.HasProducts Cᵒᵖ | true |
ProbabilityTheory.covarianceBilin_real | Mathlib.Probability.Moments.CovarianceBilin | ∀ {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsFiniteMeasure μ] (x y : ℝ),
((ProbabilityTheory.covarianceBilin μ) x) y = x * y * ProbabilityTheory.variance id μ | true |
Std.Roi.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roi α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxi.IsAlwaysFinite α] {pref suff : List α} {cur : α} (h : r.toList = pref ++ cur :: suff),
cu... | true |
Mathlib.TacticAnalysis.ComplexConfig.test | Mathlib.Tactic.TacticAnalysis | (self : Mathlib.TacticAnalysis.ComplexConfig) →
Lean.Elab.ContextInfo → Lean.Elab.TacticInfo → self.ctx → Lean.MVarId → Lean.Elab.Command.CommandElabM self.out | true |
Metric.Snowflaking.preimage_toSnowflaking_eball | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : Metric.Snowflaking X α hα₀ hα₁)
(d : ENNReal),
⇑Metric.Snowflaking.toSnowflaking ⁻¹' Metric.eball x d = Metric.eball (Metric.Snowflaking.ofSnowflaking x) (d ^ α⁻¹) | true |
List.Shortlex.cons | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Irrefl r] {a : α} {s t : List α},
List.Shortlex r s t → List.Shortlex r (a :: s) (a :: t) | true |
Min.casesOn | Init.Prelude | {α : Type u} → {motive : Min α → Sort u_1} → (t : Min α) → ((min : α → α → α) → motive { min := min }) → motive t | false |
CFC.neg_negPart_le | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [inst_2 : SMulCommClass ℝ A A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : StarRing A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A] [StarOrderedRing A]
{a : A}, autoParam (IsS... | true |
CategoryTheory.Equivalence.mapCommMon_inverse | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] (e : C ≌ D)
[ins... | true |
Homeomorph.comp_isOpenMap_iff._simp_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (h : X ≃ₜ Y) {f : Z → X}, IsOpenMap (⇑h ∘ f) = IsOpenMap f | false |
CategoryTheory.Limits.walkingCospanOpEquiv_inverse_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ (X : CategoryTheory.Limits.WidePushoutShape CategoryTheory.Limits.WalkingPair),
CategoryTheory.Limits.walkingCospanOpEquiv.inverse.obj X = Opposite.op X | true |
CategoryTheory.IsSplitMono.casesOn | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.IsSplitMono f → Sort u} →
(t : CategoryTheory.IsSplitMono f) →
((exists_splitMono : Nonempty (CategoryTheory.SplitMono f)) → motive ⋯) → motive t | false |
MultilinearMap.domDomCongr_eq_iff._simp_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] {ι₁ : Type u_1} {ι₂ : Type u_2}
(σ : ι₁ ≃ ι₂) (f g : MultilinearMap R (fun x => M₂) M₃),
(MultilinearMap.domDomCongr σ f = MultilinearMap.domDomCo... | false |
MeasureTheory.Measure.toOuterMeasure_top | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α}, ⊤.toOuterMeasure = ⊤ | true |
_private.Mathlib.Analysis.ConstantSpeed.0.unique_unit_speed_on_Icc_zero._simp_1_1 | Mathlib.Analysis.ConstantSpeed | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
instIsLocalizationAlgebraMapSubmonoidPrimeComplLocalization | Mathlib.RingTheory.DedekindDomain.Instances | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] {P : Ideal R} [inst_4 : P.IsPrime] [inst_5 : Algebra S T] [inst_6 : Algebra R T]
[IsScalarTower R S T],
IsLocalization (Algebra.algebraMapSubmonoid T (Algebra.algebraMapSubmonoid S... | true |
List.zipWithM'._sunfold | Init.Data.List.Monadic | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → m (List γ) | false |
_private.Lean.Meta.Eqns.0.Lean.Meta.mkSimpleEqThm.match_1 | Lean.Meta.Eqns | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((info : Lean.DefinitionVal) → motive (some (Lean.ConstantInfo.defnInfo info))) →
((x : Option Lean.ConstantInfo) → motive x) → motive x | false |
Function.smulCommClass | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : Type u_7} [inst : SMul M α] [inst_1 : SMul N α]
[SMulCommClass M N α], SMulCommClass M N (ι → α) | true |
CategoryTheory.LiftableCone.validLift | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | true |
FiniteGaloisIntermediateField.finGaloisGroup._proof_2 | Mathlib.FieldTheory.Galois.Profinite | ∀ {k : Type u_2} {K : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L : FiniteGaloisIntermediateField k K), Finite Gal(↥L.toIntermediateField/k) | false |
Mathlib.Tactic.LibrarySearch.observe | Mathlib.Tactic.Observe | Lean.ParserDescr | true |
List.flatten._sunfold | Init.Prelude | {α : Type u_1} → List (List α) → List α | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.D₃.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular]
(D D_1 : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ),
D = D_1 →
∀ (m₁ m₁_1 : J),
m₁ = m₁_1 →
CategoryTheory.IsCardinalFiltered.exists_cardinal_directe... | true |
continuousAt_codRestrict_iff | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {t : Set Y}
(h1 : ∀ (x : X), f x ∈ t) {x : X}, ContinuousAt (Set.codRestrict f t h1) x ↔ ContinuousAt f x | true |
_private.Mathlib.Data.Set.Insert.0.HasSubset.Subset.ssubset_of_mem_notMem._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, s ⊆ t → a ∈ t → a ∉ s → s ⊂ t | false |
SetRel.IsSeparated.empty | Mathlib.Data.Rel.Separated | ∀ {X : Type u_1} {R : SetRel X X}, R.IsSeparated ∅ | true |
Matrix.isRepresentation.toEnd._proof_8 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_1} [inst : Fintype ι] (R : Type u_2) [inst_1 : CommRing R] [inst_2 : DecidableEq ι],
ZeroMemClass (Subalgebra R (Matrix ι ι R)) (Matrix ι ι R) | false |
Finset.Ioc_subset_Ioc_left | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a₁ a₂ b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α],
a₁ ≤ a₂ → Finset.Ioc a₂ b ⊆ Finset.Ioc a₁ b | true |
CategoryTheory.CoreSmallCategoryOfSet.homEquiv | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(self : CategoryTheory.CoreSmallCategoryOfSet Ω C) →
{X Y : ↑self.obj} → ↑(self.hom X Y) ≃ (self.objEquiv X ⟶ self.objEquiv Y) | true |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.substVar.match_4 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.FVarId × Bool) → Sort u_1) →
(__discr : Option (Lean.FVarId × Bool)) →
((fvarId : Lean.FVarId) → (symm : Bool) → motive (some (fvarId, symm))) →
((x : Option (Lean.FVarId × Bool)) → motive x) → motive __discr | false |
DistribMulActionHom.mk.congr_simp | Mathlib.Algebra.Algebra.Unitization | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B]
(toMulActionHom toMulActionHom_1 : A →ₑ[⇑φ] B) (e_toMulActionHom : toMulActionHom = toMulActi... | true |
SubAddAction.closure | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | (R : Type u_1) → {M : Type u_2} → [inst : VAdd R M] → Set M → SubAddAction R M | true |
CategoryTheory.Functor.IsStronglyCartesian.domainIsoOfBaseIso._proof_5 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_4} {𝒳 : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} 𝒮]
[inst_1 : CategoryTheory.Category.{u_1, u_2} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {R R' S : 𝒮} {a a' b : 𝒳} {f : R ⟶ S}
{f' : R' ⟶ S} {g : R' ≅ R} (h : f' = CategoryTheory.CategoryStruct.comp g.hom f) (φ : a ⟶ b) (φ' : a' ⟶ b)
[i... | false |
CategoryTheory.MorphismProperty.DescendsAlong.recOn | Mathlib.CategoryTheory.MorphismProperty.Descent | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.DescendsAlong Q → Sort u} →
(t : P.DescendsAlong Q) →
((of_isPullback :
∀ {A X Y Z : C} {fst : A ⟶ X} {snd : A ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z},
... | false |
CategoryTheory.Functor.whiskerRight_comp | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G H K : CategoryTheory.Functor C D} (α : G ⟶ H)
(β : H ⟶ K) (F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (Ca... | true |
CategoryTheory.Grp.instMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whis... | false |
Subgroup.instSMul | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | {G : Type u_2} → [inst : Group G] → (H : Subgroup G) → SMul (↥H.op) G | true |
LaurentPolynomial.C_apply | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (t : R) (n : ℤ), (LaurentPolynomial.C t) n = if n = 0 then t else 0 | true |
CategoryTheory.Functor.hom_ext_of_isLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [F'.I... | true |
Bundle.Trivialization.preimageSingletonHomeomorph_symm_apply | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) {b : B} (hb : b ∈ e.baseSet) (p : F),
(e.preimageSingletonHomeomorph hb).symm p = ⟨↑e.symm (b, p), ⋯⟩ | true |
Std.ExtTreeSet.forM_eq_forM_toList | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} {m : Type w → Type w'} [inst : Std.TransCmp cmp]
[inst_1 : Monad m] [inst_2 : LawfulMonad m] {f : α → m PUnit.{w + 1}}, forM t f = t.toList.forM f | true |
Lean.Elab.ExpandDeclIdResult._sizeOf_inst | Lean.Elab.DeclModifiers | SizeOf Lean.Elab.ExpandDeclIdResult | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.isConstantApplication.aux.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : ℕ) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(n : ℕ) → motive (Lean.Expr.lam binderName binderType b binderInfo) n.succ) →
((e : Lean.Expr) → motive e ... | false |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.initAndRunWatchdogAux._sparseCasesOn_1 | Lean.Server.Watchdog | {motive : Lean.JsonRpc.Message → Sort u} →
(t : Lean.JsonRpc.Message) →
((method : String) →
(params? : Option Lean.Json.Structured) → motive (Lean.JsonRpc.Message.notification method params?)) →
((id : Lean.JsonRpc.RequestID) →
(method : String) →
(params? : Option Lean.Json.S... | false |
Nat.toInt32 | Init.Data.SInt.Basic | ℕ → Int32 | true |
Std.Time.DateTime.ofPlainDateTime | Std.Time.Zoned.DateTime | Std.Time.PlainDateTime → (tz : Std.Time.TimeZone) → Std.Time.DateTime tz | true |
CommRingCat.Colimits.descMorphism._proof_4 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(s : CategoryTheory.Limits.Cocone F), CommRingCat.Colimits.descFun F s 0 = CommRingCat.Colimits.descFun F s 0 | false |
Finset.sum_sum_Ioi_add_eq_sum_sum_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∑ i, ∑ j ∈ Finset.Ioi i, (f j i + f i j) = ∑ i, ∑ j ∈ {i}ᶜ, f j i | true |
Filter.Germ.liftPred_const_iff._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {p : β → Prop} {x : β}, Filter.Germ.LiftPred p ↑x = p x | false |
Set.seq.eq_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (s : Set (α → β)) (t : Set α), s.seq t = Set.image2 (fun f => f) s t | true |
AddSubmonoid.multiples._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_1} [inst : AddMonoid A] (x n : A) (i : ℕ), (fun i => i • x) i = n ↔ ((multiplesHom A) x) i = n | false |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_13 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (I : Finset (Set α)),
↑I ⊆ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
∀ (u v : α),
v ∈ ⋃₀ ↑I →
∀ (u' : α),
v ∈ Set.Ioc u' v →
(Set.Ioc u' v ∪ ⋃₀ ↑(I.erase (Set.Ioc u' v))) \ Set.Ioc u' v = ⋃₀ ↑(I.erase (Set.Ioc u' v)) →
Set.Ioc ... | false |
MeasureTheory.aemeasurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Group G] [MeasurableMul₂ G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant] [MeasureTheory.SFinite μ] {f g : G → ENNReal},
AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (MeasureTheory.mlconvolution f g μ) μ | true |
CategoryTheory.SmallObject.functor._proof_11 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
[CategoryTheory.Limits.HasPushouts C]
[inst_2 :
∀ {X S : C} (πX : X ⟶ S),
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIn... | false |
LinearEquiv.multilinearMapCongrLeft._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_4} {ι : Type u_1} {M₁ : ι → Type u_5} {M₁' : ι → Type u_2} {M₂ : Type u_3} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → AddCommMonoid (M₁' i)] [inst_6 : (i : ι) → Module R (... | false |
CategoryTheory.Limits.CatCospanTransform.mkIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_10} {B : Type u_6} {C : Type u_1} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_7, u_10} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_4, u_1} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3... | false |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.Subgroup.isLeast_of_closure_iff_eq_mabs._simp_1_3 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
Lean.Elab.Structural.EqnInfo.fixedParamPerms | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → Lean.Elab.FixedParamPerms | true |
List.Cursor.at._proof_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} (l : List α) (n : ℕ), List.take n l ++ List.drop n l = l | false |
CategoryTheory.Tor._proof_2 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) (X : C),
CategoryTheory.NatTrans.leftDerived
((Category... | false |
Nonneg.semiring._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : AddLeftMono α] [inst_3 : PosMulMono α]
(a b c : { x // 0 ≤ x }), a * (b + c) = a * b + a * c | false |
ODE.FunSpace.recOn | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} →
{t₀ : ↑(Set.Icc tmin tmax)} →
{x₀ : E} →
{r L : NNReal} →
{motive : ODE.FunSpace t₀ x₀ r L → Sort u} →
(t : ODE.FunSpace t₀ x₀ r L) →
((toFun : ↑(Set.Icc tmin tmax) → E) →
... | false |
_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process._unsafe_rec | Lean.Meta.Basic | Bool →
Option ℕ →
Lean.MetavarKind →
Array Lean.Expr →
Array Lean.BinderInfo → ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_emod_unique'._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (-a = -b) = (a = b) | false |
SubStarSemigroup.mk | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} →
[inst : Mul M] →
[inst_1 : Star M] →
(toSubsemigroup : Subsemigroup M) →
(∀ {a : M}, a ∈ toSubsemigroup.carrier → star a ∈ toSubsemigroup.carrier) → SubStarSemigroup M | true |
Lean.Meta.Grind.Arith.pickUnusedValue | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal → Std.HashMap Lean.Expr ℚ → Lean.Expr → ℤ → Std.HashSet ℤ → ℤ | true |
instIsSemitopologicalSemiringMulOpposite | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : TopologicalSpace R] [IsSemitopologicalSemiring R],
IsSemitopologicalSemiring Rᵐᵒᵖ | true |
CategoryTheory.Limits.CreatesFiniteProducts.creates._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | Lean.Syntax | false |
Std.TreeMap.Raw.mem_of_mem_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ ∪ t₂ → k ∉ t₁ → k ∈ t₂ | true |
AlgebraicGeometry.Scheme.qcPrecoverage | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | CategoryTheory.Precoverage AlgebraicGeometry.Scheme | true |
Finsupp.degree_add | Mathlib.Data.Finsupp.Weight | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y | true |
Encodable.fintypeArrowOfEncodable | Mathlib.Logic.Encodable.Pi | {α : Type u_2} → {β : Type u_3} → [Encodable α] → [Fintype α] → [Encodable β] → Encodable (α → β) | true |
continuousOn_tsum | Mathlib.Analysis.Normed.Group.FunctionSeries | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ}
[inst_2 : TopologicalSpace β] {f : α → β → F} {s : Set β},
(∀ (i : α), ContinuousOn (f i) s) →
Summable u → (∀ (n : α), ∀ x ∈ s, ‖f n x‖ ≤ u n) → ContinuousOn (fun x => ∑' (n : α), f n x) s | true |
Std.HashMap.Raw.Equiv.of_forall_contains_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ | true |
HomotopicalAlgebra.CofibrantObject.instWeakEquivalenceHoCatAppιCompResolutionNatTrans | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.CofibrantObject C),
HomotopicalAlgebra.WeakEquivalence (HomotopicalAlgebra.CofibrantObject.HoCat.ιCompResolutionNatTrans.app X) | true |
VectorFourier.hasFDerivAt_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountab... | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsLE_iff_exists_Ioc_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hl' : w < a), motive ⋯) → motive x | false |
Ordinal.toZFSetIso_symm_apply | Mathlib.SetTheory.ZFC.Ordinal | ∀ (x : { x // x.IsOrdinal }), (RelIso.symm Ordinal.toZFSetIso) x = (↑x).rank | true |
CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (X : T × T)
{X_1 Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2} (g : X_1 ⟶ Y),
((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).map g).left = g.left.left | true |
AnalyticAt.comp₂_analyticWithinAt | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : NormedAddCom... | true |
Batteries.Tactic.triv | Batteries.Tactic.Init | Lean.ParserDescr | true |
DirectSum.GradeZero.ring._proof_10 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GRing A] (x : A 0) (x_1 : ℕ),
(DirectSum.of A 0) (x ^ x_1) = (DirectSum.of A 0) x ^ x_1 | false |
Append.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Append α} → {α' : Type u} → {t' : Append α'} → α = α' → t ≍ t' → Append.noConfusionType P t t' | false |
LightProfinite.Extend.cone._proof_2 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (G : CategoryTheory.Functor LightProfinite C)
(S : LightProfinite) (x x_1 : CategoryTheory.StructuredArrow S FintypeCat.toLightProfinite) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.StructuredA... | false |
TendstoUniformlyOn.add | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {g g' : β → α} {s : Set β},
TendstoUniformlyOn f g l s → TendstoUniformlyOn f' g' l s → TendstoUniformlyOn (f + f') (g + g') l s | true |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_7 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {p : α → Prop} (head : α) (tail : List α), (∀ x ∈ head :: tail, p x) → tail = [] → ∀ x ∈ [], p x | false |
CategoryTheory.Quotient.lift | Mathlib.CategoryTheory.Quotient | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(r : HomRel C) →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
(∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) →
CategoryTheory.Fu... | true |
PNat.modDivAux | Mathlib.Data.PNat.Defs | ℕ+ → ℕ → ℕ → ℕ+ × ℕ | true |
SBtw.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} → {t : SBtw α} → {α' : Type u_1} → {t' : SBtw α'} → α = α' → t ≍ t' → SBtw.noConfusionType P t t' | false |
SSet.Subcomplex.Pairing.I | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N | true |
ProbabilityTheory.Kernel.swapLeft_zero | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ}, ProbabilityTheory.Kernel.swapLeft 0 = 0 | true |
AddSubsemigroup.le_op_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] {S₁ : AddSubsemigroup Mᵃᵒᵖ} {S₂ : AddSubsemigroup M}, S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ | true |
Metric.mem_thickening_iff_exists_edist_lt | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} (E : Set α) (x : α),
x ∈ Metric.thickening δ E ↔ ∃ z ∈ E, edist x z < ENNReal.ofReal δ | true |
DomAddAct.instZeroOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [Zero Mᵃᵒᵖ] → Zero Mᵈᵃᵃ | true |
CategoryTheory.ObjectProperty.trW_iff' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.