name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Class.coe_union._simp_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x y : ZFSet.{u}), ↑x ∪ ↑y = ↑(x ∪ y) | null | false |
_private.Mathlib.Algebra.Star.Unitary.0.Unitary.smul_mem_of_mem._simp_1_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | null | false |
nhdsLT_le_nhdsNE | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] (a : α), nhdsWithin a (Set.Iio a) ≤ nhdsWithin a {a}ᶜ | null | true |
CategoryTheory.Pseudofunctor.mkOfLax' | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(F : CategoryTheory.LaxFunctor B C) →
[∀ (a : B), CategoryTheory.IsIso (F.mapId a)] →
[∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g)] →
... | Construct a pseudofunctor from a lax functor whose `mapId` and `mapComp` are isomorphisms. | true |
Real.iSup_nonpos | Mathlib.Algebra.Order.Archimedean.Real.Basic | ∀ {ι : Sort u_1} {f : ι → ℝ}, (∀ (i : ι), f i ≤ 0) → ⨆ i, f i ≤ 0 | As `⨆ i, f i = 0` when the domain of the real-valued function `f` is empty,
it suffices to show that all values of `f` are nonpositive to show that `⨆ i, f i ≤ 0`. | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_mem_invtSubmodule._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | null | false |
Finset.orderIsoOfFin.congr_simp | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k), s.orderIsoOfFin h = s.orderIsoOfFin h | null | true |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderSup.of_lt._simp_1_1 | Init.Data.Order.Factories | ∀ {p q : Prop}, (¬p ∧ ¬q) = ¬(p ∨ q) | null | false |
Lean.Meta.Tactic.TryThis.instToMessageDataSuggestionText.match_1 | Lean.Meta.TryThis | (motive : Lean.Meta.Tactic.TryThis.SuggestionText → Sort u_1) →
(x : Lean.Meta.Tactic.TryThis.SuggestionText) →
((kind : Lean.SyntaxNodeKind) →
(stx : Lean.TSyntax kind) → motive (Lean.Meta.Tactic.TryThis.SuggestionText.tsyntax stx)) →
((s : String) → motive (Lean.Meta.Tactic.TryThis.SuggestionText.... | null | false |
Int32.or_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a ||| b = 0) = (a = 0 ∧ b = 0) | null | false |
Part.mk._flat_ctor | Mathlib.Data.Part | {α : Type u} → (Dom : Prop) → (Dom → α) → Part α | null | false |
OnePoint.map_some | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} {Y : Type u_2} (f : X → Y) (x : X), OnePoint.map f ↑x = ↑(f x) | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_8 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
((a ++ b).extract i j).size = (a.extract i j).size → ∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → i + w < a.size | null | false |
CategoryTheory.Comma.mapLeftId_inv_app_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) (X : CategoryTheory.Comma L R),
((CategoryTheory.Comma.mapLeftId L R... | null | true |
MeasureTheory.lpMeasToLpTrimLie_symm_indicator | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {F : Type u_2} {p : ENNReal} [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
[one_le_p : Fact (1 ≤ p)] [inst_1 : NormedSpace ℝ F] {hm : m ≤ m0} {s : Set α} {μ : MeasureTheory.Measure α}
(hs : MeasurableSet s) (hμs : (μ.trim hm) s ≠ ⊤) (c : F),
↑((MeasureTheory.lpMeasToLpTrimLie F ℝ p μ h... | When applying the inverse of `lpMeasToLpTrimLie` (which takes a function in the Lp space of
the sub-sigma algebra and returns its version in the larger Lp space) to an indicator of the
sub-sigma-algebra, we obtain an indicator in the Lp space of the larger sigma-algebra. | true |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.intCast._simp_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : IntCast α] (m : ℤ),
↑m = Matrix.diagonal ↑m | null | false |
FirstOrder.Field.fieldOfModelACF | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | (p : ℕ) →
(K : Type u_2) → [inst : FirstOrder.Language.ring.Structure K] → [h : K ⊨ FirstOrder.Language.Theory.ACF p] → Field K | A model for the Theory of algebraically closed fields is a Field. After introducing
this as a local instance on a particular Type, you should usually also introduce
`modelField_of_modelACF p M`, `compatibleRingOfModelField` and `isAlgClosed_of_model_ACF` | true |
Algebra.SubmersivePresentation.basisKaehler.eq_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {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 ι σ),
P.basisKaehler = P.basisKaehlerOfIsCompl ⋯ ⋯ | null | true |
List.mem_of_elem_eq_true._f | Init.Data.List.Basic | ∀ {α : Type u} [inst : BEq α] [LawfulBEq α] {a : α} {as : List α}
(f : List.below (motive := fun {as} => List.elem a as = true → a ∈ as) as), List.elem a as = true → a ∈ as | null | false |
cfcₙ_tsub | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalRing A] [inst_2 : PartialOrder A] [inst_3 : StarRing A]
[inst_4 : StarOrderedRing A] [inst_5 : Module ℝ A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : SMulCommClass ℝ A A]
[IsTopologicalRing A] [T2Space A] [inst_10 : NonUnitalContinuousFunctionalCalculus ... | null | true |
ProbabilityTheory.IsCondKernelCDF.toKernel._proof_1 | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | CompactIccSpace ℝ | null | false |
CategoryTheory.MorphismProperty.Arrow.homMk | 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.left ⟶ B.left) →
(g : A.right ⟶ B.right) →
a... | Make a morphism in `P.Arrow Q X` from morphisms in `T` with compatibilities. | true |
CategoryTheory.Equivalence | Mathlib.CategoryTheory.Equivalence | (C : Type u₁) →
(D : Type u₂) →
[CategoryTheory.Category.{v₁, u₁} C] → [CategoryTheory.Category.{v₂, u₂} D] → Type (max (max (max u₁ u₂) v₁) v₂) | An equivalence of categories.
We define an equivalence between `C` and `D`, with notation `C ≌ D`, as a half-adjoint equivalence:
a pair of functors `F : C ⥤ D` and `G : D ⥤ C` with a unit `η : 𝟭 C ≅ F ⋙ G` and counit
`ε : G ⋙ F ≅ 𝟭 D`, such that the natural isomorphisms `η` and `ε` satisfy the triangle law for
`F`:... | true |
Finsupp.NonTorsionWeight.ne_zero | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] (w : σ → M) [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [Nontrivial R] [Finsupp.NonTorsionWeight R w] (s : σ), w s ≠ 0 | null | true |
Lean.Elab.Term.ElabAppArgs.Context.mk | Lean.Elab.App | Bool → Bool → Bool → ℕ → Lean.Elab.Term.ElabAppArgs.Context | null | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor.congr_simp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f],
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor f =
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor f_1 | null | true |
Int.clog_of_left_le_one | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
{b : ℕ}, b ≤ 1 → ∀ (r : R), Int.clog b r = 0 | null | true |
quasiconvexOn_iff_le_max | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconvexOn 𝕜 s f ↔
Convex 𝕜 s ∧
∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b =... | null | true |
Vector.getElem_add | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {n : ℕ} [inst : Add α] (xs ys : Vector α n) (i : ℕ) (h : i < n), (xs + ys)[i] = xs[i] + ys[i] | null | true |
CategoryTheory.Abelian.SpectralObject.cyclesMap.eq_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {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 j k : ι} (f : i ⟶ j) (g : j ⟶ k) {i' j' k' : ι} (f' : i' ⟶ j')
(g' : j' ⟶ k') (α : CategoryTheory.Com... | null | true |
OpenPartialHomeomorph.EqOnSource.source_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e e' : OpenPartialHomeomorph X Y}, e ≈ e' → e.source = e'.source | Two equivalent open partial homeomorphisms have the same source. | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas.0.Nat.le_nthRoot_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Lean.Meta.AC.PreContext._sizeOf_1 | Lean.Meta.Tactic.AC.Main | Lean.Meta.AC.PreContext → ℕ | null | false |
Lean.MonadHashMapCacheAdapter.ctorIdx | Lean.Util.MonadCache | {α β : Type} → {m : Type → Type} → {inst : BEq α} → {inst_1 : Hashable α} → Lean.MonadHashMapCacheAdapter α β m → ℕ | null | false |
Nat.decreasingInduction_self | Mathlib.Data.Nat.Init | ∀ {n : ℕ} {motive : (m : ℕ) → m ≤ n → Sort u_1} (of_succ : (k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯)
(self : motive n ⋯), Nat.decreasingInduction of_succ self ⋯ = self | null | true |
_private.Lean.Environment.0.Lean.AsyncContext._sizeOf_inst | Lean.Environment | SizeOf Lean.AsyncContext✝ | null | false |
Std.Net.MACAddr._sizeOf_inst | Std.Net.Addr | SizeOf Std.Net.MACAddr | null | false |
_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.fourierIntegral_fderiv._simp_1_1 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {α : Type u_1} {𝕜 : Type u_4} [inst : NormedDivisionRing 𝕜] {G : Type u_5} [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace ℝ G] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst_3 : Module 𝕜 G]
[NormSMulClass 𝕜 G] [SMulCommClass ℝ 𝕜 G] (c : 𝕜) (f : α → G), c • ∫ (a : α), f a ∂μ = ∫ (a : α), ... | null | false |
not_nonempty_empty._simp_1 | Batteries.Logic | Nonempty Empty = False | null | false |
ContinuousMap.instNonUnitalNonAssocRingOfIsTopologicalRing._proof_3 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalNonAssocRing β] [inst_3 : IsTopologicalRing β] (a : C(α, β)), 0 * a = 0 | null | false |
CategoryTheory.Limits.PreservesFilteredColimitsOfSize.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.PreservesFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F → Sort u} →
(t : CategoryTh... | null | false |
HomotopicalAlgebra.FibrantBrownFactorization.r | Mathlib.AlgebraicTopology.ModelCategory.BrownLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
{X Y : C} → {f : X ⟶ Y} → (self : HomotopicalAlgebra.FibrantBrownFactorization f) → self.Z ⟶ X | a fibration that is a retraction of `i` | true |
Lean.Grind.Linarith.Poly.denote._sunfold | Init.Grind.Ordered.Linarith | {α : Type u_1} → [Lean.Grind.IntModule α] → Lean.Grind.Linarith.Context α → Lean.Grind.Linarith.Poly → α | null | false |
CategoryTheory.ObjectProperty.strictMap | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
{D : Type u'} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
CategoryTheory.ObjectProperty C → CategoryTheory.Functor C D → CategoryTheory.ObjectProperty D | The strict image of a property of objects by a functor. | true |
CategoryTheory.imageOpUnop._proof_2 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasImage f.op | null | false |
ProbabilityTheory.IdentDistrib.const_add | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ}
[inst_3 : Add γ] [MeasurableAdd γ],
ProbabilityTheory.IdentDistrib f g μ ν →
∀ (c : γ), Probab... | null | true |
MulDistribMulActionHom.inverse._proof_3 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} [inst : Monoid M] {A : Type u_1} [inst_1 : Monoid A] [inst_2 : MulDistribMulAction M A] {B₁ : Type u_2}
[inst_3 : Monoid B₁] [inst_4 : MulDistribMulAction M B₁] (f : A →*[M] B₁) (g : B₁ → A)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f), (↑((↑f).inverse g h₁ h₂)).toFun 1 = 1 | null | false |
ContinuousLinearMap.compLeftContinuous._proof_4 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (R : Type u_4) {M : Type u_2} [inst : TopologicalSpace M] {M₂ : Type u_3} [inst_1 : TopologicalSpace M₂]
[inst_2 : Semiring R] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M₂] [inst_5 : ContinuousAdd M]
[inst_6 : Module R M] [inst_7 : ContinuousConstSMul R M] [inst_8 : ContinuousAdd M₂] [inst_9 : Module R M... | null | false |
ExistsAndEq.mkNestedExists._sunfold | Mathlib.Tactic.Simproc.ExistsAndEq | List ExistsAndEq.VarQ → Q(Prop) → Lean.MetaM Q(Prop) | null | false |
FirstOrder.Language.quotientStructure | Mathlib.ModelTheory.Quotients | {L : FirstOrder.Language} → {M : Type u_1} → {s : Setoid M} → [ps : L.Prestructure s] → L.Structure (Quotient s) | null | true |
Ordinal.univLE_of_injective | Mathlib.SetTheory.Cardinal.UnivLE | ∀ {f : Ordinal.{u} → Ordinal.{v}}, Function.Injective f → UnivLE.{u, v} | null | true |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.constructorMatching.go._unsafe_rec | Mathlib.Tactic.CasesM | (Lean.Expr → Lean.MetaM Bool) → Lean.MVarId → optParam (Array Lean.MVarId) #[] → Lean.MetaM (Array Lean.MVarId) | null | false |
CompactlySupportedContinuousMap.instMulLeftMono | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : PartialOrder β]
[inst_3 : MulZeroClass β] [inst_4 : ContinuousMul β] [MulLeftMono β],
MulLeftMono (CompactlySupportedContinuousMap α β) | null | true |
Field.qsmul_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u} [self : Field K] (a : ℚ) (x : K), Field.qsmul a x = ↑a * x | However `qsmul` is defined, it must be propositionally equal to multiplication by `Rat.cast`.
Do not use this lemma directly. Use `Rat.cast_def` instead. | true |
_private.Mathlib.NumberTheory.Multiplicity.0.odd_sq_dvd_geom_sum₂_sub._simp_1_2 | Mathlib.NumberTheory.Multiplicity | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - (b + c) = a - b - c | null | false |
Std.Internal.List.DistinctKeys.def | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l ↔ List.Pairwise (fun a b => (a.fst == b.fst) = false) l | null | true |
fixedPoints_submonoid_iSup | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ (M : Type u_1) (α : Type u_2) [inst : Monoid M] [inst_1 : MulAction M α] {ι : Sort u_3} {P : ι → Submonoid M},
MulAction.fixedPoints (↥(iSup P)) α = ⋂ i, MulAction.fixedPoints (↥(P i)) α | Fixed points of iSup of submonoids is intersection | true |
Std.ExtTreeSet.getGE? | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → α → Option α | Tries to retrieve the smallest element that is greater than or equal to the
given element, returning `none` if no such element exists.
| true |
Lean.Linter.UnusedVariables.FVarDefinition.opts | Lean.Linter.UnusedVariables | Lean.Linter.UnusedVariables.FVarDefinition → Lean.Options | The options set locally to this part of the syntax (used by `IgnoreFn`) | true |
MeasureTheory.memLp_re_im_iff | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {K : Type u_8} [inst : RCLike K]
{f : α → K},
MeasureTheory.MemLp (fun x => RCLike.re (f x)) p μ ∧ MeasureTheory.MemLp (fun x => RCLike.im (f x)) p μ ↔
MeasureTheory.MemLp f p μ | null | true |
CategoryTheory.Bicategory.Adj.instCategoryHom._proof_4 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {X Y : a ⟶ b} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f | null | false |
Char.isLower | Init.Data.Char.Basic | Char → Bool | Returns `true` if the character is a lowercase ASCII letter.
The lowercase ASCII letters are the following: `abcdefghijklmnopqrstuvwxyz`.
| true |
MeasureTheory.withDensity_zero | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.withDensity 0 = 0 | null | true |
FreeMagma | Mathlib.Algebra.Free | Type u → Type u | If `α` is a type, then `FreeMagma α` is the free magma generated by `α`.
This is a magma equipped with a function `FreeMagma.of : α → FreeMagma α` which has
the following universal property: if `M` is any magma, and `f : α → M` is any function,
then this function is the composite of `FreeMagma.of` and a unique multipli... | true |
Stream'.WSeq.findIndex | Mathlib.Data.WSeq.Defs | {α : Type u} → (p : α → Prop) → [DecidablePred p] → Stream'.WSeq α → Computation ℕ | Get the index of the first element of `s` satisfying `p` | true |
Rep.FiniteCyclicGroup.groupHomologyIsoEven._proof_6 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_1, u_1} k G)
(g : G), (Rep.FiniteCyclicGroup.subCompNormHom A g).HasHomology | null | false |
AddCon.pi._proof_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {ι : Type u_1} {f : ι → Type u_2} [inst : (i : ι) → Add (f i)] (C : (i : ι) → AddCon (f i)) {w x y z : (i : ι) → f i},
piSetoid w x → piSetoid y z → ∀ (i : ι), (C i) (w i + y i) (x i + z i) | null | false |
_private.Mathlib.RingTheory.Polynomial.Ideal.0.Polynomial.ker_evalRingHom._simp_1_1 | Mathlib.RingTheory.Polynomial.Ideal | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (x ∈ Ideal.span {y}) = (y ∣ x) | null | false |
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.size_mkSlice_roi._simp_1_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α}, Std.Slice.size xs = (Std.Slice.toList xs).length | null | false |
Std.IterM.step_takeWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool},
(Std.IterM.takeWhile P it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterStep.yield it' out, h⟩ =>
match hP ... | null | true |
Lean.Level.PP.Result.offset | Lean.Level | Lean.Level.PP.Result → ℕ → Lean.Level.PP.Result | null | true |
_private.Lean.Elab.Parallel.0.Std.Iterators.Types.instIteratorTaskIteratorBaseIO.match_1 | Lean.Elab.Parallel | {α : Type} →
(motive : Std.IterStep (Std.IterM BaseIO α) α → Sort u_1) →
(x : Std.IterStep (Std.IterM BaseIO α) α) →
((it' : Std.IterM BaseIO α) → (out : α) → motive (Std.IterStep.yield it' out)) →
((it : Std.IterM BaseIO α) → motive (Std.IterStep.skip it)) → (Unit → motive Std.IterStep.done) → moti... | null | false |
Vector.any_iff_exists | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {xs : Vector α n}, xs.any p = true ↔ ∃ i, ∃ (x : i < n), p xs[i] = true | null | true |
Module.toMulActionWithZero._proof_1 | Mathlib.Algebra.Module.Defs | ∀ {R : Type u_2} {M : Type u_1} {x : Semiring R} {x_1 : AddCommMonoid M} [inst : Module R M] (a : R), a • 0 = 0 | null | false |
CategoryTheory.RelCat.Hom.ctorIdx | Mathlib.CategoryTheory.Category.RelCat | {X Y : CategoryTheory.RelCat} → X.Hom Y → ℕ | null | false |
LaurentSeries.instValuedSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg._proof_10 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K] (x : LaurentSeries.ratfuncAdicComplPkg.space),
nhds x =
Filter.comap (Prod.mk x)
(LaurentSeries.instValuedSpaceWithValRatFuncWithZeroMultiplicativeIntPolynomialValuationXRatfuncAdicComplPkg._aux_6
K) | null | false |
Lean.Elab.Info.ofMacroExpansionInfo.injEq | Lean.Elab.InfoTree.Types | ∀ (i i_1 : Lean.Elab.MacroExpansionInfo),
(Lean.Elab.Info.ofMacroExpansionInfo i = Lean.Elab.Info.ofMacroExpansionInfo i_1) = (i = i_1) | null | true |
Nat.Partition.ofSym_map | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ {n : ℕ} {σ : Type u_1} {τ : Type u_2} [inst : DecidableEq σ] [inst_1 : DecidableEq τ] (e : σ ≃ τ) (s : Sym σ n),
Nat.Partition.ofSym (Sym.map (⇑e) s) = Nat.Partition.ofSym s | null | true |
CategoryTheory.Limits.HasImage.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Limits.HasImage f → Sort u_1} →
(t : CategoryTheory.Limits.HasImage f) →
((exists_image : Nonempty (CategoryTheory.Limits.ImageFactorisation f)) → motive ⋯) → motive t | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Circulant.0.SimpleGraph.cycleGraph.cycleCons._simp_3 | Mathlib.Combinatorics.SimpleGraph.Circulant | ∀ {n : ℕ} {u v : Fin (n + 2)}, (SimpleGraph.cycleGraph (n + 2)).Adj u v = (u - v = 1 ∨ v - u = 1) | null | false |
Set.zero.eq_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α], Set.zero = { zero := {0} } | null | true |
Matrix._aux_Mathlib_LinearAlgebra_Matrix_ConjTranspose___unexpand_Matrix_conjTranspose_1 | Mathlib.LinearAlgebra.Matrix.ConjTranspose | Lean.PrettyPrinter.Unexpander | null | false |
intervalIntegral.integral_hasStrictFDerivAt_of_tendsto_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {ca cb : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds a) MeasureTheory.volume →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
F... | **Fundamental theorem of calculus-1**, strict differentiability in both endpoints.
If `f : ℝ → E` is integrable on `a..b` and `f x` has finite limits `ca` and `cb` almost surely as
`x` tends to `a` and `b`, respectively, then
`(u, v) ↦ ∫ x in u..v, f x` has derivative `(u, v) ↦ v • cb - u • ca` at `(a, b)`
in the sens... | true |
cfc_comp_star._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
_private.Init.Data.Rat.Lemmas.0.Rat.le_of_mul_le_mul_left._simp_1_1 | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, (b ≤ a) = ¬a < b | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.one_sub_eps_mul_card_nonuniformWitness_le_card_star | 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} {V : Finset α},
V ∈ P.parts →
U ≠ V →
¬G.IsUniform ε U V →
100 ≤ 4 ^ P.parts.card * ε ^ 5... | null | true |
PseudoMetric.finsetSup_apply | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : AddCommMonoid R] [inst_1 : LinearOrder R] [inst_2 : AddLeftStrictMono R]
[inst_3 : IsOrderedAddMonoid R] {Y : Type u_3} {f : Y → PseudoMetric X R} {s : Finset Y} (hs : s.Nonempty) (x y : X),
(s.sup f) x y = s.sup' hs fun i => (f i) x y | null | true |
Std.TreeMap.getKey?_diff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t₁ \ t₂).getKey? k = if k ∈ t₂ then none else t₁.getKey? k | null | true |
AbsoluteValue.instInhabitedIsAdmissibleIntAbs | Mathlib.NumberTheory.ClassNumber.AdmissibleAbs | Inhabited AbsoluteValue.abs.IsAdmissible | null | true |
Submodule.idemSemiring._proof_5 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(M : Submodule R A), 1 * M = M | null | false |
Lean.Meta.Grind.SymbolPriorityEntry.ctorIdx | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.SymbolPriorityEntry → ℕ | null | false |
Mathlib.Tactic.Linarith.PComp.noConfusionType | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | Sort u → Mathlib.Tactic.Linarith.PComp → Mathlib.Tactic.Linarith.PComp → Sort u | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_alterKey_eq_self._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, ((a == b) = true) = (compare a b = Ordering.eq) | null | false |
DihedralGroup.instGroup._proof_13 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (n_1 : ℕ) (a : DihedralGroup n), zpowRec npowRec (↑n_1.succ) a = zpowRec npowRec (↑n_1) a * a | null | false |
_private.Mathlib.RingTheory.Support.0.Module.support_of_noZeroSMulDivisors._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∈ Module.support R M) = ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0 | null | false |
CategoryTheory.MorphismProperty.inverseImage_op_overObj | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{v_3, u_3} T] (W : CategoryTheory.MorphismProperty T) {X : T},
W.overObj.op.inverseImage (CategoryTheory.Under.opEquivOpOver X).functor = W.op.underObj | null | true |
MeasureTheory.addEquivAddHaarChar | Mathlib.MeasureTheory.Measure.Haar.MulEquivHaarChar | {G : Type u_1} →
[inst : AddGroup G] →
[inst_1 : TopologicalSpace G] →
[inst_2 : MeasurableSpace G] →
[BorelSpace G] → [IsTopologicalAddGroup G] → [LocallyCompactSpace G] → G ≃ₜ+ G → NNReal | If `φ : A ≃ₜ+ A` then `addEquivAddHaarChar φ` is the positive
real factor by which `φ` scales Haar measures on `A`. | true |
kroneckerTMulLinearEquiv._proof_6 | Mathlib.RingTheory.MatrixAlgebra | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
_private.Mathlib.Data.Multiset.Replicate.0.Multiset.nodup_iff_ne_cons_cons.match_1_1 | Mathlib.Data.Multiset.Replicate | ∀ {α : Type u_1} {s : Multiset α} (a : α) (motive : (∃ u, s = a ::ₘ a ::ₘ 0 + u) → Prop)
(x : ∃ u, s = a ::ₘ a ::ₘ 0 + u), (∀ (t : Multiset α) (s_eq : s = a ::ₘ a ::ₘ 0 + t), motive ⋯) → motive x | null | false |
Std.ExtHashSet.casesOn | Std.Data.ExtHashSet.Basic | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Std.ExtHashSet α → Sort u_1} →
(t : Std.ExtHashSet α) → ((inner : Std.ExtHashMap α Unit) → motive { inner := inner }) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.