name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
TopCat.GlueData.recOn | Mathlib.Topology.Gluing | {motive : TopCat.GlueData → Sort u} →
(t : TopCat.GlueData) →
((toGlueData : CategoryTheory.GlueData TopCat) →
(f_open :
∀ (i j : toGlueData.J),
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (toGlueData.f i j))) →
motive { toGlueData := toGlueData, f_open := f_open }) →
motive t | false |
NonUnitalSubringClass.toNonUnitalNonAssocRing._proof_2 | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : SetLike S R]
[hSR : NonUnitalSubringClass S R] (s : S) (a b c : ↥s), (a + b) * c = a * c + b * c | false |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanIso_two._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 2) = ∃ x y, s = {x, y} | false |
ModuleCat.instModuleCarrierMkOfSMul'._proof_3 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] {A : AddCommGrpCat} (φ : R →+* CategoryTheory.End A) (x x_1 : R)
(x_2 : ↑(ModuleCat.mkOfSMul' φ)), (x + x_1) • x_2 = x • x_2 + x_1 • x_2 | false |
GrpTypeEquivalenceGrp.functor | Mathlib.CategoryTheory.Monoidal.Internal.Types.Grp_ | CategoryTheory.Functor (CategoryTheory.Grp (Type u)) GrpCat | true |
Aesop.RuleTac.ofTacticSyntax | Aesop.RuleTac.Basic | (Aesop.RuleTacInput → Lean.MetaM Lean.Syntax.Tactic) → Aesop.RuleTac | true |
ZMod.val.eq_2 | Mathlib.Data.ZMod.Basic | ∀ (n : ℕ), ZMod.val = Fin.val | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState.recOn | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | {motive : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState✝ → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState✝¹) →
((hyps : Array Lean.Meta.Hypothesis) → (seen : Std.HashSet Lean.Expr) → motive { hyps := hyps, seen := seen }) →
motive t | false |
MeasureTheory.Integrable.aefinStronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Lp | ∀ {α : Type u_1} {G : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup G]
{f : α → G}, MeasureTheory.Integrable f μ → MeasureTheory.AEFinStronglyMeasurable f μ | true |
Subalgebra.map_topologicalClosure_le | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : IsSemitopologicalSemiring A] [inst_8 : IsSemitopologicalSemiring B] (f : A →A[R] B) (s : Subalgebra R A),
Subalgebra.map (↑f) s.topologicalClosure ≤ (Subalgebra.map f.toAlgHom s).topologicalClosure | true |
Int.gcd_dvd_gcd_mul_right_right | Init.Data.Int.Gcd | ∀ (a b c : ℤ), a.gcd b ∣ a.gcd (b * c) | true |
Plausible.Shrinkable.mk._flat_ctor | Plausible.Sampleable | {α : Type u} → (α → List α) → Plausible.Shrinkable α | false |
MeasureTheory.JordanDecomposition.instSMul | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | {α : Type u_1} → [inst : MeasurableSpace α] → SMul NNReal (MeasureTheory.JordanDecomposition α) | true |
Finset.sum_Ioc_by_parts | Mathlib.Algebra.BigOperators.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : ℕ → R) (g : ℕ → M)
{m n : ℕ},
m < n →
∑ i ∈ Finset.Ioc m n, f i • g i =
f n • ∑ i ∈ Finset.range (n + 1), g i - f (m + 1) • ∑ i ∈ Finset.range (m + 1), g i -
∑ i ∈ Finset.Ioc m (n - 1), (f (i + 1) - f i) • ∑ i ∈ Finset.range (i + 1), g i | true |
CompleteLinearOrder.toCompletelyDistribLattice | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → [CompleteLinearOrder α] → CompletelyDistribLattice α | true |
_private.Init.Data.Array.Lemmas.0.Array.all_eq_true_iff_forall_mem._simp_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u} {a : α} {as : Array α}, (a ∈ as) = (a ∈ as.toList) | false |
Lean.Meta.Tactic.TryThis.addSuggestion | Lean.Meta.Tactic.TryThis | Lean.Syntax →
Lean.Meta.Tactic.TryThis.Suggestion →
optParam (Option Lean.Syntax) none →
optParam String "Try this:" →
optParam (Option String) none →
optParam Lean.Meta.Hint.DiffGranularity Lean.Meta.Hint.DiffGranularity.none → Lean.CoreM Unit | true |
selfAdjointPart._proof_4 | Mathlib.Algebra.Star.Module | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (r : R) (x : A), ⟨⅟2 • (r • x + star (r • x)), ⋯⟩ = (RingHom.id R) r • ⟨⅟2 • (x + star x), ⋯⟩ | false |
Std.Rcc.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α] {pref suff : List α} {cur : α} (h : r.toList = pref ++ cur :: suff),
cur = (Std.PRange.succMany? pref.length r.lower).get ⋯ | true |
List.modify.eq_1 | Init.Data.List.Impl | ∀ {α : Type u} (l : List α) (i : ℕ) (f : α → α), l.modify i f = l.modifyTailIdx i (List.modifyHead f) | true |
HeytAlg.mk.noConfusion | Mathlib.Order.Category.HeytAlg | {P : Sort u} →
{carrier : Type u_1} →
{str : HeytingAlgebra carrier} →
{carrier' : Type u_1} →
{str' : HeytingAlgebra carrier'} →
{ carrier := carrier, str := str } = { carrier := carrier', str := str' } →
(carrier = carrier' → str ≍ str' → P) → P | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.one_lt_rpow._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {p : NNReal}, (1 < ↑p) = (1 < p) | false |
Equiv.Perm.IsThreeCycle.inv_iff | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {f : Equiv.Perm α}, f⁻¹.IsThreeCycle ↔ f.IsThreeCycle | true |
le_iff_exists_sup | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a ≤ b ↔ ∃ c, b = a ⊔ c | true |
Lean.Meta.Sym.MatchUnifyResult._sizeOf_inst | Lean.Meta.Sym.Pattern | SizeOf Lean.Meta.Sym.MatchUnifyResult | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.ValidFor.valid.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l r : List Char} (motive : (x : String.Legacy.Iterator) → String.Legacy.Iterator.ValidFor l r x → Prop)
(x : String.Legacy.Iterator) (x_1 : String.Legacy.Iterator.ValidFor l r x),
(∀ (a : Unit), motive { s := String.ofList (l.reverseAux r), i := { byteIdx := String.utf8Len l } } ⋯) → motive x x_1 | false |
Lean.Elab.Command.PreElabHeaderResult.mk.injEq | Lean.Elab.MutualInductive | ∀ (view : Lean.Elab.Command.InductiveView) (levelNames : List Lean.Name) (numParams : ℕ) (type : Lean.Expr)
(origParams : Array Lean.Expr) (view_1 : Lean.Elab.Command.InductiveView) (levelNames_1 : List Lean.Name)
(numParams_1 : ℕ) (type_1 : Lean.Expr) (origParams_1 : Array Lean.Expr),
({ view := view, levelNames := levelNames, numParams := numParams, type := type, origParams := origParams } =
{ view := view_1, levelNames := levelNames_1, numParams := numParams_1, type := type_1,
origParams := origParams_1 }) =
(view = view_1 ∧ levelNames = levelNames_1 ∧ numParams = numParams_1 ∧ type = type_1 ∧ origParams = origParams_1) | true |
WeakFEPair._sizeOf_inst | Mathlib.NumberTheory.LSeries.AbstractFuncEq | (E : Type u_1) → {inst : NormedAddCommGroup E} → {inst_1 : NormedSpace ℂ E} → [SizeOf E] → SizeOf (WeakFEPair E) | false |
Representation.IntertwiningMap.mk | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
{ρ : Representation A G V} →
{σ : Representation A G W} →
(toLinearMap : V →ₗ[A] W) →
(∀ (g : G), toLinearMap ∘ₗ ρ g = σ g ∘ₗ toLinearMap) → ρ.IntertwiningMap σ | true |
_private.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.0.Asymptotics.IsEquivalent.smul._simp_1_9 | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
Metric.Snowflaking.image_toSnowflaking_image_ofSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} (s : Set (Metric.Snowflaking X α hα₀ hα₁)),
⇑Metric.Snowflaking.toSnowflaking '' (⇑Metric.Snowflaking.ofSnowflaking '' s) = s | true |
Filter.lift_neBot_iff | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β},
Monotone g → ((f.lift g).NeBot ↔ ∀ s ∈ f, (g s).NeBot) | true |
MonadFinally.casesOn | Init.Control.Except | {m : Type u → Type v} →
{motive : MonadFinally m → Sort u_1} →
(t : MonadFinally m) →
((tryFinally' : {α β : Type u} → m α → (Option α → m β) → m (α × β)) → motive { tryFinally' := tryFinally' }) →
motive t | false |
Std.ExtDHashMap.insert.congr_simp | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtDHashMap α β), m = m_1 → ∀ (a : α) (b b_1 : β a), b = b_1 → m.insert a b = m_1.insert a b_1 | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.eq_singleton_iff_nonempty_unique_mem._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, s = {a} ↔ s.Nonempty ∧ ∀ x ∈ s, x = a | false |
_private.Init.Data.Slice.InternalLemmas.0.Std.Slice.Internal.size_eq_length_iter._simp_1_3 | Init.Data.Slice.InternalLemmas | ∀ {α β : Type w} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Std.IteratorLoop α Id Id]
[Std.LawfulIteratorLoop α Id Id] {it : Std.Iter β}, it.length = it.toList.length | false |
Batteries.RBNode.any | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Bool) → Batteries.RBNode α → Bool | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary._proof_14 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (guess : ℕ) (hg : guess < table.size),
table[guess - 1] < guess → guess - 1 < table.size | false |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.mem_jacobson_iff.match_1_5 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} {x : R} (y : R)
(motive : (∃ M, M.IsMaximal ∧ I ⊔ Ideal.span {y * x + 1} ≤ M) → Prop)
(x_1 : ∃ M, M.IsMaximal ∧ I ⊔ Ideal.span {y * x + 1} ≤ M),
(∀ (M : Ideal R) (hm1 : M.IsMaximal) (hm2 : I ⊔ Ideal.span {y * x + 1} ≤ M), motive ⋯) → motive x_1 | false |
Ideal.comap_idₐ | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (I : Ideal S),
Ideal.comap (AlgHom.id R S) I = I | true |
MeasureTheory.AEEqFun.coeFn_sup | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β]
[inst_2 : SemilatticeSup β] [inst_3 : ContinuousSup β] (f g : α →ₘ[μ] β), ↑(f ⊔ g) =ᵐ[μ] fun x => ↑f x ⊔ ↑g x | true |
USize.toNat_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, USize.size ≤ n → (USize.ofNatTruncate n).toNat = USize.size - 1 | true |
ZNum.cmp.match_1 | Mathlib.Data.Num.Basic | (motive : ZNum → ZNum → Sort u_1) →
(x x_1 : ZNum) →
(Unit → motive ZNum.zero ZNum.zero) →
((a b : PosNum) → motive (ZNum.pos a) (ZNum.pos b)) →
((a b : PosNum) → motive (ZNum.neg a) (ZNum.neg b)) →
((a : PosNum) → (x : ZNum) → motive (ZNum.pos a) x) →
((a : PosNum) → (x : ZNum) → motive (ZNum.neg a) x) →
((x : ZNum) → (a : PosNum) → motive x (ZNum.pos a)) →
((x : ZNum) → (a : PosNum) → motive x (ZNum.neg a)) → motive x x_1 | false |
Lean.Expr.mvar | Lean.Expr | Lean.MVarId → Lean.Expr | true |
Multiset.rec._proof_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_2} {C : Multiset α → Sort u_1} (C_cons : (a : α) → (m : Multiset α) → C m → C (a ::ₘ m)) {a : α}
{l l' : List α} {b : C ⟦l⟧} {b' : C ⟦l'⟧}, l.Perm l' → b ≍ b' → C_cons a ⟦l⟧ b ≍ C_cons a ⟦l'⟧ b' | false |
Lean.Meta.SimpTheorems | Lean.Meta.Tactic.Simp.SimpTheorems | Type | true |
DFA.casesOn | Mathlib.Computability.DFA | {α : Type u} →
{σ : Type v} →
{motive : DFA α σ → Sort u_1} →
(t : DFA α σ) →
((step : σ → α → σ) →
(start : σ) → (accept : Set σ) → motive { step := step, start := start, accept := accept }) →
motive t | false |
FreeAbelianGroup.lift_add_apply | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u} {G : Type u_1} [inst : AddCommGroup G] (f g : α → G) (a : FreeAbelianGroup α),
(FreeAbelianGroup.lift (f + g)) a = (FreeAbelianGroup.lift f) a + (FreeAbelianGroup.lift g) a | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg.match_1 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | (motive : Lean.BinderInfo → Sort u_1) →
(binderInfo : Lean.BinderInfo) →
(Unit → motive Lean.BinderInfo.instImplicit) →
(Unit → motive Lean.BinderInfo.implicit) →
(Unit → motive Lean.BinderInfo.strictImplicit) → (Unit → motive Lean.BinderInfo.default) → motive binderInfo | false |
Submodule.module'._proof_1 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) [inst_2 : Semiring S] [inst_3 : SMul S R] [inst_4 : Module S M] [inst_5 : IsScalarTower S R M]
(a : S), a • 0 = 0 | false |
_private.Lean.DocString.Markdown.0.Lean.Doc.trimLeft.go.match_1 | Lean.DocString.Markdown | {i : Type u_1} →
(motive : String × Lean.Doc.Inline i → Sort u_2) →
(x : String × Lean.Doc.Inline i) → ((pre : String) → (post : Lean.Doc.Inline i) → motive (pre, post)) → motive x | false |
Matrix.toBilin_comp | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} {o : Type u_6} [inst_3 : Fintype n] [inst_4 : Fintype o] [inst_5 : DecidableEq n]
(b : Module.Basis n R₁ M₁) {M₂' : Type u_7} [inst_6 : AddCommMonoid M₂'] [inst_7 : Module R₁ M₂']
(c : Module.Basis o R₁ M₂') [inst_8 : DecidableEq o] (M : Matrix n n R₁) (P Q : Matrix n o R₁),
((Matrix.toBilin b) M).comp ((Matrix.toLin c b) P) ((Matrix.toLin c b) Q) = (Matrix.toBilin c) (P.transpose * M * Q) | true |
CategoryTheory.Functor.obj.instComonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D] (A : C)
[inst_4 : CategoryTheory.ComonObj A] (F : CategoryTheory.Functor C D) [inst_5 : F.OplaxMonoidal],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.δ F A A))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj A)
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.δ F A A))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.δ F A A))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.comp (F.map CategoryTheory.ComonObj.comul)
(CategoryTheory.Functor.OplaxMonoidal.δ F A A))
(F.obj A))
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj A) (F.obj A) (F.obj A)).hom) | false |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult.casesOn | Lean.Meta.Sym.Simp.Have | {motive : Lean.Meta.Sym.Simp.SimpHaveResult✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.SimpHaveResult✝¹) →
((result : Lean.Meta.Sym.Simp.Result) →
(α : Lean.Expr) → (u : Lean.Level) → motive { result := result, α := α, u := u }) →
motive t | false |
Fintype.expect_equiv | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : AddCommMonoid M]
[inst_3 : Module ℚ≥0 M] (e : ι ≃ κ) (f : ι → M) (g : κ → M),
(∀ (i : ι), f i = g (e i)) → (Finset.univ.expect fun i => f i) = Finset.univ.expect fun i => g i | true |
Turing.PartrecToTM2.Cont'.halt.elim | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Cont' → Sort u} →
(t : Turing.PartrecToTM2.Cont') → t.ctorIdx = 0 → motive Turing.PartrecToTM2.Cont'.halt → motive t | false |
Except.emoji | Batteries.Lean.Except | {ε : Type u_1} → {α : Type u_2} → Except ε α → String | true |
Subring.coe_prod | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (s : Subring R) (t : Subring S),
↑(s.prod t) = ↑s ×ˢ ↑t | true |
ZMod.val.eq_1 | Mathlib.Data.ZMod.Basic | ZMod.val = Int.natAbs | true |
_private.Mathlib.Util.SleepHeartbeats.0._aux_Mathlib_Util_SleepHeartbeats___elabRules_tacticSleep_heartbeats__1.match_1 | Mathlib.Util.SleepHeartbeats | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → (Unit → motive none) → ((m : ℕ) → motive (some m)) → motive x | false |
StarAlgebra.elemental.instCompleteSpaceSubtypeMemStarSubalgebra | Mathlib.Topology.Algebra.StarSubalgebra | ∀ (R : Type u_1) [inst : CommSemiring R] [inst_1 : StarRing R] {A : Type u_4} [inst_2 : UniformSpace A]
[CompleteSpace A] [inst_4 : Semiring A] [inst_5 : StarRing A] [inst_6 : IsSemitopologicalSemiring A]
[inst_7 : ContinuousStar A] [inst_8 : Algebra R A] [inst_9 : StarModule R A] (x : A),
CompleteSpace ↥(StarAlgebra.elemental R x) | true |
QuasiErgodic.smul_measure | Mathlib.Dynamics.Ergodic.Ergodic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → α} {μ : MeasureTheory.Measure α} {R : Type u_2}
[inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal],
QuasiErgodic f μ → ∀ (c : R), QuasiErgodic f (c • μ) | true |
SkewMonoidAlgebra.coeff_one_one | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : One G] [inst_1 : AddMonoidWithOne k], SkewMonoidAlgebra.coeff 1 1 = 1 | true |
Std.ExtDTreeMap.Const.contains_alter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k k' : α} {f : Option β → Option β},
(Std.ExtDTreeMap.Const.alter t k f).contains k' =
if cmp k k' = Ordering.eq then (f (Std.ExtDTreeMap.Const.get? t k)).isSome else t.contains k' | true |
ContinuousLinearEquiv.map_nhds_eq | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
[inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂) (x : M₁), Filter.map (⇑e) (nhds x) = nhds (e x) | true |
Matrix.PosDef.posDef_sqrt | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Matrix n n 𝕜},
M.PosDef → (CFC.sqrt M).PosDef | true |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.casesMatch.mkMotiveAndRefls | Lean.Meta.Tactic.Grind.CasesMatch | Lean.MVarId → Lean.Expr → Lean.Meta.MatcherApp → Lean.MetaM (Lean.Expr × Array Lean.Expr) | true |
Set.monotone_mem._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, (Monotone fun x => x ∈ s) = IsUpperSet s | false |
Nat.or_mod_two_pow | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b n : ℕ}, (a ||| b) % 2 ^ n = a % 2 ^ n ||| b % 2 ^ n | true |
Nat.log_eq_iff | Mathlib.Data.Nat.Log | ∀ {b m n : ℕ}, m ≠ 0 ∨ 1 < b ∧ n ≠ 0 → (Nat.log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)) | true |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_ne_zero_of_eq_nat._simp_1_1 | Mathlib.Algebra.Lie.Sl2 | ∀ {α : Type u} [inst : AddCommMonoid α] [Subsingleton (AddUnits α)] {a b : α}, (a + b = 0) = (a = 0 ∧ b = 0) | false |
SeparationQuotient.instCommGroup._proof_9 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : CommGroup G] [inst_2 : IsTopologicalGroup G] (x : G) (n : ℤ),
SeparationQuotient.mk (x ^ n) = SeparationQuotient.mk x ^ n | false |
isNilpotent_iff_zero_mem_powers | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : Zero R] {x : R}, IsNilpotent x ↔ 0 ∈ Submonoid.powers x | true |
Lean.Grind.OrderedRing.mul_pos | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPreorder R]
[Lean.Grind.OrderedRing R] {a b : R}, 0 < a → 0 < b → 0 < a * b | true |
false_of_ne | Init.Core | ∀ {α : Sort u} {a : α}, a ≠ a → False | true |
TopCat.GlueData._sizeOf_1 | Mathlib.Topology.Gluing | TopCat.GlueData → ℕ | false |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.rightDistributor_assoc._simp_1_2 | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y Z : C}
(f : W ⟶ X) (g : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom f (CategoryTheory.CategoryStruct.id Z))
(CategoryTheory.MonoidalCategoryStruct.tensorHom g (CategoryTheory.CategoryStruct.id Z)) =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.comp f g)
(CategoryTheory.CategoryStruct.id Z) | false |
hasFDerivAt_iff_tendsto | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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 : E → F}
{f' : E →L[𝕜] F} {x : E},
HasFDerivAt f f' x ↔ Filter.Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) (nhds x) (nhds 0) | true |
CategoryTheory.Limits.ReflectsFilteredColimits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | true |
Aesop.Strategy.noConfusion | Aesop.Options.Public | {P : Sort v✝} → {x y : Aesop.Strategy} → x = y → Aesop.Strategy.noConfusionType P x y | false |
SymmetricPower.mk._proof_2 | Mathlib.LinearAlgebra.TensorPower.Symmetric | ∀ (R ι : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : R)
(x_1 : PiTensorProduct R fun x => M),
(↑(addConGen (SymmetricPower.Rel R ι M)).mk').toFun (x • x_1) =
(↑(addConGen (SymmetricPower.Rel R ι M)).mk').toFun (x • x_1) | false |
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.GrindCnstr.isValue.formatter_7 | Lean.Meta.Tactic.Grind.Parser | IO Unit | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.resRec_of_clz_le._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w} {y : BitVec w}, 1 < w → ¬w - 1 - y.clz.toNat ≤ w - 1 → False | false |
CategoryTheory.GradedObject.total | Mathlib.CategoryTheory.GradedObject | (β : Type) →
(C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasCoproducts C] → CategoryTheory.Functor (CategoryTheory.GradedObject β C) C | true |
CategoryTheory.Limits.colimit.pre | 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] →
(F : CategoryTheory.Functor J C) →
[inst_3 : CategoryTheory.Limits.HasColimit F] →
(E : CategoryTheory.Functor K J) →
[inst_4 : CategoryTheory.Limits.HasColimit (E.comp F)] →
CategoryTheory.Limits.colimit (E.comp F) ⟶ CategoryTheory.Limits.colimit F | true |
Std.Time.OffsetX.hourMinute.elim | Std.Time.Format.Basic | {motive : Std.Time.OffsetX → Sort u} →
(t : Std.Time.OffsetX) → t.ctorIdx = 1 → motive Std.Time.OffsetX.hourMinute → motive t | false |
Rat.toNNRat_le_toNNRat_iff._simp_1 | Mathlib.Data.NNRat.Defs | ∀ {p q : ℚ}, 0 ≤ p → (q.toNNRat ≤ p.toNNRat) = (q ≤ p) | false |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy._simp_12 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {r t : ℕ} {v w : Fin r × Fin t}, (SimpleGraph.completeEquipartiteGraph r t).Adj v w = (v.1 ≠ w.1) | false |
HomotopicalAlgebra.PathObject.instIsCofibrantPOfIsVeryGood | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.PathObject A)
[inst_2 : HomotopicalAlgebra.CategoryWithFibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithCofibrations C]
[(HomotopicalAlgebra.cofibrations C).IsStableUnderComposition] [inst_5 : CategoryTheory.Limits.HasBinaryProduct A A]
[inst_6 : CategoryTheory.Limits.HasInitial C] [HomotopicalAlgebra.IsCofibrant A] [P.IsVeryGood],
HomotopicalAlgebra.IsCofibrant P.P | true |
MLList.thunk | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → (Unit → MLList m α) → MLList m α | true |
Std.ExtDTreeMap.Const.get?_insertMany_list.match_1 | Std.Data.ExtDTreeMap.Lemmas | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | false |
Int32.toNatClampNeg_ofNat_of_lt | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2 ^ 31 → (Int32.ofNat n).toNatClampNeg = n | true |
Std.DTreeMap.Internal.Impl.insertMany._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β),
t.Balanced → ∀ (r : t.IteratedInsertionInto), (↑r).Balanced | false |
IsGalois.of_card_aut_eq_finrank | Mathlib.FieldTheory.Galois.Basic | ∀ (F : Type u_1) [inst : Field F] (E : Type u_2) [inst_1 : Field E] [inst_2 : Algebra F E] [FiniteDimensional F E],
Nat.card Gal(E/F) = Module.finrank F E → IsGalois F E | true |
Ideal.rootsOfUnityMapQuot._proof_2 | Mathlib.NumberTheory.NumberField.Ideal.Basic | ∀ {K : Type u_1} [inst : Field K] (I : Ideal (NumberField.RingOfIntegers K)), I.IsTwoSided | false |
Finset.empty_covBy_singleton._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} (a : α), (∅ ⋖ {a}) = True | false |
Polynomial.aroots_C_mul | Mathlib.Algebra.Polynomial.Roots | ∀ {S : Type v} {T : Type w} [inst : CommRing T] [IsDomain T] [inst_2 : CommRing S] [inst_3 : IsDomain S]
[inst_4 : Algebra T S] [Module.IsTorsionFree T S] {a : T} (p : Polynomial T),
a ≠ 0 → (Polynomial.C a * p).aroots S = p.aroots S | true |
Mathlib.Tactic.Ring.evalPowNat._unsafe_rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{a : Q(«$α»)} →
Mathlib.Tactic.Ring.ExSum sα a →
(n : Q(ℕ)) → Lean.MetaM (Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(«$a» ^ «$n»)) | false |
_private.Init.Data.Array.OfFn.0.Array.ofFn.go.eq_2 | Init.Data.Array.OfFn | ∀ {α : Type u} {n : ℕ} (f : Fin n → α) (acc : Array α) (x_2 : 0 ≤ n), Array.ofFn.go✝ f acc 0 x_2 = acc | true |
BotHom.dual_id | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} [inst : LE α] [inst_1 : OrderBot α], BotHom.dual (BotHom.id α) = TopHom.id αᵒᵈ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.