name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Submodule.Quotient.addCommGroup._proof_5 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
(a : M ⧸ p), a + 0 = a | false |
Nat.Prime.dvd_primorial_iff | Mathlib.NumberTheory.Primorial | ∀ {p n : ℕ}, Nat.Prime p → (p ∣ primorial n ↔ p ≤ n) | true |
CategoryTheory.Limits.ConeMorphism.w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {A B : CategoryTheory.Limits.Cone F} (self : CategoryTheory.Limits.ConeMorphism A B)
(j : J) {Z : C} (h : F.obj j ⟶ Z),
CategoryTheory.CategoryStruct.comp self.h... | true |
IsTop.not_isBot | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [Nontrivial α], IsTop a → ¬IsBot a | true |
bddOrd_dual_comp_forget_to_bipointed | Mathlib.Order.Category.BddOrd | BddOrd.dual.comp (CategoryTheory.forget₂ BddOrd Bipointed) =
(CategoryTheory.forget₂ BddOrd Bipointed).comp Bipointed.swap | true |
_private.Mathlib.Topology.Algebra.Group.OpenMapping.0.isOpenMap_smul_of_sigmaCompact._simp_1_1 | Mathlib.Topology.Algebra.Group.OpenMapping | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
IsOpenMap f = ∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x) | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.toFMVarId.match_1 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) → (Unit → motive none) → ((decl : Lean.LocalDecl) → motive (some decl)) → motive x | false |
Algebra.GrothendieckAddGroup.lift | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | {M : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid M] → [inst_1 : AddCommGroup G] → (M →+ G) ≃ (Algebra.GrothendieckAddGroup M →+ G) | true |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_3 | Lean.Elab.DocString | (motive : Option Lean.Doc.ElabLink✝ → Sort u_1) →
(x : Option Lean.Doc.ElabLink✝¹) →
((name : Lean.StrLit) → motive (some { name := name })) → ((x : Option Lean.Doc.ElabLink✝²) → motive x) → motive x | false |
CategoryTheory.PrelaxFunctor.id._proof_3 | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
(CategoryTheory.PrelaxFunctorStruct.id B).map₂ (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.PrelaxFunctorStruct.id B).map₂ η)
((CategoryTheory.PrelaxFunc... | false |
Lean.Data.AC.EvalInformation.evalOp | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β → β → β | true |
Matrix.ProjectiveSpecialLinearGroup | Mathlib.LinearAlgebra.Matrix.ProjectiveSpecialLinearGroup | (n : Type u) → [DecidableEq n] → [Fintype n] → (R : Type v) → [CommRing R] → Type (max (max u v) v u) | true |
instModuleQuotientAddSubgroupTorsion._proof_2 | Mathlib.GroupTheory.Torsion | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (a : R) (x y : M),
{ toAddSubmonoid := (AddCommGroup.torsion M).toAddSubmonoid, smul_mem' := ⋯ }.quotientRel x y →
(QuotientAddGroup.leftRel
{ toAddSubmonoid := (AddCommGroup.torsion M).toAddSubmonoid, smul_mem... | false |
ByteArray.findFinIdx?.loop | Init.Data.ByteArray.Basic | (a : ByteArray) → (UInt8 → Bool) → ℕ → Option (Fin a.size) | true |
PointedCone.map_id | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] (C : PointedCone R E), PointedCone.map LinearMap.id C = C | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.differentiable_set_subset_D._simp_1_5 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Plausible.TotalFunction.rec | Plausible.Functions | {α : Type u} →
{β : Type v} →
{motive : Plausible.TotalFunction α β → Sort u_1} →
((a : List ((_ : α) × β)) → (a_1 : β) → motive (Plausible.TotalFunction.withDefault a a_1)) →
(t : Plausible.TotalFunction α β) → motive t | false |
CategoryTheory.Functor.IsStronglyCocartesian.mk._flat_ctor | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [toIsHomLift : p.IsHomLift f φ],
(∀ {b' : 𝒳} (g : S ⟶ p.obj b') (φ' : a ⟶ b') [p.IsHomLift (CategoryTheory.Cat... | false |
_private.Init.Data.Vector.Perm.0.Vector.swap_perm._simp_1_2 | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {as bs : Vector α n}, as.Perm bs = as.toList.Perm bs.toList | false |
Mathlib.Tactic.Push.pullStep | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Head → Lean.Meta.Simp.Simproc | true |
TopCat.const._proof_2 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (y : ↑Y), Continuous fun x => y | false |
Function.locallyFinsuppWithin.restrictMonoidHom_apply | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(D : Function.locallyFinsuppWithin U Y) (h : V ⊆ U),
(Function.locallyFinsuppWithin.restrictMonoidHom h) D = D.restrict h | true |
_private.Lean.Meta.Sym.Simp.Rewrite.0.Lean.Meta.Sym.Simp.Theorem.rewrite._sparseCasesOn_4 | Lean.Meta.Sym.Simp.Rewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Elab.DocString.0.Lean.Doc.findShadowedNames.match_3 | Lean.Elab.DocString | {α : Type} →
(motive : Lean.Name × α → Sort u_1) →
(x : Lean.Name × α) → ((fullName : Lean.Name) → (snd : α) → motive (fullName, snd)) → motive x | false |
FiberPrebundle.pretrivializationAt | 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)] →
FiberPrebundle F E → B → Bundle.Pretrivialization F Bundle.TotalSpace.proj | true |
Aesop.ExtResult._sizeOf_1 | Aesop.Util.Tactic.Ext | Aesop.ExtResult → ℕ | false |
UInt64.toUInt16_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a.toUInt16 < b.toUInt16 ↔ a % 65536 < b % 65536 | true |
CategoryTheory.regularTopology.EqualizerCondition.bijective_mapToEqualizer_pullback | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.Functor Cᵒᵖ (Type u_4)},
CategoryTheory.regularTopology.EqualizerCondition P →
∀ {X B : C} (π : X ⟶ B) [CategoryTheory.EffectiveEpi π] [inst_2 : CategoryTheory.Limits.HasPullback π π],
Function.Bijective
(CategoryTheo... | true |
Nonneg.conditionallyCompleteLinearOrder._proof_10 | Mathlib.Algebra.Order.Nonneg.Lattice | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {a : α} (this : Inhabited ↑(Set.Ici a)),
autoParam (∀ (a_1 b : { x // a ≤ x }), compare a_1 b = compareOfLessAndEq a_1 b)
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq._autoParam | false |
collinear_empty | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} (P : Type u_3) [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P], Collinear k ∅ | true |
Lean.Lsp.ReferenceParams.context | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceParams → Lean.Lsp.ReferenceContext | true |
CategoryTheory.Abelian.extFunctor_obj | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) (X : Cᵒᵖ),
(CategoryTheory.Abelian.extFunctor n).obj X = CategoryTheory.Abelian.extFunctorObj (Opposite.unop X) n | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.quasiIso_truncGEMap_iff._proof_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n : ℤ) (i : ℕ), n ≤ n + ↑i | false |
MeasurableSpace.measurableSet_empty | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} (self : MeasurableSpace α), MeasurableSpace.MeasurableSet' self ∅ | true |
ContinuousMultilinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G) (m... | true |
Lean.Meta.Match.Example.val.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} → {a a' : Lean.Expr} → Lean.Meta.Match.Example.val a = Lean.Meta.Match.Example.val a' → (a = a' → P) → P | false |
Mathlib.Tactic.BicategoryLike.MkEqOfNaturality.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m) →
((mkEqOfNaturality :
Lean.Expr →
Lean.Expr →
Mathlib.Tactic.BicategoryLike.IsoLift →
Mathlib.Tactic.... | false |
Batteries.PairingHeapImp.Heap.NodeWF._sunfold | Batteries.Data.PairingHeap | {α : Type u_1} → (α → α → Bool) → α → Batteries.PairingHeapImp.Heap α → Prop | false |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems | Lean.Elab.Tactic.Do.Attr | Type | true |
Aesop.SimpResult.simplified | Aesop.Search.Expansion.Simp | Lean.MVarId → Lean.Meta.Simp.UsedSimps → Aesop.SimpResult | true |
Real.sInf_nonpos | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ}, (∀ x ∈ s, x ≤ 0) → sInf s ≤ 0 | true |
Lean.Meta.initFn._@.Lean.Meta.Tactic.Util.3824588779._hygCtx._hyg.4 | Lean.Meta.Tactic.Util | IO (Lean.Option Bool) | false |
Lean.Lsp.instFromJsonTextDocumentContentChangeEvent | Lean.Data.Lsp.TextSync | Lean.FromJson Lean.Lsp.TextDocumentContentChangeEvent | true |
SchwartzMap.integralCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {D : Type u_1} [inst : NormedAddCommGroup D] (n : ℕ) (x : D), 0 < (1 + ‖x‖) ^ ↑n | false |
Valuation.Integers.one_of_isUnit | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : CommRing R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation R Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O R],
v.Integers O → ∀ {x : O}, IsUnit x → v ((algebraMap O R) x) = 1 | true |
_private.Mathlib.Data.Vector3.0.Fin2.add.match_1.eq_1 | Mathlib.Data.Vector3 | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) → {X Y : B} → (X ⟶ Y) → (self.obj X ⟶ self.obj Y) | true |
CategoryTheory.Localization.Preadditive.add | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | {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] →
[CategoryTheory.Preadditive C] →
{L : CategoryTheory.Functor C D} →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →... | true |
SimpleGraph.induceHom_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} {s : Set V} {t : Set W} (φ : G →g G')
(φst : Set.MapsTo (⇑φ) s t), Set.InjOn (⇑φ) s → Function.Injective ⇑(SimpleGraph.induceHom φ φst) | true |
Std.HashMap.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKey! k' = k | true |
Lean.StructureResolutionOrderResult.mk.noConfusion | Lean.Structure | {P : Sort u} →
{resolutionOrder : Array Lean.Name} →
{conflicts : Array Lean.StructureResolutionOrderConflict} →
{resolutionOrder' : Array Lean.Name} →
{conflicts' : Array Lean.StructureResolutionOrderConflict} →
{ resolutionOrder := resolutionOrder, conflicts := conflicts } =
... | false |
RootPairing.CorootForm | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] → RootPairing ι R M N → [Fintype ι] → LinearMap.BilinFor... | true |
Std.TreeSet.Raw.size_insertMany_list_le | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α}, (t.insertMany l).size ≤ t.size + l.length | true |
CategoryTheory.ThinSkeleton.map₂Functor._proof_2 | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_4, u_3} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (x : CategoryTheory.ThinSkeleton C)
{X Y Z : CategoryTheory.ThinS... | false |
Vector.append_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n}, xs ++ #v[] = xs | true |
TopCat.binaryCofan._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat), Continuous Sum.inr | false |
Mathlib.Tactic.Bicategory.instMonadMor₂BicategoryM | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.BicategoryLike.MonadMor₂ Mathlib.Tactic.Bicategory.BicategoryM | true |
mdifferentiableOn_iUnion_iff_of_isOpen | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
Asymptotics.isEquivalent_iff_tendsto_one | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {u v : α → β} {l : Filter α},
(∀ᶠ (x : α) in l, v x ≠ 0) → (Asymptotics.IsEquivalent l u v ↔ Filter.Tendsto (u / v) l (nhds 1)) | true |
USize.ofNatTruncate_eq_ofNat | Init.Data.UInt.Lemmas | ∀ n < USize.size, USize.ofNatTruncate n = USize.ofNat n | true |
_private.Mathlib.Data.Set.Pointwise.Support.0.support_comp_inv_smul._simp_1_2 | Mathlib.Data.Set.Pointwise.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.isoCycle._simp_6 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Markov.0.MeasureTheory.ae_lt_top'._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {p : α → Prop}, (∀ᵐ (a : α) ∂μ, p a) = (μ {a | ¬p a} = 0) | false |
UniqueAdd.of_image_filter | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] [inst_2 : DecidableEq H] (f : G →ₙ+ H) {A B : Finset G}
{aG bG : G} {aH bH : H},
f aG = aH →
f bG = bH →
UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) aH bH →
UniqueAdd ({a ∈ A | f a = aH}) ({b ∈ B | f b = bH}) aG bG → UniqueA... | true |
OpenPartialHomeomorph.trans' | Mathlib.Topology.OpenPartialHomeomorph.Composition | {X : Type u_1} →
{Y : Type u_3} →
{Z : Type u_5} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
(e : OpenPartialHomeomorph X Y) →
(e' : OpenPartialHomeomorph Y Z) → e.target = e'.source → OpenPartialHomeomorph X Z | true |
IsGroupLikeElem.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a : A},
CoalgebraStruct.counit a = 1 → CoalgebraStruct.comul a = a ⊗ₜ[R] a → IsGroupLikeElem R a | false |
_private.Mathlib.Topology.Algebra.Order.Field.0.tendsto_const_mul_pow_nhds_iff'._simp_1_1 | Mathlib.Topology.Algebra.Order.Field | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T1Space X] {l : Filter Y} [l.NeBot] {c d : X},
Filter.Tendsto (fun x => c) l (nhds d) = (c = d) | false |
OrderAddMonoidHom.coe_zero | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
[inst_3 : AddZeroClass β], ⇑0 = 0 | true |
RingHom.fromOpposite._proof_3 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(↑(f.toAddMonoidHom.comp MulOpposite.opAddEquiv.symm.toAddMonoidHom)).toFun 0 = 0 | false |
BoxIntegral.Box.mk' | Mathlib.Analysis.BoxIntegral.Box.Basic | {ι : Type u_1} → (ι → ℝ) → (ι → ℝ) → WithBot (BoxIntegral.Box ι) | true |
Nat.divMaxPow_one_left | Mathlib.Data.Nat.MaxPowDiv | ∀ (p : ℕ), Nat.divMaxPow 1 p = 1 | true |
AddAction.instElemOrbit_1 | Mathlib.GroupTheory.GroupAction.Defs | {G : Type u_1} →
{α : Type u_2} →
[inst : AddGroup G] → [inst_1 : AddAction G α] → (x : AddAction.orbitRel.Quotient G α) → AddAction G ↑x.orbit | true |
Qq.Impl.ExprBackSubstResult.quoted.injEq | Qq.Macro | ∀ (e e_1 : Lean.Expr), (Qq.Impl.ExprBackSubstResult.quoted e = Qq.Impl.ExprBackSubstResult.quoted e_1) = (e = e_1) | true |
CategoryTheory.Limits.MulticospanIndex.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : SizeOf C] (left : J.L → C) (right : J.R → C) (fst : (b : J.R) → left (J.fst b) ⟶ right b)
(snd : (b : J.R) → left (J.snd b) ⟶ right b), sizeOf { left := left, right := right, fst := fst, snd := snd } = 1 | true |
SnakeLemma.δ._proof_2 | Mathlib.Algebra.Module.SnakeLemma | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
AddSubgroup.neg_mem' | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_3} [inst : AddGroup G] (self : AddSubgroup G) {x : G}, x ∈ self.carrier → -x ∈ self.carrier | true |
Submonoid.noConfusion | Mathlib.Algebra.Group.Submonoid.Defs | {P : Sort u} →
{M : Type u_3} →
{inst : MulOneClass M} →
{t : Submonoid M} →
{M' : Type u_3} →
{inst' : MulOneClass M'} →
{t' : Submonoid M'} → M = M' → inst ≍ inst' → t ≍ t' → Submonoid.noConfusionType P t t' | false |
CategoryTheory.map_coyonedaEquiv | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {F : CategoryTheory.Functor C (Type v₁)}
(f : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y),
F.map g (CategoryTheory.coyonedaEquiv f) = f.app Y g | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_17 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.simplifyResultingUniverse.simp.match_3 | Lean.Elab.MutualInductive | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((a : Lean.Level) → motive a.succ) →
((a b : Lean.Level) → motive (a.max b)) → ((a b : L... | false |
DirichletCharacter.FactorsThrough.χ₀._proof_2 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (h : χ.FactorsThrough d),
∃ χ₀, χ = (DirichletCharacter.changeLevel ⋯) χ₀ | false |
WithBot.pred_coe | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] [inst_2 : (a : α) → Decidable (Order.pred a = a)]
[NoMinOrder α] {a : α}, Order.pred ↑a = ↑(Order.pred a) | true |
ProperCone.relative_hyperplane_separation | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
[inst_2 : CompleteSpace E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F] [inst_5 : CompleteSpace F]
{C : ProperCone ℝ E} {f : E →L[ℝ] F} {b : F},
b ∈ ProperCone.map f C ↔ ∀ (y : F), (ContinuousLinearM... | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_image_const_sub_eq_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | false |
Nat.card_ulift | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3), Nat.card (ULift.{u_4, u_3} α) = Nat.card α | true |
iteratedFDerivWithin._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F | false |
Lean.TheoremVal.all._default | Lean.Declaration | Lean.Name → List Lean.Name | false |
Aesop.Match.forwardDeps | Aesop.Forward.Match.Types | Aesop.Match → Array Aesop.PremiseIndex | true |
Module.subsingletonEquiv.congr_simp | Mathlib.LinearAlgebra.Basis.Defs | ∀ (R : Type u_4) (M : Type u_5) (ι : Type u_6) [inst : Semiring R] [inst_1 : Subsingleton R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], Module.subsingletonEquiv R M ι = Module.subsingletonEquiv R M ι | true |
CategoryTheory.Comon.MonOpOpToComon._proof_2 | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : (CategoryTheory.Mon Cᵒᵖ)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.comul
(C... | false |
_private.Lean.Elab.Tactic.Config.0.Lean.Elab.Tactic.elabConfig.match_3 | Lean.Elab.Tactic.Config | (motive : Option Lean.Term → Sort u_1) →
(source? : Option Lean.Term) →
((source : Lean.Term) → motive (some source)) → ((x : Option Lean.Term) → motive x) → motive source? | false |
CategoryTheory.WithTerminal.lift._proof_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z),
(∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) →
∀ {X Y Z_1 : CategoryTheory.Wi... | false |
CochainComplex.HomComplex.Cochain.diff | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → (K : CochainComplex C ℤ) → CochainComplex.HomComplex.Cochain K K 1 | true |
LinearMap.toContinuousLinearMap._proof_7 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type u_3}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst... | false |
_private.Mathlib.LinearAlgebra.FiniteDimensional.Basic.0.LinearMap.ker_noncommProd_eq_of_supIndep_ker._simp_1_2 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
Lean.Meta.Simp.Methods.toMethodsRef | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Methods → Lean.Meta.Simp.MethodsRef | true |
Polynomial.degree_mul_C_of_isUnit | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} {a : R} [inst : Semiring R], IsUnit a → ∀ (p : Polynomial R), (p * Polynomial.C a).degree = p.degree | true |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_separation_compact_nhds._simp_1_5 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b ∧ c) = (b ∧ a ∧ c) | false |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkLeLtPrefix | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Name → Lean.Meta.Grind.Order.OrderM Lean.Expr | true |
GenContFract.terminatedAt_iff_s_none | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {α : Type u_1} {g : GenContFract α} {n : ℕ}, g.TerminatedAt n ↔ g.s.get? n = none | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.