name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Subobject.isoOfEq._proof_4 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} (X Y : CategoryTheory.Subobject B) (h : X = Y),
CategoryTheory.CategoryStruct.comp (Y.ofLE X ⋯) (X.ofLE Y ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Subobject.underlying.obj Y) | false |
ValuativeRel.srel_of_srel_of_rel | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : ValuativeRel R] {a b c : R}, a <ᵥ b → b ≤ᵥ c → a <ᵥ c | true |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_3 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_4} {R' : Type u_5} {M : Type u_3} {M' : Type u_2} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_1} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | false |
Matrix.blockDiagonal'_zero | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [inst : DecidableEq o] [inst_1 : Zero α],
Matrix.blockDiagonal' 0 = 0 | true |
selfAdjoint.submodule | Mathlib.Algebra.Star.Module | (R : Type u_1) →
(A : Type u_2) →
[inst : Semiring R] →
[inst_1 : StarMul R] →
[TrivialStar R] →
[inst_3 : AddCommGroup A] →
[inst_4 : Module R A] → [inst_5 : StarAddMonoid A] → [StarModule R A] → Submodule R A | true |
LieEquiv.coe_toLieHom | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), ⇑e.toLieHom = ⇑e | true |
CategoryTheory.MorphismProperty.LeftFraction₃.recOn | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.LeftFraction₃ X Y → Sort u} →
(t : W.LeftFraction₃ X Y) →
({Y' : C} →
(f f' f'' : X ⟶ Y') →
(s : Y ⟶ Y') → (hs : ... | false |
List.subset_replicate | Init.Data.List.Sublist | ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, n ≠ 0 → (l ⊆ List.replicate n a ↔ ∀ x ∈ l, x = a) | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.ModuleDocstringState✝ | false |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)) {Z : ↑(F.obj b)}
(h : (F.map f).toFunctor.obj ((CategoryTheory.CategoryStruct.id (F.obj a)).toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.map f).toFu... | true |
Lean.Meta.Simp.Result.mk._flat_ctor | Lean.Meta.Tactic.Simp.Types | Lean.Expr → Option Lean.Expr → Bool → Lean.Meta.Simp.Result | false |
Lean.Elab.Deriving.FromToJson.mkToJsonBodyForStruct | Lean.Elab.Deriving.FromToJson | Lean.Elab.Deriving.Header → Lean.Name → Lean.Elab.TermElabM Lean.Term | true |
AdjoinRoot.algHomOfDvd._proof_1 | Mathlib.RingTheory.AdjoinRoot | ∀ (R : Type u_2) {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S),
g ∣ f → g ∣ Polynomial.map (↑(AlgHom.id R S)) f | false |
Substring.Raw.noConfusion | Init.Prelude | {P : Sort u} → {t t' : Substring.Raw} → t = t' → Substring.Raw.noConfusionType P t t' | false |
Finset.symmDiff_nonempty | Mathlib.Data.Finset.SymmDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (symmDiff s t).Nonempty ↔ s ≠ t | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj.0.CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheor... | false |
MonotoneOn.image_lowerBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
MonotoneOn f t → s ⊆ t → f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s) | true |
CategoryTheory.Limits.pullbackConeEquivBinaryFan._proof_15 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ X}
(X_1 : CategoryTheory.Limits.BinaryFan (CategoryTheory.Over.mk f) (CategoryTheory.Over.mk g)),
(({ obj := fun c => CategoryTheory.Limits.PullbackCone.mk c.fst.left c.snd.left ⋯,
map := fun {c₁ c₂} a =>... | false |
Metric.infDist_le_hausdorffDist_of_mem | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α} {x : α},
x ∈ s → Metric.hausdorffEDist s t ≠ ⊤ → Metric.infDist x t ≤ Metric.hausdorffDist s t | true |
Mathlib.Tactic.modifyLocalContext | Mathlib.Util.Tactic | {m : Type → Type} → [Lean.MonadMCtx m] → Lean.MVarId → (Lean.LocalContext → Lean.LocalContext) → m Unit | true |
inv_mul' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a * b)⁻¹ = a⁻¹ / b | true |
Array.reverse_eq_append_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys zs : Array α}, (xs.reverse = ys ++ zs) = (xs = zs.reverse ++ ys.reverse) | false |
ContinuousOn.cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | false |
Prod.instGeneralizedBooleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : GeneralizedBooleanAlgebra β]
(x x_1 : α × β), x ⊓ x_1 ⊔ x \ x_1 = x | false |
CategoryTheory.IsPullback.rec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{P X Y Z : C} →
{fst : P ⟶ X} →
{snd : P ⟶ Y} →
{f : X ⟶ Z} →
{g : Y ⟶ Z} →
{motive : CategoryTheory.IsPullback fst snd f g → Sort u} →
((toCommSq : CategoryTheory.CommSq fst snd f g) →
... | false |
StrongDual.toLpₗ.eq_1 | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {𝕜 : Type u_2}
[inst_1 : NontriviallyNormedField 𝕜] [inst_2 : NormedSpace 𝕜 E] (μ : MeasureTheory.Measure E) (p : ENNReal),
StrongDual.toLpₗ μ p =
if h_Lp : MeasureTheory.MemLp id p μ then
{ toFun := fun L => MeasureTheory.MemLp.to... | true |
CategoryTheory.GradedObject.mapTrifunctor._proof_8 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_2} {C₂ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_9} [inst : CategoryTheory.Category.{u_3, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_10, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_11, u_5} C₃]
[inst_3 : CategoryTheory.Category.{u_8, u_9} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Funct... | false |
Multiset.foldl_add | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β) (s t : Multiset α),
Multiset.foldl f b (s + t) = Multiset.foldl f (Multiset.foldl f b s) t | true |
CategoryTheory.Limits.FormalCoproduct.evalCompInclIsoId._proof_2 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (A : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] [inst_2 : CategoryTheory.Limits.HasCoproducts A]
(F : CategoryTheory.Functor C A) (x : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.desc fun x_1 =>
Cat... | false |
FreeMagma.of.elim | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeMagma α → Sort u_1} → (t : FreeMagma α) → t.ctorIdx = 0 → ((a : α) → motive (FreeMagma.of a)) → motive t | false |
Std.ExtTreeSet.get_union_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
(not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | true |
Int.toList_rco_eq_singleton_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, ((m...n).toList = [k]) = (n = m + 1 ∧ m = k) | false |
CategoryTheory.WithTerminal.homFrom | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : C) → CategoryTheory.WithTerminal.incl.obj X ⟶ CategoryTheory.WithTerminal.star | true |
Prop.instDistribLattice | Mathlib.Order.PropInstances | DistribLattice Prop | true |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.of_isCompact_of_forall_exists_isCompactOpenCovered._proof_1_3 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} [inst : TopologicalSpace S] {U : Set S} (Us : (x : S) → x ∈ U → Set S),
(∀ (x : S) (a : x ∈ U), Us x a ⊆ U) →
∀ (x : S) (U_1 : Set S), IsOpen U_1 → ∀ (x_1 : S) (x_2 : x_1 ∈ U), Us x_1 ⋯ = U_1 → x ∈ U_1 → x ∈ U | false |
SimplicialObject.Splitting.IndexSet.e.eq_1 | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {Δ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ), A.e = ↑A.snd | true |
_private.Mathlib.Algebra.Category.MonCat.FilteredColimits.0.MonCat.FilteredColimits.colimit_mul_mk_eq._simp_1_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type w)}
{inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))} [self : CategoryTheory.ConcreteCategory C FC]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (x : CC X),
(CategoryTheory.ConcreteCategory.h... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.head?_keys._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | false |
comap_prime | Mathlib.Algebra.Prime.Lemmas | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoidWithZero M] [inst_1 : CommMonoidWithZero N] {F : Type u_3}
{G : Type u_4} [inst_2 : FunLike F M N] [MonoidWithZeroHomClass F M N] [inst_4 : FunLike G N M] [MulHomClass G N M]
(f : F) (g : G) {p : M}, (∀ (a : M), g (f a) = a) → Prime (f p) → Prime p | true |
isUnit_unop | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_2} [inst : Monoid M] {m : Mᵐᵒᵖ}, IsUnit (MulOpposite.unop m) ↔ IsUnit m | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp.0.Real.differentiable_iteratedDeriv_sinh.match_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (motive : ℕ → Prop) (n : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive n | false |
HomotopicalAlgebra.PrepathObject.trans_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P P' : HomotopicalAlgebra.PrepathObject A)
[inst_1 : CategoryTheory.Limits.HasPullback P.p₁ P'.p₀],
(P.trans P').ι = CategoryTheory.Limits.pullback.lift P.ι P'.ι ⋯ | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.Reachable.mem_subgraphVerts.aux | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {v : V} {H : G.Subgraph},
(∀ v ∈ H.verts, ∀ (w : V), G.Adj v w → H.Adj v w) → ∀ {v' : V}, v' ∈ H.verts → ∀ (p : G.Walk v' v), v ∈ H.verts | true |
CompleteLinearOrder.toDecidableLE | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} → [self : CompleteLinearOrder α] → DecidableLE α | true |
FiberBundleCore.mem_localTrivAt_source._simp_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (p : Z.TotalSpace) (b : B),
(p ∈ (Z.localTrivAt b).source) = (p.proj ∈ (Z.localTrivAt b).baseSet) | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_216 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α)
(h :
List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] [g (g a)... | false |
complEDS₂_two | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), complEDS₂ b c d 2 = d | true |
Std.ExtDHashMap.get_filter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool} {k : α} {h' : k ∈ Std.ExtDHashMap.filter f m},
(Std.ExtDHashMap.filter f m).get k h' = m.get k ⋯ | true |
MulEquiv.coprodCongr._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHomClass (N ≃* M) N M | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_getElem_idxsOf._proof_4 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} [inst : BEq α] (h : i < (List.idxsOf x xs).length),
(List.idxsOf x xs)[i] < xs.length | false |
NNReal.rpow_sub_natCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x : NNReal}, x ≠ 0 → ∀ (y : ℝ) (n : ℕ), x ^ (y - ↑n) = x ^ y / x ^ n | true |
Quaternion.coe_ofComplex | Mathlib.Analysis.Quaternion | ⇑Quaternion.ofComplex = Quaternion.coeComplex | true |
PreAbstractSimplicialComplex.addSingletons._proof_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ (ι : Type u_1) (K : PreAbstractSimplicialComplex ι), IsRelLowerSet (K.faces ∪ {s | ∃ v, s = {v}}) Finset.Nonempty | false |
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {X : C} (h : F.cocones.CorepresentableBy X) (s : CategoryTheory.Limits.Cocone F),
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s = h.homEquiv.symm s.ι | true |
Std.DTreeMap.get_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k a : α} {h' : a ∈ t.erase k}, (t.erase k).get a h' = t.get a ⋯ | true |
GradeMaxOrder.mk.noConfusion | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
{inst : Preorder 𝕆} →
{inst_1 : Preorder α} →
{P : Sort u} →
{toGradeOrder : GradeOrder 𝕆 α} →
{isMax_grade : ∀ ⦃a : α⦄, IsMax a → IsMax (GradeOrder.grade a)} →
{toGradeOrder' : GradeOrder 𝕆 α} →
{isMax_grade' ... | false |
MulSemiringAction.ctorIdx | Mathlib.Algebra.Ring.Action.Basic | {M : Type u} → {R : Type v} → {inst : Monoid M} → {inst_1 : Semiring R} → MulSemiringAction M R → ℕ | false |
instNonemptyNormalizationMonoidOfNormalizedGCDMonoid | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [h : Nonempty (NormalizedGCDMonoid α)], Nonempty (NormalizationMonoid α) | true |
OrderEmbedding.birkhoffSet_sup | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : Fintype α] [inst_2 : DecidablePred SupIrred] (a b : α),
OrderEmbedding.birkhoffSet (a ⊔ b) = OrderEmbedding.birkhoffSet a ∪ OrderEmbedding.birkhoffSet b | true |
CategoryTheory.Functor.CorepresentableBy | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (Type v) → C → Type (max (max u₁ v) v₁) | true |
fderivWithin_congr_set_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : 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] {f : E → F} {x : E} {s t : Set E},
s =ᶠ[nhdsWithin x {x}ᶜ] t → fderivWit... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_modify._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
CategoryTheory.Equivalence.isAccessibleCategory | Mathlib.CategoryTheory.Presentable.Adjunction | ∀ {C : Type u} {D : Type u'} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v', u'} D]
(e : C ≌ D) [CategoryTheory.IsAccessibleCategory.{w, v, u} C], CategoryTheory.IsAccessibleCategory.{w, v', u'} D | true |
Set.Iic.coe_succ_of_not_isMax | Mathlib.Order.Interval.Set.SuccOrder | ∀ {J : Type u_1} [inst : PartialOrder J] [inst_1 : SuccOrder J] {j : J} {i : ↑(Set.Iic j)},
¬IsMax i → ↑(Order.succ i) = Order.succ ↑i | true |
instDistribLatticePrimeMultiset._proof_6 | Mathlib.Data.PNat.Factors | ∀ (a b c : PrimeMultiset), a ≤ b → b ≤ c → a ≤ c | false |
_private.Mathlib.Probability.Independence.Basic.0.ProbabilityTheory.iIndepSet_iff._simp_1_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndepSet s μ = ProbabilityTheory.iIndep (fun i => MeasurableSpace.generateFrom {s i}) μ | false |
TopologicalSpace.Opens.map_iSup | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} (f : X ⟶ Y) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑Y),
(TopologicalSpace.Opens.map f).obj (iSup U) = iSup ((TopologicalSpace.Opens.map f).obj ∘ U) | true |
Option.isSome.eq_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1}, none.isSome = false | true |
Chebyshev.psi.eq_1 | Mathlib.NumberTheory.Chebyshev | ∀ (x : ℝ), Chebyshev.psi x = ∑ n ∈ Finset.Ioc 0 ⌊x⌋₊, ArithmeticFunction.vonMangoldt n | true |
WithLp.prod_continuous_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous WithLp.ofLp | true |
exteriorPower.zeroEquiv_ιMulti | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Fin 0 → M),
(exteriorPower.zeroEquiv R M) ((exteriorPower.ιMulti R 0) f) = 1 | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqArgs | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.MetaM Bool | true |
LinearMap.polar_mem | Mathlib.Analysis.LocallyConvex.Polar | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedCommRing 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) (s : Set E),
∀ y ∈ B.polar s, ∀ x ∈ s, ‖(B x) y‖ ≤ 1 | true |
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.OfLocalizationSpanTarget P →
RingHom.StableUnderCompositionWithLocalizationAwaySource P → RingHom.OfLocalizationSpan P | true |
_private.Mathlib.RingTheory.Coalgebra.Convolution.0.TensorProduct.map_convMul_map._simp_1_2 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | false |
Lean.Meta.Sym.IntrosResult.failed.sizeOf_spec | Lean.Meta.Sym.Intro | sizeOf Lean.Meta.Sym.IntrosResult.failed = 1 | true |
MulAction.QuotientAction | Mathlib.GroupTheory.GroupAction.Quotient | {α : Type u} → (β : Type v) → [inst : Group α] → [inst_1 : Monoid β] → [MulAction β α] → Subgroup α → Prop | true |
AffineEquiv.ofLinearEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_10} →
{V : Type u_11} →
{P : Type u_12} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] → [inst_2 : Module k V] → [inst_3 : AddTorsor V P] → (V ≃ₗ[k] V) → P → P → P ≃ᵃ[k] P | true |
IntermediateField.fixingSubgroupEquiv._proof_3 | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_2} [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (K : IntermediateField F E)
(x x_1 : ↥K.fixingSubgroup),
(let __src := (↑(x * x_1)).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }) =
(let __src := (↑x).toRingEquiv;
{ to... | false |
ContinuousAlternatingMap.instAddCommGroup._proof_7 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {N : Type u_1} [inst : AddCommGroup N] [inst_1 : TopologicalSpace N] [IsTopologicalAddGroup N], ContinuousAdd N | false |
_private.Mathlib.Algebra.Module.Submodule.Map.0.Submodule.gc_map_comap.match_1_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_2} {M₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂]
(motive : Submodule R M → Submodule R₂ M₂ → Prop) (x : Submodule R M) (x_1 : Submodule R₂ M₂),
(∀ (x : Sub... | false |
Pi.negZeroClass.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → NegZeroClass (f i)],
Pi.negZeroClass = { toZero := Pi.instZero, toNeg := Pi.instNeg, neg_zero := ⋯ } | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_dvd_leadingCoeff_pow._simp_1_1 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime 0 x = IsUnit x | false |
MonoidAlgebra.map_single | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+ S) (r : R) (m : M),
MonoidAlgebra.map f (MonoidAlgebra.single m r) = MonoidAlgebra.single m (f r) | true |
_private.Mathlib.LinearAlgebra.Matrix.Symmetric.0.Matrix.isSymm_comp_iff_forall._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.IsSymm = ∀ (i j : n), A j i = A i j | false |
AddCon.instInfSet.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M],
AddCon.instInfSet = { sInf := fun S => { r := fun x y => ∀ c ∈ S, c x y, iseqv := ⋯, add' := ⋯ } } | true |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso_inv_app_hom_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] (X : CategoryTheory.Comon (CategoryTheory.Functor C D)) (x : C),
(CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso✝.inv.app X).hom.app x... | true |
MeasureTheory.SignedMeasure.eq_rnDeriv | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : MeasureTheory.SignedMeasure α}
(t : MeasureTheory.SignedMeasure α) (f : α → ℝ),
MeasureTheory.Integrable f μ →
MeasureTheory.VectorMeasure.MutuallySingular t μ.toENNRealVectorMeasure →
s = t + μ.withDensityᵥ f → f =ᵐ[μ] s.rnDeriv ... | true |
Lean.Grind.Ring.ofNat_sub | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α] {x y : ℕ}, y ≤ x → OfNat.ofNat (x - y) = OfNat.ofNat x - OfNat.ofNat y | true |
Set.mem_prod | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t | true |
_private.Mathlib.Algebra.Order.Module.Basic.0.abs_smul._simp_1_3 | Mathlib.Algebra.Order.Module.Basic | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
[inst_3 : Preorder α] [inst_4 : Preorder β] [SMulPosMono α β], a ≤ 0 → 0 ≤ b → (a • b ≤ 0) = True | false |
Lean.Elab.Tactic.evalRepeat' | Lean.Elab.Tactic.Repeat | Lean.Elab.Tactic.Tactic | true |
QPF.recF_eq | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] {α : Type u} (g : F α → α) (x : (QPF.P F).W),
QPF.recF g x = g (QPF.abs ((QPF.P F).map (QPF.recF g) x.dest)) | true |
ContDiffMapSupportedInClass.map_contDiff | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} [self : ContDiffMapSupportedInClass B E F n K] (f : B), ContDiff ℝ ↑... | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.ssubset_iff_exists_cons_subset._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α}, ∀ w ∉ s, w ∉ s | false |
OrderIso.image_symm_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set β), ⇑e '' (⇑e.symm '' s) = s | true |
Congr!.Config.numArgsOk | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ → Bool | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
AddCommGrpCat.zero_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (G H : AddCommGrpCat) (g : ↑G), (CategoryTheory.ConcreteCategory.hom 0) g = 0 | true |
StrictMono.injective | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
StrictMono f → Function.Injective f | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.