name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
USize | Init.Prelude | Type | true |
PNat.findX._proof_2 | Mathlib.Data.PNat.Find | ∀ {p : ℕ+ → Prop} (n : { n // (∃ n_1, ∃ (_ : n = ↑n_1), p n_1) ∧ ∀ m < n, ¬∃ n, ∃ (_ : m = ↑n), p n }), 0 < ↑n | false |
CategoryTheory.Preadditive.isCoseparating_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(P : CategoryTheory.ObjectProperty C),
P.IsCoseparating ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (G : C), P G → ∀ (h : Y ⟶ G), CategoryTheory.CategoryStruct.comp f h = 0) → f = 0 | true |
AlgebraicGeometry.Scheme.Cover.Hom.sigma._proof_1 | Mathlib.AlgebraicGeometry.Cover.Sigma | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme}
[inst : AlgebraicGeometry.IsZariskiLocalAtSource P] [inst_1 : UnivLE.{u_1, u_2}]
{𝒰 𝒱 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S} (f : 𝒰 ⟶ 𝒱) (x : 𝒰.sigma.I₀)
(b : 𝒰.I₀),
Catego... | false |
DirSupInacc.empty | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} [inst : Preorder α], DirSupInacc ∅ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.toList_eq._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) | false |
UInt8.reduceToNat._regBuiltin.UInt8.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.354 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
εNFA.IsPath.below.rec | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} {M : εNFA α σ} {motive : (a a_1 : σ) → (a_2 : List (Option α)) → M.IsPath a a_1 a_2 → Prop}
{motive_1 : {a a_1 : σ} → {a_2 : List (Option α)} → (t : M.IsPath a a_1 a_2) → εNFA.IsPath.below t → Prop},
(∀ (s : σ), motive_1 ⋯ ⋯) →
(∀ (t s u : σ) (a : Option α) (x : List (Option α)) (a_1... | false |
Int.mul_add_emod_self_right | Init.Data.Int.DivMod.Bootstrap | ∀ (a b c : ℤ), (a * b + c) % b = c % b | true |
Aesop.SearchM.State.ctorIdx | Aesop.Search.SearchM | {Q : Type} → {inst : Aesop.Queue Q} → Aesop.SearchM.State Q → ℕ | false |
Aesop.Check.script.steps | Aesop.Check | Aesop.Check | true |
SSet.N.iSup_subcomplex_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ (X : SSet), ⨆ s, s.subcomplex = ⊤ | true |
SlashInvariantForm.constℝ_toFun | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetPlusMinusOne] (x : ℝ),
⇑(SlashInvariantForm.constℝ x) = Function.const UpperHalfPlane ↑x | true |
AlgebraicGeometry.IsAffineOpen.isLocalization_of_eq_basicOpen | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : ↑(X.presheaf.obj (Opposite.op U))) {V : X.Opens} (i : V ⟶ U),
V = X.basicOpen f → IsLocalization.Away f ↑(X.presheaf.obj (Opposite.op V)) | true |
starRingEquiv | Mathlib.Algebra.Star.Basic | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → [StarRing R] → R ≃+* Rᵐᵒᵖ | true |
Finsupp.embDomain_refl | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M], Finsupp.embDomain (Function.Embedding.refl α) = id | true |
AlgebraicGeometry.StructureSheaf.globalSectionsIso._proof_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u_1) [inst : CommRing R],
NonUnitalRingHomClass (R →+* (AlgebraicGeometry.structureSheafInType R R).obj.obj (Opposite.op ⊤)) R
((AlgebraicGeometry.structureSheafInType R R).obj.obj (Opposite.op ⊤)) | false |
CategoryTheory.GrothendieckTopology.pointBot._proof_3 | Mathlib.CategoryTheory.Sites.Point.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.LocallySmall.{u_3, u_2, u_1} C]
(X : C) {U : C},
∀ R ∈ ⊥ U,
∀ (x : (CategoryTheory.shrinkYoneda.{u_3, u_2, u_1}.flip.obj (Opposite.op X)).obj U),
∃ Y f, ∃ (_ : R.arrows f), ∃ y, (CategoryTheory.shrinkYoneda.{u_3, u_2, ... | false |
Std.DTreeMap.Raw.Const.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {a : α}, a ∉ t → Std.DTreeMap.Raw.Const.get! t a = default | true |
AnalyticOn.log | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ {f : ℝ → ℝ} {s : Set ℝ}, AnalyticOn ℝ f s → (∀ x ∈ s, 0 < f x) → AnalyticOn ℝ (fun z => Real.log (f z)) s | true |
IsGaloisGroup.algebraMap_ringEquiv_apply | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (A : Type u_2) (A' : Type u_3) (B : Type u_4) [inst : Group G] [inst_1 : CommSemiring A]
[inst_2 : Semiring B] [inst_3 : Algebra A B] [inst_4 : MulSemiringAction G B] [inst_5 : FaithfulSMul A B]
[hA : IsGaloisGroup G A B] [inst_6 : CommSemiring A'] [inst_7 : Algebra A' B] [inst_8 : FaithfulSMul A' ... | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.entryAtIdxD.match_1.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (Std.DTreeMap.Internal.Impl α fun x => β) → ℕ → α × β → Sort u_3) (size : ℕ)
(k : α) (v : β) (l r : Std.DTreeMap.Internal.Impl α fun x => β) (n : ℕ) (fallback : α × β)
(h_1 : (x : ℕ) → (fallback : α × β) → motive Std.DTreeMap.Internal.Impl.leaf x fallback)
(h_2 :
(siz... | true |
Lean.Server.Watchdog.ServerContext.referenceData | Lean.Server.Watchdog | Lean.Server.Watchdog.ServerContext → Std.Mutex Lean.Server.Watchdog.ReferenceData | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.u | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Year.Offset | true |
Std.Internal.List.containsKey_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {he : l.isEmpty = false}, Std.Internal.List.containsKey (Std.Internal.List.minKey l he) l = true | true |
IsLocalRing.instCommRingResidueField._proof_7 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsLocalRing R] (a : IsLocalRing.ResidueField R), a + 0 = a | false |
WittVector.wittMulN.congr_simp | Mathlib.RingTheory.WittVector.MulP | ∀ (p p_1 : ℕ) (e_p : p = p_1) [hp : Fact (Nat.Prime p)] (a a_1 : ℕ),
a = a_1 → ∀ (a_2 a_3 : ℕ), a_2 = a_3 → WittVector.wittMulN p a a_2 = WittVector.wittMulN p_1 a_1 a_3 | true |
Equiv.Perm.sign_permCongr | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u} [inst : DecidableEq α] {β : Type v} [inst_1 : Fintype α] [inst_2 : DecidableEq β] [inst_3 : Fintype β]
(e : α ≃ β) (p : Equiv.Perm α), Equiv.Perm.sign (e.permCongr p) = Equiv.Perm.sign p | true |
_private.Mathlib.Topology.Order.0.TopologicalSpace.nhds_generateFrom.match_1_1 | Mathlib.Topology.Order | ∀ {α : Type u_1} {g : Set (Set α)} {a : α} (s : Set α) (motive : s ∈ {s | a ∈ s ∧ s ∈ g} → Prop)
(x : s ∈ {s | a ∈ s ∧ s ∈ g}), (∀ (as : a ∈ s) (sg : s ∈ g), motive ⋯) → motive x | false |
typeToPartialFunIsoPartialFunToPointed._proof_6 | Mathlib.CategoryTheory.Category.PartialFun | ∀ {X Y : Type u_1} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((typeToPartialFun.comp partialFunToPointed).map f)
{ hom := { toFun := id, map_point := ⋯ }, inv := { toFun := id, map_point := ⋯ }, hom_inv_id := ⋯,
inv_hom_id := ⋯ }.hom =
CategoryTheory.CategoryStruct.comp
{ hom := { toFu... | false |
Batteries.RBNode.IsCut.le_lt_trans | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} [self : Batteries.RBNode.IsCut cmp cut] {x y : α}
[Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut x = Ordering.lt → cut y = Ordering.lt | true |
CoalgEquiv.ext | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A]
[inst_6 : CoalgebraStruct R B] {e e' : A ≃ₗc[R] B}, (∀ (x : A), e x = e' x) → e = e' | true |
CategoryTheory.FreeMonoidalCategory.Hom.tensor.inj | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} {f : W.Hom Y} {g : X.Hom Z} {f_1 : W.Hom Y}
{g_1 : X.Hom Z}, f.tensor g = f_1.tensor g_1 → f = f_1 ∧ g = g_1 | true |
TendstoUniformlyOnFilter | Mathlib.Topology.UniformSpace.UniformConvergence | {α : Type u_1} → {β : Type u_2} → {ι : Type u_4} → [UniformSpace β] → (ι → α → β) → (α → β) → Filter ι → Filter α → Prop | true |
Int.natAbs_ediv_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, b ∣ a → (a / b).natAbs = a.natAbs / b.natAbs | true |
SimpleGraph.finsubgraphOfAdj | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Adj u v → G.Finsubgraph | true |
Real.limsInf_of_not_isCobounded | Mathlib.Order.Filter.ENNReal | ∀ {f : Filter ℝ}, ¬Filter.IsCobounded (fun x1 x2 => x1 ≥ x2) f → f.limsInf = 0 | true |
StarAddMonoid.toStarModuleNat | Mathlib.Algebra.Star.Basic | ∀ {α : Type u_1} [inst : AddMonoid α] [inst_1 : StarAddMonoid α], StarModule ℕ α | true |
MvPolynomial.algHom_ext | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
{f g : MvPolynomial σ R →ₐ[R] A}, (∀ (i : σ), f (MvPolynomial.X i) = g (MvPolynomial.X i)) → f = g | true |
_private.Init.Meta.Defs.0.Lean.Name.beq.match_1.splitter._sparseCasesOn_6 | Init.Meta.Defs | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Algebra.id._proof_4 | Mathlib.Algebra.Algebra.Defs | ∀ (R : Type u_1) [inst : CommSemiring R] (x y : R),
(↑↑(RingHom.id R)).toFun (x + y) = (↑↑(RingHom.id R)).toFun x + (↑↑(RingHom.id R)).toFun y | false |
Std.HashMap.Raw.getD_map_of_getKey?_eq_some | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → γ} {k k' : α} {fallback : γ},
m.WF → m.getKey? k = some k' → (Std.HashMap.Raw.map f m).getD k fallback = (Option.map (f k') m[k]?).getD fallback | true |
QuotientAddGroup.preimage_image_mk_eq_iUnion_image | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α) (s : Set α),
QuotientAddGroup.mk ⁻¹' (QuotientAddGroup.mk '' s) = ⋃ x, (fun x_1 => x_1 + ↑x) '' s | true |
PadicInt.instNormedCommRing._proof_2 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (a b : ℤ_[p]), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.inverseCompMapHomotopyCategorySndIso._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2) (x : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 }))
⦃x_1 y : Y.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 })⦄
(e : SSet.Truncated.Edge x_1 y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor... | false |
MeasureTheory.StronglyMeasurable.of_subsingleton_cod | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} {f : α → β} [inst : TopologicalSpace β] [Subsingleton β],
MeasureTheory.StronglyMeasurable f | true |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast.loop._unary._proof_2 | Batteries.Data.Array.Basic | ∀ {β : Type u_1} (stop : USize) (init : β) (start : USize) (acc : Array β),
start < stop →
∀ (next : β),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun init start =>
PSigma.casesOn start fun start acc => stop.toNat - min start.toNat stop.toNat)
⟨next, ⟨s... | false |
Orientation.inner_rightAngleRotation_self | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x : E), inner ℝ (o.rightAngleRotation x) x = 0 | true |
AddMonoidAlgebra.mapDomain_injective | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] {f : M → N},
Function.Injective f → Function.Injective (AddMonoidAlgebra.mapDomain f) | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend._proof_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend | ∀ (newWidth curr : ℕ), curr ≤ newWidth → ¬curr < newWidth → curr = newWidth | false |
Summable.nat_tsum_vanishing | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] {f : ℕ → G},
Summable f → ∀ ⦃e : Set G⦄, e ∈ nhds 0 → ∃ N, ∀ t ⊆ {n | N ≤ n}, ∑' (n : ↑t), f ↑n ∈ e | true |
Matroid.IsBasis.isBase_of_isBase_subset | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X B : Set α}, M.IsBasis I X → M.IsBase B → B ⊆ X → M.IsBase I | true |
Std.DTreeMap.Internal.Impl.Const.getD_insertMany!_list_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : BEq α] [Std.LawfulBEqOrd α],
t.WF →
∀ {l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Internal.Impl.Const.getD (↑(Std.DTreeMap.Int... | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites.0.CategoryTheory.Limits.createsColimitOp._proof_1 | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
(K : CategoryTheory.Functor J Cᵒᵖ) (F : CategoryTheory.Functor C D) [CategoryTheory.CreatesLimit K.leftOp F],
CategoryTheory.... | false |
Set.powersetCard.addActionHom_of_embedding_surjective | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : AddGroup G] (α : Type u_2) [inst_1 : AddAction G α] {n : ℕ} [inst_2 : DecidableEq α],
Function.Surjective ⇑(Set.powersetCard.addActionHom_of_embedding G α n) | true |
idRel_subset | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {s : SetRel α α}, idRel ⊆ s ↔ ∀ (a : α), (a, a) ∈ s | true |
LinearIsometryEquiv.ulift._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ (R : Type u_3) (E : Type u_2) [inst : Semiring R] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module R E]
(x : ULift.{u_1, u_2} E),
‖ContinuousLinearEquiv.ulift.toLinearEquiv x‖ = ‖ContinuousLinearEquiv.ulift.toLinearEquiv x‖ | false |
EReal.div_mul_cancel | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, b ≠ ⊥ → b ≠ ⊤ → b ≠ 0 → a / b * b = a | true |
Algebra.EssFiniteType.iff_of_algEquiv | Mathlib.RingTheory.EssentialFiniteness | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (f : S ≃ₐ[R] T), Algebra.EssFiniteType R S ↔ Algebra.EssFiniteType R T | true |
Lean.ErrorExplanation.instFromJsonMetadata | Lean.ErrorExplanation | Lean.FromJson Lean.ErrorExplanation.Metadata | true |
_private.Mathlib.Analysis.Normed.Algebra.MatrixExponential.0.Matrix.exp_blockDiagonal'._simp_1_3 | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {X : Type u_1} {l : Type u_3} {R : Type u_8} {m' : l → Type u_9} {n' : l → Type u_10} [inst : AddCommMonoid R]
[inst_1 : TopologicalSpace R] {L : SummationFilter X} [inst_2 : DecidableEq l] [T2Space R]
{f : X → (i : l) → Matrix (m' i) (n' i) R},
∑'[L] (x : X), Matrix.blockDiagonal' (f x) = Matrix.blockDiagonal'... | false |
Std.Roc.toArray_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α], r.toList.toArray = r.toArray | true |
SmoothBumpCovering.c | Mathlib.Geometry.Manifold.PartitionOfUnity | {ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ... | true |
DomMulAct.smul_Lp_neg | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_1} {α : Type u_3} {E : Type u_4} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure α} {p : ENNReal} [inst_2 : SMul M α] [inst_3 : MeasureTheory.SMulInvariantMeasure M α μ]
[inst_4 : MeasurableConstSMul M α] (c : Mᵈᵐᵃ) (f : ↥(MeasureTheory.Lp E p μ)), c • -f = -(c • ... | true |
Equiv.Set.univ._proof_2 | Mathlib.Logic.Equiv.Set | ∀ (α : Type u_1) (x : α), ↑⟨x, trivial⟩ = ↑⟨x, trivial⟩ | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.FDeriv.0.mdifferentiable_iff_differentiable._simp_1_2 | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {f : E → E'}
{x : E}, MDiffAt f x = DifferentiableAt 𝕜 f x | false |
AlgebraicGeometry.Flat.instDescScheme | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X : AlgebraicGeometry.Scheme} {ι : Type v} [inst : Small.{u, v} ι] {Y : ι → AlgebraicGeometry.Scheme}
{f : (i : ι) → Y i ⟶ X} [∀ (i : ι), AlgebraicGeometry.Flat (f i)],
AlgebraicGeometry.Flat (CategoryTheory.Limits.Sigma.desc f) | true |
RingCon.quotientQuotientEquivQuotientₐ_symm_mk | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} (R : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring M] [inst_2 : Algebra R M] {c d : RingCon M}
(h : c ≤ d) (x : M), (RingCon.quotientQuotientEquivQuotientₐ R h).symm ⟦x⟧ = ⟦⟦x⟧⟧ | true |
_private.Init.Data.Array.Zip.0.Array.getElem?_zipWithAll.match_1.splitter._sparseCasesOn_2 | Init.Data.Array.Zip | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Matrix.diagonal_ofNat' | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : NatCast α] (m : ℕ)
[inst_3 : m.AtLeastTwo], Matrix.diagonal (OfNat.ofNat m) = OfNat.ofNat m | true |
_private.Mathlib.LinearAlgebra.Matrix.Vec.0.Matrix.vec_inj._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Vec | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
PFunctor.M.IsPath | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → PFunctor.Approx.Path F → F.M → Prop | true |
MeasureTheory.prob_compl_eq_one_sub₀ | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.NullMeasurableSet s μ → μ sᶜ = 1 - μ s | true |
Lean.Grind.OrderedAdd.neg_nonneg_iff | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommGroup M] [Lean.Grind.OrderedAdd M]
{a : M}, 0 ≤ -a ↔ a ≤ 0 | true |
one_lt_zpow_of_neg₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a : G₀} [ZeroLEOneClass G₀]
{n : ℤ}, 0 < a → a < 1 → n < 0 → 1 < a ^ n | true |
Lean.Doc.Part | Lean.DocString.Types | Type u → Type v → Type w → Type (max u v w) | true |
ODE.FunSpace.exists_isFixedPt_next | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E → E} {tmin tmax : ℝ}
{t₀ : ↑(Set.Icc tmin tmax)} {x₀ x : E} {a r L K : NNReal} [CompleteSpace E] (hf : IsPicardLindelof f t₀ x₀ a r L K)
(hx : x ∈ Metric.closedBall x₀ ↑r), ∃ α, Function.IsFixedPt (ODE.FunSpace.next hf hx) α | true |
Turing.FinTM2.inhabitedStmt._aux_1 | Mathlib.Computability.TuringMachine.Computable | (tm : Turing.FinTM2) → tm.Stmt | false |
NonUnitalAlgHom.range_comp | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type w'} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B]
[inst_5 : NonUnitalNonAssocSemiring C] [inst_6 : Module R C] (f : A →ₙₐ[R] B) (g : B →ₙₐ[R] C),
NonUnitalAlgHom.r... | true |
MonomialOrder.span_leadingTerm_eq_span_monomial | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {m : MonomialOrder σ} {B : Set (MvPolynomial σ R)},
(∀ p ∈ B, IsUnit (m.leadingCoeff p)) →
Ideal.span (m.leadingTerm '' B) = Ideal.span ((fun p => (MvPolynomial.monomial (m.degree p)) 1) '' B) | true |
Set.toFinset_eq_empty | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], s.toFinset = ∅ ↔ s = ∅ | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₃_eq | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ : CategoryTheory.GradedObject I C) [inst_3 : X₂.HasTensor X₃]
[inst_4 : X₁.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj X₂ X₃)] (i₁ i₂ i₃ j : I) (h :... | true |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_9 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | false |
Int.lt_trichotomy | Init.Data.Int.Order | ∀ (a b : ℤ), a < b ∨ a = b ∨ b < a | true |
Set.right_mem_Icc | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ∈ Set.Icc b a ↔ b ≤ a | true |
Aesop.Goal.mk | Aesop.Tree.Data | Aesop.GoalData Aesop.Rapp Aesop.MVarCluster → Aesop.Goal | true |
CategoryTheory.CommSq.cokernelCofork.congr_simp | Mathlib.Algebra.Homology.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X₁ X₂ X₃ X₄ : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X₂ X₃] {f : X₁ ⟶ X₂} {g : X₁ ⟶ X₃} {inl inl_1 : X₂ ⟶ X₄}
(e_inl : inl = inl_1) {inr inr_1 : X₃ ⟶ X₄} (e_inr : inr = inr_1) (sq : CategoryTheory.... | true |
monadMap_refl | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (f : {α : Type u_1} → m α → m α), monadMap f = f | true |
Lean.Meta.Grind.simpOr | Lean.Meta.Tactic.Grind.SimpUtil | Lean.Meta.Simp.Simproc | true |
ENat.mul_top | Mathlib.Data.ENat.Basic | ∀ {m : ℕ∞}, m ≠ 0 → m * ⊤ = ⊤ | true |
HNNExtension.NormalWord.instFaithfulSMul_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (d : HNNExtension.NormalWord.TransversalPair G A B),
FaithfulSMul (HNNExtension G A B φ) (HNNExtension.NormalWord d) | true |
String.Slice.Pattern.ForwardPattern.startsWith | Init.Data.String.Pattern.Basic | {ρ : Type} → (pat : ρ) → [self : String.Slice.Pattern.ForwardPattern pat] → String.Slice → Bool | true |
AkraBazziRecurrence.mk | Mathlib.Computability.AkraBazzi.SumTransform | {α : Type u_1} →
[inst : Fintype α] →
[inst_1 : Nonempty α] →
{T : ℕ → ℝ} →
{g : ℝ → ℝ} →
{a b : α → ℝ} →
{r : α → ℕ → ℕ} →
(n₀ : ℕ) →
0 < n₀ →
(∀ (i : α), 0 < a i) →
(∀ (i : α), 0 < b i) →
... | true |
Set.image_inv_Iic | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a : α),
Inv.inv '' Set.Iic a = Set.Ici a⁻¹ | true |
uniqueDiffWithinAt_congr | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
nhdsWithin x s = nhdsWithin x t → (UniqueDiffWithinAt 𝕜 s x ↔ UniqueDiffWithinAt 𝕜 t x) | true |
PowerBasis.basis_eq_pow | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_7} {S : Type u_8} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (self : PowerBasis R S)
(i : Fin self.dim), self.basis i = self.gen ^ ↑i | true |
CategoryTheory.PreGaloisCategory.instMulActionAutObjFiniteVFintypeCatFunctorObjActionFunctorToAction._proof_4 | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] (F : CategoryTheory.Functor C FintypeCat) (X : C)
(b : ((CategoryTheory.PreGaloisCategory.functorToAction F).obj X).V.obj), 1 • b = b | false |
MeasureTheory.Measure.instSMul._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {R : Type u_2} [inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal]
{x : MeasurableSpace α} (c : R) (μ : MeasureTheory.Measure α), (c • μ.toOuterMeasure).trim ≤ c • μ.toOuterMeasure | false |
ContinuousMulEquiv.coe_mk' | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] (f : M ≃ₜ N) (h : ∀ (x y : M), f (x * y) = f x * f y), ⇑(ContinuousMulEquiv.mk' f h) = ⇑f | true |
Int.emod_self_add_one | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ}, 0 ≤ x → x % (x + 1) = x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.