name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
IsLocalization.map_eq | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {g : R →+* P}
{T : Submonoid P} {Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q]
(hy : M ≤ Submonoid.comap g T) (x : R), (IsLocalization.map Q g hy) ((algebraMap R S) x) = (algebraMap P Q) (g x) | true |
MvPolynomial.coe_monomial | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (n : σ →₀ ℕ) (a : R),
↑((MvPolynomial.monomial n) a) = (MvPowerSeries.monomial n) a | true |
closure_eq_self_union_frontier | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X), closure s = s ∪ frontier s | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.degree_mul_of_isRegular_left._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u_1} [inst : MulZeroClass R] {a b : R}, IsLeftRegular b → (b * a = 0) = (a = 0) | false |
PeriodPair.order_weierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), ∀ l₀ ∈ L.lattice, meromorphicOrderAt L.weierstrassP l₀ = -2 | true |
isCompl_ofDual_iff._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {a b : αᵒᵈ},
IsCompl (OrderDual.ofDual a) (OrderDual.ofDual b) = IsCompl a b | false |
_private.Init.Data.Array.Find.0.Array.find?_flatten_eq_some_iff._simp_1_3 | Init.Data.Array.Find | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | false |
String.Slice.front? | Init.Data.String.Slice | String.Slice → Option Char | true |
Lean.Parser.ParserCacheEntry.rec | Lean.Parser.Types | {motive : Lean.Parser.ParserCacheEntry → Sort u} →
((stx : Lean.Syntax) →
(lhsPrec : ℕ) →
(newPos : String.Pos.Raw) →
(errorMsg : Option Lean.Parser.Error) →
motive { stx := stx, lhsPrec := lhsPrec, newPos := newPos, errorMsg := errorMsg }) →
(t : Lean.Parser.ParserCacheEntry) → motive t | false |
cardinalMk_algHom | Mathlib.FieldTheory.Fixed | ∀ (K : Type u) (V : Type v) (W : Type w) [inst : Field K] [inst_1 : Ring V] [inst_2 : Algebra K V]
[FiniteDimensional K V] [inst_4 : Field W] [inst_5 : Algebra K W],
Cardinal.mk (V →ₐ[K] W) ≤ ↑(Module.finrank W (V →ₗ[K] W)) | true |
IsOpen.ae_eq_zero_of_integral_contMDiff_smul_eq_zero' | Mathlib.Analysis.Distribution.AEEqOfIntegralContDiff | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {F : Type u_2}
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [CompleteSpace F] {H : Type u_3}
[inst_6 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) {M : Type u_4} [inst_7 : TopologicalSpace M]
[inst_8 : ChartedSpace H M] [IsManifold I (↑⊤) M] [inst_10 : MeasurableSpace M] [BorelSpace M] [T2Space M] {f : M → F}
{μ : MeasureTheory.Measure M} {U : Set M},
IsOpen U →
IsSigmaCompact U →
MeasureTheory.LocallyIntegrableOn f U μ →
(∀ (g : M → ℝ),
ContMDiff I (modelWithCornersSelf ℝ ℝ) (↑⊤) g →
HasCompactSupport g → tsupport g ⊆ U → ∫ (x : M), g x • f x ∂μ = 0) →
∀ᵐ (x : M) ∂μ, x ∈ U → f x = 0 | true |
MonadSatisfying.instStateRefT'._aux_1 | Batteries.Classes.SatisfiesM | {m : Type → Type} →
{ω σ : Type} →
[inst : Monad m] →
[inst_1 : LawfulMonad m] →
[MonadSatisfying m] →
{α : Type} → {p : α → Prop} → {x : StateRefT' ω σ m α} → SatisfiesM p x → StateRefT' ω σ m { a // p a } | false |
cauchySeq_const | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : SemilatticeSup β] [Nonempty β] (x : α),
CauchySeq fun x_1 => x | true |
Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline.elim | Lean.Compiler.LCNF.Simp.FunDeclInfo | {motive : Lean.Compiler.LCNF.Simp.FunDeclInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.FunDeclInfo) →
t.ctorIdx = 2 → motive Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline → motive t | false |
Convex.toCone | Mathlib.Geometry.Convex.Cone.Basic | {𝕜 : Type u_1} →
{M : Type u_4} →
[inst : Field 𝕜] →
[inst_1 : LinearOrder 𝕜] →
[IsStrictOrderedRing 𝕜] →
[inst_3 : AddCommGroup M] → [inst_4 : Module 𝕜 M] → (s : Set M) → Convex 𝕜 s → ConvexCone 𝕜 M | true |
MeasureTheory.VectorMeasure.add | Mathlib.MeasureTheory.VectorMeasure.Basic | {α : Type u_1} →
{m : MeasurableSpace α} →
{M : Type u_3} →
[inst : AddCommMonoid M] →
[inst_1 : TopologicalSpace M] →
[ContinuousAdd M] →
MeasureTheory.VectorMeasure α M → MeasureTheory.VectorMeasure α M → MeasureTheory.VectorMeasure α M | true |
Lean.Order.instCCPOPProd | Init.Internal.Order.Basic | {α : Sort u} → {β : Sort v} → [Lean.Order.CCPO α] → [Lean.Order.CCPO β] → Lean.Order.CCPO (α ×' β) | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.exists_isMinOn_norm_φ | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ {F : Type u_1} [inst : NormedRing F] [inst_1 : NormedAlgebra ℝ F] [NormOneClass F] (x : F),
∃ z, IsMinOn (fun x_1 => ‖NormedAlgebra.Real.φ✝ x x_1‖) Set.univ z | true |
ClosedSubmodule.comap_id | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] (s : ClosedSubmodule R M), ClosedSubmodule.comap (ContinuousLinearMap.id R M) s = s | true |
_private.Mathlib.Topology.Constructions.0.inducing_sigma.match_1_4 | Mathlib.Topology.Constructions | ∀ {X : Type u_2} {ι : Type u_3} {σ : ι → Type u_1} [inst : (i : ι) → TopologicalSpace (σ i)]
[inst_1 : TopologicalSpace X] {f : Sigma σ → X}
(motive :
((∀ (i : ι), Topology.IsInducing (f ∘ Sigma.mk i)) ∧
∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i) →
Prop)
(x :
(∀ (i : ι), Topology.IsInducing (f ∘ Sigma.mk i)) ∧
∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i),
(∀ (h₁ : ∀ (i : ι), Topology.IsInducing (f ∘ Sigma.mk i))
(h₂ : ∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i), motive ⋯) →
motive x | false |
CategoryTheory.instGroupoidFreeGroupoid | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Groupoid (CategoryTheory.FreeGroupoid C) | true |
ContinuousMap.instNonAssocSemiringOfIsTopologicalSemiring._proof_3 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonAssocSemiring β]
[inst_3 : IsTopologicalSemiring β] (f g : C(α, β)), ⇑(f + g) = ⇑f + ⇑g | false |
Set.ncard_le_ncard_iff_ncard_diff_le_ncard_diff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α},
autoParam s.Finite Set.ncard_le_ncard_iff_ncard_diff_le_ncard_diff._auto_1 →
autoParam t.Finite Set.ncard_le_ncard_iff_ncard_diff_le_ncard_diff._auto_3 →
(s.ncard ≤ t.ncard ↔ (s \ t).ncard ≤ (t \ s).ncard) | true |
GroupSeminorm.comp._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} {F : Type u_2} [inst : Group E] [inst_1 : Group F] (p : GroupSeminorm E) (f : F →* E), p (f 1) = 0 | false |
_private.Lean.Compiler.LCNF.ResetReuse.0.Lean.Compiler.LCNF.Context.ctorIdx | Lean.Compiler.LCNF.ResetReuse | Lean.Compiler.LCNF.Context✝ → ℕ | false |
MeasureTheory.IsFundamentalDomain.mk_of_measure_univ_le | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] [Countable G],
MeasureTheory.NullMeasurableSet s μ →
(∀ (g : G), g ≠ 1 → MeasureTheory.AEDisjoint μ (g • s) s) →
(∀ (g : G), MeasureTheory.Measure.QuasiMeasurePreserving (fun x => g • x) μ μ) →
μ Set.univ ≤ ∑' (g : G), μ (g • s) → MeasureTheory.IsFundamentalDomain G s μ | true |
Multiset.coe_consEquiv_of_ne._proof_1 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {m : Multiset α} {v : α} (x : (v ::ₘ m).ToType),
x.fst ≠ v → Multiset.count x.fst (v ::ₘ m) = Multiset.count x.fst m | false |
Subtype.map_involutive | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {f : α → α} (h : ∀ (a : α), p a → p (f a)),
Function.Involutive f → Function.Involutive (Subtype.map f h) | true |
Lean.Compiler.LCNF.Simp.Config.recOn | Lean.Compiler.LCNF.Simp.Config | {motive : Lean.Compiler.LCNF.Simp.Config → Sort u} →
(t : Lean.Compiler.LCNF.Simp.Config) →
((etaPoly inlinePartial implementedBy inlineDefs : Bool) →
motive
{ etaPoly := etaPoly, inlinePartial := inlinePartial, implementedBy := implementedBy,
inlineDefs := inlineDefs }) →
motive t | false |
PosNum.ldiff.match_1 | Mathlib.Data.Num.Bitwise | (motive : PosNum → PosNum → Sort u_1) →
(x x_1 : PosNum) →
((a : PosNum) → motive PosNum.one a.bit0) →
((x : PosNum) → motive PosNum.one x) →
((p : PosNum) → motive p.bit0 PosNum.one) →
((p : PosNum) → motive p.bit1 PosNum.one) →
((p q : PosNum) → motive p.bit0 q.bit0) →
((p q : PosNum) → motive p.bit0 q.bit1) →
((p q : PosNum) → motive p.bit1 q.bit0) → ((p q : PosNum) → motive p.bit1 q.bit1) → motive x x_1 | false |
MeasureTheory.NullMeasurableSet.of_compl | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet sᶜ μ → MeasureTheory.NullMeasurableSet s μ | true |
_private.Mathlib.GroupTheory.Finiteness.0.Submonoid.FG.pi._simp_1_1 | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (s : Set M), Submonoid.closure (⇑f '' s) = Submonoid.map f (Submonoid.closure s) | false |
Finset.zero_div_subset | Mathlib.Algebra.GroupWithZero.Pointwise.Finset | ∀ {α : Type u_1} [inst : GroupWithZero α] [inst_1 : DecidableEq α] (s : Finset α), 0 / s ⊆ 0 | true |
Lean.Lsp.LeanIdentifier.mk.injEq | Lean.Data.Lsp.Internal | ∀ (module decl : Lean.Name) (isExactMatch : Bool) (module_1 decl_1 : Lean.Name) (isExactMatch_1 : Bool),
({ module := module, decl := decl, isExactMatch := isExactMatch } =
{ module := module_1, decl := decl_1, isExactMatch := isExactMatch_1 }) =
(module = module_1 ∧ decl = decl_1 ∧ isExactMatch = isExactMatch_1) | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_dvd_fdiv.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : (x x_1 x_2 : ℤ) → x ∣ x_1 → x_1 ∣ x_2 → Prop) (x x_1 x_2 : ℤ) (x_3 : x ∣ x_1) (x_4 : x_1 ∣ x_2),
(∀ (a b c : ℤ), motive a (a * b) (a * b * c) ⋯ ⋯) → motive x x_1 x_2 x_3 x_4 | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits.termL₂'_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.ParserDescr | true |
MeasureTheory.SimpleFunc.integrable_approxOn | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {β : Type u_2} {E : Type u_4} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace E] [inst_2 : NormedAddCommGroup E]
[inst_3 : BorelSpace E] {f : β → E} {μ : MeasureTheory.Measure β} (fmeas : Measurable f),
MeasureTheory.Integrable f μ →
∀ {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [inst_4 : TopologicalSpace.SeparableSpace ↑s],
MeasureTheory.Integrable (fun x => y₀) μ →
∀ (n : ℕ), MeasureTheory.Integrable (⇑(MeasureTheory.SimpleFunc.approxOn f fmeas s y₀ h₀ n)) μ | true |
ContextFreeGrammar.reverse_surjective | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1}, Function.Surjective ContextFreeGrammar.reverse | true |
Seminorm.IsBounded | Mathlib.Analysis.LocallyConvex.WithSeminorms | {𝕜 : Type u_2} →
{𝕜₂ : Type u_3} →
{E : Type u_6} →
{F : Type u_7} →
{ι : Type u_9} →
{ι' : Type u_10} →
[inst : SeminormedRing 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : SeminormedRing 𝕜₂] →
[inst_4 : AddCommGroup F] →
[inst_5 : Module 𝕜₂ F] →
{σ₁₂ : 𝕜 →+* 𝕜₂} →
[RingHomIsometric σ₁₂] → (ι → Seminorm 𝕜 E) → (ι' → Seminorm 𝕜₂ F) → (E →ₛₗ[σ₁₂] F) → Prop | true |
Batteries.RBNode.Path.recOn | Batteries.Data.RBMap.Basic | {α : Type u} →
{motive : Batteries.RBNode.Path α → Sort u_1} →
(t : Batteries.RBNode.Path α) →
motive Batteries.RBNode.Path.root →
((c : Batteries.RBColor) →
(parent : Batteries.RBNode.Path α) →
(v : α) → (r : Batteries.RBNode α) → motive parent → motive (Batteries.RBNode.Path.left c parent v r)) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) →
(v : α) →
(parent : Batteries.RBNode.Path α) →
motive parent → motive (Batteries.RBNode.Path.right c l v parent)) →
motive t | false |
Algebra.kerTensorProductMapIdToAlgHomEquiv._proof_7 | Mathlib.RingTheory.Flat.Equalizer | ∀ (R : Type u_3) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
[inst_3 : CommRing A] [inst_4 : Algebra R A] (x : S),
(Algebra.TensorProduct.comm R A S).toFun ((algebraMap S (TensorProduct R A S)) x) =
(Algebra.TensorProduct.comm R A S).toFun ((algebraMap S (TensorProduct R A S)) x) | false |
Std.Time.Timestamp.toDurationSinceUnixEpoch | Std.Time.DateTime.Timestamp | Std.Time.Timestamp → Std.Time.Duration | true |
LinearMap.comp_id_moduleCat | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_1} [inst : Ring R] {G : ModuleCat R} {H : Type u} [inst_1 : AddCommGroup H] [inst_2 : Module R H]
(f : ↑G →ₗ[R] H), f ∘ₗ ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.id G) = f | true |
Std.ExtDHashMap.isSome_get?_eq_contains | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α},
(m.get? a).isSome = m.contains a | true |
_private.Lean.Meta.Tactic.Intro.0.Lean.Meta.introNImp | Lean.Meta.Tactic.Intro | {σ : Type} →
Lean.MVarId →
ℕ →
(Lean.LocalContext → Lean.Name → Bool → σ → Lean.MetaM (Lean.Name × σ)) →
σ → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) | true |
CategoryTheory.Precoverage.ZeroHypercover._sizeOf_inst | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(J : CategoryTheory.Precoverage C) → (S : C) → [SizeOf C] → SizeOf (J.ZeroHypercover S) | false |
Lean.PersistentHashMap.findEntryAux._unsafe_rec | Lean.Data.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → [BEq α] → Lean.PersistentHashMap.Node α β → USize → α → Option (α × β) | false |
Lean.Grind.Linarith.Expr.ctorElimType | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Mathlib.MeasureTheory.Integral.Regular.0.IsOpen.measure_eq_biSup_integral_continuous._simp_1_1 | Mathlib.MeasureTheory.Integral.Regular | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (a < iSup f) = ∃ i, a < f i | false |
CategoryTheory.CatEnriched.instBicategory._proof_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b c : CategoryTheory.CatEnriched C}
(f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CatEnriched.hComp (CategoryTheory.CategoryStruct.id f) (CategoryTheory.CategoryStruct.id g) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g) | false |
MeasureTheory.memLp_piLp_iff | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≤ q)]
{ι : Type u_2} [inst_1 : Fintype ι] {E : ι → Type u_3} [inst_2 : (i : ι) → NormedAddCommGroup (E i)]
{f : X → PiLp q E}, MeasureTheory.MemLp f p μ ↔ ∀ (i : ι), MeasureTheory.MemLp (fun x => (f x).ofLp i) p μ | true |
IndepMatroid | Mathlib.Combinatorics.Matroid.IndepAxioms | Type u_2 → Type u_2 | true |
ConnectedComponents.equivOfIsClopenOfIsConnected_mk | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] {ι : Type u_3} {U : ι → Set α} (hclopen : ∀ (i : ι), IsClopen (U i))
(hdisj : Pairwise (Function.onFun Disjoint U)) (hunion : ⋃ i, U i = Set.univ) (hconn : ∀ (i : ι), IsConnected (U i))
{i : ι},
∀ x ∈ U i,
(ConnectedComponents.equivOfIsClopenOfIsConnected hclopen hdisj hunion hconn) (ConnectedComponents.mk x) = i | true |
ModuleCat.MonModuleEquivalenceAlgebra.inverse_map_hom | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u} [inst : CommRing R] {X Y : AlgCat R} (f : X ⟶ Y),
(ModuleCat.MonModuleEquivalenceAlgebra.inverse.map f).hom = ModuleCat.ofHom (AlgCat.Hom.hom f).toLinearMap | true |
Algebra.SubmersivePresentation.aeval_invJacobianOfHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (R₀ : Type u_5)
[inst_4 : CommRing R₀] [inst_5 : Algebra R₀ R] [inst_6 : Algebra R₀ S] [inst_7 : IsScalarTower R₀ R S]
[inst_8 : P.HasCoeffs R₀], (MvPolynomial.aeval P.val) (P.invJacobianOfHasCoeffs R₀) = ↑⋯.unit⁻¹ | true |
GroupTopology.coinduced | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u_1} → {β : Type u_2} → [t : TopologicalSpace α] → [inst : Group β] → (α → β) → GroupTopology β | true |
AddMonoidHom.coe_of_map_sub | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : AddGroup G] {H : Type u_8} [inst_1 : AddGroup H] (f : G → H)
(hf : ∀ (x y : G), f (x - y) = f x - f y), ⇑(AddMonoidHom.ofMapSub f hf) = f | true |
_private.Init.Data.List.Lemmas.0.List.length_eq_of_beq.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] (motive : (l₁ l₂ : List α) → (l₁ == l₂) = true → Prop) (l₁ l₂ : List α)
(h : (l₁ == l₂) = true),
(∀ (h : ([] == []) = true), motive [] [] h) →
(∀ (head : α) (tail : List α) (h : ([] == head :: tail) = true), motive [] (head :: tail) h) →
(∀ (head : α) (tail : List α) (h : (head :: tail == []) = true), motive (head :: tail) [] h) →
(∀ (a : α) (l₁ : List α) (b : α) (l₂ : List α) (h : (a :: l₁ == b :: l₂) = true),
motive (a :: l₁) (b :: l₂) h) →
motive l₁ l₂ h | false |
ContDiffMapSupportedIn.seminorm_fderivLM_top | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {K : TopologicalSpace.Compacts E} {i : ℕ} (f : ContDiffMapSupportedIn E F ⊤ K),
(ContDiffMapSupportedIn.seminorm 𝕜 E (E →L[ℝ] F) ⊤ K i) ((ContDiffMapSupportedIn.fderivLM 𝕜 ⊤ ⊤) f) =
(ContDiffMapSupportedIn.seminorm 𝕜 E F ⊤ K (i + 1)) f | true |
PiTensorProduct.ofDFinsuppEquiv | Mathlib.LinearAlgebra.PiTensorProduct.DFinsupp | {R : Type u_1} →
{ι : Type u_2} →
{κ : ι → Type u_3} →
{M : (i : ι) → κ i → Type u_4} →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → (j : κ i) → AddCommMonoid (M i j)] →
[inst_2 : (i : ι) → (j : κ i) → Module R (M i j)] →
[Fintype ι] →
[DecidableEq ι] →
[(i : ι) → DecidableEq (κ i)] →
(PiTensorProduct R fun i => Π₀ (j : κ i), M i j) ≃ₗ[R]
Π₀ (p : (i : ι) → κ i), PiTensorProduct R fun i => M i (p i) | true |
CategoryTheory.Functor.Initial.limitConeOfComp_cone | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [inst_2 : F.Initial] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.LimitCone (F.comp G)),
(CategoryTheory.Functor.Initial.limitConeOfComp F t).cone = CategoryTheory.Functor.Initial.extendCone.obj t.cone | true |
riemannZeta_re_pos_of_one_lt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {x : ℝ}, 1 < x → 0 < (riemannZeta ↑x).re | true |
Real.one_le_rpow_of_pos_of_le_one_of_nonpos | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x z : ℝ}, 0 < x → x ≤ 1 → z ≤ 0 → 1 ≤ x ^ z | true |
Interval.instUniqueOfIsEmpty._proof_1 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α] [IsEmpty α] (a : Interval α), a = default | false |
Module.Invertible.bijective_curry | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} {M : Type v} {N : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N]
[inst_3 : Module R M] [inst_4 : Module R N] (e : TensorProduct R M N ≃ₗ[R] R),
Function.Bijective ⇑(TensorProduct.curry ↑e) | true |
Lean.Meta.initFn._@.Lean.Meta.ExprDefEq.3626275840._hygCtx._hyg.4 | Lean.Meta.ExprDefEq | IO (Lean.Option Bool) | false |
RingHom.rangeRestrictFieldEquiv_apply_symm_apply | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] (f : K →+* L) (x : ↥f.fieldRange),
f (f.rangeRestrictFieldEquiv.symm x) = ↑x | true |
ProofWidgets.ExprWithCtx.ci | ProofWidgets.Compat | ProofWidgets.ExprWithCtx → Lean.Elab.ContextInfo | true |
Lean.PrettyPrinter.OneLine.State._sizeOf_inst | Lean.PrettyPrinter.Formatter | SizeOf Lean.PrettyPrinter.OneLine.State | false |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balLeft.match_4.splitter._sparseCasesOn_2 | Batteries.Data.RBMap.WF | {α : Type u} →
{motive : Batteries.RBNode α → Sort u_1} →
(t : Batteries.RBNode α) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive (Batteries.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.aux_tendsto_tsum._simp_1_5 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Mathlib.RingTheory.RingHom.OpenImmersion.0.Algebra.IsStandardOpenImmersion.trans.match_1_1 | Mathlib.RingTheory.RingHom.OpenImmersion | ∀ (S : Type u_1) (T : Type u_2) [inst : CommSemiring S] [inst_1 : CommSemiring T] [inst_2 : Algebra S T]
(motive : (∃ r, IsLocalization.Away r T) → Prop) (x : ∃ r, IsLocalization.Away r T),
(∀ (s : S) (h : IsLocalization.Away s T), motive ⋯) → motive x | false |
_private.Init.Data.String.Defs.0.String.Pos.Raw.offsetBy_sliceRawEndPos_right._simp_1_1 | Init.Data.String.Defs | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | false |
Std.DTreeMap.Internal.Impl.Const.getKey_insertManyIfNewUnit_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] (h : t.WF)
{l : List α} {k : α}
{h' : Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯) = true}
(contains : k ∈ t), (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)).getKey k h' = t.getKey k contains | true |
NumberField.RingOfIntegers.instFreeInt | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Module.Free ℤ (NumberField.RingOfIntegers K) | true |
instDecidableLtBitVec._aux_1 | Init.Prelude | {w : ℕ} → (x y : BitVec w) → Decidable (x < y) | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.val_step_filterMap.match_3.splitter | Init.Data.Iterators.Lemmas.Combinators.FilterMap | {α β : Type u_1} →
(motive : Std.IterStep (Std.Iter β) β → Sort u_2) →
(x : Std.IterStep (Std.Iter β) β) →
((it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.Iter β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x | true |
ContinuousMultilinearMap.toMultilinearMapLinear_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {R' : Type u_1} {A : Type u_2} [inst : Semiring R']
[inst_1 : Semiring A] [inst_2 : (i : ι) → AddCommMonoid (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : (i : ι) → TopologicalSpace (M₁ i)] [inst_5 : TopologicalSpace M₂] [inst_6 : ContinuousAdd M₂]
[inst_7 : (i : ι) → Module A (M₁ i)] [inst_8 : Module A M₂] [inst_9 : Module R' M₂]
[inst_10 : ContinuousConstSMul R' M₂] [inst_11 : SMulCommClass A R' M₂] (self : ContinuousMultilinearMap A M₁ M₂),
ContinuousMultilinearMap.toMultilinearMapLinear self = self.toMultilinearMap | true |
SaturatedAddSubmonoid.instMin.eq_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M],
SaturatedAddSubmonoid.instMin M =
{
min := fun s₁ s₂ =>
let __src := s₁.toAddSubmonoid ⊓ s₂.toAddSubmonoid;
{ toAddSubmonoid := __src, addSaturated := ⋯ } } | true |
RingNormClass.mk._flat_ctor | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} [inst : NonUnitalNonAssocRing α]
[inst_1 : Semiring β] [inst_2 : PartialOrder β] [inst_3 : FunLike F α β],
(∀ (f : F) (a b : α), f (a + b) ≤ f a + f b) →
(∀ (f : F), f 0 = 0) →
(∀ (f : F) (a : α), f (-a) = f a) →
(∀ (f : F) (a b : α), f (a * b) ≤ f a * f b) → (∀ (f : F) {a : α}, f a = 0 → a = 0) → RingNormClass F α β | false |
Multiset.sum_filter_add_sum_filter_not | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} [inst : AddCommMonoid M] {s : Multiset M} (p : M → Prop) [inst_1 : DecidablePred p],
(Multiset.filter p s).sum + (Multiset.filter (fun a => ¬p a) s).sum = s.sum | true |
groupHomology.mapShortComplexH1._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u_1, u_1, u_1} k G}
{B : Rep.{u_1, u_1, u_1} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.chainsMap₁ f φ) (groupHomology.shortComplexH1 B).g =
CategoryTheory.CategoryStruct.comp (groupHomology.shortComplexH1 A).g (Rep.Hom.toModuleCatHom φ) | false |
instAddCommGroupKaehlerDifferential._aux_4 | Mathlib.RingTheory.Kaehler.Basic | (R : Type u_1) → (S : Type u_2) → [inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → Ω[S⁄R] | false |
WithBot.inhabited | Mathlib.Order.TypeTags | {α : Type u_1} → Inhabited (WithBot α) | true |
Finset.image_univ_of_surjective | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : Fintype β] {f : β → α},
Function.Surjective f → Finset.image f Finset.univ = Finset.univ | true |
Lean.Firefox.FuncTable.mk | Lean.Util.Profiler | Array ℕ →
Array Lean.Json →
Array Lean.Json → Array ℤ → Array (Option ℕ) → Array (Option ℕ) → Array (Option ℕ) → ℕ → Lean.Firefox.FuncTable | true |
Differentiable.fun_inv._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_5} [inst_3 : NormedDivisionRing R] [inst_4 : NormedAlgebra 𝕜 R] {h : E → R},
Differentiable 𝕜 h → (∀ (x : E), h x ≠ 0) → (Differentiable 𝕜 fun i => (h i)⁻¹) = True | false |
UpperHemicontinuous.union | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_3} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → Set β},
UpperHemicontinuous f → UpperHemicontinuous g → UpperHemicontinuous fun x => f x ∪ g x | true |
ProofWidgets.RpcEncodablePacket._sizeOf_inst._@.ProofWidgets.Component.Basic.1956376046._hygCtx._hyg.1 | ProofWidgets.Component.Basic | SizeOf ProofWidgets.RpcEncodablePacket✝ | false |
Finset.vadd_mem_vadd | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : VAdd α β] {s : Finset α} {t : Finset β} {a : α}
{b : β}, a ∈ s → b ∈ t → a +ᵥ b ∈ s +ᵥ t | true |
Matrix.instStarMulSubtypeMemSubmonoidSpecialUnitaryGroup._proof_6 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type u_2} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A B : ↥(Matrix.specialUnitaryGroup n α)),
star ↑(A * B) ∈ ↑(Matrix.unitaryGroup n α) ∧ star ↑(A * B) ∈ ↑(MonoidHom.mker Matrix.detMonoidHom) | false |
Matrix.IsParabolic | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | {R : Type u_1} → [CommRing R] → Matrix (Fin 2) (Fin 2) R → Prop | true |
Symbol.terminal.elim | Mathlib.Computability.Language | {T : Type u_4} →
{N : Type u_5} →
{motive : Symbol T N → Sort u} →
(t : Symbol T N) → t.ctorIdx = 0 → ((t : T) → motive (Symbol.terminal t)) → motive t | false |
Sum.elimZeroLeft_apply | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {ι : Type u_6} {κ : Type u_7} {R : Type u_8} [inst : Semiring R] (g : ι → R) (a : κ ⊕ ι),
Sum.elimZeroLeft g a = Sum.elim 0 g a | true |
Lean.Lsp.CallHierarchyOutgoingCallsParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{t t' : Lean.Lsp.CallHierarchyOutgoingCallsParams} →
t = t' → Lean.Lsp.CallHierarchyOutgoingCallsParams.noConfusionType P t t' | false |
Set.Ioi_eq_empty_iff._simp_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (Set.Ioi a = ∅) = IsMax a | false |
AddUnits.rightOfAdd._proof_2 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (a b : M), AddCommute a b → AddCommute b a | false |
CategoryTheory.Abelian.SpectralObject.dCokernelSequence_exact._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Homology | Lean.Syntax | false |
MeasurableSet.coe_insert | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : MeasurableSingletonClass α] (a : α) (s : Subtype MeasurableSet),
↑(insert a s) = insert a ↑s | true |
RestrictedProduct.coeMonoidHom._proof_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} {R : ι → Type u_2} {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)]
(x x_1 : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕), ⇑(x * x_1) = ⇑(x * x_1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.