name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AlgCat.forget₂_module_map | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u) [inst : CommRing R] {X Y : AlgCat R} (f : X ⟶ Y),
(CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)).map f = ModuleCat.ofHom (AlgCat.Hom.hom f).toLinearMap | true |
List.isRotated_singleton_iff'._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {x : α}, ([x] ~r l) = ([x] = l) | false |
CategoryTheory.Limits.limit.pre_post | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_3 : CategoryTheory.Category.{v', u'} D]
(E : CategoryTheory.Functor K J) (F : CategoryTheory.Functor J C) (G : Category... | true |
Lean.Widget.TaggedText.brecOn.eq | Lean.Widget.TaggedText | ∀ {α : Type u} {motive_1 : Lean.Widget.TaggedText α → Sort u_1} {motive_2 : Array (Lean.Widget.TaggedText α) → Sort u_1}
{motive_3 : List (Lean.Widget.TaggedText α) → Sort u_1} (t : Lean.Widget.TaggedText α)
(F_1 : (t : Lean.Widget.TaggedText α) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Widget.TaggedText α)... | true |
Ideal.map_isMaximal_of_equiv | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {E : Type u_4} [inst_2 : EquivLike E R S]
[RingEquivClass E R S] (e : E) {p : Ideal R} [hp : p.IsMaximal], (Ideal.map e p).IsMaximal | true |
Tactic.NormNum.proveNatSqrt | Mathlib.Tactic.NormNum.NatSqrt | (ex : Q(ℕ)) → (ey : Q(ℕ)) × Q(«$ex».sqrt = «$ey») | true |
Polygon.toTriangle._proof_2 | Mathlib.Geometry.Polygon.Basic | NeZero (2 + 1) | false |
MeasCat.Giry._proof_5 | Mathlib.MeasureTheory.Category.MeasCat | ∀ (x : MeasCat),
CategoryTheory.CategoryStruct.comp
(MeasCat.Measure.map
({ app := fun X => ⟨MeasureTheory.Measure.join, ⋯⟩, naturality := MeasCat.Giry._proof_4 }.app x))
({ app := fun X => ⟨MeasureTheory.Measure.join, ⋯⟩, naturality := MeasCat.Giry._proof_4 }.app x) =
CategoryTheory.CategoryS... | false |
_private.Mathlib.Algebra.Module.LocalizedModule.Basic.0.IsLocalizedModule.of_restrictScalars._simp_1_1 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | false |
Std.ExtTreeMap.minKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | true |
equivShrink_sub | Mathlib.Algebra.Group.Shrink | ∀ {α : Type u_2} [inst : Small.{v, u_2} α] [inst_1 : Sub α] (x y : α),
(equivShrink α) (x - y) = (equivShrink α) x - (equivShrink α) y | true |
_private.Mathlib.NumberTheory.Padics.RingHoms.0.PadicInt.appr_spec._simp_1_2 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {M : Type u_1} [inst : Monoid M], IsUnit 1 = True | false |
SimpleGraph.Walk.edgeSet | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → Set (Sym2 V) | true |
Subalgebra.copy._proof_2 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (s : Set A) (hs : s = ↑S), 1 ∈ (S.copy s hs).carrier | false |
WithAbs._sizeOf_1 | Mathlib.Analysis.Normed.Ring.WithAbs | {R : Type u_1} →
{S : Type u_2} →
{inst : Semiring S} →
{inst_1 : PartialOrder S} →
{inst_2 : Semiring R} → {v : AbsoluteValue R S} → [SizeOf R] → [SizeOf S] → WithAbs v → ℕ | false |
Std.DTreeMap.Raw.getKeyLE! | Std.Data.DTreeMap.Raw.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → [Inhabited α] → Std.DTreeMap.Raw α β cmp → α → α | true |
Std.TreeMap.getKey_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α}
{v : β} {h₁ : a ∈ t.insertIfNew k v},
(t.insertIfNew k v).getKey a h₁ = if h₂ : cmp k a = Ordering.eq ∧ k ∉ t then k else t.getKey a ⋯ | true |
Submodule.lift_spanRank_le_iff_exists_span_set_card_le | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
{a : Cardinal.{max u v}},
Cardinal.lift.{v, u} p.spanRank ≤ a ↔ ∃ s, Cardinal.lift.{v, u} (Cardinal.mk ↑s) ≤ a ∧ Submodule.span R s = p | true |
CategoryTheory.Limits.MultispanIndex.SymmStruct.mk.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{ι : Type w} →
{I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C} →
{P : Sort u_1} →
{iso : (i j : ι) → I.left (i, j) ≅ I.left (j, i)} →
{iso_hom_fst :
∀ (i j : ι)... | false |
CategoryTheory.ObjectProperty.monoidalι._proof_4 | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsMonoidal] {X Y : P.FullSubcategory} (X' : P.FullSubcategory)
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiske... | false |
_private.Init.Data.Array.QSort.Basic.0.Array.qsort.sort | Init.Data.Array.QSort.Basic | {α : Type u_1} →
(α → α → Bool) →
{n : ℕ} →
Vector α n →
(lo hi : ℕ) →
autoParam (lo ≤ hi) Array.qsort._auto_2✝ →
autoParam (lo < n) Array.qsort._auto_4✝ → autoParam (hi < n) Array.qsort._auto_6✝ → Vector α n | true |
ModuleCat.restrictCoextendScalarsAdj._proof_1 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (X : ModuleCat S) (Y : ModuleCat R)
(g : (ModuleCat.restrictScalars f).obj X ⟶ Y),
ModuleCat.RestrictionCoextensionAdj.HomEquiv.toRestriction f
(ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction f g) =
g | false |
Mathlib.Tactic.Translate.RelevantArg._sizeOf_inst | Mathlib.Tactic.Translate.Core | SizeOf Mathlib.Tactic.Translate.RelevantArg | false |
AddSubgroup.quotientEquivProdOfLE'._proof_2 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s t : AddSubgroup α} (f : α ⧸ t → α) (a : (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t)
(b c : ↥t),
(QuotientAddGroup.leftRel (s.addSubgroupOf t)) b c →
(QuotientAddGroup.leftRel s) ((fun b => f a.1 + ↑b) b) ((fun b => f a.1 + ↑b) c) | false |
String.Slice.posLT_eq_iff | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : 0 < p} {q : s.Pos},
s.posLT p h = q ↔ q.offset < p ∧ ∀ (q' : s.Pos), q'.offset < p → q' ≤ q | true |
UInt16.instLawfulUpwardEnumerableLeast? | Init.Data.Range.Polymorphic.UInt | Std.PRange.LawfulUpwardEnumerableLeast? UInt16 | true |
Algebra.commute_of_mem_adjoin_singleton_of_commute | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {a b c : A},
c ∈ R[b] → Commute a b → Commute a c | true |
_private.Mathlib.MeasureTheory.Constructions.Cylinders.0.MeasureTheory.comap_eval_le_generateFrom_squareCylinders_singleton._proof_1_8 | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_2} (α : ι → Type u_1) (i : ι) (S : Set ((x : ι) → α x)) (t : Set (α i)),
Function.eval i ⁻¹' t = S → Set (α i) = Set (α i) | false |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformContinuous.image_hausdorff.match_1_3 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} (U : Set (β × β)) (s t : Set α)
(motive : (s, t) ∈ hausdorffEntourage ((fun x => (f x.1, f x.2)) ⁻¹' U) → Prop)
(h : (s, t) ∈ hausdorffEntourage ((fun x => (f x.1, f x.2)) ⁻¹' U)),
(∀ (h₁ : (s, t).1 ⊆ SetRel.preimage ((fun x => (f x.1, f x.2)) ⁻¹' U) (s, t).2)
(h₂... | false |
MeasureTheory.MemLp.abs | Mathlib.MeasureTheory.Function.LpOrder | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : ENNReal}
[inst : NormedAddCommGroup E] [inst_1 : Lattice E] [HasSolidNorm E] [IsOrderedAddMonoid E] {f : α → E},
MeasureTheory.MemLp f p μ → MeasureTheory.MemLp |f| p μ | true |
Vector.toArray_range' | Init.Data.Vector.Range | ∀ {start size step : ℕ}, (Vector.range' start size step).toArray = Array.range' start size step | true |
CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_term_ᘁ_1» | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.Macro | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_inter_of_contains_eq_false_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
CategoryTheory.Functor.CorepresentableBy.homEquiv | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor C (Type v)} → {X : C} → F.CorepresentableBy X → {Y : C} → (X ⟶ Y) ≃ F.obj Y | true |
Set.indicator_le_indicator_nonneg | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : LinearOrder M] (s : Set α) (f : α → M),
s.indicator f ≤ {a | 0 ≤ f a}.indicator f | true |
TrivSqZeroExt.invertibleEquivInvertibleFst | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} →
{M : Type v} →
[inst : AddCommGroup M] →
[inst_1 : Semiring R] →
[inst_2 : Module Rᵐᵒᵖ M] →
[inst_3 : Module R M] → [SMulCommClass R Rᵐᵒᵖ M] → (x : TrivSqZeroExt R M) → Invertible x ≃ Invertible x.fst | true |
Isometry.prodMap | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {δ : Type u_3} [inst_3 : PseudoEMetricSpace δ] {f : α → β} {g : γ → δ},
Isometry f → Isometry g → Isometry (Prod.map f g) | true |
_private.Batteries.Util.Cache.0.Batteries.Tactic.instNonemptyCache._proof_1 | Batteries.Util.Cache | ∀ {α : Type}, Nonempty (Batteries.Tactic.Cache α) | false |
Action.instBraidedForget | Mathlib.CategoryTheory.Action.Monoidal | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
(G : Type u_2) →
[inst_1 : Monoid G] →
[inst_2 : CategoryTheory.MonoidalCategory V] →
[inst_3 : CategoryTheory.BraidedCategory V] → (Action.forget V G).Braided | true |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_nonsquare._simp_1_1 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} [Finite α] {f : α → α}, Function.Injective f = Function.Surjective f | false |
ReprTuple.reprTuple | Init.Data.Repr | {α : Type u} → [self : ReprTuple α] → α → List Std.Format → List Std.Format | true |
CategoryTheory.ObjectProperty.limitsClosure_eq_self | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C) {α : Type t}
(J : α → Type u') [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] [P.IsClosedUnderIsomorphisms]
[∀ (a : α), P.IsClosedUnderLimitsOfShape (J a)], P.limitsClosure J = P | true |
Lean.Elab.Term.MatchExpr.ElseAlt._sizeOf_inst | Lean.Elab.MatchExpr | SizeOf Lean.Elab.Term.MatchExpr.ElseAlt | false |
Lean.Meta.Grind.Order.Struct.proofs | Lean.Meta.Tactic.Grind.Order.Types | Lean.Meta.Grind.Order.Struct → Lean.PArray (Lean.AssocList Lean.Meta.Grind.Order.NodeId Lean.Meta.Grind.Order.ProofInfo) | true |
CategoryTheory.sheafifyMap_id | Mathlib.CategoryTheory.Sites.Sheafification | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
(P : CategoryTheory.Functor Cᵒᵖ D),
CategoryTheory.sheafifyMap J (CategoryTheory.CategoryStruct.id P)... | true |
isLeast_univ_iff | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsLeast Set.univ a ↔ IsBot a | true |
_private.Mathlib.Computability.TuringMachine.StackTuringMachine.0.Turing.TM2to1.trStmts₁.match_1.splitter | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
(motive : Turing.TM2.Stmt Γ Λ σ → Sort u_5) →
(x : Turing.TM2.Stmt Γ Λ σ) →
((k : K) → (f : σ → Γ k) → (q : Turing.TM2.Stmt Γ Λ σ) → motive (Turing.TM2.Stmt.push k f q)) →
((k : K) →
... | true |
String.Pos.posGT_offset._proof_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p.offset < s.rawEndPos}, p ≠ s.endPos | false |
PrimeMultiset.coe_coeNatMonoidHom | Mathlib.Data.PNat.Factors | ⇑PrimeMultiset.coeNatMonoidHom = PrimeMultiset.toNatMultiset | true |
RingCat.limitRing | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J RingCat) →
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] →
Ring (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget RingCat))).pt | true |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_9 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L), AddSubmonoidClass (LieSubmodule R (↥H) L) L | false |
WeakDual.gelfandTransform.congr_simp | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ (𝕜 : Type u_1) (A : Type u_2) [inst : CommRing 𝕜] [inst_1 : NoZeroDivisors 𝕜] [inst_2 : TopologicalSpace 𝕜]
[inst_3 : IsTopologicalRing 𝕜] [inst_4 : TopologicalSpace A] [inst_5 : Semiring A] [inst_6 : Algebra 𝕜 A],
WeakDual.gelfandTransform 𝕜 A = WeakDual.gelfandTransform 𝕜 A | true |
CategoryTheory.instEssSurjAlgebraToMonadAdjComparison | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C),
(CategoryTheory.Monad.comparison T.adj).EssSurj | true |
CategoryTheory.ShortComplex.Hom.comp_τ₂ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁₂ : S₁.Hom S₂) (φ₂₃ : S₂.Hom S₃),
(φ₁₂.comp φ₂₃).τ₂ = CategoryTheory.CategoryStruct.comp φ₁₂.τ₂ φ₂₃.τ₂ | true |
Std.ExtHashSet.get!_eq_default_of_contains_eq_false | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : Inhabited α] [inst_1 : EquivBEq α]
[inst_2 : LawfulHashable α] {a : α}, m.contains a = false → m.get! a = default | true |
Finset.sum_card_bipartiteAbove_eq_sum_card_bipartiteBelow | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {t : Finset β}
[inst : (a : α) → (b : β) → Decidable (r a b)],
∑ a ∈ s, (Finset.bipartiteAbove r t a).card = ∑ b ∈ t, (Finset.bipartiteBelow r s b).card | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.ENNReal.tsum_top.match_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} (motive : Nonempty α → Prop) (x : Nonempty α), (∀ (a : α), motive ⋯) → motive x | false |
_private.Std.Data.Iterators.Combinators.Monadic.Drop.0.Std.Iterators.Types.Drop.ProductiveRel | Std.Data.Iterators.Combinators.Monadic.Drop | {α β : Type w} →
(m : Type w → Type w') →
[inst : Std.Iterator α m β] → [Std.Iterators.Productive α m] → Std.IterM m β → Std.IterM m β → Prop | true |
List.mapIdxMAux' | Mathlib.Data.List.Defs | {m : Type v → Type w} → [Monad m] → {α : Type u_7} → (ℕ → α → m PUnit.{v + 1}) → ℕ → List α → m PUnit.{v + 1} | true |
Polynomial.Monic.irreducible_of_degree_eq_one | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {p : Polynomial R}, p.degree = 1 → p.Monic → Irreducible p | true |
List.mapM_subtype | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {p : α → Prop}
{l : List { x // p x }} {f : { x // p x } → m β} {g : α → m β},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → List.mapM f l = List.mapM g l.unattach | true |
NonUnitalSubsemiring.mk._flat_ctor | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} →
[inst : NonUnitalNonAssocSemiring R] →
(carrier : Set R) →
(∀ {a b : R}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) →
0 ∈ carrier → (∀ {a b : R}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) → NonUnitalSubsemiring R | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_81 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Real.iSup_pow_of_ne_zero | Mathlib.Topology.Instances.NNReal.Lemmas | ∀ {ι : Sort u_1} {n : ℕ} {f : ι → ℝ}, (∀ (i : ι), 0 ≤ f i) → n ≠ 0 → (⨆ i, f i) ^ n = ⨆ i, f i ^ n | true |
KaehlerDifferential.finite | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.EssFiniteType R S], Module.Finite S Ω[S⁄R] | true |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.kerFun._simp_4 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : ... | false |
rothNumberNat_def | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ (n : ℕ), rothNumberNat n = addRothNumber (Finset.range n) | true |
RestrictedProduct.comp_single | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} {S : ι → Type u_3} {G : ι → Type u_4} [inst : (i : ι) → SetLike (S i) (G i)] (A : (i : ι) → S i)
[inst_1 : DecidableEq ι] [inst_2 : (i : ι) → Zero (G i)] [inst_3 : ∀ (i : ι), ZeroMemClass (S i) (G i)] (i : ι),
DFunLike.coe ∘ RestrictedProduct.single A i = Pi.single i | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem.match_1_3 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} {p : α → α → α → Prop} (head : α) (tail : List α)
(motive :
((∀ (i j : ℕ) (_hi : i < tail.length) (_hj : j < tail.length), i < j → p head tail[i] tail[j]) ∧
∀ (i j k : ℕ) (hij : i < j) (hjk : j < k) (hk : k < tail.length), p tail[i] tail[j] tail[k]) →
Prop)
(x :
(∀ (i j : ℕ) (... | false |
_private.Lean.Elab.Tactic.Grind.Basic.0.Lean.Elab.Tactic.Grind.getMainGoal.loop._sunfold | Lean.Elab.Tactic.Grind.Basic | List Lean.Meta.Grind.Goal → Lean.Elab.Tactic.Grind.GrindTacticM Lean.Meta.Grind.Goal | false |
Order.Ideal.nonempty | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P] (s : Order.Ideal P), (↑s).Nonempty | true |
CpltSepUniformSpace.mk.noConfusion | Mathlib.Topology.Category.UniformSpace | {P : Sort u_1} →
{α : Type u} →
{isUniformSpace : UniformSpace α} →
{isCompleteSpace : CompleteSpace α} →
{isT0 : T0Space α} →
{α' : Type u} →
{isUniformSpace' : UniformSpace α'} →
{isCompleteSpace' : CompleteSpace α'} →
{isT0' : T0Space α'} →
... | false |
IntermediateField.mk.congr_simp | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(toSubalgebra toSubalgebra_1 : Subalgebra K L) (e_toSubalgebra : toSubalgebra = toSubalgebra_1)
(inv_mem' : ∀ x ∈ toSubalgebra.carrier, x⁻¹ ∈ toSubalgebra.carrier),
{ toSubalgebra := toSubalgebra, inv_mem' := inv_mem' } = {... | true |
Std.Do.Triple.entails_wp_of_pre_post | Std.Do.Triple.Basic | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α}
{P P' : Std.Do.Assertion ps} {Q Q' : Std.Do.PostCond α ps},
⦃P'⦄ x ⦃Q'⦄ → (P ⊢ₛ P') → Q'.entails Q → P ⊢ₛ (Std.Do.wp x).apply Q | true |
Real.denselyNormedField | Mathlib.Analysis.Normed.Field.Basic | DenselyNormedField ℝ | true |
QuotientGroup.ker_le_range_iff | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : Group G] [inst_1 : Group H] [inst_2 : MulOneClass I] (f : G →* H)
[inst_3 : f.range.Normal] (g : H →* I), g.ker ≤ f.range ↔ (QuotientGroup.mk' f.range).comp g.ker.subtype = 1 | true |
Lean.Doc.Parser.UnorderedListType | Lean.DocString.Parser | Type | true |
Lean.Kernel.Exception.letTypeMismatch.injEq | Lean.Environment | ∀ (env : Lean.Kernel.Environment) (lctx : Lean.LocalContext) (name : Lean.Name) (givenType expectedType : Lean.Expr)
(env_1 : Lean.Kernel.Environment) (lctx_1 : Lean.LocalContext) (name_1 : Lean.Name)
(givenType_1 expectedType_1 : Lean.Expr),
(Lean.Kernel.Exception.letTypeMismatch env lctx name givenType expected... | true |
ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux_nonneg | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α],
ProbabilityTheory.IsMeasurableRatCDF f →
∀ (a : α) (r : ℝ), 0 ≤ ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux f a r | true |
_private.Lean.Meta.Match.0.Lean.initFn._@.Lean.Meta.Match.3442551600._hygCtx._hyg.2 | Lean.Meta.Match | IO Unit | false |
IsometryEquiv.ediam_preimage | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (h : α ≃ᵢ β) (s : Set β),
Metric.ediam (⇑h ⁻¹' s) = Metric.ediam s | true |
Vector.foldr_rel | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {γ : Type u_3} {xs : Vector α n} {f : α → β → β} {g : α → γ → γ} {a : β} {b : γ}
{r : β → γ → Prop},
r a b →
(∀ a ∈ xs, ∀ (c : β) (c' : γ), r c c' → r (f a c) (g a c')) →
r (Vector.foldr (fun a acc => f a acc) a xs) (Vector.foldr (fun a acc => g a acc) b xs) | true |
Set.image2_subset_iff_left | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {u : Set γ},
Set.image2 f s t ⊆ u ↔ ∀ a ∈ s, (fun b => f a b) '' t ⊆ u | true |
Lean.instDecidableEqDeclarationLocation.decEq | Lean.Data.DeclarationRange | (x x_1 : Lean.DeclarationLocation) → Decidable (x = x_1) | true |
StarConvex.add_smul_sub_mem | Mathlib.Analysis.Convex.Star | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] {x y : E} {s : Set E}, StarConvex 𝕜 x s → y ∈ s → ∀ {t : 𝕜}, 0 ≤ t → t ≤ 1 → x + t • (y - x) ∈ s | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup.0.Real._aux_Mathlib_Analysis_SpecialFunctions_Gamma_BohrMollerup___macroRules__private_Mathlib_Analysis_SpecialFunctions_Gamma_BohrMollerup_0_Real_termΓ_1 | Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup | Lean.Macro | false |
FirstOrder.Language.Term.subst._unsafe_rec | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → {β : Type v'} → L.Term α → (α → L.Term β) → L.Term β | false |
_private.Lean.Compiler.ExternAttr.0.Lean.expandExternPatternAux.match_3 | Lean.Compiler.ExternAttr | (motive : ℕ → (x : String) → x.Pos → String → Sort u_1) →
(x : ℕ) →
(x_1 : String) →
(x_2 : x_1.Pos) →
(x_3 : String) →
((x : String) → (x_4 : x.Pos) → (r : String) → motive 0 x x_4 r) →
((i : ℕ) → (pattern : String) → (it : pattern.Pos) → (r : String) → motive i.succ pattern i... | false |
IO.AsyncList.instInhabited | Lean.Server.AsyncList | {ε : Type u_1} → {α : Type u_2} → Inhabited (IO.AsyncList ε α) | true |
CategoryTheory.LiftRightAdjoint.constructRightAdjointEquiv_apply | Mathlib.CategoryTheory.Adjunction.Lifting.Right | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{U : CategoryTheory.Functor A B} {F : CategoryTheory.Functor B A} (L : CategoryTheory.Functor C B)
(U' : CategoryTheory.Functor A C) (... | true |
lipschitzWith_smul | Mathlib.Analysis.Normed.MulAction | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
[inst_2 : SMulZeroClass α β] [IsBoundedSMul α β] (s : α), LipschitzWith ‖s‖₊ fun x => s • x | true |
_private.Mathlib.Combinatorics.Quiver.Covering.0.Prefunctor.pathStar_surjective._simp_1_1 | Mathlib.Combinatorics.Quiver.Covering | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | false |
range_euclideanHalfSpace | Mathlib.Geometry.Manifold.Instances.Real | ∀ (n : ℕ) [inst : NeZero n], Set.range Subtype.val = {y | 0 ≤ y.ofLp 0} | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr.0.Lean.Meta.Grind.Arith.CommRing.PolyDerivation.simplify.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | (motive : Option Lean.Meta.Grind.Arith.CommRing.PolyDerivation → Sort u_1) →
(x : Option Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
(Unit → motive none) → ((a : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) → motive (some a)) → motive x | false |
List.alternatingSum | Mathlib.Algebra.BigOperators.Group.List.Defs | {G : Type u_4} → [Zero G] → [Add G] → [Neg G] → List G → G | true |
Bipointed.noConfusionType | Mathlib.CategoryTheory.Category.Bipointed | Sort u_1 → Bipointed → Bipointed → Sort u_1 | false |
MonomialOrder.zero_le._simp_1 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} (m : MonomialOrder σ) (a : m.syn), (0 ≤ a) = True | false |
NonarchAddGroupSeminorm.instSMul._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {E : Type u_2} [inst : AddGroup E] [inst_1 : SMul R ℝ] (r : R) (p : NonarchAddGroupSeminorm E) (x : E),
r • p (-x) = r • p x | false |
_private.Mathlib.Topology.ContinuousMap.Compact.0.ContinuousMap.instNormOneClassOfNonempty._simp_1 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] (f : C(α, E)), ‖f‖ = ‖BoundedContinuousFunction.mkOfCompact f‖ | false |
SSet.modelCategoryQuillen.cofibrations_eq | Mathlib.AlgebraicTopology.SimplicialSet.CategoryWithFibrations | HomotopicalAlgebra.cofibrations SSet = CategoryTheory.MorphismProperty.monomorphisms SSet | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.