name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.DidChangeWatchedFilesParams.mk.injEq | Lean.Data.Lsp.Workspace | ∀ (changes changes_1 : Array Lean.Lsp.FileEvent),
({ changes := changes } = { changes := changes_1 }) = (changes = changes_1) | null | true |
Lean.Omega.Int.add_le_zero_iff_le_neg | Init.Omega.Int | ∀ {a b : ℤ}, a + b ≤ 0 ↔ a ≤ -b | null | true |
_private.Init.Data.List.Basic.0.List.lengthTRAux.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → ℕ → Sort u_2) →
(x : List α) →
(x_1 : ℕ) →
((n : ℕ) → motive [] n) → ((head : α) → (as : List α) → (n : ℕ) → motive (head :: as) n) → motive x x_1 | null | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.below.noConfusion | Lean.Meta.IndPredBelow | {P : Sort u} →
{decl : Lean.LocalDecl} →
{indName : Lean.Name} →
{vars : Array Lean.FVarId} →
{decl' : Lean.LocalDecl} →
{indName' : Lean.Name} →
{vars' : Array Lean.FVarId} →
Lean.Meta.IndPredBelow.NewDecl.below✝ decl indName vars =
Lean.Meta.In... | null | false |
_private.Mathlib.Analysis.Complex.Periodic.0.Function.Periodic.qParam_ne_zero._simp_1_2 | Mathlib.Analysis.Complex.Periodic | ∀ (x : ℂ), (Complex.exp x = 0) = False | null | false |
Action.instConcreteCategoryHomSubtypeV._proof_7 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G]
{FV : V → V → Type u_5} {CV : V → Type u_4} [inst_2 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)]
[inst_3 : CategoryTheory.ConcreteCategory V FV] {X Y Z : Action V G} (x : X ⟶ Y) (x_1 : Y ⟶ Z) (x_2 : CV X.V),
(Catego... | null | false |
ENat.epow_zero | Mathlib.Data.ENat.Pow | ∀ {x : ℕ∞}, x ^ 0 = 1 | null | true |
SemiNormedGrp._sizeOf_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | SemiNormedGrp → ℕ | null | false |
Matrix.SpecialLinearGroup.coe_int_neg | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
[inst_3 : Fact (Even (Fintype.card n))] (g : Matrix.SpecialLinearGroup n ℤ),
(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) (-g) = -(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) g | null | true |
Filter.indicator_const_eventuallyEq | Mathlib.Order.Filter.IndicatorFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero β] {l : Filter α} {c : β},
c ≠ 0 → ∀ {s t : Set α}, ((s.indicator fun x => c) =ᶠ[l] t.indicator fun x => c) ↔ s =ᶠ[l] t | null | true |
Cardinal.mul_natCast_lt_mul_natCast._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n < b * ↑n) = (a < b) | null | false |
Subgroup.saturated_iff_npow | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : Monoid G] {H : Submonoid G}, H.PowSaturated ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H | **Alias** of `Submonoid.powSaturated_iff_npow`. | true |
ContinuousMapZero.instCanLift | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R], CanLift C(X, R) (ContinuousMapZero X R) toContinuousMap fun f => f 0 = 0 | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.builderParser.go._f | Std.Time.Format.Basic | {α : Type} →
Std.Time.FormatConfig →
(format : Std.Time.FormatString) →
List.below (motive := fun format => Std.Time.FormatType (Option α) format → Std.Internal.Parsec.String.Parser α)
format →
Std.Time.FormatType (Option α) format → Std.Internal.Parsec.String.Parser α | null | false |
List.find?_some._f | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {a : α} (x : List α)
(f : List.below (motive := fun x => List.find? p x = some a → p a = true) x), List.find? p x = some a → p a = true | null | false |
UpperSet.erase._proof_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : UpperSet α) (a : α), IsUpperSet (↑s \ ↑(LowerSet.Iic a)) | null | false |
List.drop.eq_2 | Init.Data.Array.GetLit | ∀ {α : Type u} (n : ℕ), List.drop n.succ [] = [] | null | true |
HVertexOperator.coeff._proof_5 | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_2} [inst : PartialOrder Γ] {R : Type u_1} {W : Type u_3} [inst_1 : CommRing R] [inst_2 : AddCommGroup W]
[inst_3 : Module R W], SMulCommClass R R (HahnModule Γ R W) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKey!_modify._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CategoryTheory.GrothendieckTopology.W_of_preservesSheafification | Mathlib.CategoryTheory.Sites.PreservesSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1}
{B : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_1} A] [inst_2 : CategoryTheory.Category.{v_2, u_2} B]
(F : CategoryTheory.Functor A B) [J.PreservesSheafification F] {P₁ P₂ : CategoryTheory.Fu... | null | true |
DFinsupp.instDecidableEq.match_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → DecidableEq (β i)] (f g : Π₀ (i : ι), β i)
(motive : (f.support = g.support ∧ ∀ i ∈ f.support, f i = g i) → Prop)
(x : f.support = g.support ∧ ∀ i ∈ f.support, f i = g i),
(∀ (h₁ : f.support = g.suppor... | null | false |
Int32.or_comm | Init.Data.SInt.Bitwise | ∀ (a b : Int32), a ||| b = b ||| a | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.isoMk₅._proof_5 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬2 + 1 ≤ 5 → False | null | false |
Flow.isSemiconjugacy_id_iff_eq | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} [inst : AddMonoid τ] [inst_1 : TopologicalSpace τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
[inst_3 : TopologicalSpace α] (ϕ ψ : Flow τ α), Flow.IsSemiconjugacy id ϕ ψ ↔ ϕ = ψ | The identity is a semiconjugacy from `ϕ` to `ψ` if and only if `ϕ` and `ψ` are equal. | true |
Std.DHashMap.Const.get_alter_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β} {h : k ∈ Std.DHashMap.Const.alter m k f},
Std.DHashMap.Const.get (Std.DHashMap.Const.alter m k f) k h = (f (Std.DHashMap.Const.get? m k)).get ⋯ | null | true |
_private.Mathlib.Data.Nat.Choose.Sum.0.Nat.sum_range_choose_halfway._proof_1_1 | Mathlib.Data.Nat.Choose.Sum | ∀ (m : ℕ), m + 1 ≤ 2 * m + 1 + 1 | null | false |
AlgebraicGeometry.Scheme.isLocallyArtinianScheme_Spec | Mathlib.AlgebraicGeometry.Artinian | ∀ {R : CommRingCat}, AlgebraicGeometry.IsLocallyArtinian (AlgebraicGeometry.Spec R) ↔ IsArtinianRing ↑R | A commutative ring `R` is Artinian if and only if `Spec R` is an Artinian scheme. | true |
Complex.sin.eq_1 | Mathlib.Analysis.Complex.Trigonometric | ∀ (z : ℂ), Complex.sin z = (Complex.exp (-z * Complex.I) - Complex.exp (z * Complex.I)) * Complex.I / 2 | null | true |
CategoryTheory.SimplicialObject.Augmented.w₀_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject.Augmented C} (f : X ⟶ Y)
{Z : C} (h : ((CategoryTheory.SimplicialObject.const C).obj Y.right).obj (Opposite.op { len := 0 }) ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.SimplicialObject.Augmented.drop... | The compatibility of a morphism with the augmentation, on 0-simplices | true |
InvolutiveNeg.recOn | Mathlib.Algebra.Group.Defs | {A : Type u_2} →
{motive : InvolutiveNeg A → Sort u} →
(t : InvolutiveNeg A) →
([toNeg : Neg A] → (neg_neg : ∀ (x : A), - -x = x) → motive { toNeg := toNeg, neg_neg := neg_neg }) → motive t | null | false |
Projectivization.lift_mk | Mathlib.LinearAlgebra.Projectivization.Basic | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {α : Type u_3}
(f : { v // v ≠ 0 } → α) (hf : ∀ (a b : { v // v ≠ 0 }) (t : K), ↑a = t • ↑b → f a = f b) (v : V) (hv : v ≠ 0),
Projectivization.lift f hf (Projectivization.mk K v hv) = f ⟨v, hv⟩ | null | true |
Nonneg.linearOrderedCommGroupWithZero._proof_5 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α], Nontrivial { x // 0 ≤ x } | null | false |
Polynomial.Splits.X._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R], Polynomial.X.Splits = True | null | false |
AlgCat.instMonoidalCategory | Mathlib.Algebra.Category.AlgCat.Monoidal | {R : Type u} → [inst : CommRing R] → CategoryTheory.MonoidalCategory (AlgCat R) | null | true |
contDiffOn_congr | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f f₁ : E → F} {n : WithTop ℕ∞}, (∀ x ∈ s, f₁ x = f x) → (ContDiffOn 𝕜 n f₁ s ↔ ContDiffOn 𝕜 n f s) | null | true |
Std.Rxo.Iterator.mk.noConfusion | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} →
{P : Sort u_1} →
{next : Option α} →
{upperBound : α} →
{next' : Option α} →
{upperBound' : α} →
{ next := next, upperBound := upperBound } = { next := next', upperBound := upperBound' } →
(next ≍ next' → upperBound ≍ upperBound' → P) → P | null | false |
translate_add' | Mathlib.Algebra.Group.Translate | ∀ {α : Type u_2} {G : Type u_5} [inst : AddCommGroup G] (a b : G) (f : G → α),
translate (a + b) f = translate b (translate a f) | See `translate_add` | true |
compHausToTop.createsLimits | Mathlib.Topology.Category.CompHaus.Basic | CategoryTheory.CreatesLimits compHausToTop | null | true |
_private.Mathlib.CategoryTheory.GradedObject.Unitor.0.CategoryTheory.GradedObject.mapBifunctor_triangle._simp_1_1 | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
HomologicalComplex.HomologySequence.snakeInput._proof_27 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.ShortComplex.π₃.PreservesZeroMorphisms | null | false |
Lean.Elab.Tactic.Conv.evalNestedTactic | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic | null | true |
SimpleGraph.Walk.nil_nil._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u : V}, SimpleGraph.Walk.nil.Nil = True | null | false |
CategoryTheory.Adjunction.corepresentableBy._proof_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (X : C) {Y Y' : D} (g : Y ⟶ Y') (f : F.obj X ⟶ Y),
(adj.homEquiv X Y') (CategoryTheory.CategoryStruct.comp f... | null | false |
Lean.Elab.Term.Do.Alt.noConfusionType | Lean.Elab.Do.Legacy | Sort u → {σ : Type} → Lean.Elab.Term.Do.Alt σ → {σ' : Type} → Lean.Elab.Term.Do.Alt σ' → Sort u | null | false |
RingHom.instMonoid._proof_1 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_1} {x : NonAssocSemiring α} (n : ℕ) (f : α →+* α), (⇑f)^[n] = ⇑(npowRec n f) | null | false |
Lean.Elab.Term.Do.ToTerm.returnToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Elab.Term.Do.ToTerm.M Lean.Syntax | null | true |
MeasureTheory.FiniteMeasure.normalize_eq_inv_mass_smul_of_nonzero | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : Nonempty Ω] {m0 : MeasurableSpace Ω} (μ : MeasureTheory.FiniteMeasure Ω),
μ ≠ 0 → μ.normalize.toFiniteMeasure = μ.mass⁻¹ • μ | null | true |
Nat.shiftLeft'.eq_1 | Mathlib.Data.Nat.Bits | ∀ (b : Bool) (m : ℕ), Nat.shiftLeft' b m 0 = m | null | true |
_private.Mathlib.RingTheory.Grassmannian.0.Module.Grassmannian.map._proof_3 | Mathlib.RingTheory.Grassmannian | ∀ {R : Type u_3} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {k : ℕ}
{A : Type u_1} [inst_3 : CommRing A] [inst_4 : Algebra R A] {B : Type u_1} [inst_5 : CommRing B]
[inst_6 : Algebra R B] (f : A →ₐ[R] B) (N : Module.Grassmannian A (TensorProduct R A M) k),
Module.Finite B (... | null | false |
QuadraticForm.isometryEquivWeightedSumSquares._proof_3 | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_1} [inst : Field K], SMulCommClass K K K | null | false |
Lean.PrettyPrinter.Formatter.Context | Lean.PrettyPrinter.Formatter | Type | null | true |
List.SortedLE.of_map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, l.SortedLE → (List.map (⇑OrderDual.toDual) l).SortedGE | **Alias** of the reverse direction of `List.sortedGE_map_toDual`. | true |
CategoryTheory.GrothendieckTopology.Point.skyscraperSheafFunctor | Mathlib.CategoryTheory.Sites.Point.Skyscraper | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
J.Point →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[CategoryTheory.Limits.HasProducts A] → CategoryTheory.Functor A (CategoryTheory.Sheaf J A) | Given a point `Φ` of a site `(C, J)`, this is the skyscraper sheaf functor
`A ⥤ Sheaf J A`. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput.recOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig) →
((w : ℕ) → (vec : aig.BinaryRefVec w) → (cin : aig.Ref... | null | false |
Finset.sum_singleton | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] (f : ι → M) (a : ι), ∑ x ∈ {a}, f x = f a | null | true |
CategoryTheory.ObjectProperty.IsSeparating.isDetecting | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.ObjectProperty C}
[CategoryTheory.Balanced C], P.IsSeparating → P.IsDetecting | null | true |
Nat.mul_le_add_right | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, k * m ≤ m + n ↔ (k - 1) * m ≤ n | null | true |
Std.DTreeMap.get?_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, (t₁ ∩ t₂).get? k = if k ∈ t₂ then t₁.get? k else none | null | true |
MeasureTheory.StronglyAdapted.integrable_upcrossingsBefore | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {a b : ℝ} {f : ℕ → Ω → ℝ} {N : ℕ}
{ℱ : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.StronglyAdapted ℱ f →
a < b → MeasureTheory.Integrable (fun ω => ↑(MeasureTheory.upcrossingsBefore a b f N ω)) μ | null | true |
_private.Mathlib.LinearAlgebra.SesquilinearForm.Basic.0.LinearMap.isOrtho_flip._simp_1_1 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_5} {M₁ : Type u_6} {M₂ : Type u_7} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : AddCommMonoid M₁] [inst_3 : Module R₁ M₁] [inst_4 : CommSemiring R₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₂ M₂] [inst_7 : AddCommMonoid M] [inst_8 : M... | null | false |
_private.Lean.Parser.Extension.0.Lean.Parser.addParserCategoryCore | Lean.Parser.Extension | Lean.Parser.ParserCategories → Lean.Name → Lean.Parser.ParserCategory → Except String Lean.Parser.ParserCategories | null | true |
Submodule.topEquiv | Mathlib.Algebra.Module.Submodule.Lattice | {R : Type u_1} → {M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → ↥⊤ ≃ₗ[R] M | The top submodule is linearly equivalent to the module.
This is the module version of `AddSubmonoid.topEquiv`. | true |
AddAction.block_stabilizerOrderIso.match_5 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ (G : Type u_2) [inst : AddGroup G] {X : Type u_1} [inst_1 : AddAction G X] (a : X)
(motive : { B // a ∈ B ∧ AddAction.IsBlock G B } → Prop) (x : { B // a ∈ B ∧ AddAction.IsBlock G B }),
(∀ (val : Set X) (ha : a ∈ val) (hB : AddAction.IsBlock G val), motive ⟨val, ⋯⟩) → motive x | null | false |
CategoryTheory.Mod.forget._proof_2 | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (A : C) [inst_4 : CategoryTheory.MonObj A]
{X Y Z : CategoryTheory.Mod D A} (... | null | false |
Lean.Lsp.DocumentSymbol.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{sym sym' : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol} →
Lean.Lsp.DocumentSymbol.mk sym = Lean.Lsp.DocumentSymbol.mk sym' → (sym = sym' → P) → P | null | false |
Fin.reverseInduction._proof_3 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : Fin (n + 1)), ↑i ≤ 0 → ¬↑i = 0 → False | null | false |
Filter.isBoundedUnder_const | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} [Std.Refl r] {l : Filter β} {a : α},
Filter.IsBoundedUnder r l fun x => a | null | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.isSorryAlt._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Split | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
IsOrderBornology.cobounded_le_atBot_sup_atTop | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} [inst : Bornology α] [Nonempty α] [inst_2 : LinearOrder α] [IsOrderBornology α],
Bornology.cobounded α ≤ Filter.atBot ⊔ Filter.atTop | null | true |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorRightObjFunctorFlipTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | null | true |
Std.DTreeMap.Internal.Impl.minKey?.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : α → Type v} (x : Std.DTreeMap.Internal.Impl α β),
x.minKey? =
match x with
| Std.DTreeMap.Internal.Impl.leaf => none
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r => some k
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.... | null | true |
WithTop.Ioc_coe_top | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a : α),
Finset.Ioc ↑a ⊤ = Finset.insertNone (Finset.Ioi a) | null | true |
_private.Mathlib.MeasureTheory.Group.Action.0.MeasureTheory.measure_isOpen_pos_of_vaddInvariant_of_compact_ne_zero.match_1_1 | Mathlib.MeasureTheory.Group.Action | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {K U : Set α}
(motive : (∃ I, K ⊆ ⋃ g ∈ I, g +ᵥ U) → Prop) (x : ∃ I, K ⊆ ⋃ g ∈ I, g +ᵥ U),
(∀ (t : Finset G) (ht : K ⊆ ⋃ g ∈ t, g +ᵥ U), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.CofanTypes | Mathlib.CategoryTheory.Limits.Types.Coproducts | {C : Type u} → (C → Type v) → Type (max (max u v) (w + 1)) | Given a functor `F : Discrete C ⥤ Type v`, this is a "cofan" for `F`,
but we allow the point to be in `Type w` for an arbitrary universe `w`. | true |
InfHom.top_apply | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : SemilatticeInf β] [inst_2 : Top β] (a : α), ⊤ a = ⊤ | null | true |
Std.Internal.UV.System.PasswdInfo._sizeOf_1 | Std.Internal.UV.System | Std.Internal.UV.System.PasswdInfo → ℕ | null | false |
CStarMatrix.conjTranspose_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Star A] (M : CStarMatrix m n A) (i : n) (j : m),
M.conjTranspose i j = star (M j i) | null | true |
CategoryTheory.MonoidalOpposite.unmopEquiv_functor_map | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ} (f : X ⟶ Y),
(CategoryTheory.MonoidalOpposite.unmopEquiv C).functor.map f = f.unmop | null | true |
CategoryTheory.Iso.retract | Mathlib.CategoryTheory.Retract | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ≅ Y) → CategoryTheory.Retract X Y | If `X` is isomorphic to `Y`, then `X` is a retract of `Y`. | true |
CategoryTheory.CostructuredArrow.costructuredArrowToOverEquivalence.functor._proof_3 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} T] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor D T) {X : T} (Y : CategoryTheory.Over X)
{X_1 Y_1 Z : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.toOver F X) Y} (f : X_1 ⟶ Y_1)
(g : Y_1... | null | false |
Qq.Impl.floatQMatch | Qq.Match | Lean.TSyntax `Lean.Parser.Term.doSeqIndent →
Lean.Term → StateT (List (Lean.TSyntax `Lean.Parser.Term.doSeqItem)) Lean.MacroM Lean.Term | null | true |
Asymptotics.«term_~[_]_» | Mathlib.Analysis.Asymptotics.Defs | Lean.TrailingParserDescr | Two functions `u` and `v` are said to be asymptotically equivalent along a filter `l`
(denoted as `u ~[l] v` in the `Asymptotics` namespace)
when `u x - v x = o(v x)` as `x` converges along `l`. | true |
Ordinal.small_Icc | Mathlib.SetTheory.Ordinal.Basic | ∀ (a b : Ordinal.{u}), Small.{u, u + 1} ↑(Set.Icc a b) | null | true |
Lean.instInhabitedNoConfusionInfo.default | Lean.AuxRecursor | Lean.NoConfusionInfo | null | true |
_private.Mathlib.Tactic.NormNum.Irrational.0.Tactic.NormNum.evalIrrationalRpow._proof_1 | Mathlib.Tactic.NormNum.Irrational | ∀ (gy : Q(ℕ)), «$gy» =Q 1 | null | false |
Rack.toEnvelGroup.map._proof_2 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G))
(x y : Rack.EnvelGroup R),
Quotient.liftOn (x * y) (Rack.toEnvelGroup.mapAux f) ⋯ =
Quotient.liftOn x (Rack.toEnvelGroup.mapAux f) ⋯ * Quotient.liftOn y (Rack.toEnvelGroup.mapAux f) ⋯ | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.ContDiff.div._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞}, ContDiff 𝕜 n f = ∀ (x : E), ContDiffAt 𝕜 n f x | null | false |
_private.Mathlib.Topology.UrysohnsLemma.0.Urysohns.CU.approx_le_one._simp_1_4 | Mathlib.Topology.UrysohnsLemma | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
MulAction.smul_zpow_movedBy_eq_of_commute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g h : G},
Commute g h → ∀ (j : ℤ), h ^ j • (MulAction.fixedBy α g)ᶜ = (MulAction.fixedBy α g)ᶜ | If `g` and `h` commute, then `g` moves `h ^ j • x` iff `g` moves `x`.
| true |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.Submonoid.pi_empty._simp_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι) {S : (i : ι) → Submonoid (M i)}
{p : (i : ι) → M i}, (p ∈ Submonoid.pi I S) = ∀ i ∈ I, p i ∈ S i | null | false |
Std.HashMap.ofList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {k : α} {v : β} {tl : List (α × β)},
Std.HashMap.ofList ((k, v) :: tl) = (∅.insert k v).insertMany tl | null | true |
continuousAt_iff_lower_upperSemicontinuousAt | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_4} [inst_1 : LinearOrder γ]
[inst_2 : TopologicalSpace γ] [OrderTopology γ] {f : α → γ},
ContinuousAt f x ↔ LowerSemicontinuousAt f x ∧ UpperSemicontinuousAt f x | null | true |
BoxIntegral.Box.ne_of_disjoint_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, Disjoint ↑I ↑J → I ≠ J | null | true |
Std.ToFormat.format | Init.Data.Format.Basic | {α : Type u} → [self : Std.ToFormat α] → α → Std.Format | Converts a value to a `Format` object, with no expectation that the resulting string is valid
code.
| true |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (lhs : Bool) (s : Lean.Grind.AC.Seq) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (c₂ : Lean.Meta.Grind.AC.DiseqCnstr),
sizeOf (Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac lhs s c₁ c₂) = 1 + sizeOf lhs + sizeOf s + sizeOf c₁ + sizeOf c₂ | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.atLeastTwo_eq_halfAdder | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | ∀ (lhsBit rhsBit carry : Bool), lhsBit.atLeastTwo rhsBit carry = ((lhsBit ^^ rhsBit) && carry || lhsBit && rhsBit) | null | true |
BoundedContinuousFunction.mem_charPoly | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : Module ℝ V] [inst_2 : TopologicalSpace V]
[inst_3 : AddCommGroup W] [inst_4 : Module ℝ W] [inst_5 : TopologicalSpace W] {e : AddChar ℝ Circle}
{L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ} {he : Continuous ⇑e} {hL : Continuous fun p => (L p.1) p.2}
(f : BoundedContinuou... | null | true |
OreLocalization.instSemiring._proof_2 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (n : ℕ),
(n + 1).unaryCast = n.unaryCast + 1 | null | false |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s t : Set α}, (¬s ⊆ t) = ∃ a ∈ s, a ∉ t | null | false |
MeasureTheory.Measure.pi_Ioc_ae_eq_pi_Icc | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), MeasureTheory.NoAtoms (μ i)] {s : Set ι} {f g : (i : ι) → α i},
(s.pi fun i... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.