name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousMap.instNonAssocRingOfIsTopologicalRing._proof_2 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonAssocRing β]
[inst_3 : IsTopologicalRing β] (a : C(α, β)), a * 1 = a | null | false |
AffineMap.lineMap_mem_affineSpan_pair | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (r : k) (p₁ p₂ : P), (AffineMap.lineMap p₁ p₂) r ∈ line[k, p₁, p₂] | A combination of two points expressed with `lineMap` lies in their affine span. | true |
OptionT.run_lift | Init.Control.Lawful.Instances | ∀ {m : Type u → Type v} {α : Type u} [inst : Monad m] (x : m α),
(OptionT.lift x).run = do
let __do_lift ← x
pure (some __do_lift) | null | true |
Set.iUnionLift._proof_1 | Mathlib.Data.Set.UnionLift | ∀ {α : Type u_2} {ι : Sort u_1} (S : ι → Set α), ∀ T ⊆ Set.iUnion S, ∀ (x : ↑T), ∃ i, ↑x ∈ S i | null | false |
CategoryTheory.FunctorToTypes.prod.fst_app | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} (x : C),
CategoryTheory.FunctorToTypes.prod.fst.app x = TypeCat.ofHom fun a => a.1 | null | true |
ISize.toBitVec64_toInt64 | Init.Data.SInt.IntToBitVec | ∀ (n : ISize) (h : System.Platform.numBits = 64), n.toInt64.toBitVec = BitVec.signExtend 64 (n.toBitVec64 h) | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0.WeierstrassCurve.Jacobian.addU_smul._simp_1_10 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.foldl_eq_foldl_toList._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
HasStrictFDerivAt.restrictScalars | Mathlib.Analysis.Calculus.FDeriv.RestrictScalars | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCo... | null | true |
List.pmap._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {P : α → Prop} (a : α) (l : List α), (∀ a_1 ∈ a :: l, P a_1) → P a | null | false |
ContinuousLinearMap.IsIdempotentElem.commute_iff | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Idempotent | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {f T : M →L[R] M},
IsIdempotentElem f → (Commute f T ↔ (↑f).range ∈ Module.End.invtSubmodule ↑T ∧ (↑f).ker ∈ Module.End.invtSubmodule ↑T) | An idempotent operator `f` commutes with `T` if and only if
both `range f` and `ker f` are invariant under `T`. | true |
BinaryTree | Mathlib.Data.Tree.Basic | Type u → Type u | A binary tree with values stored in non-leaf nodes. | true |
Nat.pred_le_of_le_succ | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n ≤ m.succ → n.pred ≤ m | null | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(α : Mathlib.Tactic.BicategoryLike.Structural) → motive (Mathlib.Tactic.BicategoryLike.NormalExpr.nil e α)) →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(α : Mathlib.Tactic.BicategoryLike.Stru... | null | false |
WeierstrassCurve.Affine.Point.xRep_add_self_of_Y_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] {x y : F}
(h : W.Nonsingular x y),
y = W.negY x y → (WeierstrassCurve.Affine.Point.some x y h + WeierstrassCurve.Affine.Point.some x y h).xRep = ![1, 0] | We give an explicit expression for `xRep` of `P + P` when `P ≠ 0` and `2*P = 0`. | true |
_private.Lean.Meta.Basic.0.Lean.Meta.orelseMergeErrorsImp | Lean.Meta.Basic | {α : Type} →
Lean.MetaM α →
Lean.MetaM α →
(optParam (Lean.Syntax → Lean.Syntax → Lean.Syntax) fun r₁ x => r₁) →
(optParam (Lean.MessageData → Lean.MessageData → Lean.MessageData) fun m₁ m₂ =>
m₁ ++ Lean.MessageData.ofFormat Std.Format.line ++ m₂) →
Lean.MetaM α | null | true |
ODE.FunSpace.dist_iterate_next_le | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E → E} {tmin tmax : ℝ}
{t₀ : ↑(Set.Icc tmin tmax)} {x₀ x : E} {a r L K : NNReal} (hf : IsPicardLindelof f t₀ x₀ a r L K)
(hx : x ∈ Metric.closedBall x₀ ↑r) (α : ODE.FunSpace t₀ x₀ r L) (n : ℕ),
dist α ((ODE.FunSpace.next hf hx)^[n]... | null | true |
List.pmap_reverse._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α}, ∀ a ∈ xs, a ∈ xs.reverse | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁._auto_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | Lean.Syntax | null | false |
Module.Basis.dualBasis_repr | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (l : Module.Dual R M) (i : ι),
(b.dualBasis.repr l) i = l (b i) | null | true |
CategoryTheory.Subgroupoid.mem_iff | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (F : (c : C) × (d : C) × (c ⟶ d)),
F ∈ S ↔ F.snd.snd ∈ S.arrows F.fst F.snd.fst | null | true |
AlgebraicGeometry.Scheme.GlueData.oneHypercover_p₁ | Mathlib.AlgebraicGeometry.GluingOneHypercover | ∀ (D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x : PUnit.{u + 1}), D.oneHypercover.p₁ x = D.f i₁ i₂ | null | true |
Mathlib.Meta.FunProp.withIncreasedTransitionDepth | Mathlib.Tactic.FunProp.Types | {α : Type} → Mathlib.Meta.FunProp.FunPropM (Option α) → Mathlib.Meta.FunProp.FunPropM (Option α) | Increase transition depth. Return `none` if maximum transition depth has been reached. | true |
AddCon.instPartialOrder._proof_3 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (x x_1 x_2 : AddCon M), x ≤ x_1 → x_1 ≤ x_2 → ∀ (x_3 x_4 : M), x x_3 x_4 → x_2 x_3 x_4 | null | false |
Lean.Compiler.LCNF.CtorFieldInfo | Lean.Compiler.LCNF.ToImpureType | Type | null | true |
Nat.add_right_inj | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, n + m = n + k ↔ m = k | null | true |
CategoryTheory.ComonadHom.recOn | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{M N : CategoryTheory.Comonad C} →
{motive : CategoryTheory.ComonadHom M N → Sort u} →
(t : CategoryTheory.ComonadHom M N) →
((toNatTrans : CategoryTheory.NatTrans M.toFunctor N.toFunctor) →
(app_ε : ∀ (X : C), Cat... | null | false |
Filter.eventually_bind | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → Filter β} {p : β → Prop},
(∀ᶠ (y : β) in f.bind m, p y) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y | null | true |
CategoryTheory.Pretriangulated.binaryProductTriangleIsoBinaryBiproductTriangle._proof_4 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X₁ X₂ : C)
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasBinaryBiproduct X₁ X₂],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.binaryProductTriangle X₁... | null | false |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.add._simp_1_9 | Mathlib.Probability.Moments.SubGaussian | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
List.takeWhile_append | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {xs ys : List α},
List.takeWhile p (xs ++ ys) =
if (List.takeWhile p xs).length = xs.length then xs ++ List.takeWhile p ys else List.takeWhile p xs | null | true |
Matrix.Nondegenerate.recOn | Mathlib.LinearAlgebra.Matrix.Nondegenerate | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : Finite m] →
[inst_2 : Finite n] →
{M : Matrix m n R} →
{motive : M.Nondegenerate → Sort u} →
(t : M.Nondegenerate) →
((separatingL... | null | false |
LinearRecurrence.mk.inj | Mathlib.Algebra.LinearRecurrence | ∀ {R : Type u_1} {inst : CommSemiring R} {order : ℕ} {coeffs : Fin order → R} {order_1 : ℕ}
{coeffs_1 : Fin order_1 → R},
{ order := order, coeffs := coeffs } = { order := order_1, coeffs := coeffs_1 } → order = order_1 ∧ coeffs ≍ coeffs_1 | null | true |
Lean.Meta.SimpAll.State.mk.inj | Lean.Meta.Tactic.Simp.SimpAll | ∀ {modified : Bool} {mvarId : Lean.MVarId} {entries : Array Lean.Meta.SimpAll.Entry} {ctx : Lean.Meta.Simp.Context}
{simprocs : Lean.Meta.Simp.SimprocsArray} {usedTheorems : Lean.Meta.Simp.UsedSimps}
{diag : Lean.Meta.Simp.Diagnostics} {modified_1 : Bool} {mvarId_1 : Lean.MVarId}
{entries_1 : Array Lean.Meta.Simp... | null | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.mk_dvdNotUnit_mk_iff._simp_1_2 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : MonoidWithZero M] {a : M}, (Associates.mk a ≠ 0) = (a ≠ 0) | null | false |
Lean.Compiler.LCNF.LCtx.funDeclsPure._default | Lean.Compiler.LCNF.LCtx | Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) | null | false |
Std.DTreeMap.mk._flat_ctor | Std.Data.DTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : autoParam (α → α → Ordering) Std.DTreeMap._auto_1} →
(inner : Std.DTreeMap.Internal.Impl α β) → inner.WF → Std.DTreeMap α β cmp | null | false |
Composition.recOnSingleAppend.match_1 | Mathlib.Combinatorics.Enumerative.Composition | (motive : (blocks : List ℕ) → (∀ {i : ℕ}, i ∈ blocks → 0 < i) → Sort u_1) →
(blocks : List ℕ) →
(blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i) →
((blocks_pos : ∀ {i : ℕ}, i ∈ [] → 0 < i) → motive [] blocks_pos) →
((tail : List ℕ) → (blocks_pos : ∀ {i : ℕ}, i ∈ 0 :: tail → 0 < i) → motive (0 :: tail) b... | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabRoo._regBuiltin.Lean.PrettyPrinter.Delaborator.delabRoo_1 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | null | false |
Std.TreeMap.Raw.getD_alter_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {fallback : β} {f : Option β → Option β}, (t.alter k f).getD k fallback = (f t[k]?).getD fallback | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.le_bmod._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (¬a < b) = (b ≤ a) | null | false |
CategoryTheory.MorphismProperty.Comma.rec | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B ... | null | false |
SSet.Subcomplex.toPairFunctor._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.SSetPair | ∀ (X : SSet) (X_1 : X.Subcomplex),
SSetPair.homMk (SSet.Subcomplex.homOfLE ⋯) (CategoryTheory.CategoryStruct.id X_1.pair.right) ⋯ =
CategoryTheory.CategoryStruct.id X_1.pair | null | false |
Lean.Lsp.ResolvableCompletionItem.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {label : String} {detail? : Option String} {documentation? : Option Lean.Lsp.MarkupContent}
{kind? : Option Lean.Lsp.CompletionItemKind} {textEdit? : Option Lean.Lsp.InsertReplaceEdit}
{sortText? : Option String} {data? : Option Lean.Lsp.ResolvableCompletionItemData}
{tags? : Option (Array Lean.Lsp.CompletionIt... | null | true |
Lean.Elab.Term.ElabElim.Context.noConfusion | Lean.Elab.App | {P : Sort u} →
{t t' : Lean.Elab.Term.ElabElim.Context} → t = t' → Lean.Elab.Term.ElabElim.Context.noConfusionType P t t' | null | false |
AddIrreducible.isAddUnit_or_isAddUnit | Mathlib.Algebra.Group.Irreducible.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {p : M}, AddIrreducible p → ∀ ⦃a b : M⦄, p = a + b → IsAddUnit a ∨ IsAddUnit b | If an irreducible element can be written as a sum, then one term is an additive unit. | true |
CategoryTheory.Equivalence.comp_asNatTrans_assoc | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{e f g : C ≌ D} (α : e ⟶ f) (β : f ⟶ g) {Z : CategoryTheory.Functor C D} (h : g.functor ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Equivalence.asNatTrans (CategoryTheory.CategoryStru... | null | true |
SeparationQuotient.uniformContinuous_lift | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β}
(h : ∀ (a b : α), Inseparable a b → f a = f b), UniformContinuous (SeparationQuotient.lift f h) ↔ UniformContinuous f | null | true |
IsNormalClosure.mk._flat_ctor | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_1} {K : Type u_2} {L : Type u_3} [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L],
(∀ (x : K), (Polynomial.map (algebraMap F L) (minpoly F x)).Splits) →
⨆ x, IntermediateField.adjoin F ((minpoly F x).rootSet L) = ⊤ → IsNormalClosure F K L | null | false |
_private.Mathlib.Order.Atoms.0.Set.isSimpleOrder_Ici_iff_isCoatom.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α} (motive : (x : ↑(Set.Ici a)) → ⊥ < x → Prop)
(x : ↑(Set.Ici a)) (hbotb : ⊥ < x),
(∀ (b : α) (property : b ∈ Set.Ici a) (hbotb : ⊥ < ⟨b, property⟩), motive ⟨b, property⟩ hbotb) → motive x hbotb | null | false |
LocallyConstant.instOne | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [One Y] → One (LocallyConstant X Y) | null | true |
CategoryTheory.Lax.OplaxTrans.Modification.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} [inst_2 : SizeOf B] [inst_3 : SizeOf C]
(app : (a : B) → η.app a ⟶ θ.app a)
(naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheo... | null | true |
Lean.Lsp.LeanDidOpenTextDocumentParams.recOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanDidOpenTextDocumentParams → Sort u} →
(t : Lean.Lsp.LeanDidOpenTextDocumentParams) →
((toDidOpenTextDocumentParams : Lean.Lsp.DidOpenTextDocumentParams) →
(dependencyBuildMode? : Option Lean.Lsp.DependencyBuildMode) →
motive
{ toDidOpenTextDocumentParams := toD... | null | false |
Set.PairwiseDisjoint.image_finset_of_le | Mathlib.Data.Finset.Pairwise | ∀ {α : Type u_1} {ι : Type u_2} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : DecidableEq ι] {s : Finset ι}
{f : ι → α},
(↑s).PairwiseDisjoint f → ∀ {g : ι → ι}, (∀ (a : ι), f (g a) ≤ f a) → (↑(Finset.image g s)).PairwiseDisjoint f | null | true |
Std.Stream.drop._sunfold | Batteries.Data.Stream | {σ : Type u_1} → {α : Type u_2} → [Std.Stream σ α] → σ → ℕ → σ | null | false |
ProbabilityTheory.hasSubgaussianMGF_of_mem_Icc | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ}
[MeasureTheory.IsProbabilityMeasure μ] {a b : ℝ},
AEMeasurable X μ →
(∀ᵐ (ω : Ω) ∂μ, X ω ∈ Set.Icc a b) →
ProbabilityTheory.HasSubgaussianMGF (fun ω => X ω - ∫ (x : Ω), X x ∂μ) ((‖b - a‖₊ / 2) ^ 2) μ | A corollary of Hoeffding's lemma for bounded random variables. | true |
Std.Tactic.BVDecide.BVBit.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVBit → Sort u} →
(t : Std.Tactic.BVDecide.BVBit) →
((var : ℕ) → {w : ℕ} → (idx : Fin w) → motive { var := var, w := w, idx := idx }) → motive t | null | false |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln_sound._simp_1_22 | Mathlib.Computability.PartrecCode | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → Option α},
(x.bind f = some b) = ∃ a, x = some a ∧ f a = some b | null | false |
nnnorm_map' | Mathlib.Analysis.Normed.Group.Uniform | ∀ {𝓕 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F]
[inst_2 : FunLike 𝓕 E F] [IsometryClass 𝓕 E F] [OneHomClass 𝓕 E F] (f : 𝓕) (x : E), ‖f x‖₊ = ‖x‖₊ | null | true |
CategoryTheory.MorphismProperty.IsLocalAtTarget.of_zeroHypercover | Mathlib.CategoryTheory.MorphismProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
{K : CategoryTheory.Precoverage C} [P.IsLocalAtTarget K] {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover Y)
[inst_2 : K.HasPullbacks], (∀ (i : 𝒰.I₀), P (CategoryTheory.Limits.pullback.snd f (𝒰.f i))) → P f | null | true |
List.foldl_map_hom | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {g : α → β} {f : α → α → α} {f' : β → β → β} {a : α} {l : List α},
(∀ (x y : α), f' (g x) (g y) = g (f x y)) → List.foldl f' (g a) (List.map g l) = g (List.foldl f a l) | null | true |
Lean.Meta.Grind.SplitCandidateWithAnchor.casesOn | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitCandidateWithAnchor → Sort u} →
(t : Lean.Meta.Grind.SplitCandidateWithAnchor) →
((c : Lean.Meta.Grind.SplitInfo) →
(numCases : ℕ) →
(isRec : Bool) →
(e : Lean.Expr) →
(anchor : UInt64) → motive { c := c, numCases := numCases, isRec := isR... | null | false |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_2 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (pq : ℕ × ℕ), 2 ≤ r → WithBotTop.coe (-↑pq.2 - r + 2) ≤ WithBotTop.coe (-↑pq.2) | null | false |
Vector.foldlM_append | Init.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {n k : ℕ} [inst : Monad m] [LawfulMonad m] {f : β → α → m β}
{b : β} {xs : Vector α n} {ys : Vector α k},
Vector.foldlM f b (xs ++ ys) = do
let b ← Vector.foldlM f b xs
Vector.foldlM f b ys | null | true |
SchwartzMap.injective_toLp | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] [inst_4 : MeasurableSpace E] [inst_5 : OpensMeasurableSpace E]
[inst_6 : SecondCountableTopologyEither E F] (p : ENNReal)
(μ : autoParam (MeasureTheory.Measure E) Sch... | null | true |
Batteries.PairingHeapImp.Heap.noSibling_combine | Batteries.Data.PairingHeap | ∀ {α : Type u_1} (le : α → α → Bool) (s : Batteries.PairingHeapImp.Heap α),
(Batteries.PairingHeapImp.Heap.combine le s).NoSibling | null | true |
ContinuousAffineMap.snd_decompContinuousLinearEquiv | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ (R : Type u_1) (V : Type u_2) (W : Type u_3) [inst : NormedField R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
[inst_7 : IsTopologicalAddGroup V] [inst_8 : ContinuousSMul R V] [inst_9 : IsTopologicalAd... | null | true |
UniformSpace.Core.comp_mem_uniformity_sets | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {c : UniformSpace.Core α} {s : SetRel α α}, s ∈ c.uniformity → ∃ t ∈ c.uniformity, SetRel.comp t t ⊆ s | null | true |
BitVec.isLt | Init.Data.BitVec.BasicAux | ∀ {w : ℕ} (x : BitVec w), x.toNat < 2 ^ w | Return the bound in terms of toNat. | true |
Mathlib.Tactic.DepRewrite.Context.p | Mathlib.Tactic.DepRewrite | Mathlib.Tactic.DepRewrite.Context → Lean.Expr | The pattern to generalize over. | true |
_private.Mathlib.Data.List.Sigma.0.List.dlookup_eq_none._simp_1_1 | Mathlib.Data.List.Sigma | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {l : List (Sigma β)},
(a ∈ l.keys) = ((List.dlookup a l).isSome = true) | null | false |
Ordinal.cof_omega0 | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | Ordinal.omega0.cof = Cardinal.aleph0 | null | true |
Qq.Impl.delabQuotedLevelDefEq | Qq.Delab | Lean.PrettyPrinter.Delaborator.Delab | null | true |
CategoryTheory.Over.tensorUnit_hom | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C},
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Over X)).hom = CategoryTheory.CategoryStruct.id X | null | true |
CategoryTheory.ObjectProperty.IsGaloisSubcategory.isClosedUnderLimitsOfShape_discrete_pEmpty | Mathlib.CategoryTheory.Galois.FullSubcategory | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.ObjectProperty C}
[self : P.IsGaloisSubcategory], P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) | If `C` has a terminal object,`P` is sat. | true |
SSet.PtSimplex.MulStruct.rec | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op { len := 0 })} →
{f g fg : X.PtSimplex n x} →
{i : Fin n} →
{motive : f.MulStruct g fg i → Sort u_1} →
((map : SSet.stdSimplex.obj { len := n + 1 } ⟶ X) →
(δ_castSucc_castSucc_map :
CategoryTheor... | null | false |
instFunLikeContRepresentationContinuousLinearMapId | Mathlib.RepresentationTheory.Continuous.Basic | (R : Type u_1) →
(G : Type u_2) →
(V : Type u_3) →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
[inst_5 : Module R V] → FunLike (ContRepresentation R G V) G... | null | true |
ENNReal.tsum_prod' | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {β : Type u_2} {f : α × β → ENNReal}, ∑' (p : α × β), f p = ∑' (a : α) (b : β), f (a, b) | null | true |
String.Slice.Pos.Splits.copy_sliceTo_eq | Init.Data.String.Lemmas.Splits | ∀ {t₁ t₂ : String} {s : String.Slice} {p : s.Pos}, p.Splits t₁ t₂ → (s.sliceTo p).copy = t₁ | null | true |
Lean.Compiler.LCNF.LetDecl.applyRenaming | Lean.Compiler.LCNF.Renaming | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetDecl pu →
Lean.Compiler.LCNF.Renaming → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.LetDecl pu) | null | true |
_private.Lean.Expr.0.Lean.Expr.isLit.match_1 | Lean.Expr | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((a : Lean.Literal) → motive (Lean.Expr.lit a)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
extChartAt_target_eventuallyEqSet' | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x y : M},
y ∈ (extChartAt I x).sourc... | Around the image of a point in the source, `(extChartAt I x).target` and `range I`
coincide locally. | true |
Lean.Server.RequestError.mk.injEq | Lean.Server.Requests | ∀ (code : Lean.JsonRpc.ErrorCode) (message : String) (code_1 : Lean.JsonRpc.ErrorCode) (message_1 : String),
({ code := code, message := message } = { code := code_1, message := message_1 }) =
(code = code_1 ∧ message = message_1) | null | true |
Besicovitch.BallPackage.noConfusion | Mathlib.MeasureTheory.Covering.Besicovitch | {P : Sort u} →
{β : Type u_1} →
{α : Type u_2} →
{t : Besicovitch.BallPackage β α} →
{β' : Type u_1} →
{α' : Type u_2} →
{t' : Besicovitch.BallPackage β' α'} →
β = β' → α = α' → t ≍ t' → Besicovitch.BallPackage.noConfusionType P t t' | null | false |
_private.Mathlib.AlgebraicGeometry.AffineScheme.0.AlgebraicGeometry.IsAffineOpen.self_le_iSup_basicOpen_iff._simp_1_1 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a | null | false |
AddOpposite.instCommGroup._proof_4 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CommGroup α] (x x_1 : αᵃᵒᵖ), AddOpposite.unop (x / x_1) = AddOpposite.unop (x / x_1) | null | false |
PositiveContinuousLinearMap.toContinuousLinearMap_nsmul | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] [inst_7 : TopologicalSpace E₁] [inst_8 : TopologicalSpace E₂] [inst_9 : IsOrderedAddMonoid ... | null | true |
_private.Init.Data.SInt.Bitwise.0.ISize.shiftLeft_xor._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : ISize}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
PointedCone.IsFaceOf.inf | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C₁ C₂ F₁ F₂ : PointedCone R M},
F₁.IsFaceOf C₁ → F₂.IsFaceOf C₂ → (F₁ ⊓ F₂).IsFaceOf (C₁ ⊓ C₂) | The intersection of two faces of two cones is a face of the intersection of the cones. | true |
Mathlib.Tactic.GCongr.instInhabitedGCongrKey.default | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrKey | null | true |
Finset.truncatedInf_sups | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : DecidableEq α] {s t : Finset α} {a : α} [inst_2 : DecidableLE α]
[inst_3 : BoundedOrder α],
a ∈ upperClosure ↑s → a ∈ upperClosure ↑t → (s ⊻ t).truncatedInf a = s.truncatedInf a ⊔ t.truncatedInf a | null | true |
TemperedDistribution.instLaplacian._proof_5 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : AddCommGroup F]
[inst_3 : Module ℂ F] [inst_4 : TopologicalSpace F] [inst_5 : IsTopologicalAddGroup F]
[inst_6 : ContinuousConstSMul ℂ F], ContinuousLineDeriv E (TemperedDistribution E F) (TemperedDistribution E... | null | false |
Real.cos_two_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (2 * Real.pi - x) = Real.cos x | null | true |
NNReal.rpow_intCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : NNReal) (n : ℤ), x ^ ↑n = x ^ n | null | true |
Lean.Level.isExplicit._sunfold | Lean.Level | Lean.Level → Bool | null | false |
ProbabilityTheory.condVar.eq_1 | Mathlib.Probability.CondVar | ∀ {Ω : Type u_1} {m₀ : MeasurableSpace Ω} (m : MeasurableSpace Ω) (X : Ω → ℝ) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.condVar m X μ = μ[(X - μ[X | m]) ^ 2 | m] | null | true |
Lean.Compiler.LCNF.LetValue._sizeOf_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetValue pu → ℕ | null | false |
Function.HasTemperateGrowth.isBigO_uniform | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {f : E → F},
Function.HasTemperateGrowth f → ∀ (N : ℕ), ∃ k, ∀ n ≤ N, iteratedFDeriv ℝ n f =O[⊤] fun x => (1 + ‖x‖) ^ k | If `f` has temperate growth, then for any `N : ℕ` one can find `k` such that *all* iterated
derivatives of `f` of order `≤ N` are `O((1 + ‖x‖) ^ k)`.
Note that the `O` here is with respect to the `⊤` filter, meaning that the bound holds everywhere.
| true |
_private.Std.Do.WP.Sound.0.Std.Do.instWPSoundExceptTExceptPureOfLawfulMonad.match_5.splitter | Std.Do.WP.Sound | {ε α : Type u_1} →
{P : α → Prop} →
(motive :
(r : Except ε α) →
(match r with
| Except.ok a => P a
| Except.error a => True) →
Sort u_2) →
(r : Except ε α) →
(h :
match r with
| Except.ok a => P a
| Except.err... | null | true |
Mathlib.Meta.FunProp.Result._sizeOf_inst | Mathlib.Tactic.FunProp.Types | SizeOf Mathlib.Meta.FunProp.Result | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.