name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Int.pairwise_one_le_dist | Mathlib.Topology.Instances.Int | Pairwise fun m n => 1 ≤ dist m n | true |
Std.DTreeMap.Internal.Impl.Const.get_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h : t.WF) {k a : α}
{h' : Std.DTreeMap.Internal.Impl.contains a (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl = true},
Std.DTreeMap.Internal.Impl.Const.get (Std.DTreeMap.Internal.Impl.erase k t ⋯).... | true |
ENNReal.add_rpow_le_rpow_add | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p : ℝ} (a b : ENNReal), 1 ≤ p → a ^ p + b ^ p ≤ (a + b) ^ p | true |
CategoryTheory.Aut.autMulEquivOfIso._proof_10 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (h : X ≅ Y) (x : CategoryTheory.Aut X),
(fun y =>
{ hom := CategoryTheory.CategoryStruct.comp h.hom (CategoryTheory.CategoryStruct.comp y.hom h.inv),
inv := CategoryTheory.CategoryStruct.comp h.hom (CategoryTheory.CategoryStruc... | false |
CategoryTheory.GrpObj.ofIso_inv | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G X : C} [inst_2 : CategoryTheory.GrpObj G] (e : G ≅ X),
CategoryTheory.GrpObj.inv =
CategoryTheory.CategoryStruct.comp e.inv (CategoryTheory.CategoryStruct.comp CategoryTheory.GrpObj.inv e.hom) | true |
_private.Init.Data.Nat.Fold.0.Nat.fold_eq_foldTR.go | Init.Data.Nat.Fold | ∀ (α : Type u_1) (init : α) (m n : ℕ) (f : (i : ℕ) → i < m + n → α → α),
(m + n).fold f init = Nat.foldTR.loop✝ (m + n) f m ⋯ (n.fold (fun i h => f i ⋯) init) | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Basic.0.Mathlib.Tactic.BicategoryLike.ofNormalizedEq._sparseCasesOn_1 | Mathlib.Tactic.CategoryTheory.Coherence.Basic | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Subtype.property | Init.Prelude | ∀ {α : Sort u} {p : α → Prop} (self : Subtype p), p ↑self | true |
Finset.biUnion_union | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t₁ t₂ : α → Finset β} [inst : DecidableEq β],
(s.biUnion fun x => t₁ x ∪ t₂ x) = s.biUnion t₁ ∪ s.biUnion t₂ | true |
Order.succ_eq_succ_iff_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
¬IsMax a → ¬IsMax b → (Order.succ a = Order.succ b ↔ a = b) | true |
CategoryTheory.SheafOfTypes.adhesive | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[CategoryTheory.HasSheafify J (Type w)], CategoryTheory.Adhesive (CategoryTheory.Sheaf J (Type w)) | true |
_private.Mathlib.Data.Fintype.Quotient.0.Quotient.listChoice_mk.match_1_1 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (motive : (a : ι) → a ∈ [] → Prop) (a : ι) (a_1 : a ∈ []), motive a a_1 | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.initFn._@.Lean.Meta.ExprDefEq.1034906399._hygCtx._hyg.2 | Lean.Meta.ExprDefEq | IO Unit | false |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.noConfusionType | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
CategoryTheory.StrictlyUnitaryLaxFunctorCore B C →
{B' : Type u₁} →
[inst' : CategoryTheory.Bicategory B'] →
{C' : Type u₂} →
... | false |
PeriodPair.casesOn | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | {motive : PeriodPair → Sort u} →
(t : PeriodPair) →
((ω₁ ω₂ : ℂ) → (indep : LinearIndependent ℝ ![ω₁, ω₂]) → motive { ω₁ := ω₁, ω₂ := ω₂, indep := indep }) → motive t | false |
Filter.Tendsto.eventually_le_const | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {γ : Type w} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {l : Filter γ}
{f : γ → α} {u v : α}, v < u → Filter.Tendsto f l (nhds v) → ∀ᶠ (a : γ) in l, f a ≤ u | true |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.mk.inj | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W : CategoryTheory.MorphismProperty C} {J : Type w}
{inst_1 : LinearOrder J} {inst_2 : SuccOrder J} {inst_3 : OrderBot J} {inst_4 : WellFoundedLT J} {X Y : C} {f : X ⟶ Y}
{toTransfiniteCompositionOfShape : CategoryTheory.TransfiniteCompositionOfShape J f}
... | true |
Valuation.IsEquiv.uniformEquiv.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_4} {Γ₀ : Type u_5} {Γ₀' : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[inst_2 : LinearOrderedCommGroupWithZero Γ₀'] {v : Valuation R Γ₀} {w : Valuation R Γ₀'} (h : v.IsEquiv w),
h.uniformEquiv = h.uniformEquiv | true |
WithZero.instNontrivialUnits | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Group α] [Nontrivial α], Nontrivial (WithZero α)ˣ | true |
Std.Ric.HasRcoIntersection.mk | Init.Data.Range.Polymorphic.PRange | {α : Type w} → (Std.Ric α → Std.Rco α → Std.Rco α) → Std.Ric.HasRcoIntersection α | true |
Lean.Meta.Grind.instToMessageDataActionResult | Lean.Meta.Tactic.Grind.Action | Lean.ToMessageData Lean.Meta.Grind.ActionResult | true |
CategoryTheory.Equivalence.isDenseSubsite_functor_of_isCocontinuous | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D) (e : C ≌ D)
[e.functor.IsCocontinuous J K] [e.inverse.IsCocontinuous K J], CategoryTheory.Functor.IsDenseSub... | true |
BoolAlg.ctorIdx | Mathlib.Order.Category.BoolAlg | BoolAlg → ℕ | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.adj_spanningCoe_toSimpleGraph._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W) (G : SimpleGraph V) (u v : W),
(SimpleGraph.map (⇑f) G).Adj u v = ∃ u' v', G.Adj u' v' ∧ f u' = u ∧ f v' = v | false |
CategoryTheory.Sum.Swap.isEquivalence | Mathlib.CategoryTheory.Sums.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D],
(CategoryTheory.Sum.swap C D).IsEquivalence | true |
FirstOrder.Language.LHom.instUniqueOfIsAlgebraicOfIsRelational | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → [L.IsAlgebraic] → [L.IsRelational] → Unique (L →ᴸ L') | true |
MvPolynomial.coe_eq_one_iff._simp_1 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {φ : MvPolynomial σ R}, (↑φ = 1) = (φ = 1) | false |
WittVector.ctorIdx | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → WittVector p R → ℕ | false |
cauchySeq_bdd | Mathlib.Topology.MetricSpace.Cauchy | ∀ {α : Type u} [inst : PseudoMetricSpace α] {u : ℕ → α}, CauchySeq u → ∃ R > 0, ∀ (m n : ℕ), dist (u m) (u n) < R | true |
RootPairing.Equiv.comp_indexEquiv_apply | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₁ : Type u_8} {M₁ : Type u_9} {N₁ : Type u_10}
{ι₂ : Type u_11} {M₂ : Type u_12} {N₂ : Type u_13} [inst_5 : AddCommGroup M₁] [inst_6 : M... | true |
Std.DHashMap.Internal.Raw₀.Const.get_eq_getD | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m).WF →
∀ {a : α} {fallback : β} {h : m.contains a = true},
Std.DHashMap.Internal.Raw₀.Const.get m a h = Std.DHashMap.Internal.Raw₀.Const.getD m a fallback | true |
DistribMulActionHom.instZero._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {A : Type u_2} [inst : AddMonoid A] {B : Type u_1} [inst_1 : AddMonoid B], (↑0).toFun 0 = 0 | false |
Multipliable.vanishing | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [IsTopologicalGroup G] {f : α → G},
Multipliable f → ∀ ⦃e : Set G⦄, e ∈ nhds 1 → ∃ s, ∀ (t : Finset α), Disjoint t s → ∏ k ∈ t, f k ∈ e | true |
CategoryTheory.Limits.reflexivePair.compRightIso._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {A B : C} (f g : A ⟶ B) (s : B ⟶ A)
(sl : CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B)
(sr : CategoryTheory.CategoryStruct.comp s g = CategoryTheory.Categor... | false |
Lean.FileMap.toPosition | Lean.Data.Position | Lean.FileMap → String.Pos.Raw → Lean.Position | true |
ContDiffBump.one_of_mem_closedBall | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E] {c : E}
(f : ContDiffBump c) {x : E}, x ∈ Metric.closedBall c f.rIn → ↑f x = 1 | true |
Set.not_nontrivial_empty | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, ¬∅.Nontrivial | true |
MeasureTheory.L1.SimpleFunc.setToL1SCLM_zero_left | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{C : ℝ} (hT : MeasureTheory.DominatedFinMeasAdditive μ 0 C) (f : ↥(MeasureTheory.Lp.simpleFunc E 1 ... | true |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.range_liftAux._simp_1_4 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type w'} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : B →ₐ[R] C), Subalgebra.map g f.range = (g.comp f).range | false |
Lean.Meta.Grind.Order.instDecidableLEWeight | Lean.Meta.Tactic.Grind.Order.Util | DecidableLE Lean.Meta.Grind.Order.Weight | true |
Module.supportDim_eq_bot_iff_subsingleton | Mathlib.RingTheory.KrullDimension.Module | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.supportDim R M = ⊥ ↔ Subsingleton M | true |
instIsPartialOrder_mathlib | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α], Std.IsPartialOrder α | true |
_private.Mathlib.NumberTheory.Pell.0.Pell.Solution₁.x_pow_pos._simp_1_1 | Mathlib.NumberTheory.Pell | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | false |
AddMonoidHom.ofInjective._proof_3 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_2} [inst_1 : AddGroup N] {f : G →+ N},
Function.Injective ⇑f → Function.Injective ⇑(f.codRestrict f.range ⋯) ∧ Function.Surjective ⇑(f.codRestrict f.range ⋯) | false |
AddCon.toSetoid_injective | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M], Function.Injective AddCon.toSetoid | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.isCyclotomicExtension_iff_eq_adjoin._simp_1_6 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') | false |
_private.Mathlib.Data.EReal.Basic.0.EReal.le_coe_toReal._simp_1_1 | Mathlib.Data.EReal.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | false |
AntivaryOn.mul_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f₁ f₂ : ι → α} {g : ι → β},
AntivaryOn f₁ g s → AntivaryOn f₂ g s → AntivaryOn (f₁ * f₂) g s | true |
SSet.Truncated.instSetoidEdge | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | {A : SSet.Truncated 2} →
[A.Quasicategory₂] →
(x y : A.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Quasicategory₂._proof_1 })) →
Setoid (SSet.Truncated.Edge x y) | true |
OrderAddMonoidHom.instAddOfIsOrderedAddMonoid._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : AddCommMonoid β]
[inst_3 : Preorder β] [IsOrderedAddMonoid β] (f g : α →+o β), Monotone fun x => (↑f.toAddMonoidHom).toFun x + ↑g x | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.casesExpand.match_21 | Batteries.CodeAction.Misc | (motive : Option (Array Lean.Elab.TermInfo) → Sort u_1) →
(x : Option (Array Lean.Elab.TermInfo)) →
((discrInfos : Array Lean.Elab.TermInfo) → motive (some discrInfos)) →
((x : Option (Array Lean.Elab.TermInfo)) → motive x) → motive x | false |
RestrictedProduct.instGroupCoeOfSubgroupClass._proof_3 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → Group (R i)] [∀ (i : ι), SubgroupClass (S i) (R i)] (i : ι), SubmonoidClass (S i) (R i) | false |
TrivSqZeroExt.liftEquiv._proof_3 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {S : Type u_3} {R : Type u_4} {M : Type u_2} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Algebra S R] [inst_4 : Module S M] [inst_5 : Module R M] [inst_6 : Module Rᵐᵒᵖ M] {A : Type u_1}
[inst_7 : Semiring A] [inst_8 : Algebra S A]
(fg :
{ fg //
(∀ (x y : M), fg.2... | false |
_private.Init.Data.Dyadic.Basic.0.Int.trailingZeros._proof_5 | Init.Data.Dyadic.Basic | ∀ (i : ℤ) (k : ℕ), i.natAbs ≤ k + 1 → i % 2 = 0 → ¬(i / 2).natAbs ≤ k → False | false |
Finset.mulETransformRight | Mathlib.Combinatorics.Additive.ETransform | {α : Type u_1} → [DecidableEq α] → [Group α] → α → Finset α × Finset α → Finset α × Finset α | true |
Finsupp.multinomial_update | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} (a : α) (f : α →₀ ℕ), f.multinomial = (f.sum fun x => id).choose (f a) * (f.update a 0).multinomial | true |
DistribMulActionHom.comp._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {N : Type u_3} [inst : Monoid N] {P : Type u_4} [inst_1 : Monoid P] {ψ : N →* P} {B : Type u_1} [inst_2 : AddMonoid B]
[inst_3 : DistribMulAction N B] {C : Type u_2} [inst_4 : AddMonoid C] [inst_5 : DistribMulAction P C],
MulActionSemiHomClass (B →ₑ+[ψ] C) (⇑ψ) B C | false |
Order.isSuccPrelimitRecOn.eq_1 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} (b : α) {motive : α → Sort u_2} [inst : PartialOrder α] [inst_1 : SuccOrder α]
(succ : (a : α) → ¬IsMax a → motive (Order.succ a)) (isSuccPrelimit : (a : α) → Order.IsSuccPrelimit a → motive a),
Order.isSuccPrelimitRecOn b succ isSuccPrelimit =
if hb : Order.IsSuccPrelimit b then isSuccPrelimit... | true |
FirstOrder.Language.HomClass.map_rel | Mathlib.ModelTheory.Basic | ∀ {L : outParam FirstOrder.Language} {F : Type u_3} {M : outParam (Type u_4)} {N : outParam (Type u_5)}
{inst : FunLike F M N} {inst_1 : L.Structure M} {inst_2 : L.Structure N} [self : L.HomClass F M N] (φ : F) {n : ℕ}
(r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r x → FirstOrder.Lang... | true |
Lean.Meta.Sym.Pattern.unify? | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.Pattern → Lean.Expr → optParam Bool true → Lean.Meta.Sym.SymM (Option Lean.Meta.Sym.MatchUnifyResult) | true |
CategoryTheory.Limits.Cofork.isColimitCoforkPushoutEquivIsColimitForkOpPullback._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasPullback f f] [inst_2 : CategoryTheory.Limits.HasPushout f.op f.op],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl (Opposite.op X)).hom
(CategoryTheory.Limits.pushout.inl f.op ... | false |
ProbabilityTheory.IdentDistrib.div_const | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ}
[inst_3 : Div γ] [MeasurableDiv γ],
ProbabilityTheory.IdentDistrib f g μ ν →
∀ (c : γ), Probab... | true |
CategoryTheory.Limits.isLimitEquivIsColimitOp | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} → CategoryTheory.Limits.IsLimit t ≃ CategoryTheory.Limits.IsColimit t.op | true |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.vectorMeasure_Iic._proof_1_2 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {E : Type u_1} [inst_7 : NormedAddCommGroup E], Nonempty E | false |
AddSemigroupIdeal.FG | Mathlib.Algebra.Group.Ideal | {M : Type u_1} → [inst : Add M] → AddSemigroupIdeal M → Prop | true |
Algebra.map_intTraceAux | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ {A : Type u_1} {K : Type u_2} {L : Type u_3} {B : Type u_6} [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Algebra A B] [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K] [inst_6 : IsFractionRing A K]
[inst_7 : Algebra K L] [inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : Algebra B ... | true |
AugmentedSimplexCategory.inl' | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | (x y : SimplexCategory) → x ⟶ AugmentedSimplexCategory.tensorObjOf x y | true |
CategoryTheory.FreeBicategory.mk_left_unitor_hom | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b : CategoryTheory.FreeBicategory B} (f : a ⟶ b),
Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.left_unitor f) =
(CategoryTheory.Bicategory.leftUnitor f).hom | true |
Finset.union_assoc | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ s₃ : Finset α), s₁ ∪ s₂ ∪ s₃ = s₁ ∪ (s₂ ∪ s₃) | true |
Finset.set_biUnion_option_toFinset | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_2} {β : Type u_3} (o : Option α) (f : α → Set β), ⋃ x ∈ o.toFinset, f x = ⋃ x ∈ o, f x | true |
Representation.character.eq_1 | Mathlib.RepresentationTheory.Character | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Monoid G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (g : G), ρ.character g = (LinearMap.trace k V) (ρ g) | true |
MeasureTheory.StronglyAdapted.isStoppingTime_crossing | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ℱ : MeasureTheory.Filtration ℕ m0},
MeasureTheory.StronglyAdapted ℱ f →
(MeasureTheory.IsStoppingTime ℱ fun ω => ↑(MeasureTheory.upperCrossingTime a b f N n ω)) ∧
MeasureTheory.IsStoppingTime ℱ fun ω => ↑(MeasureTheory.lowerCross... | true |
ContinuousMap.instAddCommSemigroupOfContinuousAdd | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : AddCommSemigroup β] → [ContinuousAdd β] → AddCommSemigroup C(α, β) | true |
PFunctor.MIntl.noConfusion | Mathlib.Data.PFunctor.Univariate.M | {P : Sort u} →
{F : PFunctor.{uA, uB}} →
{t : F.MIntl} → {F' : PFunctor.{uA, uB}} → {t' : F'.MIntl} → F = F' → t ≍ t' → PFunctor.MIntl.noConfusionType P t t' | false |
Submodule.reflection_apply | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [inst_3 : K.HasOrthogonalProjection] (p : E), K.reflection p = 2 • K.starProjection p - p | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Ceva.0.Affine.Triangle.prod_eq_prod_one_sub_of_mem_line_point_lineMap._proof_1_6 | Mathlib.LinearAlgebra.AffineSpace.Ceva | ∀ {k : Type u_1} [inst : CommRing k] (w' : Fin (2 + 1) → k),
w' ((fun i => i) ⟨1, ⋯⟩ + 1) = 0 → w' ((fun i => i) ⟨1, ⋯⟩ + 2) = 0 → w' ⟨1, ⋯⟩ = w' 0 + w' 1 + w' 2 | false |
Std.HashMap.find?_toArray_eq_none_iff_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, Array.find? (fun x_2 => x_2.1 == k) m.toArray = none ↔ m.contains k = false | true |
isDomain_iff_noZeroDivisors_and_nontrivial | Mathlib.Algebra.Ring.Basic | ∀ (α : Type u_3) [inst : Ring α], IsDomain α ↔ NoZeroDivisors α ∧ Nontrivial α | true |
EStateM.Backtrackable.noConfusionType | Init.Prelude | Sort u_1 → {δ σ : Type u} → EStateM.Backtrackable δ σ → {δ' σ' : Type u} → EStateM.Backtrackable δ' σ' → Sort u_1 | false |
ProbabilityTheory.cdf_le_one | Mathlib.Probability.CDF | ∀ (μ : MeasureTheory.Measure ℝ) (x : ℝ), ↑(ProbabilityTheory.cdf μ) x ≤ 1 | true |
ProofWidgets.Util.joinArrays | ProofWidgets.Util | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → [Lean.MonadQuotation m] → Array Lean.Term → m Lean.Term | true |
Finsupp.comapDistribMulAction._proof_2 | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_2} {G : Type u_3} [inst : Monoid G] [inst_1 : MulAction G α] [inst_2 : AddCommMonoid M]
(g : G) (f f' : α →₀ M), g • (f + f') = g • f + g • f' | false |
Set.Icc.instMonoidWithZero._proof_2 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] (a : ↑(Set.Icc 0 1)),
1 * a = a | false |
Function.Injective.divInvMonoid._proof_8 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Inv M₁] [inst_1 : Pow M₁ ℤ] [inst_2 : DivInvMonoid M₂] (f : M₁ → M₂),
Function.Injective f →
(∀ (x : M₁), f x⁻¹ = (f x)⁻¹) →
(∀ (x : M₁) (n : ℤ), f (x ^ n) = f x ^ n) → ∀ (n : ℕ) (x : M₁), x ^ Int.negSucc n = (x ^ ↑n.succ)⁻¹ | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.visitFunDecl | Lean.Compiler.LCNF.Specialize | Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.Specialize.SpecializeM✝ (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) | true |
Sigma.fst_injective | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} [h : ∀ (a : α), Subsingleton (β a)], Function.Injective Sigma.fst | true |
cfcₙ_zero | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ (R : Type u_1) {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | true |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.getRemainingArgs.match_1 | Lean.Compiler.LCNF.Specialize | (motive : Lean.Compiler.LCNF.SpecParamInfo → Sort u_1) →
(info : Lean.Compiler.LCNF.SpecParamInfo) →
(Unit → motive Lean.Compiler.LCNF.SpecParamInfo.other) →
((x : Lean.Compiler.LCNF.SpecParamInfo) → motive x) → motive info | false |
Lean.Grind.GrobnerConfig.noConfusion | Init.Grind.Config | {P : Sort u} → {t t' : Lean.Grind.GrobnerConfig} → t = t' → Lean.Grind.GrobnerConfig.noConfusionType P t t' | false |
CategoryTheory.Bimon.mk'X_X | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C) [inst_3 : CategoryTheory.BimonObj X],
(CategoryTheory.Bimon.mk'X X).X = X | true |
Lean.Meta.Grind.NormalizePattern.State.bvarsFound | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.NormalizePattern.State → Std.HashSet ℕ | true |
_private.Mathlib.RingTheory.Unramified.LocalRing.0.Localization.exists_awayMap_bijective_of_localRingHom_bijective._simp_1_10 | Mathlib.RingTheory.Unramified.LocalRing | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
(algebraMap R A) r * x = r • x | false |
Plausible.TotalFunction.reprAux | Plausible.Functions | {α : Type u} → {β : Type v} → [Repr α] → [Repr β] → List ((_ : α) × β) → String | true |
IsPredArchimedean.findAtom_le._simp_1 | Mathlib.Order.SuccPred.Tree | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] [inst_2 : IsPredArchimedean α] [inst_3 : OrderBot α]
[inst_4 : DecidableEq α] (r : α), (IsPredArchimedean.findAtom r ≤ r) = True | false |
IsFreeGroup.definition._proof_1._@.Mathlib.GroupTheory.FreeGroup.IsFreeGroup.3798820966._hygCtx._hyg.2 | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ (G : Type u_1) [inst : Group G] [inst_1 : IsFreeGroup G], Nonempty (FreeGroupBasis ⋯.choose G) | false |
CategoryTheory.OrthogonalReflection.isLocal_reflectionObj | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} (Z : C)
[inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_3 : ∀ (Z : C), CategoryTheory.Limits.HasCoproduct Categ... | true |
Lean.Internal.isStage0 | Init.Meta.Defs | Unit → Bool | true |
AdjoinRoot.isAlgebraic_root | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R}, f ≠ 0 → IsAlgebraic R (AdjoinRoot.root f) | true |
ProofWidgets.RpcEncodablePacket.mk._flat_ctor._@.ProofWidgets.Component.Basic.2987839534._hygCtx._hyg.1 | ProofWidgets.Component.Basic | Lean.Json → ProofWidgets.RpcEncodablePacket✝ | false |
CompactlySupportedContinuousMap.pullback_addMonoidHom | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : TopologicalSpace α] →
[R1Space α] →
[inst_2 : AddGroup α] →
[inst_3 : TopologicalSpace β] →
[R1Space β] →
[inst_5 : AddGroup β] →
[ContinuousAdd β] →
[... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.