name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.Calculus.FDeriv.Const.0.differentiableAt_of_fderiv_injective._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F}, fderiv 𝕜 f = fderivWithin 𝕜 f Set.univ | null | false |
Lean.Meta.Grind.Order.instInhabitedCnstr | Lean.Meta.Tactic.Grind.Order.Types | {a : Type} → [Inhabited a] → Inhabited (Lean.Meta.Grind.Order.Cnstr a) | null | true |
AlgebraicGeometry.Scheme.residueFieldCongr | Mathlib.AlgebraicGeometry.ResidueField | {X : AlgebraicGeometry.Scheme} → {x y : ↥X} → x = y → (X.residueField x ≅ X.residueField y) | The isomorphism between residue fields of equal points. | true |
CategoryTheory.MorphismProperty.HasLocalization.noConfusionType | Mathlib.CategoryTheory.Localization.HasLocalization | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
W.HasLocalization →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{W' : CategoryTheory.MorphismProperty C'} → W'.HasLocalization → Sort ... | null | false |
Lean.Server.MonadCancellable.noConfusionType | Lean.Server.RequestCancellation | Sort u →
{m : Type → Type v} → Lean.Server.MonadCancellable m → {m' : Type → Type v} → Lean.Server.MonadCancellable m' → Sort u | null | false |
LinearMap.prod_eq_inf_comap | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (q : Submodule R M₂),
p.prod q = Submodule.comap (LinearMap.fst R M M₂) p ⊓ Submodule.comap (LinearMap.snd R M M₂) q | null | true |
Std.TreeMap.size_left_le_size_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t₁.size ≤ (t₁ ∪ t₂).size | null | true |
Std.TreeSet.getD_eq_fallback | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getD a fallback = fallback | null | true |
List.Perm.filterMap | Init.Data.List.Perm | ∀ {α : Type u_1} {β : Type u_2} (f : α → Option β) {l₁ l₂ : List α},
l₁.Perm l₂ → (List.filterMap f l₁).Perm (List.filterMap f l₂) | null | true |
LSeriesHasSum.smul | Mathlib.NumberTheory.LSeries.Linearity | ∀ {f : ℕ → ℂ} (c : ℂ) {s a : ℂ}, LSeriesHasSum f s a → LSeriesHasSum (c • f) s (c * a) | null | true |
_private.Mathlib.LinearAlgebra.Multilinear.DFinsupp.0.MultilinearMap.dfinsuppFamily._simp_2 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {β : α → Type u_2} (m : Multiset α) (t : (a : α) → Multiset (β a))
(f : (a : α) → a ∈ m → β a), (f ∈ m.pi t) = ∀ (a : α) (h : a ∈ m), f a h ∈ t a | null | false |
sdiff_le_inf_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, a \ b ≤ a ⊓ ￢b | null | true |
addUnitsCenterToCenterAddUnits.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ (M : Type u_1) [inst : AddMonoid M],
addUnitsCenterToCenterAddUnits M =
(AddUnits.map (AddSubmonoid.center M).subtype).codRestrict (AddSubmonoid.center (AddUnits M)) ⋯ | null | true |
CategoryTheory.WithTerminal.comp.match_1 | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u_1} →
(motive : CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → CategoryTheory.WithTerminal C → Sort u_2) →
(x x_1 x_2 : CategoryTheory.WithTerminal C) →
((_X _Y _Z : C) →
motive (CategoryTheory.WithTerminal.of _X) (CategoryTheory.WithTerminal.of _Y)
(Categor... | null | false |
CompleteSublattice.ext_iff | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {S T : ↥L}, S = T ↔ ∀ (x : X), x ∈ S ↔ x ∈ T | null | true |
CategoryTheory.Limits.ι_comp_colimitLeftOpIsoUnopLimit_hom | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor J Cᵒᵖ) [inst_2 : CategoryTheory.Limits.HasLimit F] (j : Jᵒᵖ),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F.leftOp j)
(CategoryTheory.Limi... | null | true |
sSupHom.rec | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
[inst : SupSet α] →
[inst_1 : SupSet β] →
{motive : sSupHom α β → Sort u} →
((toFun : α → β) →
(map_sSup' : ∀ (s : Set α), toFun (sSup s) = sSup (toFun '' s)) →
motive { toFun := toFun, map_sSup' := map_sSup' }) →
... | null | false |
Lean.Lsp.InitializationOptions.hasWidgets? | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializationOptions → Option Bool | Whether the client supports interactive widgets. When true, in order to improve performance
the server may cease including information which can be retrieved interactively in some standard
LSP messages. Defaults to false. | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point.0.WeierstrassCurve.Jacobian.Point.toAffine_some._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} (a b c : R), ![a, b, c] 0 = a | null | false |
Filter.Tendsto.atTop_of_add_le_const | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelAddMonoid M]
{l : Filter α} {f g : α → M},
(∃ C, ∀ (x : α), g x ≤ C) → Filter.Tendsto (fun x => f x + g x) l Filter.atTop → Filter.Tendsto f l Filter.atTop | null | true |
Quaternion.imJ_fst_dualNumberEquiv | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R] (q : Quaternion (DualNumber R)),
(TrivSqZeroExt.fst (Quaternion.dualNumberEquiv q)).imJ = TrivSqZeroExt.fst q.imJ | null | true |
groupCohomology.coboundaries₁_le_cocycles₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{max u u_1, u, u} k G),
groupCohomology.coboundaries₁ A ≤ groupCohomology.cocycles₁ A | null | true |
Padic.limSeq | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [inst : Fact (Nat.Prime p)] → CauSeq ℚ_[p] ⇑padicNormE → ℕ → ℚ | `limSeq f`, for `f` a Cauchy sequence of `p`-adic numbers, is a sequence of rationals with the
same limit point as `f`. | true |
Vector.eq_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {xs : Vector α 0}, xs = #v[] | A vector of length `0` is the empty vector. | true |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.Grading.0.ExteriorAlgebra.ιMulti_span.match_1_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {i : ℕ}
(motive : ↥(⋀[R]^i M) → Prop) (hm : ↥(⋀[R]^i M)),
(∀ (m : ExteriorAlgebra R M) (hm : m ∈ ⋀[R]^i M), motive ⟨m, hm⟩) → motive hm | null | false |
FiberPrebundle.totalSpaceMk_preimage_source | Mathlib.Topology.FiberBundle.Basic | ∀ {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : (x : B) → TopologicalSpace (E x)] (a : FiberPrebundle F E) (b : B),
Bundle.TotalSpace.mk b ⁻¹' (a.pretrivializationAt b).source = Set.univ | null | true |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.explainMutualFailure.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | (motive : Array (Array String) × String → Sort u_1) →
(x : Array (Array String) × String) →
((headerss : Array (Array String)) → (footer : String) → motive (headerss, footer)) → motive x | null | false |
derivWithin_ofNat | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (n : ℕ) [inst_3 : OfNat F n], derivWithin (OfNat.ofNat n) s = 0 | null | true |
_private.Mathlib.RingTheory.KrullDimension.Basic.0.Ring.krullDimLE_one_iff._simp_1_1 | Mathlib.RingTheory.KrullDimension.Basic | ∀ (n : ℕ) (α : Type u_1) [inst : Preorder α], Order.KrullDimLE n α = (Order.krullDim α ≤ ↑n) | null | false |
Lean.Meta.instReduceEvalUInt64_qq | Qq.ForLean.ReduceEval | Lean.Meta.ReduceEval UInt64 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_eq_false_right._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 |
Lean.«_aux_Init_BinderPredicates___macroRules_Lean_term∃__,__1» | Init.BinderPredicates | Lean.Macro | null | false |
_private.Mathlib.FieldTheory.Normal.Closure.0.IntermediateField.normalClosure_def'.match_1_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_2} {L : Type u_1} [inst : Field F] [inst_1 : Field L] [inst_2 : Algebra F L] (K : IntermediateField F L)
(f : L →ₐ[F] L) (b : L) (motive : b ∈ IntermediateField.map f K → Prop) (x : b ∈ IntermediateField.map f K),
(∀ (a : L) (h : a ∈ ↑K.toSubsemiring ∧ ↑f a = b), motive ⋯) → motive x | null | false |
Polynomial.splits_mul_X | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [IsDomain R], (f * Polynomial.X).Splits ↔ f.Splits | null | true |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_1 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (A B : GL n R),
↑A * ↑B = ↑(A * B) | null | false |
Std.Iterators.Types.Zip.right | Std.Data.Iterators.Combinators.Monadic.Zip | {α₁ : Type w} →
{m : Type w → Type w'} →
{β₁ : Type w} →
[inst : Std.Iterator α₁ m β₁] → {α₂ β₂ : Type w} → Std.Iterators.Types.Zip α₁ m α₂ β₂ → Std.IterM m β₂ | null | true |
Lean.AttributeExtensionState.ctorIdx | Lean.Attributes | Lean.AttributeExtensionState → ℕ | null | false |
Mathlib.Tactic.ITauto.prove._unsafe_rec | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Mathlib.Tactic.ITauto.IProp → StateM ℕ (Bool × Mathlib.Tactic.ITauto.Proof) | null | false |
Lean.Lsp.instFileSourceTextDocumentPositionParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.TextDocumentPositionParams | null | true |
LightCondSet | Mathlib.Condensed.Light.Basic | Type (u + 1) | Light condensed sets. Because `LightProfinite` is an essentially small category, we don't need the
same universe bump as in `CondensedSet`.
| true |
CategoryTheory.Linear | Mathlib.CategoryTheory.Linear.Basic | (R : Type w) →
[Semiring R] →
(C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.Preadditive C] → Type (max (max u v) w) | A category is called `R`-linear if `P ⟶ Q` is an `R`-module such that composition is
`R`-linear in both variables. | true |
Vector.eraseIdx_append_of_lt_size._proof_2 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n → k < n + m → n - 1 + m = n + m - 1 | null | false |
CategoryTheory.GrothendieckTopology.Point.presheafFiberDesc | Mathlib.CategoryTheory.Sites.Point.Basic | {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] →
[inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] →
{P : Cate... | Constructor for morphisms from the fiber of a presheaf. | true |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalUnaryBitVec'.match_1 | Lean.Meta.Sym.Simp.EvalGround | (motive : OptionT Id Lean.Meta.Sym.BitVecValue → Sort u_1) →
(x : OptionT Id Lean.Meta.Sym.BitVecValue) →
((a : Lean.Meta.Sym.BitVecValue) → motive (some a)) →
((x : OptionT Id Lean.Meta.Sym.BitVecValue) → motive x) → motive x | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cons_append._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ : ℕ}, ¬w₁ + w₂ + 1 = w₁ + 1 + w₂ → False | null | false |
AlgCat.limitSemiring._proof_24 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (... | null | false |
Matrix.IsAdjMatrix.toGraph_adj | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} {A : Matrix V V α} [inst : MulZeroOneClass α] [inst_1 : Nontrivial α]
(h : A.IsAdjMatrix) (i j : V), h.toGraph.Adj i j = (A i j = 1) | null | true |
Function.Surjective.moduleLeft._proof_3 | Mathlib.Algebra.Module.RingHom | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Semiring S] [inst_4 : SMul S M] (f : R →+* S) (hf : Function.Surjective ⇑f)
(hsmul : ∀ (c : R) (x : M), f c • x = c • x) (y₁ y₂ : S) (x : M), (y₁ + y₂) • x = y₁ • x + y₂ • x | null | false |
Filter.instInf._proof_2 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f g : Filter α) {x y : Set α},
x ∈ {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b} → x ⊆ y → y ∈ {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b} | null | false |
LocallyConstant.coeFnAlgHom._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_3) [inst_1 : CommSemiring R]
[inst_2 : Semiring Y] [inst_3 : Algebra R Y] (x : R),
(↑↑LocallyConstant.coeFnRingHom).toFun ((algebraMap R (LocallyConstant X Y)) x) =
(↑↑LocallyConstant.coeFnRingHom).toFun ((algebraMap R (LocallyConstant X Y)... | null | false |
Std.HashMap.getKeyD_alter_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[Inhabited α] {k fallback : α} {f : Option β → Option β},
(m.alter k f).getKeyD k fallback = if (f m[k]?).isSome = true then k else fallback | null | true |
TopModuleCat.isColimitCoker._proof_4 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N)
(s : CategoryTheory.Limits.CokernelCofork φ), ContinuousSMul R ↑s.1.toModuleCat | null | false |
ValuationRing.iff_dvd_total | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R], ValuationRing R ↔ Std.Total fun x1 x2 => x1 ∣ x2 | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.USize.reduceToNat._regBuiltin.USize.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1306150149._hygCtx._hyg.15 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
disjointed_add_one | Mathlib.Algebra.Order.Disjointed | ∀ {α : Type u_1} {ι : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : LinearOrder ι]
[inst_2 : LocallyFiniteOrderBot ι] [inst_3 : Add ι] [inst_4 : One ι] [SuccAddOrder ι] [NoMaxOrder ι] (f : ι → α)
(i : ι), disjointed f (i + 1) = f (i + 1) \ (partialSups f) i | null | true |
Lean.instFromJsonUnit | Lean.Data.Json.FromToJson.Basic | Lean.FromJson Unit | null | true |
MulEquiv.mapSubgroup.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H : Type u_6} [inst_1 : Group H] (f : G ≃* H),
f.mapSubgroup =
{ toFun := Subgroup.map ↑f, invFun := Subgroup.map ↑f.symm, left_inv := ⋯, right_inv := ⋯, map_rel_iff' := ⋯ } | null | true |
Lean.Lsp.ShowDocumentClientCapabilities | Lean.Data.Lsp.Capabilities | Type | null | true |
Std.DTreeMap.Internal.RcoSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RcoSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RcoSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Rco α) → motive { treeMap := treeMap, range := range }) ... | null | false |
SimplexCategory.skeletalEquivalence | Mathlib.AlgebraicTopology.SimplexCategory.Basic | SimplexCategory ≌ NonemptyFinLinOrd | The equivalence that exhibits `SimplexCategory` as skeleton
of `NonemptyFinLinOrd` | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.exists_le_of_le._proof_1_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a b : α} {P Q : Finpartition a},
(∀ p ∈ P.parts, ∃ q ∈ Q.parts.erase b, p ≤ q) → P.parts.sup id ≤ (Q.parts.erase b).sup id | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.finite_finsupp_iff._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.finite_finsupp_iff._simp_1_4 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {α : Type u_1}, (¬Subsingleton α) = Nontrivial α | null | false |
MeasureTheory.Measure.isOpenPosMeasure_smul | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) [μ.IsOpenPosMeasure]
{c : ENNReal}, c ≠ 0 → (c • μ).IsOpenPosMeasure | null | true |
SimpleGraph.Finsubgraph.coe_compl._simp_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {G : SimpleGraph V} [inst : Finite V] (G' : G.Finsubgraph), (↑G')ᶜ = ↑G'ᶜ | null | false |
BddLat.Iso.mk._proof_6 | Mathlib.Order.Category.BddLat | ∀ {α β : BddLat} (e : ↑α.toLat ≃o ↑β.toLat) (a b : ↑α.1),
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊓ b) =
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊓ { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | null | false |
gronwallBound_x0 | Mathlib.Analysis.ODE.Gronwall | ∀ (δ K ε : ℝ), gronwallBound δ K ε 0 = δ | null | true |
Std.HashMap.Raw.Equiv.diff_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ m₃ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | null | true |
_private.Mathlib.CategoryTheory.NatTrans.0.CategoryTheory.NatTrans.ext.match_1 | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u_3} {inst : CategoryTheory.Category.{u_1, u_3} C} {D : Type u_4}
{inst_1 : CategoryTheory.Category.{u_2, u_4} D} {F G : CategoryTheory.Functor C D}
(motive : CategoryTheory.NatTrans F G → Prop) (h : CategoryTheory.NatTrans F G),
(∀ (app : (X : C) → F.obj X ⟶ G.obj X)
(naturality :
∀ ⦃X ... | null | false |
_private.Mathlib.SetTheory.ZFC.Class.0.ZFSet.coe_equiv_aux._simp_1_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x : PSet.{u_1}), x.Equiv x = True | null | false |
CategoryTheory.Localization.instHasSmallLocalizedHomObjShiftFunctor | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (W : CategoryTheory.MorphismProperty C) {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] (X Y : C)
[CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y] (m : M),
CategoryTheory.Localization.HasSmallLocalizedHom W X ... | null | true |
Lean.Meta.Hint.Suggestion | Lean.Meta.Hint | Type | A code action suggestion associated with a hint in a message.
Refer to `TryThis.Suggestion`. This extends that structure with several fields specific to inline
hints.
| true |
_private.Mathlib.MeasureTheory.Function.LpSpace.Basic.0.MeasureTheory.Lp.instNormedAddCommGroup._simp_3 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {r q : NNReal}, (↑r ≤ ↑q) = (r ≤ q) | null | false |
Lean.Grind.instSubNatCiOfNatInt | Init.GrindInstances.ToInt | Lean.Grind.ToInt.Sub ℕ (Lean.Grind.IntInterval.ci 0) | null | true |
Quaternion.instRing._proof_45 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
String.Slice.endsWith_string_eq_false_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s : String.Slice}, (s.endsWith pat = false) = ¬pat.toList <:+ s.copy.toList | null | false |
OpenPartialHomeomorph.subtypeRestr_source | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : TopologicalSpace.Opens X} (hs : Nonempty ↥s),
(e.subtypeRestr hs).source = Subtype.val ⁻¹' e.source | null | true |
_private.Mathlib.Order.Bounds.Basic.0.upperBounds_empty._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_decl_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w) (idx : ℕ) (h1 : idx < aig.decls.size)
(h2 : idx < (Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.de... | null | true |
AddMonoidAlgebra.mapDomain.eq_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] (f : M → N) (x : AddMonoidAlgebra R M),
AddMonoidAlgebra.mapDomain f x = Finsupp.mapDomain f x | null | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processCtorApp._sparseCasesOn_1 | Lean.Elab.PatternVar | {motive : Lean.Elab.Term.Arg → Sort u} →
(t : Lean.Elab.Term.Arg) →
((val : Lean.Syntax) → motive (Lean.Elab.Term.Arg.stx val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Int.Linear.orOver_one | Init.Data.Int.Linear | ∀ {p : ℕ → Prop}, Int.Linear.OrOver 1 p → p 0 | null | true |
Lean.Parser.setExpected | Lean.Parser.Basic | List String → Lean.Parser.Parser → Lean.Parser.Parser | null | true |
CategoryTheory.GlueData.mapGlueData._proof_6 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {C' : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C'] (D : CategoryTheory.GlueData C) (F : CategoryTheory.Functor C C')
[inst_2 : ∀ (i j k : D.J), CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan (D.f i j) (D.f i k)) F]
(i... | null | false |
_private.Mathlib.Order.Fin.Tuple.0.Fin.preimage_insertNth_Icc_of_notMem._simp_1_1 | Mathlib.Order.Fin.Tuple | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Polynomial.dickson_of_two_le | Mathlib.RingTheory.Polynomial.Dickson | ∀ {R : Type u_1} [inst : CommRing R] (k : ℕ) (a : R) {n : ℕ},
2 ≤ n →
Polynomial.dickson k a n =
Polynomial.X * Polynomial.dickson k a (n - 1) - Polynomial.C a * Polynomial.dickson k a (n - 2) | null | true |
UInt8.toUInt64_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a <<< b).toUInt64 = a.toUInt64 <<< (b % 8).toUInt64 % 256 | null | true |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.hasPullback_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Z)
[hf : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (g : Y ⟶ Z), CategoryTheory.Limits.HasPullback g f | null | true |
_private.Mathlib.LinearAlgebra.Dimension.DivisionRing.0.rank_add_rank_split._simp_1_2 | Mathlib.LinearAlgebra.Dimension.DivisionRing | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
LightDiagram.cone | Mathlib.Topology.Category.LightProfinite.Basic | (self : LightDiagram) → CategoryTheory.Limits.Cone (self.diagram.comp FintypeCat.toProfinite) | The limit cone. | true |
Equidecomp.mk._flat_ctor | Mathlib.Algebra.Group.Action.Equidecomp | {X : Type u_1} →
{G : Type u_2} →
[inst : SMul G X] →
(toFun invFun : X → X) →
(source target : Set X) →
(∀ ⦃x : X⦄, x ∈ source → toFun x ∈ target) →
(∀ ⦃x : X⦄, x ∈ target → invFun x ∈ source) →
(∀ ⦃x : X⦄, x ∈ source → invFun (toFun x) = x) →
(∀ ... | null | false |
FunLike.commMonoid._proof_1 | Mathlib.Data.FunLike.Group | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : One F] [inst_2 : CommMonoid β]
[IsOneApply F α β], ⇑1 = 1 | null | false |
_private.Batteries.Data.List.Basic.0.List.rotate.match_1.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α × List α → Sort u_2) (l₁ l₂ : List α) (h_1 : (l₁ l₂ : List α) → motive (l₁, l₂)),
(match (l₁, l₂) with
| (l₁, l₂) => h_1 l₁ l₂) =
h_1 l₁ l₂ | null | true |
WeierstrassCurve.Jacobian.fin3_def_ext | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} (a b c : R), ![a, b, c] 0 = a ∧ ![a, b, c] 1 = b ∧ ![a, b, c] 2 = c | null | true |
Hyperreal.Infinitesimal | Mathlib.Analysis.Real.Hyperreal | ℝ* → Prop | A hyperreal number is infinitesimal if its standard part is 0.
**Do not use.** Write `0 < ArchimedeanClass.mk x` instead. | true |
LinearPMap._sizeOf_inst | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
{inst : Ring R} →
{inst_1 : Ring S} →
(σ : R →+* S) →
(E : Type u_3) →
{inst_2 : AddCommGroup E} →
{inst_3 : Module R E} →
(F : Type u_4) →
{inst_4 : AddCommGroup F} →
{inst_5 ... | null | false |
hfdifferential._proof_2 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_2}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq._sparseCasesOn_2 | Aesop.Forward.State | {motive : Aesop.RawHyp → Sort u} →
(t : Aesop.RawHyp) →
((subst : Aesop.Substitution) → motive (Aesop.RawHyp.patSubst subst)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Polynomial.SplittingField.instField._proof_13 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K], IsScalarTower ℚ K K | null | false |
Finpartition.casesOn | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{a : α} →
{motive : Finpartition a → Sort u} →
(t : Finpartition a) →
((parts : Finset α) →
(supIndep : parts.SupIndep id) →
(sup_parts : parts.sup id = a) →
(bot... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.