name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.ObjectProperty.colimitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {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)] (X : C), P X → P.colimitsClosure J X |
IncidenceAlgebra.instModule._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {𝕝 : Type u_3} {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : Semiring 𝕜]
[inst_3 : Semiring 𝕝] [inst_4 : Module 𝕜 𝕝] (x y : IncidenceAlgebra 𝕜 α) (z : IncidenceAlgebra 𝕝 α),
(x • y) • z = x • y • z |
HomologicalComplex.opInverse._proof_4 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y Z : HomologicalComplex Vᵒᵖ c.symm} (f : X ⟶ Y) (g : Y ⟶ Z),
Quiver.Hom.op { f := fun i => ((CategoryTheory.CategoryStruct.comp f g).f i).unop, comm' := ⋯ } =
CategoryTheory.CategoryStruct.comp (Quiver.Hom.op { f := fun i => (f.f i).unop, comm' := ⋯ })
(Quiver.Hom.op { f := fun i => (g.f i).unop, comm' := ⋯ }) |
IsGroupLikeElem.mul | Mathlib.RingTheory.Bialgebra.GroupLike | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A] {a b : A},
IsGroupLikeElem R a → IsGroupLikeElem R b → IsGroupLikeElem R (a * b) |
CochainComplex.degreewiseEpiWithInjectiveKernel._proof_1 | Mathlib.Algebra.Homology.Factorizations.Basic | IsRightCancelAdd ℤ |
Lean.Server.RpcEncodable.mk | Lean.Server.Rpc.Basic | {α : Type} →
(α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) → Lean.Server.RpcEncodable α |
CategoryTheory.IsGrothendieckAbelian.instMonoIMonomorphismsRlpMonoMapFactorizationDataRlp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono (CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp f).i |
OrderIso.divRight_symm_apply | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [inst_2 : MulRightMono α] (a b : α),
(RelIso.symm (OrderIso.divRight a)) b = b * a |
BitVec.ushiftRight_eq'._simp_1 | Std.Tactic.BVDecide.Normalize.Canonicalize | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂), x >>> y.toNat = x >>> y |
Language.toDFA | Mathlib.Computability.MyhillNerode | {α : Type u} → (L : Language α) → DFA α ↑(Set.range L.leftQuotient) |
Monoid.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {M : Type u} →
(mul : M → M → M) →
(∀ (a b c : M), a * b * c = a * (b * c)) →
(one : M) →
(∀ (a : M), 1 * a = a) →
(∀ (a : M), a * 1 = a) →
(npow : ℕ → M → M) →
autoParam (∀ (x : M), npow 0 x = 1) Monoid.npow_zero._autoParam →
autoParam (∀ (n : ℕ) (x : M), npow (n + 1) x = npow n x * x) Monoid.npow_succ._autoParam → Monoid M |
Lean.Parser.instInhabitedParserInfo.default | Lean.Parser.Types | Lean.Parser.ParserInfo |
Std.List.stream_drop_eq_drop | Batteries.Data.Stream | ∀ {α : Type u_1} {n : ℕ} (l : List α), Std.Stream.drop l n = List.drop n l |
Polynomial.eq_X_add_C_of_natDegree_le_one | Mathlib.Algebra.Polynomial.Degree.SmallDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
p.natDegree ≤ 1 → p = Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 0) |
Array.takeWhile_map | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : β → Bool} {as : Array α},
Array.takeWhile p (Array.map f as) = Array.map f (Array.takeWhile (p ∘ f) as) |
Std.ExtDTreeMap.self_le_maxKey!_insert | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, (cmp k (t.insert k v).maxKey!).isLE = true |
GromovHausdorff.instInhabitedGHSpace | Mathlib.Topology.MetricSpace.GromovHausdorff | Inhabited GromovHausdorff.GHSpace |
List.eraseIdx_eq_self | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {k : ℕ}, l.eraseIdx k = l ↔ l.length ≤ k |
neg_add_cancel_left | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), -a + (a + b) = b |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn_obj_zero._simp_1_12 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) |
CategoryTheory.over._auto_1 | Mathlib.CategoryTheory.Comma.Over.OverClass | Lean.Syntax |
IsClosedMap.codRestrict | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → ∀ {s : Set Y} (hs : ∀ (a : X), f a ∈ s), IsClosedMap (Set.codRestrict f s hs) |
Option.any_none | Init.Data.Option.Basic | ∀ {α : Type u_1} {p : α → Bool}, Option.any p none = false |
Lean.Elab.enableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → [Lean.Elab.MonadInfoTree m] → optParam Bool true → m Unit |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_46 | Mathlib.Combinatorics.SimpleGraph.Walks.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p₁ : G.Walk u v} (i : ℕ),
i - 1 + 1 ≤ p₁.support.tail.length → i - 1 < p₁.support.tail.length |
_private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.evalInv.match_3 | Mathlib.Algebra.Order.Field.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(a : Q(«$α»)) →
(motive : Mathlib.Meta.Positivity.Strictness zα pα a → Sort u_1) →
(ra : Mathlib.Meta.Positivity.Strictness zα pα a) →
((pa : Q(0 < «$a»)) → motive (Mathlib.Meta.Positivity.Strictness.positive pa)) →
((pa : Q(0 ≤ «$a»)) → motive (Mathlib.Meta.Positivity.Strictness.nonnegative pa)) →
((pa : Q(«$a» ≠ 0)) → motive (Mathlib.Meta.Positivity.Strictness.nonzero pa)) →
(Unit → motive Mathlib.Meta.Positivity.Strictness.none) → motive ra |
_private.Mathlib.CategoryTheory.FiberedCategory.BasedCategory.0.CategoryTheory.BasedNatTrans.instReflectsIsomorphismsBasedFunctorFunctorObjForgetful._simp_1 | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (S : 𝒮) {a b : 𝒳} (φ : a ⟶ b) [inst_2 : CategoryTheory.IsIso φ]
[p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ],
p.IsHomLift (CategoryTheory.CategoryStruct.id S) (CategoryTheory.inv φ) = True |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux.match_1_3 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
(S : RootPairing (↥LieSubalgebra.root) K (Module.Dual K ↥H) ↥H) (i j : ↥LieSubalgebra.root)
(motive : S.root i - S.root j ∈ Set.range ⇑S.root → Prop) (h : S.root i - S.root j ∈ Set.range ⇑S.root),
(∀ (idx : ↥LieSubalgebra.root) (hidx : S.root idx = S.root i - S.root j), motive ⋯) → motive h |
AdjoinRoot.mapAlgEquiv._proof_6 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_3} {S : Type u_2} {T : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (f : S ≃ₐ[R] T) (p : Polynomial S) (q : Polynomial T),
Associated (Polynomial.map (↑f) p) q → q ∣ Polynomial.map (↑f) p |
Associates.isUnit_iff_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : Associates M), IsUnit a ↔ a = 1 |
mul_lt_mul_of_neg_left | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] {a b c : R} [ExistsAddOfLE R] [PosMulStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R], b < a → c < 0 → c * a < c * b |
MonCat.Colimits.descFunLift.eq_3 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (x_1 y : MonCat.Colimits.Prequotient F),
MonCat.Colimits.descFunLift F s (x_1.mul y) = MonCat.Colimits.descFunLift F s x_1 * MonCat.Colimits.descFunLift F s y |
_private.Mathlib.Algebra.Group.Finsupp.0.Finsupp.addCommute_of_disjoint._simp_1_2 | Mathlib.Algebra.Group.Finsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, Disjoint s t = (s ∩ t = ∅) |
_private.Mathlib.Algebra.Category.CommAlgCat.Basic.0.CommAlgCat.mk._flat_ctor | Mathlib.Algebra.Category.CommAlgCat.Basic | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [commRing : CommRing carrier] → [algebra : Algebra R carrier] → CommAlgCat R |
CategoryTheory.Sieve.essSurjFullFunctorGaloisInsertion | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.EssSurj] →
[F.Full] →
(X : C) →
GaloisInsertion (CategoryTheory.Sieve.functorPushforward F) (CategoryTheory.Sieve.functorPullback F) |
extChartAt_target_eventuallyEq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x).target → (extChartAt I x).target =ᶠ[nhds z] Set.range ↑I |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.List.filter.match_1.eq_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.foldrM.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← Std.DHashMap.Internal.AssocList.foldrM f x es
f a b d |
Mathlib.Notation3.mkFoldlMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name →
Lean.Name →
Lean.Term →
Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) |
_private.Lean.Compiler.CSimpAttr.0.Lean.Compiler.CSimp.isConstantReplacement?._sparseCasesOn_1 | Lean.Compiler.CSimpAttr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
algebraMap_comp_natCast | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⇑(algebraMap R A) ∘ Nat.cast = Nat.cast |
ArchimedeanClass.stdPart_eq_sSup | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] (f : ℝ →+*o K) (x : K),
ArchimedeanClass.stdPart x = sSup {r | f r < x} |
Fintype.prod_empty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : Fintype ι] [inst_1 : CommMonoid M] [IsEmpty ι] (f : ι → M), ∏ x, f x = 1 |
CategoryTheory.Limits.WidePushout.head | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{B : C} →
{objs : J → C} →
(arrows : (j : J) → B ⟶ objs j) →
[inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] →
B ⟶ CategoryTheory.Limits.widePushout B objs arrows |
BooleanSubalgebra.mem_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {f : BoundedLatticeHom α β}
{a : α} {L : BooleanSubalgebra β}, a ∈ BooleanSubalgebra.comap f L ↔ f a ∈ L |
Std.TreeSet.get!_insertMany_list_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α}
{k : α}, k ∈ t → (t.insertMany l).get! k = t.get! k |
Int.gcd_sub_right_right_of_dvd | Init.Data.Int.Gcd | ∀ {n k : ℤ} (m : ℤ), n ∣ k → n.gcd (m - k) = n.gcd m |
Representation.coinvariantsToFinsupp._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_3} {G : Type u_4} {V : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (α : Type u_2) (x : G),
Finsupp.mapRange.linearMap (Representation.Coinvariants.mk ρ) ∘ₗ (ρ.finsupp α) x =
Finsupp.mapRange.linearMap (Representation.Coinvariants.mk ρ) |
Lean.Meta.coeDeclAttr._regBuiltin.Lean.Meta.coeDeclAttr.declRange_3 | Lean.Meta.Coe | IO Unit |
_private.Mathlib.MeasureTheory.Function.ConditionalLExpectation.0.MeasureTheory.measurable_condLExp'._simp_1_1 | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : Zero α],
Measurable 0 = True |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.exists_mem_of_isBasis._simp_1_8 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Subalgebra.algebraicClosure | Mathlib.RingTheory.Algebraic.Integral | (R : Type u_1) →
(S : Type u_2) → [inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → [IsDomain R] → Subalgebra R S |
Submodule.orthogonal_disjoint | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E), Disjoint K Kᗮ |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMultispan.functorExt.match_1.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (motive : CategoryTheory.Limits.WalkingMultispan J → Sort u_3) (i : J.L)
(h_1 : (i : J.L) → motive (CategoryTheory.Limits.WalkingMultispan.left i))
(h_2 : (i : J.R) → motive (CategoryTheory.Limits.WalkingMultispan.right i)),
(match CategoryTheory.Limits.WalkingMultispan.left i with
| CategoryTheory.Limits.WalkingMultispan.left i => h_1 i
| CategoryTheory.Limits.WalkingMultispan.right i => h_2 i) =
h_1 i |
CategoryTheory.ComposableArrows.homMk₅_app_three | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_441✝ ⟶ g.obj' 0 _proof_441✝¹) (app₁ : f.obj' 1 _proof_442✝ ⟶ g.obj' 1 _proof_442✝¹)
(app₂ : f.obj' 2 _proof_443✝ ⟶ g.obj' 2 _proof_443✝¹) (app₃ : f.obj' 3 _proof_444✝ ⟶ g.obj' 3 _proof_444✝¹)
(app₄ : f.obj' 4 _proof_445✝ ⟶ g.obj' 4 _proof_445✝¹) (app₅ : f.obj' 5 _proof_446✝ ⟶ g.obj' 5 _proof_446✝¹)
(w₀ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_442✝²)
app₁ =
CategoryTheory.CategoryStruct.comp app₀
(g.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_442✝³))
_auto_483✝)
(w₁ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 1 2 _proof_238✝ _proof_443✝²) app₂ =
CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 _proof_238✝¹ _proof_443✝³))
_auto_485✝)
(w₂ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 2 3 _proof_291✝ _proof_444✝²) app₃ =
CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 _proof_291✝¹ _proof_444✝³))
_auto_487✝)
(w₃ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 3 4 _proof_356✝ _proof_445✝²) app₄ =
CategoryTheory.CategoryStruct.comp app₃ (g.map' 3 4 _proof_356✝¹ _proof_445✝³))
_auto_489✝)
(w₄ :
autoParam
(CategoryTheory.CategoryStruct.comp (f.map' 4 5 _proof_445✝⁴ _proof_446✝²) app₅ =
CategoryTheory.CategoryStruct.comp app₄ (g.map' 4 5 _proof_445✝⁵ _proof_446✝³))
_auto_491✝),
(CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app
⟨3, CategoryTheory.ComposableArrows.homMk₅._proof_4⟩ =
app₃ |
BitVec.reverse.eq_1 | Init.Data.BitVec.Lemmas | ∀ (x_2 : BitVec 0), x_2.reverse = x_2 |
WithTop.coe_sInf._simp_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α},
s.Nonempty → BddBelow s → ⨅ a ∈ s, ↑a = ↑(sInf s) |
SemistandardYoungTableau.casesOn | Mathlib.Combinatorics.Young.SemistandardTableau | {μ : YoungDiagram} →
{motive : SemistandardYoungTableau μ → Sort u} →
(t : SemistandardYoungTableau μ) →
((entry : ℕ → ℕ → ℕ) →
(row_weak' : ∀ {i j1 j2 : ℕ}, j1 < j2 → (i, j2) ∈ μ → entry i j1 ≤ entry i j2) →
(col_strict' : ∀ {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → entry i1 j < entry i2 j) →
(zeros' : ∀ {i j : ℕ}, (i, j) ∉ μ → entry i j = 0) →
motive { entry := entry, row_weak' := row_weak', col_strict' := col_strict', zeros' := zeros' }) →
motive t |
Lean.Compiler.LCNF.SpecEntry.mk.sizeOf_spec | Lean.Compiler.LCNF.SpecInfo | ∀ (declName : Lean.Name) (paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo) (alreadySpecialized : Bool),
sizeOf { declName := declName, paramsInfo := paramsInfo, alreadySpecialized := alreadySpecialized } =
1 + sizeOf declName + sizeOf paramsInfo + sizeOf alreadySpecialized |
Real.sinh_eq_tsum | Mathlib.Analysis.SpecialFunctions.Trigonometric.Series | ∀ (r : ℝ), Real.sinh r = ∑' (n : ℕ), r ^ (2 * n + 1) / ↑(2 * n + 1).factorial |
CategoryTheory.MonoidalCategory.«term𝟙__» | Mathlib.CategoryTheory.Monoidal.Category | Lean.ParserDescr |
Turing.ListBlank.tail_cons | Mathlib.Computability.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ), (Turing.ListBlank.cons a l).tail = l |
ContinuousLinearMap.completion._proof_4 | Mathlib.Topology.Algebra.LinearMapCompletion | ∀ {α : Type u_1} {β : Type u_2} {R₁ : Type u_3} {R₂ : Type u_4} [inst : UniformSpace α] [inst_1 : AddCommGroup α]
[inst_2 : Semiring R₁] [inst_3 : Module R₁ α] [inst_4 : Semiring R₂] [inst_5 : UniformSpace β]
[inst_6 : AddCommGroup β] [inst_7 : Module R₂ β] {σ : R₁ →+* R₂} (f : α →SL[σ] β),
Continuous (UniformSpace.Completion.map ⇑(↑f).toAddMonoidHom) |
LinearGrowth.le_linearGrowthSup_iff | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {u : ℕ → EReal} {a : EReal}, a ≤ LinearGrowth.linearGrowthSup u ↔ ∀ b < a, ∃ᶠ (n : ℕ) in Filter.atTop, b * ↑n ≤ u n |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.discharge._default | Lean.Meta.Tactic.Backtrack | Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId)) |
_private.Std.Data.ExtTreeMap.Lemmas.0.Std.ExtTreeMap.alter_eq_empty_iff._simp_1_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t t' : Std.ExtTreeMap α β cmp}, (t = t') = (t.inner = t'.inner) |
_private.Mathlib.Control.Basic.0.map_seq._simp_1_1 | Mathlib.Control.Basic | ∀ {f : Type u → Type v} {inst : Applicative f} [self : LawfulApplicative f] {α β : Type u} (g : α → β) (x : f α),
g <$> x = pure g <*> x |
Numbering.prefixedEquiv._proof_14 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X), ∀ x ∉ s, x ∈ sᶜ |
Order.IsSuccLimit.sSup_Iio | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrderBot α] {x : α}, Order.IsSuccLimit x → sSup (Set.Iio x) = x |
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} →
{β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → β → Option (Std.Sat.Literal α) |
IsLocalizedModule.commonDenom | Mathlib.Algebra.Module.LocalizedModule.Int | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{M' : Type u_3} →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') → [IsLocalizedModule S f] → {ι : Type u_4} → Finset ι → (ι → M') → ↥S |
TensorPower.gMul._proof_4 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {i j : ℕ},
IsScalarTower R R (PiTensorProduct R fun i => M) |
AntivaryOn.empty | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
AntivaryOn f g ∅ |
CategoryTheory.Limits.initialMonoClass_of_coproductsDisjoint | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.BinaryCoproductsDisjoint C],
CategoryTheory.Limits.InitialMonoClass C |
DifferentiableOn.sub_iff_left._simp_2 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{s : Set E}, DifferentiableOn 𝕜 g s → DifferentiableOn 𝕜 (f - g) s = DifferentiableOn 𝕜 f s |
BitVec.noConfusionType | Init.Prelude | Sort u → {w : ℕ} → BitVec w → {w' : ℕ} → BitVec w' → Sort u |
SimpleGraph.IsCompleteBetween.disjoint | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {s t : Set V}, G.IsCompleteBetween s t → Disjoint s t |
BialgCat.category | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} → [inst : CommRing R] → CategoryTheory.Category.{v, max (v + 1) u} (BialgCat R) |
_private.Mathlib.Algebra.Ring.NonZeroDivisors.0.le_nonZeroDivisorsLeft_iff_isLeftRegular._simp_1_1 | Mathlib.Algebra.Ring.NonZeroDivisors | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T |
Fin.castLT_sub_nezero._proof_2 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i j : Fin n}, i < j → n - ↑i ≠ 0 |
norm_pow | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a ^ n‖ = ‖a‖ ^ n |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minKey?_eq_some_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b |
Lean.instHashableLevelMVarId.hash | Lean.Level | Lean.LevelMVarId → UInt64 |
AlgHomClass.toRingHomClass | Mathlib.Algebra.Algebra.Hom | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} {inst : CommSemiring R}
{inst_1 : Semiring A} {inst_2 : Semiring B} {inst_3 : Algebra R A} {inst_4 : Algebra R B} {inst_5 : FunLike F A B}
[self : AlgHomClass F R A B], RingHomClass F A B |
suggestSteps | Mathlib.Tactic.Widget.Calc | Array Lean.SubExpr.GoalsLocation →
Lean.Expr → CalcParams → Lean.MetaM (String × String × Option (String.Pos.Raw × String.Pos.Raw)) |
AffineSubspace.direction_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], ⊥.direction = ⊥ |
DerivedCategory.instPretriangulated._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomotopyCategory.subcategoryAcyclic C).trW.IsCompatibleWithTriangulation |
connectedComponentIn_mem_nhds | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {F : Set α} {x : α},
F ∈ nhds x → connectedComponentIn F x ∈ nhds x |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isPartial._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.RecKind → Sort u} →
(t : Lean.Elab.RecKind) → motive Lean.Elab.RecKind.partial → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
zpow_one_add | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℤ), a ^ (1 + n) = a * a ^ n |
Subbimodule.mk._proof_5 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsScalarTower R B M]
[inst_11 : SMulCommClass A B M] (p : AddSubmonoid M) (m : M) (z w : TensorProduct R A B),
(m ∈ ↑p → z • m ∈ ↑p) → (m ∈ ↑p → w • m ∈ ↑p) → m ∈ ↑p → (z + w) • m ∈ ↑p |
Absorbs.zero | Mathlib.Topology.Bornology.Absorbs | ∀ {M : Type u_1} {E : Type u_2} [inst : Bornology M] [inst_1 : Zero E] [inst_2 : SMulZeroClass M E] {s : Set E},
0 ∈ s → Absorbs M s 0 |
InformationTheory.klDiv_of_not_ac | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
¬μ.AbsolutelyContinuous ν → InformationTheory.klDiv μ ν = ⊤ |
MeasureTheory.Measure.haarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsMulLeftInvariant], MeasureTheory.Measure.haarMeasure K₀ = μ ↔ μ ↑K₀ = 1 |
FreeMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : Monoid M] (f : FreeMonoid α →* M), FreeMonoid.lift (⇑f ∘ FreeMonoid.of) = f |
Filter.tendsto_atTop_atBot_of_antitone | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone f → (∀ (b : β), ∃ a, f a ≤ b) → Filter.Tendsto f Filter.atTop Filter.atBot |
String.append_left_inj | Init.Data.String.Defs | ∀ {s₁ s₂ : String} (t : String), s₁ ++ t = s₂ ++ t ↔ s₁ = s₂ |
TwoUniqueSums.of_addOpposite | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u} [inst : Add G], TwoUniqueSums Gᵃᵒᵖ → TwoUniqueSums G |
CategoryTheory.Cat.HasLimits.limitConeX_str | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat),
(CategoryTheory.Cat.HasLimits.limitConeX F).str = inferInstance |
Lean.Meta.Grind.ParentSet.mk | Lean.Meta.Tactic.Grind.Types | List Lean.Expr → Lean.Meta.Grind.ParentSet |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.