name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasurableSMul.mk | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : MeasurableSpace M] [inst_2 : MeasurableSpace α]
[toMeasurableConstSMul : MeasurableConstSMul M α],
autoParam (∀ (x : α), Measurable fun x_1 => x_1 • x) MeasurableSMul.measurable_smul_const._autoParam →
MeasurableSMul M α | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.completeBipartiteGraph_isContained_iff.match_1_7 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_2} {G : SimpleGraph V} {α : Type u_3} {β : Type u_1} [inst : Fintype β]
(f : (completeBipartiteGraph α β).Copy G) (x : V)
(motive : (∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x) → Prop)
(hr : ∃ a ∈ Finset.univ, { toFun := ⇑f ∘ Sum.inr, inj' := ⋯ } a = x),
(∀ (w : β) (left : w ∈ F... | null | false |
List.flatMap | Init.Prelude | {α : Type u} → {β : Type v} → (α → List β) → List α → List β | Applies a function that returns a list to each element of a list, and concatenates the resulting
lists.
Examples:
* `[2, 3, 2].flatMap List.range = [0, 1, 0, 1, 2, 0, 1]`
* `["red", "blue"].flatMap String.toList = ['r', 'e', 'd', 'b', 'l', 'u', 'e']`
| true |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).map' 0 1 C... | null | false |
PiNat.mem_cylinder_comm | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) (n : ℕ), y ∈ PiNat.cylinder x n ↔ x ∈ PiNat.cylinder y n | null | true |
delabNotIn | Mathlib.Util.Delaborators | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `∉`. | true |
CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusion | Mathlib.CategoryTheory.Bicategory.Grothendieck | {P : Sort u} →
{𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} →
{t : F.CoGrothendieck} →
{𝒮' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} 𝒮'} →
... | null | false |
CategoryTheory.Limits.instPreservesColimitsOfShapeDiscreteOfFiniteOfPreservesFiniteCoproducts | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (J : Type u) [Finite J] [CategoryTheory.Limits.PreservesFiniteCoproducts F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete J) F | null | true |
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L]... | Given `x : CohomologyClass K L n`, this is the element in the type
`SmallShiftedHom` relatively to quasi-isomorphisms that is associated
to the `x`. | true |
Function.Surjective.involutiveNeg._proof_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Neg M₂] [inst_1 : InvolutiveNeg M₁] (f : M₁ → M₂),
(∀ (x : M₁), f (-x) = -f x) → ∀ (x : M₁), - -f x = f x | null | false |
ContinuousAlgEquiv.coeCLE_apply | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B) (a : A), ↑e a = e a | null | true |
_private.Init.Data.Array.Find.0.Array.getElem?_zero_flatten._simp_1_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {l : List α}, l[0]? = l.head? | null | false |
Std.DTreeMap.Raw.Equiv.forIn_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {b : δ}
{f : (a : α) × β a → δ → m (ForInStep δ)}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forIn t₁ b f = forIn t₂ b f | null | true |
Subgroup.mulSingle_mem_pi._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), (Pi.mulSingle i x ∈ Subgroup.pi I H) = (i ∈ I → x ∈ H i) | null | false |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceOpcyclesE_X₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.Cat... | null | true |
CommHopfAlgCat.casesOn | Mathlib.Algebra.Category.CommHopfAlgCat | {R : Type u} →
[inst : CommRing R] →
{motive : CommHopfAlgCat R → Sort u_1} →
(t : CommHopfAlgCat R) →
((X : Type v) →
[commRing : CommRing X] →
[hopfAlgebra : HopfAlgebra R X] → motive { X := X, commRing := commRing, hopfAlgebra := hopfAlgebra }) →
motive t | null | false |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.integral_riesz_aux._simp_1_7 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_12 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | (ComplexShape.embeddingUpIntLE 0).IsTruncLE | null | false |
_private.Init.Omega.Int.0.Lean.Omega.Fin.ne_iff_lt_or_gt._simp_1_1 | Init.Omega.Int | ∀ {a b : ℕ}, (a ≠ b) = (a < b ∨ b < a) | null | false |
SSet.Subcomplex.Pairing.RankFunction.filtration_of_isSuccLimit | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι) [OrderBot ι]
[SuccOrder ι] (i : ι), Order.IsSuccLimit i → f.filtration i = ⨆ j, ⨆ (_ : j < i), f.filtration j | null | true |
NNRat.instContinuousSub | Mathlib.Topology.Instances.Rat | ContinuousSub ℚ≥0 | null | true |
Std.TreeMap.getKeyD_diff_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ \ t₂).getKeyD k fallback = t₁.getKeyD k fallback | null | true |
genLoopEquivOfUnique._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [inst_1 : Unique N] (p : LoopSpace X x),
{ toFun := fun c => p (c default), continuous_toFun := ⋯ } ∈ GenLoop N X x | null | false |
Lean.Server.instMonadLiftCancellableMRequestM.match_1 | Lean.Server.Requests | {α : Type} →
(motive : Except Lean.Server.RequestCancellation α → Sort u_1) →
(r : Except Lean.Server.RequestCancellation α) →
((a : Lean.Server.RequestCancellation) → motive (Except.error a)) → ((v : α) → motive (Except.ok v)) → motive r | null | false |
FinPartOrd.Iso.mk_inv | Mathlib.Order.Category.FinPartOrd | ∀ {α β : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd), (FinPartOrd.Iso.mk e).inv = FinPartOrd.ofHom ↑e.symm | null | true |
Std.TreeSet.Raw.min?_insert_le_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k kmi : α},
(t.insert k).min?.get ⋯ = kmi → (cmp kmi k).isLE = true | null | true |
ContinuousMap.casesOn | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : C(X, Y) → Sort u} →
(t : C(X, Y)) →
((toFun : X → Y) →
(continuous_toFun : Continuous toFun) →
motive { toFun := toFun, continuous_toFun :... | null | false |
_private.Mathlib.Topology.Instances.RatLemmas.0.«termℚ∞» | Mathlib.Topology.Instances.RatLemmas | Lean.ParserDescr | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a : G), (↑a)⁻¹ = ↑a⁻¹ | null | false |
ArithmeticFunction.instAlgebra | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{S : Type u_2} → [inst : CommSemiring R] → [inst_1 : Semiring S] → [Algebra R S] → Algebra R (ArithmeticFunction S) | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isCongruentCheck.go._unsafe_rec | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | false |
CategoryTheory.PrelaxFunctorStruct.map₂ | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : Quiver B] →
[inst_1 : (a b : B) → Quiver (a ⟶ b)] →
{C : Type u₂} →
[inst_2 : Quiver C] →
[inst_3 : (a b : C) → Quiver (a ⟶ b)] →
(self : CategoryTheory.PrelaxFunctorStruct B C) →
{a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (self.map f ⟶ self.map... | The action of a lax prefunctor on 2-morphisms. | true |
EReal.neg_eq_top_iff | Mathlib.Data.EReal.Operations | ∀ {x : EReal}, -x = ⊤ ↔ x = ⊥ | null | true |
ArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M]
(c : ArchimedeanClass M), c.closedBallAddSubgroup = ArchimedeanClass.addSubgroup (UpperSet.Ici c) | null | true |
Std.DTreeMap.Internal.Const.RicSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RicSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.Ric... | null | false |
ModuleCat.CoextendScalars.obj' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} → {S : Type u₂} → [inst : Ring R] → [inst_1 : Ring S] → (R →+* S) → ModuleCat R → ModuleCat S | If `M` is an `R`-module, then the set of `R`-linear maps `S →ₗ[R] M` is an `S`-module with
scalar multiplication defined by `s • l := x ↦ l (x • s)`.
This is an implementation detail: use `(coextendScalars f).obj` instead.
| true |
Lean.Data.AC.Variable.mk | Init.Data.AC | {α : Sort u} → {op : α → α → α} → (value : α) → Option (PLift (Std.LawfulIdentity op value)) → Lean.Data.AC.Variable op | null | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow_covBySMul_sq_inter_sq._simp_1_10 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
CommRingCat.Colimits.Prequotient.noConfusion | Mathlib.Algebra.Category.Ring.Colimits | {P : Sort u} →
{J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J CommRingCat} →
{t : CommRingCat.Colimits.Prequotient F} →
{J' : Type v} →
{inst' : CategoryTheory.SmallCategory J'} →
{F' : CategoryTheory.Functor J' CommRingCat}... | null | false |
PartOrd.dual | Mathlib.Order.Category.PartOrd | CategoryTheory.Functor PartOrd PartOrd | `OrderDual` as a functor. | true |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.pushNegBuiltin._sparseCasesOn_2 | Mathlib.Tactic.Push | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.Filter.Germ.Basic.0.Filter.Germ.IsConstant.match_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {β : Type u_1} {l : Filter α} (f : α → β) (motive : (∃ b, f =ᶠ[l] fun x => b) → Prop)
(x : ∃ b, f =ᶠ[l] fun x => b), (∀ (b : β) (hb : f =ᶠ[l] fun x => b), motive ⋯) → motive x | null | false |
Int.ModEq.prod_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f : α → ℤ} {s : Finset α}, (∀ x ∈ s, f x ≡ 1 [ZMOD n]) → ∏ x ∈ s, f x ≡ 1 [ZMOD n] | null | true |
Std.Internal.Do.Spec.forIn_iter | Std.Internal.Do.Triple.SpecLemmas | ∀ {α β γ : Type u} {m : Type u → Type w} {Pred EPred : Type u} [inst : Monad m]
[inst_1 : Std.Internal.Do.Assertion Pred] [inst_2 : Std.Internal.Do.Assertion EPred]
[inst_3 : Std.Internal.Do.WPMonad m Pred EPred] [LawfulMonad m] [inst_5 : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_7 : Std.IteratorLoop... | null | true |
Matroid.isBasis_iff_isBasis'_subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis I X ↔ M.IsBasis' I X ∧ X ⊆ M.E | null | true |
CategoryTheory.Adjunction.leftAdjointUniq_trans_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F F' F'' : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) (adj3 : F'' ⊣ G) {Z : CategoryTheory.Functor C D}
(h : F'' ⟶ Z),
CategoryTheory.Ca... | null | true |
_private.Mathlib.MeasureTheory.Integral.PeakFunction.0.tendsto_integral_comp_smul_smul_of_integrable._simp_1_3 | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | null | false |
UInt64.toNat_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt64), (-a).toNat = (UInt64.size - a.toNat) % UInt64.size | null | true |
ContinuousAffineMap.coe_const | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (R : Type u_1) {V : Type u_2} {W : Type u_3} (P : Type u_4) {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (q : Q),
⇑(Cont... | null | true |
_private.Init.Data.Array.Sort.Lemmas.0.Subarray.mergeSort_eq_mergeSort_toArray._simp_1_1 | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, (xs = ys) = (xs.toList = ys.toList) | null | false |
Polynomial.cyclotomic.roots_eq_primitiveRoots_val | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [inst_1 : IsDomain R] [NeZero ↑n],
(Polynomial.cyclotomic n R).roots = (primitiveRoots n R).val | null | true |
Subtype.mk.hinj | Mathlib.Data.Subtype | ∀ {α : Sort u} {p : α → Prop} {val : α} {property : p val} {α_1 : Sort u} {p_1 : α_1 → Prop} {val_1 : α_1}
{property_1 : p_1 val_1}, α = α_1 → p ≍ p_1 → ⟨val, property⟩ ≍ ⟨val_1, property_1⟩ → α = α_1 ∧ p ≍ p_1 ∧ val ≍ val_1 | null | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.AnalyzeResult.maxS?._default | Mathlib.Tactic.FBinop | Option FBinopElab.SRec | null | false |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.mapGen_apply_apply_of_surjective.match_1_1 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring N] {c : RingCon M} (f : M →+* N)
{x y : M} (motive : (∃ a b, c a b ∧ f a = f x ∧ f b = f y) → Prop) (x_1 : ∃ a b, c a b ∧ f a = f x ∧ f b = f y),
(∀ (a b : M) (h₁ : c a b) (h₂ : f a = f x) (h₃ : f b = f y), motive ⋯) → motive x_1 | null | false |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParamPerm.pickFixed.go._f | Lean.Elab.PreDefinition.FixedParams | {α : Type u_1} →
(x : List (Option ℕ × α)) → List.below (motive := fun x => Array α → Id (Array α)) x → Array α → Id (Array α) | null | false |
Module.FaithfullyFlat.iff_exact_iff_rTensor_exact | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔
∀ {N1 : Type (max u v)} [inst_3 : AddCommGroup N1] [inst_4 : Module R N1] {N2 : Type (max u v)}
[inst_5 : AddCommGroup N2] [inst_6 : Module R N2] {N3 : Type (max u v)} [inst_7 : AddCo... | null | true |
Complex.addCommGroup._proof_11 | Mathlib.Data.Complex.Basic | ∀ (a b : ℂ), a + b = b + a | null | false |
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_2 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R}, I.IsMaximal → NoZeroDivisors (R ⧸ I) | null | false |
UpperSemicontinuous.inf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} {β : Type u_5} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] {f g : α → β},
UpperSemicontinuous f → UpperSemicontinuous g → UpperSemicontinuous fun x => min (f x) (g x) | null | true |
Equiv.Perm.sigmaCongrRight_refl | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : α → Type u_2}, (Equiv.Perm.sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) × β a) | null | true |
Aesop.GoalState.toNodeState | Aesop.Tree.Data | Aesop.GoalState → Aesop.NodeState | null | true |
UInt64.toUInt32_ofNatLT | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt64.size), (UInt64.ofNatLT n hn).toUInt32 = UInt32.ofNat n | null | true |
LocallyLipschitz.pow_end._f | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : Function.End α},
LocallyLipschitz f → ∀ (x : ℕ) (f_1 : Nat.below x), LocallyLipschitz (f ^ x) | null | false |
MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed_set_eq | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(S : μ.FiniteSpanningSetsIn {s | MeasurableSet s}), S.disjointed.set = disjointed S.set | null | true |
NNReal.arith_mean_le_rpow_mean | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → NNReal),
∑ i ∈ s, w i = 1 → ∀ {p : ℝ}, 1 ≤ p → ∑ i ∈ s, w i * z i ≤ (∑ i ∈ s, w i * z i ^ p) ^ (1 / p) | Weighted generalized mean inequality, version for sums over finite sets, with `ℝ≥0`-valued
functions and real exponents. | true |
CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C))
(j : J), (CategoryTheory.CategoryStruct.comp P.p P.p).app j = P.p.app j | null | false |
String.isInt | Init.Data.String.Search | String → Bool | Checks whether the string can be interpreted as the decimal representation of an integer.
A string can be interpreted as a decimal integer if it only consists of at least one decimal digit
and optionally `-` in front. Leading `+` characters are not allowed.
Use `String.toInt?` or `String.toInt!` to convert
such a str... | true |
ENNReal.toNNReal_zero | Mathlib.Data.ENNReal.Basic | ENNReal.toNNReal 0 = 0 | null | true |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_13 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p q : Submodule R M},
(p = q) = ∀ (x : M), x ∈ p ↔ x ∈ q | null | false |
CategoryTheory.Under.forgetCone._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) ⦃X_1 Y : CategoryTheory.Under X⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Under X)).obj X).map f) Y.hom =
CategoryTheory.CategoryStruct.comp X_1.hom ((CategoryTheory.Under.forget X).map ... | null | false |
Aesop.PhaseSpec.safe.elim | Aesop.Builder.Basic | {motive : Aesop.PhaseSpec → Sort u} →
(t : Aesop.PhaseSpec) → t.ctorIdx = 0 → ((info : Aesop.SafeRuleInfo) → motive (Aesop.PhaseSpec.safe info)) → motive t | null | false |
CategoryTheory.MonoidalClosed.enrichedCategorySelf_id | Mathlib.CategoryTheory.Monoidal.Closed.Enrichment | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] (X : C), CategoryTheory.eId C X = CategoryTheory.MonoidalClosed.id X | null | true |
Std.DTreeMap.Internal.Impl.toList_map | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
{f : (a : α) → β a → γ a},
(Std.DTreeMap.Internal.Impl.map f t).toList = List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) t.toList | null | true |
ContinuousLinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : ... | null | true |
Aesop.LocalRuleSet.mk.noConfusion | Aesop.RuleSet | {P : Sort u} →
{toBaseRuleSet : Aesop.BaseRuleSet} →
{simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems)} →
{simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size} →
{simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs)} →
{simprocsArrayNonempty : 0 < simprocsArray.size} →
... | null | false |
Nonneg.nat_ceil_coe | Mathlib.Algebra.Order.Nonneg.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedRing α] [inst_3 : FloorSemiring α]
(a : { r // 0 ≤ r }), ⌈↑a⌉₊ = ⌈a⌉₊ | null | true |
Std.DTreeMap.Internal.Impl.minKey?_insert!_le_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {v : β k} {km kmi : α},
t.minKey? = some km → (Std.DTreeMap.Internal.Impl.insert! k v t).minKey?.get ⋯ = kmi → (compare kmi km).isLE = true | null | true |
Std.DTreeMap.Raw.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {a : α} [inst_1 : Inhabited (β a)], a ∉ t → t.get! a = default | null | true |
Set.inclusion_inclusion | Mathlib.Data.Set.Inclusion | ∀ {α : Type u_1} {s t u : Set α} (hst : s ⊆ t) (htu : t ⊆ u) (x : ↑s),
Set.inclusion htu (Set.inclusion hst x) = Set.inclusion ⋯ x | null | true |
Finset.isScalarTower' | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : DecidableEq β] [inst_2 : SMul α β]
[inst_3 : SMul α γ] [inst_4 : SMul β γ] [IsScalarTower α β γ], IsScalarTower α (Finset β) (Finset γ) | null | true |
CategoryTheory.ShortComplex.SnakeInput.L₀'_exact | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), S.L₀'.Exact | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback.0.CategoryTheory.MonoidalCategory.Limits.pushout.condition_whiskerRight._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y : C}
(f : W ⟶ X) (g : X ⟶ Y) (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight g Z) =
Category... | null | false |
Sym.coe_equivNatSumOfFintype_apply_apply | Mathlib.Data.Finsupp.Multiset | ∀ (α : Type u_1) [inst : DecidableEq α] (n : ℕ) [inst_1 : Fintype α] (s : Sym α n) (a : α),
↑((Sym.equivNatSumOfFintype α n) s) a = Multiset.count a ↑s | null | true |
Aesop.Script.STactic.ctorIdx | Aesop.Script.Tactic | Aesop.Script.STactic → ℕ | null | false |
SemiNormedGrp.explicitCokernel | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | {X Y : SemiNormedGrp} → (X ⟶ Y) → SemiNormedGrp | An explicit choice of cokernel, which has good properties with respect to the norm. | true |
Lean.Grind.Linarith.le_lt_combine_cert | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool | null | true |
AddSubsemigroup.toSubsemigroup_closure | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {A : Type u_5} [inst : Add A] (S : Set A),
AddSubsemigroup.toSubsemigroup (AddSubsemigroup.closure S) = Subsemigroup.closure (⇑Multiplicative.toAdd ⁻¹' S) | null | true |
Lean.Expr.containsFVar | Lean.Expr | Lean.Expr → Lean.FVarId → Bool | Return `true` if `e` contains the given free variable. | true |
Aesop.instToJsonPhaseName.toJson | Aesop.Rule.Name | Aesop.PhaseName → Lean.Json | null | true |
Std.PRange.UpwardEnumerable.Map.PreservesLT.casesOn | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : LT α] →
[inst_3 : LT β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesLT → Sort u} →
(t : f.Preserv... | null | false |
FirstOrder.Language.IsFraisse.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [h : FirstOrder.Language.IsFraisse K]
{M N : CategoryTheory.Bundled L.Structure}, Nonempty (L.Equiv ↑M ↑N) → (M ∈ K ↔ N ∈ K) | null | true |
PiLp.nnnorm_single | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] (i : ι) (b : β i),
‖PiLp.single p i b‖₊ = ‖b‖₊ | null | true |
String.take_eq | Batteries.Data.String.Lemmas | ∀ (s : String) (n : ℕ), String.Legacy.take s n = String.ofList (List.take n s.toList) | null | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.getIndexToInclude? | Lean.Elab.Match | Lean.Expr → List ℕ → Lean.Elab.TermElabM (Option Lean.Expr) | Collect problematic index for the "discriminant refinement feature". This method is invoked
when we detect a type mismatch at a pattern #`idx` of some alternative. | true |
Std.DTreeMap.Internal.Impl.toListModel_insertMin | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced},
(Std.DTreeMap.Internal.Impl.insertMin k v t h).impl.toListModel = ⟨k, v⟩ :: t.toListModel | null | true |
Preord.inv_hom_apply | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (e : X ≅ Y) (x : ↑X),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
ContinuousAffineMap._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousAffineMap | (R : Type u_1) →
{V : Type u_2} →
{W : Type u_3} →
(P : Type u_4) →
(Q : Type u_5) →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P} →
{inst_4 : AddTorsor V P} →
... | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.midπ_w_f_assoc | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] [inst_3 : CategoryTheory.Mono f]
(n₀ : ℤ) [inst_4 : K.IsStrictlyGE (n₀ + 1)] [inst_5 : L.IsStrictlyGE (n₀ + 1)] (q₁ q₂ : ℕ) (hq : q₁ ... | null | true |
CategoryTheory.Presheaf.isSheaf_iff_extensiveSheaf_of_projective | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] (F : CategoryTheory.Functor Cᵒᵖ A)
[inst_2 : CategoryTheory.Preregular C] [inst_3 : CategoryTheory.FinitaryExtensive C]
[∀ (X : C), CategoryTheory.Projective X],
CategoryTheory.Presheaf.IsS... | null | true |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CompleteSpace Aᵐᵒᵖ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.