name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AlgebraicGeometry.StructureSheaf.const_mul_cancel' | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u} [inst : CommRing R] (f g₁ g₂ : R) (U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
(hu₁ : U ≤ PrimeSpectrum.basicOpen g₁) (hu₂ : U ≤ PrimeSpectrum.basicOpen g₂),
AlgebraicGeometry.StructureSheaf.const g₁ g₂ U hu₂ * AlgebraicGeometry.StructureSheaf.const f g₁ U hu₁ =
Algebraic... | true |
MeasureTheory.Measure.AbsolutelyContinuous.add | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ₁ μ₂ ν ν' : MeasureTheory.Measure α},
μ₁.AbsolutelyContinuous ν → μ₂.AbsolutelyContinuous ν' → (μ₁ + μ₂).AbsolutelyContinuous (ν + ν') | true |
CategoryTheory.effectiveEpiStructOfIsIso._proof_1 | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.IsIso f]
{W : C} (x : X ⟶ W),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) x) = x | false |
OrderHom.snd_coe | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (self : α × β), OrderHom.snd self = self.2 | true |
_private.Mathlib.Tactic.DeriveTraversable.0.Mathlib.Deriving.Traversable.mkCasesOnMatch.match_1 | Mathlib.Tactic.DeriveTraversable | (motive : List Lean.Meta.Match.Pattern → Sort u_1) →
(x : List Lean.Meta.Match.Pattern) →
((ctor : Lean.Name) →
(us : List Lean.Level) →
(params : List Lean.Expr) →
(cpats : List Lean.Meta.Match.Pattern) → motive [Lean.Meta.Match.Pattern.ctor ctor us params cpats]) →
((x : List... | false |
instZeroContMDiffAddMonoidMorphism.eq_1 | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_2} [inst_1 : TopologicalSpace H]
{E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : AddMonoid G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G]... | true |
SheafOfModules.mk.injEq | Mathlib.Algebra.Category.ModuleCat.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} (val : PresheafOfModules R.obj)
(isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf) (val_1 : PresheafOfModules R.obj)
(isSheaf_1 : CategoryTheory.Presheaf.IsSheaf J v... | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsCyclotomicExtension.Rat.discr._simp_1_3 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | false |
CategoryTheory.ShortComplex.Exact.isColimitCoimage._proof_2 | Mathlib.CategoryTheory.Abelian.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C}
(h :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limits.cokernel.π S.f) = 0)
{Z' : C} (g' : S.X₂ ⟶ Z') (eq' : CategoryTheory.Catego... | false |
Option.instReflBEq | Init.Data.Option.Basic | ∀ (α : Type u_1) [inst : BEq α] [ReflBEq α], ReflBEq (Option α) | true |
Nonneg.mk_nnqsmul._proof_1 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (q : ℚ≥0) (a : α),
0 ≤ a → 0 ≤ q • a | false |
Std.HashMap.Raw.get?_diff_of_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → (m₁ \ m₂).get? k = none | true |
Array.mapM' | Init.Data.Array.BasicAux | {m : Type u_1 → Type u_2} →
{α : Type u_3} → {β : Type u_1} → [Monad m] → (α → m β) → (as : Array α) → m { bs // bs.size = as.size } | true |
StarSubalgebra.mem_bot | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {x : A},
x ∈ ⊥ ↔ x ∈ Set.range ⇑(algebraMap R A) | true |
_private.Mathlib.Topology.UniformSpace.Defs.0.mem_nhds_uniformity_iff_left._simp_1_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) | false |
TestFunctionClass.mk | Mathlib.Analysis.Distribution.TestFunction | {B : Type u_6} →
{E : outParam (Type u_7)} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : outParam (TopologicalSpace.Opens E)} →
{F : outParam (Type u_8)} →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ou... | true |
Lean.Core.Cache.casesOn | Lean.CoreM | {motive : Lean.Core.Cache → Sort u} →
(t : Lean.Core.Cache) →
((instLevelType instLevelValue : Lean.Core.InstantiateLevelCache) →
motive { instLevelType := instLevelType, instLevelValue := instLevelValue }) →
motive t | false |
MeasureTheory.MemLp.eLpNorm_mk_lt_top | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_6} {E : Type u_7} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : NormedAddCommGroup E]
{p : ENNReal} {f : α → E} (hfp : MeasureTheory.MemLp f p μ),
MeasureTheory.eLpNorm (↑(MeasureTheory.AEEqFun.mk f ⋯)) p μ < ⊤ | true |
Std.Do.SPred.and_elim_l' | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, (P ⊢ₛ R) → P ∧ Q ⊢ₛ R | true |
Bundle.Pretrivialization.continuousLinearMap.match_1 | Mathlib.Topology.VectorBundle.Hom | ∀ {𝕜₁ : Type u_6} [inst : NontriviallyNormedField 𝕜₁] {𝕜₂ : Type u_7} [inst_1 : NontriviallyNormedField 𝕜₂]
(σ : 𝕜₁ →+* 𝕜₂) {B : Type u_1} {F₁ : Type u_3} [inst_2 : NormedAddCommGroup F₁] [inst_3 : NormedSpace 𝕜₁ F₁]
{E₁ : B → Type u_5} [inst_4 : (x : B) → AddCommGroup (E₁ x)] [inst_5 : (x : B) → Module 𝕜₁ ... | false |
SimpleGraph.ConnectedComponent.isoEquivSupp._proof_4 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_1} {V' : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G ≃g G') (C : G.ConnectedComponent)
(v : ↑C.supp), ⟨φ.symm ↑⟨φ ↑v, ⋯⟩, ⋯⟩ = v | false |
Lean.Lsp.DocumentSymbolAux.children? | Lean.Data.Lsp.LanguageFeatures | {Self : Type} → Lean.Lsp.DocumentSymbolAux Self → Option (Array Self) | true |
invOf_two_add_invOf_two | Mathlib.Algebra.Ring.Invertible | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : Invertible 2], ⅟2 + ⅟2 = 1 | true |
instCompleteLinearOrderElemIccOfFactLe._proof_6 | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {a b : α} [inst_1 : Fact (a ≤ b)]
(a_1 b_1 c : ↑(Set.Icc a b)), a_1 \ b_1 ≤ c ↔ a_1 ≤ max b_1 c | false |
Topology.WithUpper.instNonempty | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [Nonempty α], Nonempty (Topology.WithUpper α) | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_pos_of_mem_ball._simp_1_10 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | (¬False) = True | false |
Lean.Parser.ppGroup | Lean.Parser.Extra | Lean.Parser.Parser → Lean.Parser.Parser | true |
CategoryTheory.GrpObj.rec | Mathlib.CategoryTheory.Monoidal.Grp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{X : C} →
{motive : CategoryTheory.GrpObj X → Sort u} →
([toMonObj : CategoryTheory.MonObj X] →
(inv : X ⟶ X) →
(left_inv :
... | false |
_private.Mathlib.Algebra.Order.Group.Abs.0.mabs_mul_eq_mul_mabs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G},
a ≤ b → (|a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1) | true |
_private.Lean.MetavarContext.0.Lean.DependsOn.main | Lean.MetavarContext | (Lean.FVarId → Bool) → (Lean.MVarId → Bool) → Lean.Expr → Lean.DependsOn.M✝ Bool | true |
Std.TreeMap.getD_modify_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {fallback : β}
{f : β → β}, (t.modify k f).getD k fallback = (Option.map f t[k]?).getD fallback | true |
SemiNormedGrp₁.mkIso_hom | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (f : M ≅ N) (i : (SemiNormedGrp.Hom.hom f.hom).NormNoninc)
(i' : (SemiNormedGrp.Hom.hom f.inv).NormNoninc),
(SemiNormedGrp₁.mkIso f i i').hom = SemiNormedGrp₁.mkHom (SemiNormedGrp.Hom.hom f.hom) i | true |
CategoryTheory.Adjunction.adjunctionOfEquivLeft._proof_4 | 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] {G : CategoryTheory.Functor D C} {F_obj : C → D}
(e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y))
(he :
∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y),
(e X Y') (Cate... | false |
Lean.PrettyPrinter.Parenthesizer.sepByNoAntiquot.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | true |
MeasureTheory.extend_union | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} {P : Set α → Prop} {m : (s : Set α) → P s → ENNReal} (P0 : P ∅),
m ∅ P0 = 0 →
∀ (PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)),
(∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
Pairwise (Function.onFun Disjoint f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯) →
∀ {... | true |
ZMod.neg_eq_self_iff | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (a : ZMod n), -a = a ↔ a = 0 ∨ 2 * a.val = n | true |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.MinImports.minImportsLinter.match_1 | Mathlib.Tactic.Linter.MinImports | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) →
((impPos : Lean.Syntax) → motive (some impPos)) → ((x : Option Lean.Syntax) → motive x) → motive x | false |
InfTopHom._sizeOf_inst | Mathlib.Order.Hom.BoundedLattice | (α : Type u_6) →
(β : Type u_7) →
{inst : Min α} →
{inst_1 : Min β} → {inst_2 : Top α} → {inst_3 : Top β} → [SizeOf α] → [SizeOf β] → SizeOf (InfTopHom α β) | false |
AddSubgroup.addCommGroupTopologicalClosure._proof_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : T2Space G] (s : AddSubgroup G) (hs : ∀ (x y : ↥s), x + y = y + x) (a b : ↥s.topologicalClosure),
a + b = b + a | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IicProdIoc_preimage._simp_1_5 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | false |
ByteArray.size_data | Init.Data.ByteArray.Basic | ∀ {a : ByteArray}, a.data.size = a.size | true |
Lean.Lsp.Ipc.ModuleHierarchy.mk.sizeOf_spec | Lean.Data.Lsp.Ipc | ∀ (item : Lean.Lsp.LeanImport) (children : Array Lean.Lsp.Ipc.ModuleHierarchy),
sizeOf { item := item, children := children } = 1 + sizeOf item + sizeOf children | true |
HahnSeries.embDomainAlgHom | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] →
[inst_3 : CommSemiring R] →
{A : Type u_6} →
[inst_4 : Semiring A] →
[inst_5 : Algebra R A] →
{Γ' : T... | true |
Std.CancellationToken.State.ctorIdx | Std.Sync.CancellationToken | Std.CancellationToken.State → ℕ | false |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →... | true |
_private.Batteries.Tactic.SqueezeScope.0.Batteries.Tactic._aux_Batteries_Tactic_SqueezeScope___elabRules__private_Batteries_Tactic_SqueezeScope_0_Batteries_Tactic_squeezeWrap_1.match_13 | Batteries.Tactic.SqueezeScope | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc | false |
Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo.mk.injEq | Lean.Compiler.LCNF.JoinPoints | ∀ (arity : ℕ) (associated : Std.HashSet Lean.FVarId) (arity_1 : ℕ) (associated_1 : Std.HashSet Lean.FVarId),
({ arity := arity, associated := associated } = { arity := arity_1, associated := associated_1 }) =
(arity = arity_1 ∧ associated = associated_1) | true |
AddMonoidHom.compHom.eq_1 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type uM} {N : Type uN} {P : Type uP} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N]
[inst_2 : AddCommMonoid P],
AddMonoidHom.compHom =
{ toFun := fun g => { toFun := g.comp, map_zero' := ⋯, map_add' := ⋯ }, map_zero' := ⋯, map_add' := ⋯ } | true |
_private.Mathlib.RingTheory.WittVector.Truncated.0._aux_Mathlib_RingTheory_WittVector_Truncated___unexpand_WittVector_1 | Mathlib.RingTheory.WittVector.Truncated | Lean.PrettyPrinter.Unexpander | false |
MeasureTheory.Measure.MeasureDense.of_generateFrom_isSetAlgebra_sigmaFinite | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_1} [m : MeasurableSpace X] {μ : MeasureTheory.Measure X} {𝒜 : Set (Set X)},
MeasureTheory.IsSetAlgebra 𝒜 → ∀ (S : μ.FiniteSpanningSetsIn 𝒜), m = MeasurableSpace.generateFrom 𝒜 → μ.MeasureDense 𝒜 | true |
SetLike.gsemiring._proof_8 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : AddMonoid ι] [inst_1 : Semiring R] [inst_2 : SetLike σ R]
[AddSubmonoidClass σ R] (A : ι → σ) [SetLike.GradedMonoid A], ↑0 ∈ A 0 | false |
NonUnitalStarAlgebra.elemental.self_mem._simp_1 | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] [inst_8 : TopologicalSpace A] [inst_9 : IsSemitopologicalSemiring A]
[ins... | false |
AddConstMapClass.map_int_add' | Mathlib.Algebra.AddConstMap.Basic | ∀ {F : Type u_1} {G : Type u_2} {H : Type u_3} [inst : FunLike F G H] {b : H} [inst_1 : AddCommGroupWithOne G]
[inst_2 : AddGroup H] [AddConstMapClass F G H 1 b] (f : F) (n : ℤ) (x : G), f (↑n + x) = f x + n • b | true |
CategoryTheory.Limits.pullbackIsPullbackOfCompMono._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z : C} (f : X ⟶ W) (g : Y ⟶ W) (i : W ⟶ Z)
[CategoryTheory.Mono i] [inst_2 : CategoryTheory.Limits.HasPullback f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f g) (CategoryTheory.CategoryStruct.comp f i) =
Catego... | false |
Int8.neg_ne_zero._simp_1 | Init.Data.SInt.Lemmas | ∀ {a : Int8}, (-a ≠ 0) = (a ≠ 0) | false |
CategoryTheory.ShortComplex.HasRightHomology.mk | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, Nonempty S.RightHomologyData → S.HasRightHomology | true |
IsUltrametricDist.norm_add_le_max | Mathlib.Analysis.Normed.Group.Ultra | ∀ {S : Type u_1} [inst : SeminormedAddGroup S] [IsUltrametricDist S] (x y : S), ‖x + y‖ ≤ max ‖x‖ ‖y‖ | true |
PosNum.divMod | Mathlib.Data.Num.Basic | PosNum → PosNum → Num × Num | true |
CategoryTheory.eqToIso.inv | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (p : X = Y),
(CategoryTheory.eqToIso p).inv = CategoryTheory.eqToHom ⋯ | true |
LinearMap.splittingOfFinsuppSurjective_splits | Mathlib.LinearAlgebra.Finsupp.LSum | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_4}
(f : M →ₗ[R] α →₀ R) (s : Function.Surjective ⇑f), f ∘ₗ f.splittingOfFinsuppSurjective s = LinearMap.id | true |
LeftCancelMonoid.rec | Mathlib.Algebra.Group.Defs | {M : Type u} →
{motive : LeftCancelMonoid M → Sort u_1} →
([toMonoid : Monoid M] →
[toIsLeftCancelMul : IsLeftCancelMul M] →
motive { toMonoid := toMonoid, toIsLeftCancelMul := toIsLeftCancelMul }) →
(t : LeftCancelMonoid M) → motive t | false |
IsLprojection.coe_zero | Mathlib.Analysis.Normed.Module.MStructure | ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X], ↑0 = 0 | true |
_private.Mathlib.Topology.AlexandrovDiscrete.0.gc_nhdsKer_interior._simp_1_2 | Mathlib.Topology.AlexandrovDiscrete | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, (t ⊆ interior s) = ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s | false |
Units.embedding_val_mk | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_4} [inst : DivisionMonoid M] [inst_1 : TopologicalSpace M],
ContinuousOn Inv.inv {x | IsUnit x} → Topology.IsEmbedding Units.val | true |
List.perm_permutations_iff | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {s t : List α}, s.permutations.Perm t.permutations ↔ s.Perm t | true |
Finsupp.sum_ite_eq' | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] [inst_2 : DecidableEq α]
(f : α →₀ M) (a : α) (b : α → M → N),
(f.sum fun x v => if x = a then b x v else 0) = if a ∈ f.support then b a (f a) else 0 | true |
IsPrimitiveRoot.isRoot_geom_sum | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {k : ℕ} [inst : CommRing R] [IsDomain R] {ζ : R},
IsPrimitiveRoot ζ k → 1 < k → (∑ i ∈ Finset.range k, Polynomial.X ^ i).IsRoot ζ | true |
Int.toList_roc_eq_cons_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {xs : List ℤ} {m n a : ℤ}, ((m<...=n).toList = a :: xs) = (m + 1 = a ∧ m < n ∧ ((m + 1)<...=n).toList = xs) | false |
Subring.unop_iSup | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {ι : Sort u_1} {R : Type u_2} [inst : NonAssocRing R] (S : ι → Subring Rᵐᵒᵖ), (iSup S).unop = ⨆ i, (S i).unop | true |
Int64.le_refl | Init.Data.SInt.Lemmas | ∀ (a : Int64), a ≤ a | true |
ENNReal.coe_finset_prod | Mathlib.Data.ENNReal.BigOperators | ∀ {α : Type u_1} {s : Finset α} {f : α → NNReal}, ↑(∏ a ∈ s, f a) = ∏ a ∈ s, ↑(f a) | true |
Set.image_affine_Icc' | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {K : Type u_2} [inst : DivisionSemiring K] [inst_1 : PartialOrder K] [PosMulReflectLT K] [IsOrderedCancelAddMonoid K]
[ExistsAddOfLE K] {a : K},
0 < a → ∀ (b c d : K), (fun x => a * x + b) '' Set.Icc c d = Set.Icc (a * c + b) (a * d + b) | true |
_private.Mathlib.Data.Set.Piecewise.0.Set.piecewise_insert._simp_1_2 | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_7 | Lean.Elab.DeclNameGen | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
_private.Init.Data.Vector.MapIdx.0.Vector.mapIdx_mapIdx._simp_1_1 | Init.Data.Vector.MapIdx | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs : Vector α n} {f : ℕ → α → β} {ys : Vector β n},
(Vector.mapIdx f xs = ys) = ∀ (i : ℕ) (h : i < n), f i xs[i] = ys[i] | false |
NumberField.instNonemptyInfinitePlaceOfRingHomComplex | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ (K : Type u_1) [inst : Field K] [Nonempty (K →+* ℂ)], Nonempty (NumberField.InfinitePlace K) | true |
Lean.Lsp.VersionedTextDocumentIdentifier._sizeOf_inst | Lean.Data.Lsp.Basic | SizeOf Lean.Lsp.VersionedTextDocumentIdentifier | false |
isNoetherianRing_iff | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} [inst : Semiring R], IsNoetherianRing R ↔ IsNoetherian R R | true |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Expr.alphaEqv._sparseCasesOn_11 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) →
((x : Lean.IR.VarId) → motive (Lean.IR.Expr.unbox x)) → (Nat.hasNotBit 1024 t.ctorIdx → motive t) → motive t | false |
Graph.IsSpanningSubgraph.trans | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G G₁ G₂ : Graph α β}, G ≤s G₁ → G₁ ≤s G₂ → G ≤s G₂ | true |
MvPolynomial.supportedEquivMvPolynomial._proof_1 | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (s : Set σ),
Function.Injective ⇑(MvPolynomial.rename Subtype.val) | false |
MeasureTheory.QuasiMeasurePreserving.snd | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {τ : MeasureTheory.Measure γ}
{f : α → β × γ},
MeasureTheory.Measure.QuasiMeasurePreserving f μ (ν.prod τ) →
MeasureTh... | true |
CategoryTheory.Limits.CokernelCofork.IsColimit.ofπ._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {Z : C} (g : Y ⟶ Z)
(desc : {Z' : C} → (g' : Y ⟶ Z') → CategoryTheory.CategoryStruct.comp f g' = 0 → (Z ⟶ Z')),
(∀ {Z' : C} (g' : Y ⟶ Z') (eq' : CategoryTheory.CategoryStruct.co... | false |
_private.Mathlib.Analysis.InnerProductSpace.StandardSubspace.0.StandardSubspace.ext.match_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} (motive : StandardSubspace H → Prop)
(h : StandardSubspace H),
(∀ (toClosedSubmodule : ClosedSubmodule ℝ H) (IsSeparating : toClosedSubmodule ⊓ toClosedSubmodule.mulI = ⊥)
(IsCyclic : toClosedSubmodule ⊔ toClosedSubmodule.mulI = ⊤... | false |
Topology.WithGeneratedByTopology.instTopologicalSpace._aux_1 | Mathlib.Topology.Convenient.GeneratedBy | {ι : Type u_2} →
{X : ι → Type u_3} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y : Type u_1} → [inst_1 : TopologicalSpace Y] → TopologicalSpace (Topology.WithGeneratedByTopology X Y) | false |
Std.DHashMap.keysArray | Std.Data.DHashMap.Basic | {α : Type u} → {β : α → Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.DHashMap α β → Array α | true |
HomologicalComplex.shortComplexTruncLEX₃ToTruncGE | Mathlib.Algebra.Homology.Embedding.AreComplementary | {ι : Type u_1} →
{ι₁ : Type u_2} →
{ι₂ : Type u_3} →
{c : ComplexShape ι} →
{c₁ : ComplexShape ι₁} →
{c₂ : ComplexShape ι₂} →
{C : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_4} C] →
[inst_1 : CategoryTheory.Abelian C] →
(... | true |
Ideal.coe_smul_primesOver_eq_map_galRestrict | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {p : Ideal A}
(K : Type u_4) (L : Type u_5) [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K]
[inst_6 : IsFractionRing A K] [inst_7 : Algebra B L] [inst_8 : Algebra K L] [inst_9 : Algebra A L]
[inst_10 : Is... | true |
Set.indicator_const_smul | Mathlib.Algebra.Module.Basic | ∀ {α : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : SMulZeroClass R M] (s : Set α) (r : R)
(f : α → M), (s.indicator fun x => r • f x) = fun x => r • s.indicator f x | true |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_6 | Mathlib.RingTheory.LittleWedderburn | ∀ {D : Type u_1} [inst : DivisionRing D] {R : Subring D} [inst_1 : Fintype D] [inst_2 : DecidableEq D]
[inst_3 : DecidablePred fun x => x ∈ R] (n : ℕ) (a : ↥R),
DivisionRing.zpow (Int.negSucc n) a = (DivisionRing.zpow (↑n.succ) a)⁻¹ | false |
AddAction.set_mem_fixedBy_of_subset_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {s : Set α} {g : G},
s ⊆ AddAction.fixedBy α g → s ∈ AddAction.fixedBy (Set α) g | true |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.evalRename.match_1 | Lean.Elab.Tactic.ElabTerm | (motive : Option Lean.FVarId → Sort u_1) →
(fvarId? : Option Lean.FVarId) →
(Unit → motive none) → ((fvarId : Lean.FVarId) → motive (some fvarId)) → motive fvarId? | false |
SlashInvariantForm.coe_zero | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ}, ⇑0 = 0 | true |
Lean.IR.EmitLLVM.emitFnArgs | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} →
LLVM.Builder llvmctx → Bool → LLVM.Value llvmctx → Array Lean.IR.Param → Lean.IR.EmitLLVM.M llvmctx Unit | true |
CategoryTheory.Subgroupoid.instCompleteLattice | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} → [inst : CategoryTheory.Groupoid C] → CompleteLattice (CategoryTheory.Subgroupoid C) | true |
Lean.IR.EmitLLVM.Context.noConfusion | Lean.Compiler.IR.EmitLLVM | {P : Sort u} →
{llvmctx : LLVM.Context} →
{t : Lean.IR.EmitLLVM.Context llvmctx} →
{llvmctx' : LLVM.Context} →
{t' : Lean.IR.EmitLLVM.Context llvmctx'} →
llvmctx = llvmctx' → t ≍ t' → Lean.IR.EmitLLVM.Context.noConfusionType P t t' | false |
CategoryTheory.kernelCokernelCompSequence.snakeInput_L₀_f | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z),
(CategoryTheory.kernelCokernelCompSequence.snakeInput f g).L₀.f =
CategoryTheory.Limits.kernel.map f (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.id X) g ⋯ | true |
SimpleGraph.Walk.IsCircuit.mk | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.IsTrail → p ≠ SimpleGraph.Walk.nil → p.IsCircuit | true |
Subsemiring.center.commSemiring._proof_11 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ) (x : ↥(Submonoid.center R)), Monoid.npow (n + 1) x = Monoid.npow n x * x | false |
Matroid.contract_spanning_iff' | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {X C : Set α}, (M.contract C).Spanning X ↔ M.Spanning (X ∪ C ∩ M.E) ∧ Disjoint X C | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.