name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.0.Asymptotics.IsEquivalent.smul._simp_1_6 | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Rack.act'_symm_apply | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] (x y : R), (Rack.act' x).symm y = Rack.invAct x y |
FreeAddGroup.zero_ne_of | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (a : α), 0 ≠ FreeAddGroup.of a |
Ordering.Compares.inj | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] {o₁ o₂ : Ordering} {a b : α}, o₁.Compares a b → o₂.Compares a b → o₁ = o₂ |
AddSubgroup.card_le_one_iff_eq_bot | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [Finite ↥H], Nat.card ↥H ≤ 1 ↔ H = ⊥ |
ModuleCat.instPreservesFiniteLimitsLocalizationLocalizedModuleFunctor | Mathlib.Algebra.Category.ModuleCat.Localization | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] (S : Submonoid R),
CategoryTheory.Limits.PreservesFiniteLimits (ModuleCat.localizedModuleFunctor S) |
_private.Lean.Compiler.LCNF.ElimDead.0.Lean.Compiler.LCNF.collectLocalDeclsLetValue.match_1 | Lean.Compiler.LCNF.ElimDead | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue pu) →
(Unit → motive Lean.Compiler.LCNF.LetValue.erased) →
((value : Lean.Compiler.LCNF.LitValue) → motive (Lean.Compiler.LCNF.LetValue.lit value)) →
((typeName : Lean.Name) →
(idx : ℕ) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.LetValue.proj typeName idx fvarId h)) →
((n : ℕ) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.reset n fvarId h)) →
((n offset : ℕ) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.sproj n offset fvarId h)) →
((i : ℕ) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.uproj i fvarId h)) →
((i : ℕ) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.oproj i fvarId h)) →
((ty : Lean.Expr) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.box ty fvarId h)) →
((fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.unbox fvarId h)) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.LetValue.const declName us args h)) →
((fvarId : Lean.FVarId) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
motive (Lean.Compiler.LCNF.LetValue.fvar fvarId args)) →
((fvarId : Lean.FVarId) →
(i : Lean.Compiler.LCNF.CtorInfo) →
(updateHeader : Bool) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.reuse fvarId i updateHeader args h)) →
((fn : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.fap fn args h)) →
((fn : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.pap fn args h)) →
((i : Lean.Compiler.LCNF.CtorInfo) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.LetValue.ctor i args h)) →
motive e |
CategoryTheory.Equalizer.Presieve.SecondObj._proof_1 | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (R : CategoryTheory.Presieve X)
[R.HasPairwisePullbacks] (fg : ((Y : C) × { f // R f }) × (Z : C) × { g // R g }),
CategoryTheory.Limits.HasPullback ↑fg.1.snd ↑fg.2.snd |
Lean.Doc.Syntax.codeblock._regBuiltin.Lean.Doc.Syntax.codeblock.docString_1 | Lean.DocString.Syntax | IO Unit |
CategoryTheory.ComposableArrows.homMk₃._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | 2 < 3 + 1 |
Nat.sum_div | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_5} {s : Finset ι} {f : ι → ℕ} {n : ℕ}, (∀ i ∈ s, n ∣ f i) → (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n |
AddSubmonoidClass.toAddMonoid._proof_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_2} [inst : AddMonoid M] {A : Type u_1} [inst_1 : SetLike A M] [AddSubmonoidClass A M], ZeroMemClass A M |
Matrix.GeneralLinearGroup.continuous_det | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_5} {R : Type u_8} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R]
[inst_3 : TopologicalSpace R] [IsTopologicalRing R], Continuous ⇑Matrix.GeneralLinearGroup.det |
Lean.Elab.Tactic.Do.ProofMode.MGoal.assumption._unsafe_rec | Lean.Elab.Tactic.Do.ProofMode.Assumption | Lean.Elab.Tactic.Do.ProofMode.MGoal → OptionT Lean.MetaM Lean.Expr |
_private.Mathlib.MeasureTheory.PiSystem.0.mem_generatePiSystem_iUnion_elim'._simp_1_1 | Mathlib.MeasureTheory.PiSystem | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Plausible.Configuration.numInst._default | Plausible.Testable | ℕ |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.StructInstState.optParamFields._default | Lean.Elab.StructInst | Array (Lean.Name × Lean.Expr × Bool) |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse._proof_6 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.Functor C (CategoryTheory.Comon D)} (f : X ⟶ Y) (g : Y ⟶ Z) (x x_1 : C) (f_1 : x ⟶ x_1),
(CategoryTheory.CategoryStruct.comp (X.map f_1) ((CategoryTheory.CategoryStruct.comp f g).app x_1)).hom =
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp f g).app x) (Z.map f_1)).hom |
CancelMonoidWithZero | Mathlib.Algebra.GroupWithZero.Defs | Type u_2 → Type u_2 |
_private.Lean.Meta.Sym.ReplaceS.0.Lean.Meta.Sym.visitChild.match_1.eq_5 | Lean.Meta.Sym.ReplaceS | ∀ (motive : Lean.Expr → Sort u_1) (declName : Lean.Name) (us : List Lean.Level)
(h_1 : (a : Lean.Literal) → motive (Lean.Expr.lit a)) (h_2 : (mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId))
(h_3 : (deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex))
(h_4 : (fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId))
(h_5 : (declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us))
(h_6 : (u : Lean.Level) → motive (Lean.Expr.sort u)) (h_7 : (e : Lean.Expr) → motive e),
(match Lean.Expr.const declName us with
| Lean.Expr.lit a => h_1 a
| Lean.Expr.mvar mvarId => h_2 mvarId
| Lean.Expr.bvar deBruijnIndex => h_3 deBruijnIndex
| Lean.Expr.fvar fvarId => h_4 fvarId
| Lean.Expr.const declName us => h_5 declName us
| Lean.Expr.sort u => h_6 u
| e => h_7 e) =
h_5 declName us |
Lean.Lsp.SymbolKind.variable | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind |
_private.Mathlib.Topology.UniformSpace.Separation.0.t0Space_iff_ker_uniformity._simp_1_4 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.card_edgeFinset_turanGraph._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {r : ℕ} (n : ℕ),
(n % r + r * (n / r) + n % r) * (r * (n / r)) * (r - 1) =
(2 * (n % r * (n / r) * (r - 1)) + r * (r - 1) * (n / r) ^ 2) * r |
FirstOrder.Language.LHom._sizeOf_1 | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → (L →ᴸ L') → ℕ |
IsMaxOn.dual | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α},
IsMaxOn f s a → IsMinOn (⇑OrderDual.toDual ∘ f) s a |
SimplexCategory.Hom.ext_one_left._auto_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | Lean.Syntax |
CategoryTheory.SplitEpi | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → (X ⟶ Y) → Type v₁ |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.Defs.0.MvPolynomial.support_esymm''._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) |
OpenPartialHomeomorph.pi._proof_4 | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {ι : Type u_1} {X : ι → Type u_3} {Y : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → TopologicalSpace (Y i)] (ei : (i : ι) → OpenPartialHomeomorph (X i) (Y i)),
ContinuousOn (PartialEquiv.pi fun i => (ei i).toPartialEquiv).invFun
(PartialEquiv.pi fun i => (ei i).toPartialEquiv).target |
String.reduceGE._regBuiltin.String.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.2055768308._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit |
Lean.PrettyPrinter.Delaborator.appUnexpanderAttribute | Lean.PrettyPrinter.Delaborator.Basic | Lean.KeyedDeclsAttribute Lean.PrettyPrinter.Unexpander |
MonoidAlgebra.mul_apply_left | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {G : Type u_3} [inst : Semiring R] [inst_1 : Group G] (x y : MonoidAlgebra R G) (g : G),
(x * y) g = Finsupp.sum x fun h r => r * y (h⁻¹ * g) |
TensorProduct.tensorQuotEquivQuotSMul_symm_mk | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(x : M), (TensorProduct.tensorQuotEquivQuotSMul M I).symm (Submodule.Quotient.mk x) = x ⊗ₜ[R] 1 |
Bornology.IsCobounded.superset | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {x : Bornology α} {s t : Set α}, Bornology.IsCobounded s → s ⊆ t → Bornology.IsCobounded t |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic.0.CStarAlgebra.spectralOrder._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ (R : Type u_1) [inst : AddMonoid R] [inst_1 : StarAddMonoid R], IsSelfAdjoint 0 = True |
Lean.Server.Watchdog.ModuleQueryMatch.noConfusion | Lean.Server.Watchdog | {P : Sort u} →
{t t' : Lean.Server.Watchdog.ModuleQueryMatch} → t = t' → Lean.Server.Watchdog.ModuleQueryMatch.noConfusionType P t t' |
Sigma._sizeOf_inst._@.Mathlib.Util.CompileInductive.4222055393._hygCtx._hyg.9 | Mathlib.Util.CompileInductive | {α : Type u} → (β : α → Type v) → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Sigma β) |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.normalizeBound | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | Lean.Expr → Lean.Meta.Grind.GrindM Lean.Meta.Grind.Arith.Cutsat.SymbolicBound |
CategoryTheory.Abelian.SpectralObject.dHomologyData._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Homology | Lean.Syntax |
_private.Mathlib.CategoryTheory.ObjectProperty.Basic.0.CategoryTheory.ObjectProperty.singleton_le_iff._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {ι : Type u'} (X : ι → C)
(P : CategoryTheory.ObjectProperty C), (CategoryTheory.ObjectProperty.ofObj X ≤ P) = ∀ (i : ι), P (X i) |
Multiset.sort_range | Mathlib.Data.Multiset.Sort | ∀ (n : ℕ), ((Multiset.range n).sort fun a b => a ≤ b) = List.range n |
Mathlib.Tactic.Translate.Config.tgt | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.Config → Lean.Name |
Lean.Grind.CommRing.Poly.recOn | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Poly → Sort u} →
(t : Lean.Grind.CommRing.Poly) →
((k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k)) →
((k : ℤ) →
(v : Lean.Grind.CommRing.Mon) →
(p : Lean.Grind.CommRing.Poly) → motive p → motive (Lean.Grind.CommRing.Poly.add k v p)) →
motive t |
Lean.Firefox.FrameTable.Entry.mk.inj | Lean.Util.Profiler | ∀ {address : ℤ} {inlineDepth : ℕ} {category subcategory : Option ℕ} {func : ℕ}
{nativeSymbol innerWindowID implementation : Option Lean.Json} {line column : Option ℕ} {address_1 : ℤ}
{inlineDepth_1 : ℕ} {category_1 subcategory_1 : Option ℕ} {func_1 : ℕ}
{nativeSymbol_1 innerWindowID_1 implementation_1 : Option Lean.Json} {line_1 column_1 : Option ℕ},
{ address := address, inlineDepth := inlineDepth, category := category, subcategory := subcategory, func := func,
nativeSymbol := nativeSymbol, innerWindowID := innerWindowID, implementation := implementation, line := line,
column := column } =
{ address := address_1, inlineDepth := inlineDepth_1, category := category_1, subcategory := subcategory_1,
func := func_1, nativeSymbol := nativeSymbol_1, innerWindowID := innerWindowID_1,
implementation := implementation_1, line := line_1, column := column_1 } →
address = address_1 ∧
inlineDepth = inlineDepth_1 ∧
category = category_1 ∧
subcategory = subcategory_1 ∧
func = func_1 ∧
nativeSymbol = nativeSymbol_1 ∧
innerWindowID = innerWindowID_1 ∧ implementation = implementation_1 ∧ line = line_1 ∧ column = column_1 |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.trivialStructureInfoExt | Lean.Compiler.LCNF.MonoTypes | Lean.Compiler.LCNF.CacheExtension Lean.Name (Option Lean.Compiler.LCNF.TrivialStructureInfo) |
AlgebraicIndependent.option_iff_transcendental | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {ι : Type u_1} {R : Type u_3} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A],
AlgebraicIndependent R x →
∀ (a : A), (AlgebraicIndependent R fun o => o.elim a x) ↔ Transcendental (↥(Algebra.adjoin R (Set.range x))) a |
mabs_div | 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|ₘ |
MvPolynomial.sumToIter_iterToSum | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (p : MvPolynomial S₁ (MvPolynomial S₂ R)),
(MvPolynomial.sumToIter R S₁ S₂) ((MvPolynomial.iterToSum R S₁ S₂) p) = p |
Lean.Omega.Int.ofNat_natAbs | Init.Omega.Int | ∀ (a : ℤ), ↑a.natAbs = if 0 ≤ a then a else -a |
CategoryTheory.LocalizerMorphism.RightResolution.unopFunctor._proof_3 | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_4} {C₂ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) (X₂ : C₂ᵒᵖ)
{X Y : (Φ.op.RightResolution X₂)ᵒᵖ} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (Φ.functor.map φ.unop.f.unop) (Opposite.unop Y).unop.w = (Opposite.unop X).unop.w |
Opposite.unop_injective | Mathlib.Data.Opposite | ∀ {α : Sort u}, Function.Injective Opposite.unop |
generatePiSystem.recOn | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)} {motive : (a : Set α) → generatePiSystem S a → Prop} {a : Set α}
(t : generatePiSystem S a),
(∀ {s : Set α} (h_s : s ∈ S), motive s ⋯) →
(∀ {s t : Set α} (h_s : generatePiSystem S s) (h_t : generatePiSystem S t) (h_nonempty : (s ∩ t).Nonempty),
motive s h_s → motive t h_t → motive (s ∩ t) ⋯) →
motive a t |
LinearIsometryEquiv.smul_apply | Mathlib.Analysis.RCLike.Basic | ∀ {𝕜 : Type u_3} {V : Type u_4} {W : Type u_5} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : Module 𝕜 V] [inst_3 : SeminormedAddCommGroup W] [inst_4 : NormedSpace 𝕜 W] (e : V ≃ₗᵢ[𝕜] W)
(α : ↥(unitary 𝕜)) (x : V), (α • e) x = ↑α • e x |
MulArchimedean.rec | Mathlib.Algebra.Order.Archimedean.Basic | {M : Type u_5} →
[inst : CommMonoid M] →
[inst_1 : PartialOrder M] →
{motive : MulArchimedean M → Sort u} →
((arch : ∀ (x : M) {y : M}, 1 < y → ∃ n, x ≤ y ^ n) → motive ⋯) → (t : MulArchimedean M) → motive t |
Lean.Elab.Tactic.ElimTargetView.casesOn | Lean.Elab.Tactic.Induction | {motive : Lean.Elab.Tactic.ElimTargetView → Sort u} →
(t : Lean.Elab.Tactic.ElimTargetView) →
((hIdent? : Option Lean.Ident) → (term : Lean.Syntax) → motive { hIdent? := hIdent?, term := term }) → motive t |
AddOreLocalization.universalAddHom.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {T : Type u_2}
[inst_2 : AddMonoid T] (f : R →+ T) (fS : ↥S →+ AddUnits T) (hf : ∀ (s : ↥S), f ↑s = ↑(fS s)),
AddOreLocalization.universalAddHom f fS hf =
{ toFun := fun x => AddOreLocalization.liftExpand (fun r s => ↑(-fS s) + f r) ⋯ x, map_zero' := ⋯, map_add' := ⋯ } |
ContinuousAddMonoidHom.toContinuousMap_toContinuousAddMonoidHom | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] {F : Type u_7} [inst_4 : FunLike F A B] [inst_5 : AddMonoidHomClass F A B]
[inst_6 : ContinuousMapClass F A B] (f : F), ↑↑f = ↑f |
MeasureTheory.Lp.instFourierPairInv | Mathlib.Analysis.Fourier.LpSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : BorelSpace E]
[inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℂ F] [inst_5 : CompleteSpace F]
[inst_6 : InnerProductSpace ℝ E] [inst_7 : FiniteDimensional ℝ E],
FourierInvPair ↥(MeasureTheory.Lp F 2 MeasureTheory.volume) ↥(MeasureTheory.Lp F 2 MeasureTheory.volume) |
Lean.Elab.Tactic.Do.instInhabitedUses.default | Lean.Elab.Tactic.Do.LetElim | Lean.Elab.Tactic.Do.Uses |
Filter.liminf_eq_sSup_sInf | Mathlib.Order.LiminfLimsup | ∀ {ι : Type u_6} {R : Type u_7} (F : Filter ι) [inst : CompleteLattice R] (a : ι → R),
Filter.liminf a F = sSup ((fun I => sInf (a '' I)) '' F.sets) |
Std.TreeSet.Raw.mem_of_mem_insertMany_list | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp], t.WF → ∀ {l : List α} {k : α}, l.contains k = false → k ∈ t.insertMany l → k ∈ t |
WeierstrassCurve.Affine.baseChange_equation | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W : WeierstrassCurve.Affine R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScalarTower R S B]
{f : A →ₐ[S] B} (x y : A),
Function.Injective ⇑f →
((WeierstrassCurve.baseChange W B).toAffine.Equation (f x) (f y) ↔
(WeierstrassCurve.baseChange W A).toAffine.Equation x y) |
List.instLawfulBEqCmpCompareLex | Init.Data.Order.Ord | ∀ {α : Type u_1} {cmp : α → α → Ordering} [inst : BEq α] [Std.LawfulBEqCmp cmp], Std.LawfulBEqCmp (List.compareLex cmp) |
_private.Mathlib.LinearAlgebra.Matrix.Stochastic.0.Matrix.colStochastic._proof_1 | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ (R : Type u_2) (n : Type u_1) [inst : Fintype n] [inst_1 : Semiring R] [inst_2 : PartialOrder R] [IsOrderedRing R]
{M N : Matrix n n R},
M ∈ {M | (∀ (i j : n), 0 ≤ M i j) ∧ Matrix.vecMul 1 M = 1} →
N ∈ {M | (∀ (i j : n), 0 ≤ M i j) ∧ Matrix.vecMul 1 M = 1} →
∀ (i j i_1 : n), i_1 ∈ Finset.univ → 0 ≤ M i i_1 * N i_1 j |
_private.Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral.0.MeasureTheory.HasFiniteIntegral.norm._simp_1_1 | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε] {f : α → ε},
MeasureTheory.HasFiniteIntegral f μ = (∫⁻ (a : α), ‖f a‖ₑ ∂μ < ⊤) |
HahnSeries.toPowerSeries_symm_apply_coeff | Mathlib.RingTheory.HahnSeries.PowerSeries | ∀ {R : Type u_2} [inst : Semiring R] (f : PowerSeries R) (n : ℕ),
(HahnSeries.toPowerSeries.symm f).coeff n = (PowerSeries.coeff n) f |
SimpleGraph.ConnectedComponent.lift | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} →
{G : SimpleGraph V} →
{β : Sort u_1} → (f : V → β) → (∀ (v w : V) (p : G.Walk v w), p.IsPath → f v = f w) → G.ConnectedComponent → β |
CategoryTheory.Equivalence.symmEquivInverse_obj_inverse | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (X : (D ≌ C)ᵒᵖ),
((CategoryTheory.Equivalence.symmEquivInverse C D).obj X).inverse = (Opposite.unop X).functor |
LinearMap.toMatrix₂._proof_6 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} [inst : CommSemiring R] {σ₁ : R →+* R}, RingHomCompTriple (RingHom.id R) σ₁ σ₁ |
Set.symmDiff_subset_union | Mathlib.Data.Set.SymmDiff | ∀ {α : Type u} {s t : Set α}, symmDiff s t ⊆ s ∪ t |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.MBTC.0.Lean.Meta.Grind.Arith.Linear.eqAssignment.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.MBTC | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((structId : ℕ) → motive (some structId)) → ((x : Option ℕ) → motive x) → motive x |
FreeSimplexQuiver.Hom._sizeOf_1 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | {a a_1 : FreeSimplexQuiver} → a.Hom a_1 → ℕ |
_private.Mathlib.Tactic.Linter.UnusedInstancesInType.0.Mathlib.Linter.UnusedInstancesInType.collectFVarsOutsideOfProofs._sparseCasesOn_1 | Mathlib.Tactic.Linter.UnusedInstancesInType | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
ProofWidgets.GetExprPresentationsParams.casesOn | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.GetExprPresentationsParams → Sort u} →
(t : ProofWidgets.GetExprPresentationsParams) →
((expr : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx) → motive { expr := expr }) → motive t |
UpperHemicontinuousWithinAt.of_forall_isOpen | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → Set β} {s : Set α}
{x : α},
(∀ (u : Set β), IsOpen u → f x ⊆ u → ∀ᶠ (x' : α) in nhdsWithin x s, f x' ⊆ u) → UpperHemicontinuousWithinAt f s x |
MonovaryOn.of_inv_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn f⁻¹ g s → AntivaryOn f g s |
Partrec.map | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
{f : α →. β} {g : α → β → σ}, Partrec f → Computable₂ g → Partrec fun a => Part.map (g a) (f a) |
Std.Iterators.Types.ArrayIterator.pos | Std.Data.Iterators.Producers.Monadic.Array | {α : Type w} → Std.Iterators.Types.ArrayIterator α → ℕ |
Int.ediv_lt_ediv_iff_of_dvd_of_neg_of_pos | Init.Data.Int.DivMod.Lemmas | ∀ {a b c d : ℤ}, b < 0 → 0 < d → b ∣ a → d ∣ c → (a / b < c / d ↔ c * b < d * a) |
Turing.PartrecToTM2.Cont'.cons₁.sizeOf_spec | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.PartrecToTM2.Cont'),
sizeOf (Turing.PartrecToTM2.Cont'.cons₁ a a_1) = 1 + sizeOf a + sizeOf a_1 |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k : α},
k ∉ m → l.contains k = false → (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey? k = none |
CategoryTheory.Mon.instCreatesLimitsOfSizeForget | Mathlib.CategoryTheory.Monoidal.Internal.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.CreatesLimitsOfSize.{w, u_1, v, v, max u v, u} (CategoryTheory.Mon.forget C) |
Std.HashSet.Equiv.union_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ ∪ m₂).Equiv (m₁ ∪ m₃) |
CategoryTheory.mateEquiv_hcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] [inst_3 : CategoryTheory.Category.{v₄, u₄} D]
[inst_4 : CategoryTheory.Category.{v₅, u₅} E] [inst_5 : CategoryTheory.Category.{v₆, u₆} F]
{G : CategoryTheory.Functor A D} {H : CategoryTheory.Functor B E} {K : CategoryTheory.Functor C F}
{L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor D E}
{R₂ : CategoryTheory.Functor E D} {L₃ : CategoryTheory.Functor B C} {R₃ : CategoryTheory.Functor C B}
{L₄ : CategoryTheory.Functor E F} {R₄ : CategoryTheory.Functor F E} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃)
(adj₄ : L₄ ⊣ R₄) (α : CategoryTheory.TwoSquare G L₁ L₂ H) (β : CategoryTheory.TwoSquare H L₃ L₄ K),
(CategoryTheory.mateEquiv (adj₁.comp adj₃) (adj₂.comp adj₄)) (α.vComp β) =
((CategoryTheory.mateEquiv adj₃ adj₄) β).hComp ((CategoryTheory.mateEquiv adj₁ adj₂) α) |
_private.Qq.MatchImpl.0.Lean.Syntax.stripPos.match_1 | Qq.MatchImpl | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) → (a : String) → motive (Lean.Syntax.atom info a)) →
((info : Lean.SourceInfo) →
(r : Substring.Raw) →
(v : Lean.Name) → (p : List Lean.Syntax.Preresolved) → motive (Lean.Syntax.ident info r v p)) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info kind args)) →
(Unit → motive Lean.Syntax.missing) → motive x |
SSet.horn₂₁.ι₁₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 0 ≠ 1 |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.mem_toList_iff_isPlausibleIndirectOutput._simp_1_4 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] {it' it : Std.Iter β},
it'.IsPlausibleSuccessorOf it = ∃ step, step.successor = some it' ∧ it.IsPlausibleStep step |
_private.Mathlib.Order.SuccPred.WithBot.0.WithBot.succ_strictMono.match_1_1 | Mathlib.Order.SuccPred.WithBot | ∀ {α : Type u_1} [inst : Preorder α] (motive : (x x_1 : WithBot α) → x < x_1 → Prop) (x x_1 : WithBot α)
(x_2 : x < x_1),
(∀ (b : α) (hab : ⊥ < ↑b), motive none (some b) hab) →
(∀ (a b : α) (hab : ↑a < ↑b), motive (some a) (some b) hab) → motive x x_1 x_2 |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.fdo_eq_interior_fd._simp_1_1 | Mathlib.NumberTheory.Modular | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.le_sum_card_subset_chunk_parts | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {𝒜 : Finset (Finset α)}
{s : Finset α},
𝒜 ⊆ (SzemerediRegularity.chunk hP G ε hU).parts →
s ∈ 𝒜 →
↑𝒜.card * ↑s.card *
(↑(Fintype.card α / SzemerediRegularity.stepBound P.parts.card) /
(↑(Fintype.card α / SzemerediRegularity.stepBound P.parts.card) + 1)) ≤
↑(𝒜.sup id).card |
Fin2.last.eq_1 | Mathlib.Data.Fin.Fin2 | Fin2.last = Fin2.fz |
exists_eq_pow_of_mul_eq_pow | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] [Subsingleton αˣ] {a b c : α},
IsUnit (gcd a b) → ∀ {k : ℕ}, a * b = c ^ k → ∃ d, a = d ^ k |
_private.Batteries.Tactic.HelpCmd.0.Batteries.Tactic.elabHelpCat._sparseCasesOn_12 | Batteries.Tactic.HelpCmd | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Rat.padicValuation._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ), (if 0 = 0 then 0 else WithZero.exp (-padicValRat p 0)) = 0 |
Lean.Meta.withFreshCache | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → n α → n α |
Metric.coveringNumber_empty | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (ε : NNReal), Metric.coveringNumber ε ∅ = 0 |
Module.isTorsionBySet_iff_subseteq_ker_lsmul | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R M s ↔ s ⊆ ↑(LinearMap.lsmul R M).ker |
Real.volume_Ioo | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {a b : ℝ}, MeasureTheory.volume (Set.Ioo a b) = ENNReal.ofReal (b - a) |
PiTensorProduct.tprod._proof_2 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_2) [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {x : DecidableEq ι} {f : (i : ι) → s i} (i : ι) (x_1 y : s i),
PiTensorProduct.tprodCoeff R 1 (Function.update f i (x_1 + y)) =
PiTensorProduct.tprodCoeff R 1 (Function.update f i x_1) + PiTensorProduct.tprodCoeff R 1 (Function.update f i y) |
Finset.centerMass | Mathlib.Analysis.Convex.Combination | {R : Type u_1} →
{E : Type u_3} →
{ι : Type u_5} → [inst : Field R] → [inst_1 : AddCommGroup E] → [Module R E] → Finset ι → (ι → R) → (ι → E) → E |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.