name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 →
optParam Lean.MessageData Lean.MessageData.nil → ... | Add a "try this" suggestion. This has two effects:
* A widget diagnostic is displayed, saying `Try this: <suggestion>` with a link on `<suggestion>`
to apply the suggestion
* A code action is added, which will apply the suggestion.
The parameters are:
* `ref`: the span of the widget diagnostic
* `s`: a `Suggestion`... | 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), ⋯⟩ | null | 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),
cu... | null | true |
LinearMap.BilinForm.Isometry.instSubsingleton | Mathlib.LinearAlgebra.BilinearForm.Isometry | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {B₁ : LinearMap.BilinForm R M₁}
{B₂ : LinearMap.BilinForm R M₂} [Subsingleton M₂], Subsingleton (B₁ →bᵢ B₂) | Maps into the zero module are trivial | 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) | null | 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 | null | 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) | null | 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 | null | true |
CategoryTheory.IsIso.hom_inv_id_map | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [I : CategoryTheory.IsIso f]
{D : Type u_1} [_instD : CategoryTheory.Category.{u_2, u_1} D] (F : CategoryTheory.Functor C D),
CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.inv f)) =
CategoryTheory.CategoryStruct... | null | true |
le_iff_exists_sup | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, a ≤ b ↔ ∃ c, b = a ⊔ c | null | true |
Lean.Meta.Sym.MatchUnifyResult._sizeOf_inst | Lean.Meta.Sym.Pattern | SizeOf Lean.Meta.Sym.MatchUnifyResult | null | 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),
(∀ (_ : Unit), motive { s := String.ofList (l.reverseAux r), i := { byteIdx := String.utf8Len l } } ⋯) → motive x x_1 | null | 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... | null | true |
WeakFEPair._sizeOf_inst | Mathlib.NumberTheory.LSeries.AbstractFuncEq | (E : Type u_1) → {inst : NormedAddCommGroup E} → {inst_1 : NormedSpace ℂ E} → [SizeOf E] → SizeOf (WeakFEPair E) | null | 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] →
... | null | 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 | null | 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 | null | 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) | null | 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 | null | 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 | null | 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 | null | 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 | null | false |
RBTree.RBNode.All.reverse | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {p : α → Prop} {t : RBTree.RBNode α}, RBTree.RBNode.All p t.reverse ↔ RBTree.RBNode.All p t | null | true |
_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 | null | false |
_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 | null | 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 | null | 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 | null | true |
USize.toNat_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, USize.size ≤ n → (USize.ofNatClamp n).toNat = USize.size - 1 | null | true |
IsCoprime.mul_sub_right_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y z : R}, IsCoprime (z * y - x) y ↔ IsCoprime x y | null | 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... | null | false |
Convexity.IsAffineMap.const_smul | Mathlib.Geometry.Convex.ConvexSpace.Module | ∀ {R : Type u_2} {N : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Convexity.ConvexSpace R N]
[Convexity.IsModuleConvexSpace R N] {X : Type u_6} [inst_7 : Convexity.ConvexSpace R X] {f : X → N} {M : Type u_7}
[i... | null | true |
Lean.Expr.mvar | Lean.Expr | Lean.MVarId → Lean.Expr | Metavariables are used to represent "holes" in expressions, and goals in the
tactic framework. Metavariable declarations are stored in the `MetavarContext`.
Metavariables are used during elaboration, and are not allowed in the kernel,
or in the code generator.
| 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' | null | false |
Cardinal.preAleph_symm_univ | Mathlib.SetTheory.Cardinal.Regular | Cardinal.preAleph.symm Cardinal.univ.{u, v} = Ordinal.univ.{u, v} | null | true |
AdicCompletion.map._proof_11 | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
Lean.Meta.SimpTheorems | Lean.Meta.Tactic.Simp.SimpTheorems | Type | The theorems in a simp set.
| true |
Std.Async.MaybeTask.joinTask | Std.Async.Basic | {α : Type} → Task (Std.Async.MaybeTask α) → Task α | Join the `MaybeTask` to an `Task`.
| true |
CategoryTheory.Types.instIsLocallyPresentableType | Mathlib.CategoryTheory.Presentable.Type | CategoryTheory.IsLocallyPresentable.{u, u, u + 1} (Type u) | null | 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 | null | 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 | null | 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 | null | 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 | null | 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 | null | 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 : Mod... | null | 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.OplaxMonoi... | null | false |
Fintype.expect_equiv | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_4} [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 | `Fintype.expect_equiv` is a specialization of `Finset.expect_bij` that automatically fills in
most arguments.
See `Equiv.expect_comp` for a version without `h`. | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.liftOption.match_1 | Std.Http.Protocol.H1.Parser | {α : Type} →
(motive : Option α → Sort u_1) →
(x : Option α) → ((res : α) → motive (some res)) → ((x : Option α) → motive x) → motive x | null | false |
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 | null | false |
Except.emoji | Batteries.Data.Except | {ε : Type u_1} → {α : Type u_2} → Except ε α → String | Visualize an `Except` using a checkmark or a cross. | true |
MeasureTheory.Measure.measure_compl_support_of_regular | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.Regular],
μ μ.supportᶜ = 0 | A regular measure has conull support. | 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 | null | true |
ZMod.val.eq_1 | Mathlib.Data.ZMod.Basic | ZMod.val = Int.natAbs | null | 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 | null | 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 ↥(StarAlg... | null | 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 • μ) | null | 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 | null | 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' | null | true |
ContinuousLinearEquiv.map_nhds_eq | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {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 : Ad... | null | 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) | null | true |
Set.monotone_mem._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, (Monotone fun x => x ∈ s) = IsUpperSet s | null | false |
Nat.or_mod_two_pow | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b n : ℕ}, (a ||| b) % 2 ^ n = a % 2 ^ n ||| b % 2 ^ n | null | 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)) | null | true |
CategoryTheory.FilteredObject.instIsStrictHomId | Mathlib.CategoryTheory.Filtration.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type u_1} [inst_1 : CategoryTheory.Category.{u_2, u_1} I]
(F : CategoryTheory.FilteredObject C I),
CategoryTheory.FilteredObject.IsStrictHom (CategoryTheory.CategoryStruct.id F) | null | 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 : AddMonoid α] [IsDedekindFiniteAddMonoid α] [Subsingleton (AddUnits α)] {a b : α},
(a + b = 0) = (a = 0 ∧ b = 0) | null | false |
isNilpotent_iff_zero_mem_powers | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ {R : Type u_1} {x : R} [inst : Monoid R] [inst_1 : Zero R], IsNilpotent x ↔ 0 ∈ Submonoid.powers x | null | 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 | null | true |
false_of_ne | Init.Core | ∀ {α : Sort u} {a : α}, a ≠ a → False | null | true |
TopCat.GlueData._sizeOf_1 | Mathlib.Topology.Gluing | TopCat.GlueData → ℕ | null | 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.... | null | 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... | null | 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 | A functor is said to reflect filtered colimits, if it reflects all colimits of shape `J`, where
`J` is a filtered category which is small relative to the universe in which morphisms of the source
live.
| true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.dbgTrace._regBuiltin.Lean.Parser.Term.dbgTrace.formatter_9 | Lean.Parser.Term | IO Unit | null | false |
Aesop.Strategy.noConfusion | Aesop.Options.Public | {P : Sort v✝} → {x y : Aesop.Strategy} → x = y → Aesop.Strategy.noConfusionType P x y | null | 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) | null | 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 | null | 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 | The total object of a graded object is the coproduct of the graded components.
| 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... | The canonical morphism from the colimit of `E ⋙ F` to the colimit of `F`. | true |
Std.Time.OffsetX.hourMinute.elim | Std.Time.Format.Modifier | {motive : Std.Time.OffsetX → Sort u} →
(t : Std.Time.OffsetX) → t.ctorIdx = 1 → motive Std.Time.OffsetX.hourMinute → motive t | null | false |
Rat.toNNRat_le_toNNRat_iff._simp_1 | Mathlib.Data.NNRat.Defs | ∀ {p q : ℚ}, 0 ≤ p → (q.toNNRat ≤ p.toNNRat) = (q ≤ p) | null | false |
SSet.Truncated.FundamentalGroupoid.mk.injEq | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | ∀ {X : SSet.Truncated 2}
(pt pt_1 : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.FundamentalGroupoid._proof_1 })),
({ pt := pt } = { pt := pt_1 }) = (pt = pt_1) | null | true |
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) | null | 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).I... | null | true |
MLList.thunk | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {α : Type u_1} → (Unit → MLList m α) → MLList m α | Embed a non-monadic thunk as a lazy list. | 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 | null | false |
Int32.toNatClampNeg_ofNat_of_lt | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2 ^ 31 → (Int32.ofNat n).toNatClampNeg = n | null | 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 → ∀ (__s : t.IteratedInsertionInto), (↑__s).Balanced | null | 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 | Let $E / F$ be a finite extension of fields. If $|\text{Aut}(E/F)| = [E : F]$, then
$E$ is Galois over $F$. | true |
Ideal.rootsOfUnityMapQuot._proof_2 | Mathlib.NumberTheory.NumberField.Ideal.Basic | ∀ {K : Type u_1} [inst : Field K] (I : Ideal (NumberField.RingOfIntegers K)), I.IsTwoSided | null | false |
Finset.empty_covBy_singleton._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} (a : α), (∅ ⋖ {a}) = True | null | 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 | null | true |
BotHom.dual_id | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} [inst : LE α] [inst_1 : OrderBot α], BotHom.dual (BotHom.id α) = TopHom.id αᵒᵈ | null | true |
_private.Mathlib.SetTheory.ZFC.Cardinal.0.ZFSet.card_insert._simp_1_1 | Mathlib.SetTheory.ZFC.Cardinal | ∀ {x : ZFSet.{u}}, Cardinal.lift.{u + 1, u} x.card = Cardinal.mk ↥x | null | false |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_add_right_lt | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LT α] [DenselyOrdered α] [AddLeftStrictMono α] {a b c : α},
a + b < c → ∃ b' > b, a + b' < c | null | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.Recv.response.inj | Std.Http.Server.Connection | ∀ {β : Type} {x x_1 : Except IO.Error (Std.Http.Response β)},
Std.Http.Server.Connection.Recv.response✝ x = Std.Http.Server.Connection.Recv.response✝ x_1 → x = x_1 | null | true |
Tilt.instField._proof_63 | Mathlib.RingTheory.Perfection | ∀ (K : Type u_1) [inst : Field K] (v : Valuation K NNReal) (O : Type u_2) [inst_1 : CommRing O] [inst_2 : Algebra O K]
(hv : v.Integers O) (p : ℕ) [inst_3 : Fact (Nat.Prime p)] [hvp : Fact (v ↑p ≠ 1)] (this : Fact ¬IsUnit ↑p)
(this_1 : IsDomain (PreTilt O p)) (a : Tilt K v O hv p), a ≠ 0 → a * a⁻¹ = 1 | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.toReal_add_of_sign_pos_sign_neg._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ ψ : Real.Angle}, θ.sign = 1 → ψ.sign = -1 → -Real.pi < θ.toReal + ψ.toReal ∧ θ.toReal + ψ.toReal ≤ Real.pi | null | false |
CategoryTheory.Functor.map_inv_hom'_assoc | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ≅ Y) {Z : D} (h : F.obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map f.inv) (CategoryTheory.CategoryStruct.comp (F.map f.hom) h) = h | null | true |
LightProfinite.instWEqualsLocallyBijectiveCoherentTopology | Mathlib.Condensed.Light.Instances | ∀ (A : Type u') [inst : CategoryTheory.Category.{u, u'} A] [CategoryTheory.Limits.HasLimits A]
[CategoryTheory.Limits.HasColimits A] {FA : A → A → Type v} {CA : A → Type u}
[inst_3 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_4 : CategoryTheory.ConcreteCategory A FA]
[CategoryTheory.Limits.PreservesFiltere... | null | true |
CategoryTheory.Functor.mapConeInv.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D)
{F : CategoryTheory.Functor J C} [inst_3 : H.IsEquivalence] (c : CategoryTheory.Limits.Cone (F.comp H))... | null | true |
ball_add_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (s : Set E), Metric.ball 0 δ + s = Metric.thickening δ s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.