name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DFinsupp.equivFunOnFintype | Mathlib.Data.DFinsupp.Defs | {ι : Type u} → {β : ι → Type v} → [inst : (i : ι) → Zero (β i)] → [Fintype ι] → (Π₀ (i : ι), β i) ≃ ((i : ι) → β i) | Given `Fintype ι`, `equivFunOnFintype` is the `Equiv` between `Π₀ i, β i` and `Π i, β i`.
(All dependent functions on a finite type are finitely supported.) | true |
String.Slice.Pattern.Model.ForwardStringSearcher.lawfulToForwardSearcherModel | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : String}, pat ≠ "" → String.Slice.Pattern.Model.LawfulToForwardSearcherModel pat | null | true |
List.nil_lex_cons'._simp_1 | Init.Data.List.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {a : α} {l : List α}, List.Lex r [] (a :: l) = True | null | false |
CategoryTheory.Limits.biproduct.desc_eq | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
[inst_2 : Fintype J] {f : J → C} [inst_3 : CategoryTheory.Limits.HasBiproduct f] {T : C} {g : (j : J) → f j ⟶ T},
CategoryTheory.Limits.biproduct.desc g =
∑ j, CategoryTheory.CategoryStruct.comp (Cate... | null | true |
Antitone.map_limsSup_of_continuousAt._auto_1 | Mathlib.Topology.Order.LiminfLimsup | Lean.Syntax | null | false |
HomotopicalAlgebra.ModelCategory.transport._proof_6 | Mathlib.AlgebraicTopology.ModelCategory.Transport | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : HomotopicalAlgebra.ModelCategory D]
[inst_3 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (e : C ≌ D),
HomotopicalAlgebra.weakEquivalences C = (HomotopicalAlgebra.weakEqui... | null | false |
Matrix.mem_range_scalar_iff_commute_single | Mathlib.Data.Matrix.Basis | ∀ {n : Type u_3} {α : Type u_7} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : Semiring α] {M : Matrix n n α},
M ∈ Set.range ⇑(Matrix.scalar n) ↔ ∀ (i j : n), i ≠ j → Commute (Matrix.single i j 1) M | null | true |
_aux_Mathlib_Algebra_Star_MonoidHom___unexpand_StarMonoidHom_1 | Mathlib.Algebra.Star.MonoidHom | Lean.PrettyPrinter.Unexpander | null | false |
List.findIdxNth_eq_length_iff | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {n : ℕ} {xs : List α}, List.findIdxNth p xs n = xs.length ↔ List.countP p xs ≤ n | null | true |
Flow.ext_iff | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} {α : Type u_2} [inst : TopologicalSpace τ] [inst_1 : TopologicalSpace α] [inst_2 : AddZero τ]
{ϕ₁ ϕ₂ : Flow τ α}, ϕ₁ = ϕ₂ ↔ ∀ (t : τ) (x : α), ϕ₁.toFun t x = ϕ₂.toFun t x | null | true |
_private.Aesop.Util.Tactic.Unfold.0.Aesop._aux_Aesop_Util_Tactic_Unfold___elabRules_Aesop_tacticAesop_unfold__1.match_1 | Aesop.Util.Tactic.Unfold | (motive : Option (Lean.MVarId × Array Lean.Name) → Sort u_1) →
(__do_lift : Option (Lean.MVarId × Array Lean.Name)) →
(Unit → motive none) →
((goal : Lean.MVarId) → (snd : Array Lean.Name) → motive (some (goal, snd))) → motive __do_lift | null | false |
Lean.Lsp.FileSystemWatcher.mk.noConfusion | Lean.Data.Lsp.Workspace | {P : Sort u} →
{globPattern : String} →
{kind? : Option ℕ} →
{globPattern' : String} →
{kind?' : Option ℕ} →
{ globPattern := globPattern, kind? := kind? } = { globPattern := globPattern', kind? := kind?' } →
(globPattern = globPattern' → kind? = kind?' → P) → P | null | false |
AlgHom.fieldRange_of_normal | Mathlib.FieldTheory.Normal.Basic | ∀ {F : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K] {E : IntermediateField F K}
[Normal F ↥E] (f : ↥E →ₐ[F] K), f.fieldRange = E | null | true |
_private.Mathlib.Analysis.Convex.StdSimplex.0.stdSimplex_eq_inter._simp_1_3 | Mathlib.Analysis.Convex.StdSimplex | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
Representation.IntertwiningMap.comp | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
{U : Type u_5} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : AddCommMonoid U] →
... | Composition of intertwining maps.
A convenience variant of `IntertwiningMap.llcomp` for use in dot notation. | true |
SeparatedNhds.disjoint_closure_left | Mathlib.Topology.Separation.SeparatedNhds | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X}, SeparatedNhds s t → Disjoint (closure s) t | null | true |
Std.ExtHashMap.getKey_modify | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [Inhabited α] {k k' : α} {f : β → β} {h : k' ∈ m.modify k f},
(m.modify k f).getKey k' h = if (k == k') = true then k else m.getKey k' ⋯ | null | true |
SSet.Truncated.HomotopyCategory.homToNerveMk | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | {X : SSet.Truncated 2} →
{C : Type u} →
[inst : CategoryTheory.SmallCategory C] →
CategoryTheory.Functor X.HomotopyCategory C → (X ⟶ (SSet.truncation 2).obj (CategoryTheory.nerve C)) | Given a `2`-truncated simplicial set `X` and a category `C`,
this is the morphism `X ⟶ (truncation 2).obj (nerve C)` corresponding
to a functor `X.HomotopyCategory ⥤ C`. | true |
HomologicalComplex.opcyclesToCycles_iCycles_assoc | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι)
[inst_2 : K.HasHomology i] [inst_3 : K.HasHomology j] {Z : C} (h : K.X j ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.opcycle... | null | true |
Lean.Environment.getModuleFor? | ImportGraph.Lean.Environment | Lean.Environment → Lean.Name → optParam Bool false → Option Lean.Name | Return the name of the module in which a declaration was defined.
Returns the main module for declarations defined in the current environment. | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.tendsto_logDeriv_euler_sin_div._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {z : ℝ}, (↑z = 0) = (z = 0) | null | false |
DeltaGeneratedSpace | Mathlib.Topology.Compactness.DeltaGeneratedSpace | (Y : Type u_1) → [TopologicalSpace Y] → Prop | A topological space is Delta-generated if its topology is generated
by the continuous maps from topological spaces of the form `Fin n → ℝ`. | true |
AnalyticAt.hasStrictFDerivAt | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E}, AnalyticAt 𝕜 f x → HasStrictFDerivAt f (fderiv 𝕜 f x) x | null | true |
MeasureTheory.Measure.haar.addIndex.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (K V : Set G),
MeasureTheory.Measure.haar.addIndex K V = sInf (Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g + h) ⁻¹' V}) | null | true |
Lean.Elab.Tactic.ConfigItemView.casesOn | Lean.Elab.Tactic.Config | {motive : Lean.Elab.Tactic.ConfigItemView → Sort u} →
(t : Lean.Elab.Tactic.ConfigItemView) →
((ref : Lean.Syntax) →
(option : Lean.Ident) →
(value : Lean.Term) → (bool : Bool) → motive { ref := ref, option := option, value := value, bool := bool }) →
motive t | null | false |
Real.one_le_sqrt._simp_1 | Mathlib.Analysis.Real.Sqrt | ∀ {x : ℝ}, (1 ≤ √x) = (1 ≤ x) | null | false |
NonUnitalSubring.comap_center_le_center | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalRing R] [inst_1 : NonUnitalRing S] {f : R →ₙ+* S},
Function.Injective ⇑f → NonUnitalSubring.comap f (NonUnitalSubring.center S) ≤ NonUnitalSubring.center R | null | true |
_private.Mathlib.Data.Finset.Grade.0.CovBy.exists_finset_cons.match_1_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} {s t : Finset α} (motive : (∃ a, ∃ (h : a ∉ s), Finset.cons a s h ⊆ t) → Prop)
(x : ∃ a, ∃ (h : a ∉ s), Finset.cons a s h ⊆ t),
(∀ (a : α) (ha : a ∉ s) (hst : Finset.cons a s ha ⊆ t), motive ⋯) → motive x | null | false |
MeasureTheory.IsProjectiveMeasureFamily.eq_zero_of_isEmpty | Mathlib.MeasureTheory.Constructions.Projective | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)]
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} [h : IsEmpty ((i : ι) → α i)],
MeasureTheory.IsProjectiveMeasureFamily P → ∀ (I : Finset ι), P I = 0 | null | true |
WithBot.Ioo_coe_coe | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : LocallyFiniteOrder α] (a b : α),
Finset.Ioo ↑b ↑a = Finset.map Function.Embedding.some (Finset.Ioo b a) | null | true |
CategoryTheory.Limits.StrongEpiMonoFactorisation.recOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Limits.StrongEpiMonoFactorisation f → Sort u_1} →
(t : CategoryTheory.Limits.StrongEpiMonoFactorisation f) →
((toMonoFactorisation : CategoryTheory.Limits.MonoFactorisa... | null | false |
Rat.intCast_lt_cast | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℤ} {n : ℚ}, ↑m < ↑n ↔ ↑m < n | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_modify._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverSubfunctor._proof_1 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) {U V : CategoryTheory.Over X} (x_1 : U ⟶ V),
∀ x_2 ∈ ⇑(CategoryTheory.ConcreteCategory.hom (F.map U.hom)) ⁻¹' {x},
x_2 ∈
⇑(CategoryTheory.ConcreteCategory.hom (((CategoryTheory.Ov... | null | false |
CategoryTheory.Functor.mapContActionCongr_hom | Mathlib.CategoryTheory.Action.Continuous | ∀ {V : Type u_5} {W : Type u_6} [inst : CategoryTheory.Category.{v_2, u_5} V] {FV : V → V → Type u_7}
{CV : V → Type u_8} [inst_1 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)]
[inst_2 : CategoryTheory.ConcreteCategory V FV] [inst_3 : CategoryTheory.HasForget₂ V TopCat]
[inst_4 : CategoryTheory.Category.{v_3, u_6}... | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Lemmas.0.RootPairing.Base.root_sub_root_mem_of_mem_of_mem._simp_1_3 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Lemmas | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (b - a = c - a) = (b = c) | null | false |
faithfulVAdd_iff | Mathlib.Algebra.Group.Action.Faithful | ∀ {G : Type u_2} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α],
FaithfulVAdd G α ↔ ∀ (g : G), (∀ (a : α), g +ᵥ a = a) → g = 0 | null | true |
ConditionallyCompleteLinearOrderedField.to_archimedean | Mathlib.Algebra.Order.CompleteField | ∀ {α : Type u_1} [inst : Field α] [inst_1 : ConditionallyCompleteLinearOrder α] [IsStrictOrderedRing α], Archimedean α | Any conditionally complete linearly ordered field is archimedean. | true |
LinearAlgebra.FreeProduct.rel_id | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)] (i : I),
LinearAlgebra.FreeProduct.rel R A ((TensorAlgebra.ι R) ((DirectSum.lof R I A i) 1)) 1 | null | true |
CategoryTheory.MonoOver.factorThruImage_comp_existsPullbackAdj_counit_app_hom_left_assoc | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasPullbacks C] (B : CategoryTheory.MonoOver Y) {Z : C}
(h : B.obj.left ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.factorThruIma... | null | true |
Lean.EnumAttributes.casesOn | Lean.Attributes | {α : Type} →
{motive : Lean.EnumAttributes α → Sort u} →
(t : Lean.EnumAttributes α) →
((attrs : List Lean.AttributeImpl) →
(ext : Lean.PersistentEnvExtension (Lean.Name × α) (Lean.Name × α) (Lean.NameMap α)) →
motive { attrs := attrs, ext := ext }) →
motive t | null | false |
SymbolicDynamics.FullShift.MulSubshift.isClosed | Mathlib.Dynamics.SymbolicDynamics.Basic | ∀ {A : Type u_1} [inst : TopologicalSpace A] {G : Type u_2} [inst_1 : Monoid G]
(self : SymbolicDynamics.FullShift.MulSubshift A G), IsClosed self.carrier | Closedness of `carrier`. | true |
AddMonoidHom.associator_eq_zero | Mathlib.Algebra.Ring.Associator | ∀ {R : Type u_1} [inst : NonUnitalRing R], AddMonoidHom.associator = 0 | null | true |
CategoryTheory.ObjectProperty.IsCodetecting | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.ObjectProperty C → Prop | We say that `P : ObjectProperty C` is codetecting if the functors `C(-, G)`
for `G : C` such that `P G` collectively reflect isomorphisms,
i.e., if any `h` with codomain `G` such that `P G` uniquely factors through `f`,
then `f` is an isomorphism. | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.get?_set_of_not_terminatedAt._simp_1_3 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {o : Option α}, (∃ x, o = some x) = (o ≠ none) | null | false |
LocallyBoundedVariationOn.exists_monotoneOn_sub_monotoneOn' | Mathlib.Topology.EMetricSpace.VariationOnFromTo | ∀ {α : Type u_1} [inst : LinearOrder α] {f : α → ℝ} {s : Set α},
LocallyBoundedVariationOn f s →
∃ p q,
MonotoneOn p s ∧
MonotoneOn q s ∧ f = p - q ∧ ∀ x ∈ s, ∀ y ∈ s, p y - p x + (q y - q x) = variationOnFromTo f s x y | If a real-valued function has bounded variation on a set, then it is a difference of monotone
functions there. Moreover, one can make sure that the two monotone functions add up to the
variation of `f`. | true |
ModuleCat.hom_zsmul | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u} [inst : Ring R] {M N : ModuleCat R} (n : ℤ) (f : M ⟶ N),
ModuleCat.Hom.hom (n • f) = n • ModuleCat.Hom.hom f | null | true |
CategoryTheory.GradedObject.mapBifunctorRightUnitor_inv_naturality | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C : Type u_1} {D : Type u_2} {I : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : Zero I] [inst_3 : DecidableEq I]
[inst_4 : CategoryTheory.Limits.HasInitial C] (F : CategoryTheory.Functor D (CategoryTheory.Functor C D)) {Y : C}
(... | null | true |
achart | Mathlib.Geometry.Manifold.ChartedSpace | (H : Type u) →
{M : Type u_2} →
[inst : TopologicalSpace H] → [inst_1 : TopologicalSpace M] → [inst_2 : ChartedSpace H M] → M → ↑(atlas H M) | `achart H x` is the chart at `x`, considered as an element of the atlas.
Especially useful for working with `BasicContMDiffVectorBundleCore`. | true |
Lean.Parser.CacheableParserContext._sizeOf_inst | Lean.Parser.Types | SizeOf Lean.Parser.CacheableParserContext | null | false |
Set.subset_fst_image_prod_snd_image | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set (α × β)}, s ⊆ (Prod.fst '' s) ×ˢ (Prod.snd '' s) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_union_of_contains_eq_false_left._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Lean.Compiler.LCNF.casesIntToMono._unsafe_rec | Lean.Compiler.LCNF.ToMono | (c : Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure) →
(c.typeName == `Int) = true → Lean.Compiler.LCNF.ToMonoM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | null | false |
AbsolutelyContinuousOnInterval.fun_neg | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {F : Type u_2} [inst : SeminormedAddCommGroup F] {a b : ℝ} {f : ℝ → F},
AbsolutelyContinuousOnInterval f a b → AbsolutelyContinuousOnInterval (fun i => -f i) a b | Eta-expanded form of `AbsolutelyContinuousOnInterval.neg` | true |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.sup'_nonneg_of_ne_zero | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u_1} {F : Type u_2} [inst : Semiring R] [inst_1 : FunLike F R ℝ] (v : F) {c : ℝ} [NonnegHomClass F R ℝ]
{p : Polynomial R} (h : p.support.Nonempty), 0 ≤ c → 0 ≤ p.support.sup' h fun i => v (p.coeff i) * c ^ i | null | true |
QuotientAddGroup.norm_mk_eq_zero | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {S : AddSubgroup M} {m : M} [hS : IsClosed ↑S], ‖↑m‖ = 0 ↔ m ∈ S | The norm of the image of `m : M` in the quotient by a closed subgroup `S` is zero
if and only if `m ∈ S`. | true |
forall_eq_apply_imp_iff._simp_1 | Init.PropLemmas | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), b = f a → p b) = ∀ (a : α), p (f a) | null | false |
addIrreducible_addUnits_add | Mathlib.Algebra.Group.Irreducible.Lemmas | ∀ {M : Type u_2} [inst : AddMonoid M] {y : M} (u : AddUnits M), AddIrreducible (↑u + y) ↔ AddIrreducible y | null | true |
Seminorm.finset_sup_le_sum | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} {ι : Type u_11} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] (p : ι → Seminorm 𝕜 E) (s : Finset ι), s.sup p ≤ ∑ i ∈ s, p i | null | true |
_private.Mathlib.Algebra.Module.ZLattice.Summable.0.ZLattice.exists_finsetSum_norm_rpow_le_tsum._simp_1_9 | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G},
(-b ≤ a ∧ a ≤ b) = (|a| ≤ b) | null | false |
CategoryTheory.Functor.LeftExtension.mk_right | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F'), (Cat... | null | true |
Option.pbind | Init.Data.Option.Instances | {α : Type u_1} → {β : Type u_2} → (o : Option α) → ((a : α) → o = some a → Option β) → Option β | Given an optional value and a function that can be applied when the value is `some`, returns the
result of applying the function if this is possible.
The function `f` is _partial_ because it is only defined for the values `a : α` such that
`o = some a`. This restriction allows the function to use the fact that it can ... | true |
DifferentiableAt.prodMk._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f₁ : E → F} {x : E} {f₂ : E → G},
... | null | false |
instTwoUniqueSumsOfModuleRat | Mathlib.Algebra.Group.UniqueProds.VectorSpace | ∀ {G : Type u_1} [inst : AddCommGroup G] [Module ℚ G], TwoUniqueSums G | Any `ℚ`-vector space has `TwoUniqueSums`, because it is isomorphic to some
`(Basis.ofVectorSpaceIndex ℚ G) →₀ ℚ` by choosing a basis, and `ℚ` already has
`TwoUniqueSums` because it's ordered. | true |
ExteriorAlgebra.ιMulti._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ (R : Type u_1) [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (n : ℕ)
(f : Fin n → M) (x y : Fin n),
f x = f y →
x ≠ y → ((MultilinearMap.mkPiAlgebraFin R n (ExteriorAlgebra R M)).compLinearMap fun x => ExteriorAlgebra.ι R) f = 0 | null | false |
NonUnitalStarSubalgebra.map_toNonUnitalSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B] [inst_5 : Module R B] [inst_6 : Star B]
{S : NonUnitalStarSubalgebra R A} {f : A →⋆ₙₐ[R] B},
(NonUnitalStarSubalgebra.map f S).toNo... | null | true |
UniformEquiv.setCongr._proof_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u_1} {s t : Set α}, s = t → ∀ (x : { a // a ∈ s }), (Equiv.refl α) ↑x ∈ t | null | false |
Ideal.Quotient.instUniqueQuotientTop._proof_1 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (a : R ⧸ ⊤), a = default | null | false |
MeasureTheory.eLpNorm_mono_nnnorm | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_6} {G : Type u_7} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
MeasureTheory.AEStronglyMeasurable f μ →
(∀ (x : α), ‖f x‖₊ ≤ ‖g x‖₊) → MeasureTheory.eLpNorm f p μ ≤ Measure... | null | true |
DiffeologicalSpace.CorePlotsOn.rec | Mathlib.Geometry.Diffeology.Basic | {X : Type u_1} →
{motive : DiffeologicalSpace.CorePlotsOn X → Sort u} →
((isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop) →
(isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fi... | null | false |
commandUnsuppress_compilationIn_ | Mathlib.Tactic.SuppressCompilation | Lean.ParserDescr | The command `unsuppress_compilation in def foo : ...` makes sure that the definition is
compiled to executable code, even if `suppress_compilation` is active. | true |
Graph.instSimpleBot | Mathlib.Combinatorics.Graph.Simple | ∀ {α : Type u_1} {β : Type u_2}, ⊥.Simple | null | true |
partialOrderOfSO._proof_7 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [IsStrictOrder α r] (x y : α), r x y → y = x → False | null | false |
CategoryTheory.CommaMorphism.sub_left | Mathlib.CategoryTheory.Preadditive.Comma | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Preadditive A] {B : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} B] [inst_3 : CategoryTheory.Preadditive B] {T : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} T] [inst_5 : CategoryTheory.Preadditive T] (L : CategoryThe... | null | true |
Int8.toInt.inj | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, x.toInt = y.toInt → x = y | null | true |
Finset.mul_inf_le_inf_mul_of_nonneg | Mathlib.Algebra.Order.GroupWithZero.Finset | ∀ {ι : Type u_1} {M₀ : Type u_2} [inst : MonoidWithZero M₀] {s : Finset ι} {a b : ι → M₀} [inst_1 : SemilatticeInf M₀]
[inst_2 : OrderTop M₀] [PosMulMono M₀] [MulPosMono M₀],
(∀ i ∈ s, 0 ≤ a i) → (∀ i ∈ s, 0 ≤ b i) → s.inf a * s.inf b ≤ s.inf (a * b) | null | true |
Fin.castSucc_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, a.castSucc = 0 ↔ a = 0 | null | true |
ContinuousMulEquiv.rec | Mathlib.Topology.Algebra.ContinuousMonoidHom | {G : Type u} →
[inst : TopologicalSpace G] →
{H : Type v} →
[inst_1 : TopologicalSpace H] →
[inst_2 : Mul G] →
[inst_3 : Mul H] →
{motive : G ≃ₜ* H → Sort u_1} →
((toMulEquiv : G ≃* H) →
(continuous_toFun : Continuous toMulEquiv.toFun) →
... | null | false |
ESeminormedMonoid.recOn | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
[inst : TopologicalSpace E] →
{motive : ESeminormedMonoid E → Sort u} →
(t : ESeminormedMonoid E) →
([toContinuousENorm : ContinuousENorm E] →
[toMonoid : Monoid E] →
(enorm_zero : ‖1‖ₑ = 0) →
(enorm_mul_le : ∀ (x y : E), ‖x * y‖ₑ ≤ ‖x‖ₑ + ‖... | null | false |
MeasureTheory.SimpleFunc.instMul | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Mul β] → Mul (MeasureTheory.SimpleFunc α β) | null | true |
Stream'.cycle._proof_1 | Mathlib.Data.Stream.Defs | ∀ {α : Type u_1}, [] = [] | null | false |
_private.Mathlib.Topology.Algebra.Support.0.LocallyFinite.exists_finset_nhds_mulSupport_subset._simp_1_1 | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
Diffeomorph.sumEmpty_apply_inl | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_9}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {n : WithTop ℕ∞} {M' : Type u_13}
[in... | null | true |
Std.DHashMap.Raw.emptyWithCapacity | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → optParam ℕ 8 → Std.DHashMap.Raw α β | Creates a new empty hash map. The optional parameter `capacity` can be supplied to presize the
map so that it can hold the given number of mappings without reallocating. It is also possible to
use the empty collection notations `∅` and `{}` to create an empty hash map with the default
capacity.
| true |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.isType'.match_1 | Mathlib.Util.Notation3 | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
CategoryTheory.monoidalOfHasFiniteCoproducts.associator_hom | Mathlib.CategoryTheory.Monoidal.OfHasFiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] (X Y Z : C),
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom =
CategoryTheory.Limits.coprod.desc
(CategoryTheory.Limits.coprod.desc Cat... | null | true |
CategoryTheory.MorphismProperty.Arrow.w | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q W : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative] {A B : P.Arrow Q W} (f : A ⟶ B),
CategoryTheory.CategoryStruct.comp f.left B.hom = CategoryTheory.CategoryStruct.comp A.hom f.right | null | true |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.SFinite.0.MeasureTheory.Measure.add_right_inj._simp_1_1 | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ₁ μ₂ : MeasureTheory.Measure α}, (μ₁ = μ₂) = ∀ (s : Set α), μ₁ s = μ₂ s | null | false |
CategoryTheory.Limits.piConstAdj._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasProducts C] (X : C)
(x x_1 : Cᵒᵖ) (x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.yoneda.obj X).comp (CategoryTheory.Limits.piConst.obj X).rightOp).map x_2)
(CategoryTheory.Limits.Pi.l... | null | false |
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite.match_8 | Mathlib.Tactic.GRewrite.Core | (motive : Option (Lean.Name × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Name × Lean.Expr × Lean.Expr)) →
((fst : Lean.Name) → (lhs' rhs' : Lean.Expr) → motive (some (fst, lhs', rhs'))) →
((x : Option (Lean.Name × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
_private.Mathlib.Analysis.Analytic.OfScalars.0.FormalMultilinearSeries.ofScalarsSum_zero._simp_1_1 | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : Ring E] [inst_2 : Algebra 𝕜 E] [inst_3 : TopologicalSpace E]
[inst_4 : IsTopologicalRing E] (c : ℕ → 𝕜) (x : E) (n : ℕ),
c n • x ^ n = (FormalMultilinearSeries.ofScalars E c n) fun x_1 => x | null | false |
EReal.induction₂_symm_neg | Mathlib.Data.EReal.Operations | ∀ {P : EReal → EReal → Prop},
(∀ {x y : EReal}, P x y → P y x) →
(∀ {x y : EReal}, P x y → P (-x) y) →
P ⊤ ⊤ → (∀ (x : ℝ), 0 < x → P ⊤ ↑x) → P ⊤ 0 → (∀ (x y : ℝ), P ↑x ↑y) → ∀ (x y : EReal), P x y | Induct on two ereals by performing case splits on the sign of one whenever the other is
infinite. This version eliminates some cases by assuming that `P` is symmetric and `P x y` implies
`P (-x) y` for all `x`, `y`. | true |
MonCat.instConcreteCategoryMonoidHomCarrier.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | MonCat.instConcreteCategoryMonoidHomCarrier =
{ hom := fun {X Y} => MonCat.Hom.hom', ofHom := fun {X Y} => MonCat.Hom._mkInternal,
hom_ofHom := @MonCat.instConcreteCategoryMonoidHomCarrier._proof_1,
ofHom_hom := @MonCat.instConcreteCategoryMonoidHomCarrier._proof_2,
id_apply := @MonCat.instConcreteCategor... | null | true |
Std.ExtDHashMap.Const.getKeyD_unitOfList_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α}
{k k' fallback : α},
(k == k') = true →
List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.ExtDHashMap.Const.unitOfList l).getKeyD k' fallback = k | null | true |
_private.Mathlib.Data.Nat.PrimeFin.0.Nat.disjoint_primeFactors._simp_1_2 | Mathlib.Data.Nat.PrimeFin | ∀ {m n : ℕ}, m.Coprime n = (m.gcd n = 1) | null | false |
Lean.Lsp.ChangeAnnotationSupport.mk.noConfusion | Lean.Data.Lsp.Capabilities | {P : Sort u} →
{groupsOnLabel? groupsOnLabel?' : Option Bool} →
{ groupsOnLabel? := groupsOnLabel? } = { groupsOnLabel? := groupsOnLabel?' } →
(groupsOnLabel? = groupsOnLabel?' → P) → P | null | false |
Matroid.IsCircuit.subset_closure_diff_singleton | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C : Set α}, M.IsCircuit C → ∀ (e : α), C ⊆ M.closure (C \ {e}) | **Alias** of `Matroid.IsCircuit.subset_closure_sdiff_singleton`. | true |
R1Space.mk | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_3} [inst : TopologicalSpace X], (∀ (x y : X), x ⤳ y ∨ Disjoint (nhds x) (nhds y)) → R1Space X | null | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf._unary.induct_unfolding | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded (Std.Rxi.Iterator α) Id Pl) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardE... | null | false |
List.unattach_flatten | Init.Data.List.Attach | ∀ {α : Type u_1} {p : α → Prop} {l : List (List { x // p x })}, l.flatten.unattach = (List.map List.unattach l).flatten | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.