name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicIndependent.to_subtype_range | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
AlgebraicIndependent R x → AlgebraicIndependent R Subtype.val | null | true |
Decidable.decide.congr_simp | Init.SimpLemmas | ∀ (p p_1 : Prop), p = p_1 → ∀ {self : Decidable p} [self_1 : Decidable p_1], decide p = decide p_1 | null | true |
IsLocalization.map_units | 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] [IsLocalization M S] (y : ↥M), IsUnit ((algebraMap R S) ↑y) | Everything in the image of `algebraMap` is a unit. | true |
MvPFunctor.B | Mathlib.Data.PFunctor.Multivariate.Basic | {n : ℕ} → (self : MvPFunctor.{u} n) → self.A → TypeVec.{u} n | The child family of types | true |
Real.cos_sub_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (x - 2 * Real.pi) = Real.cos x | null | true |
WithBot.sumHomeomorph._proof_2 | Mathlib.Topology.Order.WithTop | ∀ (ι : Type u_1) [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι],
Continuous fun x =>
match x with
| Sum.inl i => ↑i
| Sum.inr PUnit.unit => ⊥ | null | false |
AlgebraicGeometry.Scheme.Hom.asFiberHom._proof_1 | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (x : ↥X),
CategoryTheory.Limits.HasPullback f (Y.fromSpecResidueField (f x)) | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.CFC.monotoneOn_one_sub_one_add_inv_real._proof_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] ⦃a : A⦄,
0 ≤ a → ∀ x ∈ quasispectrum ℝ a, 0 ≤ x | null | false |
RootPairing.restrictScalars._proof_1 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_5)
[inst_5 : Field K] [inst_6 : Algebra K L] [P.IsCrystallographic], P.IsValuedIn K | null | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_univ._simp_1_1 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u}, Set.univ.Countable = Countable α | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ediv_toInt_nonpos_of_nonpos_of_nonneg._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)}, x.toInt ≤ 0 → 0 ≤ y.toInt → ¬x.toInt = 0 → ¬y.toInt = 0 → ¬x.toInt < 0 → False | null | false |
Submonoid.powers._proof_2 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M], MonoidHomClass (Multiplicative ℕ →* M) (Multiplicative ℕ) M | null | false |
SSet.Subcomplex.image_preimage_le._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (B : X.Subcomplex) (f : Y ⟶ X), ((B.preimage f).image f ≤ B) = True | null | false |
Fin.prod_zero_zero_lt_iff | Mathlib.Order.Fin.Prod | ∀ {p q : ℕ} (i : Fin (p + 1) × Fin (q + 1)), (0, 0) < i ↔ 0 < ↑i.1 + ↑i.2 | null | true |
Algebra.Presentation.mk.inj | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S}
{toGenerators : Algebra.Generators R S ι} {relation : σ → toGenerators.Ring}
{span_range_relation_eq_ker : Ideal.span (Set.range relation) = toGenerators.ker}
{toGenerators_1 : Algebra.Generators... | null | true |
selfAdjoint.unitarySelfAddISMul._proof_5 | Mathlib.Analysis.CStarAlgebra.Unitary.Span | ∀ {A : Type u_1} [inst : CStarAlgebra A], SMulCommClass ℝ A A | null | false |
Lean.Expr.isHEq | Lean.Util.Recognizers | Lean.Expr → Bool | null | true |
Filter.IsBoundedUnder.bddAbove_range_of_cofinite | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [IsDirectedOrder β] {f : α → β},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) Filter.cofinite f → BddAbove (Set.range f) | null | true |
String.head_toList | Init.Data.String.Basic | ∀ {b : String} {h : b.toList ≠ []}, b.toList.head h = b.toByteArray.utf8DecodeChar 0 ⋯ | null | true |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset.match_4 | Lean.Meta.Sym.Offset | (motive : Lean.Expr → Sort u_1) →
(n : Lean.Expr) → ((n : ℕ) → motive (Lean.Expr.lit (Lean.Literal.natVal n))) → ((x : Lean.Expr) → motive x) → motive n | null | false |
lt_map_inv_iff | Mathlib.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : EquivLike F α β]
[OrderIsoClass F α β] (f : F) {a : α} {b : β}, a < EquivLike.inv f b ↔ f a < b | null | true |
Lean.Elab.Tactic.filterSuggestionsAndLocalsFromGrindConfig | Lean.Elab.Tactic.Grind.Main | Lean.TSyntax `Lean.Parser.Tactic.optConfig → Lean.TSyntax `Lean.Parser.Tactic.optConfig | Filter out `+suggestions` and `+locals` from the config syntax | true |
_private.Init.Data.String.Basic.0.String.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String}, (s = "") = (s.utf8ByteSize = 0) | null | false |
OrderDual.isOrderedAddCancelMonoid | Mathlib.Algebra.Order.Monoid.OrderDual | ∀ {α : Type u} [inst : AddCommMonoid α] [inst_1 : Preorder α] [IsOrderedCancelAddMonoid α], IsOrderedCancelAddMonoid αᵒᵈ | null | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyzeAppStagedCore.match_8 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | (motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State → Sort u_1) →
(x : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State) →
((bottomUps higherOrders funBinders provideds : Array Bool) →
(namedArgs : Array Lean.Name) →
motive
{ bottomUps := bottomUps, higherOrders ... | null | false |
SimpleGraph.neighborFinset_eq_filter | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] {v : V} [inst_1 : DecidableRel G.Adj],
G.neighborFinset v = {w | G.Adj v w} | null | true |
Std.Rio.pairwise_toList_ne | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α], List... | null | true |
IsModuleTopology.topologicalAddGroup | Mathlib.Topology.Algebra.Module.ModuleTopology | ∀ (R : Type u_1) [τR : TopologicalSpace R] [inst : Semiring R] (C : Type u_6) [inst_1 : AddCommGroup C]
[inst_2 : Module R C] [inst_3 : TopologicalSpace C] [IsModuleTopology R C], IsTopologicalAddGroup C | **Alias** of `IsModuleTopology.isTopologicalAddGroup`. | true |
AList.insertRec._proof_3 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2} (c : Sigma β) (l : List (Sigma β)) (h : (c :: l).NodupKeys),
c.fst ∉ { entries := l, nodupKeys := ⋯ }.entries.keys | null | false |
_private.Std.Http.Internal.IndexMultiMap.0.Std.Internal.IndexMultiMap.insert._proof_4 | Std.Http.Internal.IndexMultiMap | ∀ {α : Type u_1} {β : Type u_2} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α]
(map : Std.Internal.IndexMultiMap α β) (key w : α),
(w ∈
map.indexes.alter key fun x =>
match x with
| some idxs => some (idxs.push map.entries.size)
| none => some { ... | null | false |
AddAction.IsQuasiPreprimitive.casesOn | Mathlib.GroupTheory.GroupAction.Primitive | {G : Type u_1} →
{X : Type u_2} →
[inst : AddGroup G] →
[inst_1 : AddAction G X] →
{motive : AddAction.IsQuasiPreprimitive G X → Sort u} →
(t : AddAction.IsQuasiPreprimitive G X) →
([toIsPretransitive : AddAction.IsPretransitive G X] →
(isPretransitive_of_normal... | null | false |
Finset.sum_induction_nonempty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {s : Finset ι} {M : Type u_7} [inst : AddCommMonoid M] (f : ι → M) (p : M → Prop),
(∀ (a b : M), p a → p b → p (a + b)) → s.Nonempty → (∀ x ∈ s, p (f x)) → p (∑ x ∈ s, f x) | To prove a property of a sum, it suffices to prove that
the property is additive and holds on summands. | true |
ZFSet.powerset.match_5 | Mathlib.SetTheory.ZFC.Basic | ∀ («Type» : Type u_1) (A : «Type» → PSet.{u_1}) (Type_1 : Type u_1) (B : Type_1 → PSet.{u_1})
(q : Set { «Type» := Type_1, Func := B }.Type) (motive : ↑{a | ∃ b ∈ q, (A a).Equiv (B b)} → Prop)
(x : ↑{a | ∃ b ∈ q, (A a).Equiv (B b)}),
(∀ (val : { «Type» := «Type», Func := A }.Type) (b : { «Type» := Type_1, Func :=... | null | false |
Lean.Parser.ParserAttributeHook.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
(t : Lean.Parser.ParserAttributeHook) →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) → motive t | null | false |
Lean.Elab.CompletionInfo.dotId.sizeOf_spec | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (id : Lean.Name) (lctx : Lean.LocalContext) (expectedType? : Option Lean.Expr),
sizeOf (Lean.Elab.CompletionInfo.dotId stx id lctx expectedType?) =
1 + sizeOf stx + sizeOf id + sizeOf lctx + sizeOf expectedType? | null | true |
Lean.PrettyPrinter.Formatter.charLitNoAntiquot.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | null | true |
TopologicalSpace.rec | Mathlib.Topology.Defs.Basic | {X : Type u} →
{motive : TopologicalSpace X → Sort u_1} →
((IsOpen : Set X → Prop) →
(isOpen_univ : IsOpen Set.univ) →
(isOpen_inter : ∀ (s t : Set X), IsOpen s → IsOpen t → IsOpen (s ∩ t)) →
(isOpen_sUnion : ∀ (s : Set (Set X)), (∀ t ∈ s, IsOpen t) → IsOpen (⋃₀ s)) →
m... | null | false |
_private.Std.Sync.Semaphore.0.Std.SemaphoreState.ctorIdx | Std.Sync.Semaphore | Std.SemaphoreState✝ → ℕ | null | false |
NumberField.InfinitePlace.Completion.bijective_extensionEmbeddingOfIsReal | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] {v : NumberField.InfinitePlace K} (hv : v.IsReal),
Function.Bijective ⇑(NumberField.InfinitePlace.Completion.extensionEmbeddingOfIsReal hv) | If `v` is a real infinite place, then the embedding `v.Completion →+* ℝ` is bijective. | true |
Lean.Compiler.LCNF.LCtx.eraseLetDecl | Lean.Compiler.LCNF.LCtx | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LCtx → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.LCtx | null | true |
Metric.IsCover.subset_iUnion_closedBall | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {ε : NNReal} {s N : Set X},
Metric.IsCover ε s N → s ⊆ ⋃ y ∈ N, Metric.closedBall y ↑ε | **Alias** of the forward direction of `Metric.isCover_iff_subset_iUnion_closedBall`. | true |
FP.RMode.recOn | Mathlib.Data.FP.Basic | {motive : FP.RMode → Sort u} → (t : FP.RMode) → motive FP.RMode.NE → motive t | null | false |
Lean.Elab.Command.MacroExpandedSnapshot.isFatal._inherited_default | Lean.Elab.Command | Bool | null | false |
Lean.Elab.Term.Do.ToCodeBlock.expandNestedAction | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Elab.Term.Do.ToCodeBlock.M (List Lean.Syntax × Lean.Syntax) | null | true |
_private.Mathlib.NumberTheory.Bernoulli.0.bernoulli'_eq_bernoulli._simp_1_4 | Mathlib.NumberTheory.Bernoulli | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | null | false |
BoxIntegral.integral_sub | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {f g : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
BoxI... | null | true |
_private.Mathlib.Data.List.Duplicate.0.List._aux_Mathlib_Data_List_Duplicate___unexpand_List_Duplicate_1 | Mathlib.Data.List.Duplicate | Lean.PrettyPrinter.Unexpander | null | false |
ContinuousLinearMap.flip_zero | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E' : Type u_6} {F' : Type u_10} {G' : Type u_14}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : NontriviallyNormedField 𝕜₃]
{σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃} [inst_3 : AddCommGroup E'] [inst_4 : Module 𝕜 E'] [inst_5 : ... | null | true |
LinearMap.instDistribMulAction._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_2} {S : Type u_5} {M : Type u_3} {M₂ : Type u_4} [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₂} [inst_6 : Monoid S] [inst_7 : DistribMulAction S M₂]
[inst_8 : SMulCommCla... | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.instHasBiproductSigmaFstSndOfBiproduct.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {ι : Type u_1} (f : ι → Type u_2) (motive : (i : ι) × f i → Prop) (x : (i : ι) × f i),
(∀ (j' : ι) (y : f j'), motive ⟨j', y⟩) → motive x | null | false |
CategoryTheory.Subgroupoid.mem_top_objs | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (c : C), c ∈ ⊤.objs | null | true |
MeasurableMul | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → [MeasurableSpace M] → [Mul M] → Prop | We say that a type has `MeasurableMul` if `(c * ·)` and `(· * c)` are measurable functions.
For a typeclass assuming measurability of `uncurry (*)` see `MeasurableMul₂`. | true |
LinearMap.ext_on | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring R₂] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{s : Set M} {f g : M →ₛₗ[σ₁₂] M₂}, Submodule.span R s = ⊤ → Set.EqOn (⇑f) (⇑g) s → f = g | If `s` generates the whole module and linear maps `f`, `g` are equal on `s`, then they are
equal. | true |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.swap_eq_refl_iff._proof_1_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α → (Equiv.refl α) x = (Equiv.refl α) y | null | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.memLp_stoppedValue._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
Aesop.RappData.successProbability | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Aesop.Percent | null | true |
Holor.instAddMonoid | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddMonoid α] → AddMonoid (Holor α ds) | null | true |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.MeasureTheory.eLpNorm_le_eLpNorm_fderiv_of_eq_inner._simp_1_14 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | null | false |
FDerivMeasurableAux.B | Mathlib.Analysis.Calculus.FDeriv.Measurable | {𝕜 : 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] → (E → F) → Set (E →L[𝕜] F) → ℝ → ℝ → ℝ → Set E | The set `B f K r s ε` is the set of points `x` around which there exists a continuous linear map
`L` belonging to `K` (a given set of continuous linear maps) that approximates well the
function `f` (up to an error `ε`), simultaneously at scales `r` and `s`. | true |
OmegaCompletePartialOrder.Chain.map_comp | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(c : OmegaCompletePartialOrder.Chain α) {f : α →o β} (g : β →o γ), (c.map f).map g = c.map (g.comp f) | null | true |
Std.DTreeMap.Raw.minKey!_alter_eq_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] [inst_1 : Inhabited α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(t.alter k f).isEmpty = false →
((t.alter k f).minKey! = k ↔ (f (t.get? k)).isSome = t... | null | true |
one_lt_iff_ne_one | Mathlib.Algebra.Order.IsBotOne | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : One α] [IsBotOneClass α], 1 < a ↔ a ≠ 1 | null | true |
CauSeq.le_total | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs),
f ≤ g ∨ g ≤ f | null | true |
MeasureTheory.tendstoInMeasure_of_tendsto_eLpNorm_top | Mathlib.MeasureTheory.Function.ConvergenceInMeasure | ∀ {α : Type u_1} {ι : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_5}
[inst : SeminormedAddCommGroup E] {f : ι → α → E} {g : α → E} {l : Filter ι},
Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - g) ⊤ μ) l (nhds 0) → MeasureTheory.TendstoInMeasure μ f l g | See also `MeasureTheory.tendstoInMeasure_of_tendsto_eLpNorm` which work for general
Lp-convergence for all `p ≠ 0`. | true |
Nat.RecursiveIn.below.pair | Mathlib.Computability.RecursiveIn | ∀ {O : Set (ℕ →. ℕ)} {motive : (a : ℕ →. ℕ) → Nat.RecursiveIn O a → Prop} {f h : ℕ →. ℕ} (hf : Nat.RecursiveIn O f)
(hh : Nat.RecursiveIn O h),
Nat.RecursiveIn.below hf → motive f hf → Nat.RecursiveIn.below hh → motive h hh → Nat.RecursiveIn.below ⋯ | null | true |
CStarMatrix.instAddMonoid._proof_7 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : AddMonoid A] (a : CStarMatrix m n A), 0 + a = a | null | false |
Lean.mkCIdentFromRef | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → Lean.Name → optParam Bool false → m Lean.Syntax | Creates an identifier referring to a constant `c`. The identifier's position is copied from the
syntax returned by `getRef`.
This variant of `mkIdentFrom` makes sure that the identifier cannot accidentally be captured.
| true |
MeasureTheory.Measure.completion._proof_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_1} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α), μ.trim ≤ μ.toOuterMeasure | null | false |
HomotopicalAlgebra.PathObject.recOn | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
{A : C} →
{motive : HomotopicalAlgebra.PathObject A → Sort u_1} →
(t : HomotopicalAlgebra.PathObject A) →
((toPrepathObject : HomotopicalAlgebra.PrepathObje... | null | false |
Subsemiring.center.smulCommClass_right | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R' : Type u_1} [inst : Semiring R'], SMulCommClass R' (↥(Subsemiring.center R')) R' | The center of a semiring acts commutatively on that semiring. | true |
IsCompact.exists_bound_of_continuousOn' | Mathlib.Analysis.Normed.Group.Bounded | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedGroup E] [inst_1 : TopologicalSpace α] {s : Set α},
IsCompact s → ∀ {f : α → E}, ContinuousOn f s → ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C | null | true |
NonemptyInterval.instPartialOrderLex | Mathlib.Order.Interval.Lex | {α : Type u_1} → [inst : PartialOrder α] → PartialOrder (Lex (NonemptyInterval α)) | null | true |
CategoryTheory.Quotient.comp_natTransLift | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C) {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F G H : CategoryTheory.Functor (CategoryTheory.Quotient r) D}
(τ : (CategoryTheory.Quotient.functor r).comp F ⟶ (CategoryTheory.Quotient.functor r).comp G)
(τ' : (CategoryT... | null | true |
Algebra.Extension.h1Cotangentι_apply | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(self : ↥P.cotangentComplex.ker), Algebra.Extension.h1Cotangentι self = ↑self | null | true |
_private.Mathlib.Data.Finset.Pi.0.Finset.pi_nonempty._simp_1_1 | Mathlib.Data.Finset.Pi | ∀ {α : Sort u} {b : α → Sort v} {p : (x : α) → b x → Prop}, (∀ (x : α), ∃ y, p x y) = ∃ f, ∀ (x : α), p x (f x) | null | false |
RCLike.ofReal_re_ax | Mathlib.Analysis.RCLike.Basic | ∀ {K : semiOutParam (Type u_1)} [self : RCLike K] (r : ℝ), RCLike.re ((algebraMap ℝ K) r) = r | null | true |
SSet.Subcomplex.image_comp | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (A : X.Subcomplex) (f : X ⟶ Y) {Z : SSet} (g : Y ⟶ Z),
A.image (CategoryTheory.CategoryStruct.comp f g) = (A.image f).image g | null | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.idCompletionCore._sparseCasesOn_1 | Lean.Server.Completion.CompletionCollectors | {motive : Lean.SourceInfo → Sort u} →
(t : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) →... | null | false |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_61 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α) (head : α) (tail : List α), head :: tail = xs → ¬xs ++ [x].dropLast = [] | null | false |
_private.Std.Async.System.0.Std.Async.System.instDecidableEqCPUTimes.decEq._proof_3 | Std.Async.System | ∀ (a a_1 a_2 a_3 a_4 b b_1 : Std.Time.Millisecond.Offset),
¬a_3 = b →
{ userTime := a, niceTime := a_1, systemTime := a_2, idleTime := a_3, interruptTime := a_4 } =
{ userTime := a, niceTime := a_1, systemTime := a_2, idleTime := b, interruptTime := b_1 } →
False | null | false |
Mathlib.Tactic.RingNF.instBEqConfig.beq | Mathlib.Tactic.Ring.RingNF | Mathlib.Tactic.RingNF.Config → Mathlib.Tactic.RingNF.Config → Bool | null | true |
MulSemiringActionHom.map_one' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_10} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_12} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S]
(self : R →ₑ+*[φ] S), self.toFun 1 = 1 | The proposition that the function preserves 1 | true |
HasCompactSupport.convolutionExists_left_of_continuous_right | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_252 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
WeakDual.CharacterSpace.equivAlgHom_symm_coe | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : CompleteSpace A]
[inst_3 : NormedAlgebra 𝕜 A] (f : A →ₐ[𝕜] 𝕜), ⇑(WeakDual.CharacterSpace.equivAlgHom.symm f) = ⇑f | null | true |
Simps.ProjectionRule.erase.injEq | Mathlib.Tactic.Simps.Basic | ∀ (a : Lean.Name) (a_1 : Lean.Syntax) (a_2 : Lean.Name) (a_3 : Lean.Syntax),
(Simps.ProjectionRule.erase a a_1 = Simps.ProjectionRule.erase a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls.loop._unary | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.PreElabHeaderResult →
(Array Lean.Expr → Array Lean.Expr → Lean.Elab.TermElabM α) →
Array Lean.Expr → (_ : ℕ) ×' Array Lean.Expr → Lean.Elab.TermElabM α | null | false |
mem_residual_iff | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
s ∈ residual X ↔ ∃ S, (∀ t ∈ S, IsOpen t) ∧ (∀ t ∈ S, Dense t) ∧ S.Countable ∧ ⋂₀ S ⊆ s | A set is residual iff it includes a countable intersection of dense open sets. | true |
Submonoid.map_coe_toMonoidHom | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {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 : Submonoid M), Submonoid.map (↑f) S = Submonoid.map f S | null | true |
CategoryTheory.Equivalence.functor_map_ε_inverse_comp_counit_app | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal],
CategoryTheory.C... | null | true |
lowerSemicontinuous_biSup | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Sort u_4} {δ : Type u_5} [inst_1 : CompleteLinearOrder δ]
{p : ι → Prop} {f : (i : ι) → p i → α → δ},
(∀ (i : ι) (hi : p i), LowerSemicontinuous (f i hi)) → LowerSemicontinuous fun x' => ⨆ i, ⨆ (hi : p i), f i hi x' | null | true |
_private.Mathlib.Order.SuccPred.WithBot.0.WithBot.succ_eq_succ.match_1_1 | Mathlib.Order.SuccPred.WithBot | ∀ {α : Type u_1} (motive : WithBot α → Prop) (x : WithBot α),
(∀ (_ : Unit), motive none) → (∀ (a : α), motive (some a)) → motive x | null | false |
Metric.Snowflaking.dist_ofSnowflaking_ofSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoMetricSpace X]
(x y : Metric.Snowflaking X α hα₀ hα₁),
dist (Metric.Snowflaking.ofSnowflaking x) (Metric.Snowflaking.ofSnowflaking y) = dist x y ^ α⁻¹ | null | true |
SimpleGraph.Partition.partOfVertex._proof_1 | Mathlib.Combinatorics.SimpleGraph.Partition | ∀ {V : Type u_1} {G : SimpleGraph V} (P : G.Partition) (v : V), ∃! b, b ∈ P.parts ∧ v ∈ b | null | false |
_private.Mathlib.Data.Sigma.Basic.0.Sigma.eq.match_1_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_2}
(motive : (x x_1 : (a : α) × β a) → (x_2 : x.fst = x_1.fst) → Eq.recOn x_2 x.snd = x_1.snd → Prop)
(x x_1 : (a : α) × β a) (x_2 : x.fst = x_1.fst) (x_3 : Eq.recOn x_2 x.snd = x_1.snd),
(∀ (fst : α) (snd : β fst), motive ⟨fst, snd⟩ ⟨fst, snd⟩ ⋯ ⋯) → motive x x_1 x_2 x_3 | null | false |
Lean.instBEqDeclaration.beq | Lean.Declaration | Lean.Declaration → Lean.Declaration → Bool | null | true |
Mathlib.Tactic.Echelon.mkPerm | Mathlib.Tactic.Echelon.Cert | (m : ℕ) → Array (ℕ × ℕ) → Lean.MetaM Q(Equiv.Perm (Fin «$m»)) | Build the permutation `σ = swap a₀ b₀ * swap a₁ b₁ * ⋯` from the recorded swaps. | true |
HasDerivAt.const_mul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {d : 𝕜 → 𝔸} {d' : 𝔸} (c : 𝔸),
HasDerivAt d d' x → HasDerivAt (fun y => c * d y) (c * d') x | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.recOn | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | {X : AlgebraicGeometry.Scheme} →
{motive : X.IdealSheafData → Sort u_1} →
(t : X.IdealSheafData) →
((ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))) →
(map_ideal_basicOpen :
∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Idea... | null | false |
CategoryTheory.projective_iff_llp_epimorphisms_of_isZero | Mathlib.CategoryTheory.Preadditive.Projective.LiftingProperties | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] {P Z : C}
(i : Z ⟶ P),
CategoryTheory.Limits.IsZero Z →
(CategoryTheory.Projective P ↔ (CategoryTheory.MorphismProperty.epimorphisms C).llp i) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.