name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.InlayHintParams | Lean.Data.Lsp.LanguageFeatures | Type | null | true |
_private.Lean.Server.AsyncList.0.IO.AsyncList.getFinishedPrefix.match_5 | Lean.Server.AsyncList | {ε α : Type} →
(motive : IO.AsyncList ε α → Sort u_1) →
(x : IO.AsyncList ε α) →
((hd : α) → (tl : IO.AsyncList ε α) → motive (IO.AsyncList.cons hd tl)) →
(Unit → motive IO.AsyncList.nil) →
((tl : Lean.Server.ServerTask (Except ε (IO.AsyncList ε α))) → motive (IO.AsyncList.delayed tl)) → m... | null | false |
DifferentiableOn.sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {s : Set E}
{ι : Type u_4} {u : Finset ι} {A : ι → E → F},
(∀ i ∈ u, DifferentiableOn 𝕜 (A i) s) → Differenti... | null | true |
MeasurableEquiv.piCongrLeft.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {δ : Type u_4} {δ' : Type u_5} (π : δ' → Type u_6) [inst : (x : δ') → MeasurableSpace (π x)] (f : δ ≃ δ'),
MeasurableEquiv.piCongrLeft π f = { toEquiv := Equiv.piCongrLeft π f, measurable_toFun := ⋯, measurable_invFun := ⋯ } | null | true |
Lean.Meta.forallMetaTelescopeReducingUntilDefEq | Mathlib.Lean.Meta.Basic | Lean.Expr →
Lean.Expr →
optParam Lean.MetavarKind Lean.MetavarKind.natural →
Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | This function is similar to `forallMetaTelescopeReducing`: Given `e` of the
form `forall ..xs, A`, this combinator will create a new metavariable for
each `x` in `xs` until it reaches an `x` whose type is defeq to `t`,
and instantiate `A` with these, while also reducing `A` if needed.
It uses `forallMetaTelescopeReduci... | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabUnsafe._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.CommSq.mk._flat_ctor | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z},
autoParam (CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g i)
CategoryTheory.CommSq.w._autoParam →
CategoryTheory.CommSq f g h i | null | false |
PartOrdEmb.of.injEq | Mathlib.Order.Category.PartOrdEmb | ∀ (carrier : Type u_1) [str : PartialOrder carrier] (carrier_1 : Type u_1) (str_1 : PartialOrder carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | null | true |
surjective_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_5 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_6 : (r : ↑s) → Module R (Mₚ r)]
(... | null | true |
_private.Mathlib.SetTheory.Cardinal.CountableCover.0.Cardinal.mk_subtype_le_of_countable_eventually_mem._simp_1_1 | Mathlib.SetTheory.Cardinal.CountableCover | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Batteries.CodeAction.instInhabitedTacticCodeActionEntry.default | Batteries.CodeAction.Attr | Batteries.CodeAction.TacticCodeActionEntry | null | true |
neZero_iff | Init.Data.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n ↔ n ≠ 0 | null | true |
_private.Mathlib.Order.Interval.Set.Pi.0.Set.Icc_sdiff_pi_univ_Ioo_subset._simp_1_10 | Mathlib.Order.Interval.Set.Pi | ∀ {α : Sort u_1} {p q : α → Prop}, ((∃ x, p x) ∨ ∃ x, q x) = ∃ x, p x ∨ q x | null | false |
CategoryTheory.IsCardinalFiltered.coeq_condition | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [hκ : Fact κ.IsRegular]
[inst_1 : CategoryTheory.IsCardinalFiltered J κ] {K : Type v'} {j j' : J} (f : K → (j ⟶ j')) (hK : HasCardinalLT K κ)
(k : K),
CategoryTheory.CategoryStruct.comp (f k) (CategoryTheory.IsCardinalFiltered.coeqHom f h... | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Basic.0.CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_inv_app_eq._simp_1_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
CategoryTheory.ObjectProperty.coproductFromFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.CostructuredArrow P.ι X → C | Given `P : ObjectProperty C` and `X : C`, this is the map which
sends `i : CostructuredArrow P.ι X` to `i.left.obj : C`. The coproduct
of this family is the source of the morphism `P.coproductFrom X`. | true |
List.TProd.elim._proof_1 | Mathlib.Data.Prod.TProd | ∀ {ι : Type u_1} (i : ι) (is : List ι), ∀ j ∈ i :: is, ¬j = i → j ∈ is | null | false |
StieltjesFunction.mk.inj | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} {inst : LinearOrder R} {inst_1 : TopologicalSpace R} {toFun : R → ℝ} {mono' : Monotone toFun}
{right_continuous' : ∀ (x : R), ContinuousWithinAt toFun (Set.Ici x) x} {toFun_1 : R → ℝ} {mono'_1 : Monotone toFun_1}
{right_continuous'_1 : ∀ (x : R), ContinuousWithinAt toFun_1 (Set.Ici x) x},
{ toFun... | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._simp_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} {a b : Additive α}, (a = b) = (Additive.toMul a = Additive.toMul b) | null | false |
BooleanSubalgebra.instTopCoe | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → {L : BooleanSubalgebra α} → Top ↥L | A Boolean subalgebra of a lattice inherits a top element. | true |
LightProfinite.instEpiAppOppositeNatπAsLimitCone | Mathlib.Topology.Category.LightProfinite.Extend | ∀ (S : LightProfinite) (i : ℕᵒᵖ), CategoryTheory.Epi (S.asLimitCone.π.app i) | null | true |
MeasureTheory.Measure.tprod | Mathlib.MeasureTheory.Constructions.Pi | {δ : Type u_4} →
{X : δ → Type u_5} →
[inst : (i : δ) → MeasurableSpace (X i)] →
(l : List δ) → ((i : δ) → MeasureTheory.Measure (X i)) → MeasureTheory.Measure (List.TProd X l) | A product of measures in `tprod α l`. | true |
Lean.Lsp.SymbolKind.interface.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 10 → motive Lean.Lsp.SymbolKind.interface → motive t | null | false |
Polynomial.Chebyshev.C_add_two | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R] (n : ℤ),
Polynomial.Chebyshev.C R (n + 2) = Polynomial.X * Polynomial.Chebyshev.C R (n + 1) - Polynomial.Chebyshev.C R n | null | true |
Lean.Import._sizeOf_1 | Lean.Setup | Lean.Import → ℕ | null | false |
ProfiniteAddGrp.hom_ext | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {f g : A ⟶ B}, ProfiniteAddGrp.Hom.hom f = ProfiniteAddGrp.Hom.hom g → f = g | null | true |
notMem_nonZeroDivisorsLeft_iff | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀}, x ∉ nonZeroDivisorsLeft M₀ ↔ {y | x * y = 0 ∧ y ≠ 0}.Nonempty | null | true |
CommGrpCat.id_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (X : CommGrpCat) (x : ↑X), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x | null | true |
Std.Iter.toArray_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toArray = it.toArray.extract n | null | true |
Ideal.quotientInfToPiQuotient.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {ι : Type u_1} (I : ι → Ideal R) [inst_1 : ∀ (i : ι), (I i).IsTwoSided],
Ideal.quotientInfToPiQuotient I = Ideal.Quotient.lift (⨅ i, I i) (RingHom.pi fun i => Ideal.Quotient.mk (I i)) ⋯ | null | true |
HasProd.mul_isCompl | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a b : α}
[ContinuousMul α] {s t : Set β},
IsCompl s t → HasProd (f ∘ Subtype.val) a → HasProd (f ∘ Subtype.val) b → HasProd f (a * b) | null | true |
Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusion | Lean.Elab.Do.Legacy | {P : Sort u} →
{t t' : Lean.Elab.Term.Do.ToCodeBlock.Context} → t = t' → Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusionType P t t' | null | false |
Interval.«_aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_term[[_,_]]_1» | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro | null | false |
minpoly.dvd_map_of_isScalarTower | Mathlib.FieldTheory.Minpoly.Field | ∀ (A : Type u_3) (K : Type u_4) {R : Type u_5} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Ring R]
[inst_3 : Algebra A K] [inst_4 : Algebra A R] [inst_5 : Algebra K R] [IsScalarTower A K R] (x : R),
minpoly K x ∣ Polynomial.map (algebraMap A K) (minpoly A x) | null | true |
Lean.Doc.Block.brecOn_2.eq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} {motive_1 : Lean.Doc.Block i b → Sort u_1}
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1}
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1}
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1}
{motive_5 : List (Lean.Doc.L... | null | true |
MonomialOrder.degree_smul_of_mem_nonZeroDivisors | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {r : R},
r ∈ nonZeroDivisors R → ∀ {f : MvPolynomial σ R}, m.degree (r • f) = m.degree f | null | true |
Set.fintypeImage2._proof_1 | Mathlib.Data.Finite.Prod | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} (f : α → β → γ) (s : Set α) (t : Set β),
Fintype ↑(Set.image2 f s t) = Fintype ↑((fun x => f x.1 x.2) '' s ×ˢ t) | null | false |
Algebra.FiniteType.out | Mathlib.RingTheory.FiniteType | ∀ {R : Type uR} {A : Type uA} {inst : CommSemiring R} {inst_1 : Semiring A} {inst_2 : Algebra R A}
[self : Algebra.FiniteType R A], ⊤.FG | null | true |
GradedMonoid.GMul.casesOn | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : Add ι] →
{motive : GradedMonoid.GMul A → Sort u} →
(t : GradedMonoid.GMul A) → ((mul : {i j : ι} → A i → A j → A (i + j)) → motive { mul := mul }) → motive t | null | false |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.balLeft.match_4.splitter | BatteriesRecycling.RBTree.Lemmas | {α : Type u_1} →
(motive : RBTree.RBNode α → Sort u_2) →
(l : RBTree.RBNode α) →
((a : RBTree.RBNode α) → (x : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node RBTree.RBColor.red a x b)) →
((l : RBTree.RBNode α) →
(∀ (a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α),
... | null | true |
RatFunc.laurent_laurent | Mathlib.FieldTheory.Laurent | ∀ {R : Type u} [inst : CommRing R] (r s : R) (f : RatFunc R) [inst_1 : IsDomain R],
(RatFunc.laurent r) ((RatFunc.laurent s) f) = (RatFunc.laurent (r + s)) f | null | true |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1)
{Z : C} (h : ((CategoryTheory.shiftFunctor Cᵒᵖᵒᵖ n).comp (CategoryTheory.unopUnop C)... | null | true |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape._sizeOf_1 | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
{inst_1 : LinearOrder J} →
{inst_2 : SuccOrder J} →
{inst_3 : OrderBot J} →
{inst_4 : WellFoundedLT J} →
{X Y : C} →
... | null | false |
MeasurableEquiv.mulLeft.congr_simp | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g g_1 : G),
g = g_1 → MeasurableEquiv.mulLeft g = MeasurableEquiv.mulLeft g_1 | null | true |
Filter.lift_lift_same_le_lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Filter β},
(f.lift fun s => f.lift (g s)) ≤ f.lift fun s => g s s | null | true |
MeasureTheory.withDensityᵥ_toReal | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ (hf : ∫⁻ (x : α), f x ∂μ ≠ ⊤), (μ.withDensityᵥ fun x => (f x).toReal) = (μ.withDensity f).toSignedMeasure | null | true |
BooleanSubalgebra.copy | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → (L : BooleanSubalgebra α) → (s : Set α) → s = ↑L → BooleanSubalgebra α | Copy of a Boolean subalgebra with a new `carrier` equal to the old one. Useful to fix
definitional equalities. | true |
FirstOrder.Language.partialOrderTheory.eq_1 | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered],
L.partialOrderTheory = insert FirstOrder.Language.leSymb.antisymmetric L.preorderTheory | null | true |
Lean.ErrorExplanation.mk.injEq | Lean.ErrorExplanation | ∀ (doc : String) (metadata : Lean.ErrorExplanation.Metadata) (declLoc? : Option Lean.DeclarationLocation)
(doc_1 : String) (metadata_1 : Lean.ErrorExplanation.Metadata) (declLoc?_1 : Option Lean.DeclarationLocation),
({ doc := doc, metadata := metadata, declLoc? := declLoc? } =
{ doc := doc_1, metadata := met... | null | true |
_private.Mathlib.Order.Category.DistLat.0.DistLat.Hom.mk.inj | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} {hom' hom'_1 : LatticeHom ↑X ↑Y}, { hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | true |
CompactlySupportedContinuousMap.coeFnMonoidHom._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddMonoid β]
[inst_3 : ContinuousAdd β] (f g : CompactlySupportedContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g | null | false |
IsIntegralClosure.equiv.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (A' : Type u_4)
[inst_6 : CommRing A'] [inst_7 : Algebra A' B] [inst_8 : IsIntegralClosure A' R B] [inst_9 : Algebra R A]
... | null | true |
Ideal.fiberIsoOfBijectiveResidueField | Mathlib.RingTheory.Etale.QuasiFinite | {R : Type u_1} →
{R' : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing R'] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R R'] →
[inst_4 : Algebra R S] →
{p : Ideal R} →
{q : Ideal R'} →
[in... | If `q` is a prime of `R'` lying over `p`, a prime of `R`, such that `κ(q) = κ(p)`, then
the fiber of `R' → R' ⊗[R] S` over `q` is in bijection with the fiber of `R → S` over `p`. | true |
EReal.add_iInf_le_iInf_add | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {u v : α → EReal}, (⨅ x, u x) + ⨅ x, v x ≤ ⨅ x, (u + v) x | null | true |
Real.fromBinary_surjective | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | Function.Surjective Real.fromBinary | null | true |
Std.ExtDTreeMap.instDecidableMem | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} → [inst : Std.TransCmp cmp] → {m : Std.ExtDTreeMap α β cmp} → {a : α} → Decidable (a ∈ m) | null | true |
Std.DHashMap.Raw | Std.Data.DHashMap.RawDef | (α : Type u) → (α → Type v) → Type (max u v) | Dependent hash maps without a bundled well-formedness invariant, suitable for use in nested
inductive types. The well-formedness invariant is called `Raw.WF`. When in doubt, prefer `DHashMap`
over `DHashMap.Raw`. Lemmas about the operations on `Std.Data.DHashMap.Raw` are available in the
module `Std.Data.DHashMap.RawLe... | true |
Ideal.quotientEquiv._proof_6 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S], RingHomClass (S →+* R) S R | null | false |
CategoryTheory.GlueData'.t''._proof_14 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (D : CategoryTheory.GlueData' C) (i : D.J), D.U i = D.U i | null | false |
ULift.distrib | Mathlib.Algebra.Ring.ULift | {R : Type u} → [Distrib R] → Distrib (ULift.{u_1, u} R) | null | true |
RBTree.RBNode.Path.insertNew_eq_insert | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : RBTree.RBNode α} {path : RBTree.RBNode.Path α} {v : α},
RBTree.RBNode.zoom (cmp v) t = (RBTree.RBNode.nil, path) → path.insertNew v = (RBTree.RBNode.insert cmp t v).setBlack | null | true |
Std.DHashMap.Raw.get?_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k | null | true |
CategoryTheory.Monad.algebraEquivOfIsoMonads_unitIso | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂),
(CategoryTheory.Monad.algebraEquivOfIsoMonads h).unitIso =
CategoryTheory.Monad.algebraFunctorOfMonadHomId.symm ≪≫
CategoryTheory.Monad.algebraFunctorOfMonadHomEq ⋯ ≪≫ CategoryTheory.Monad.algebraFunc... | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_smul._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Set.Icc_union_Icc' | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
c ≤ b → a ≤ d → Set.Icc a b ∪ Set.Icc c d = Set.Icc (min a c) (max b d) | null | true |
Std.ExtTreeMap.getKey!_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey! t.minKey! = t.minKey! | null | true |
MonadWriter.mk.noConfusion | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} →
{M : Type u → Type v} →
{P : Sort u_1} →
{tell : ω → M PUnit.{u + 1}} →
{listen : {α : Type u} → M α → M (α × ω)} →
{pass : {α : Type u} → M (α × (ω → ω)) → M α} →
{tell' : ω → M PUnit.{u + 1}} →
{listen' : {α : Type u} → M α → M (α × ω)}... | null | false |
MeasureTheory.quasiMeasurePreserving_sub_left | Mathlib.MeasureTheory.Group.Prod | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd₂ G] (μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ] [MeasurableNeg G] [μ.IsAddLeftInvariant] (g : G),
MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g - h) μ μ | null | true |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap! f t) = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal.Impl.... | null | true |
Ring.instDirectLimit._proof_16 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j), autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
HopfAlgebra.ofConvInverse | Mathlib.RingTheory.HopfAlgebra.Basic | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Bialgebra R A] →
(antipode : A →ₗ[R] A) →
WithConv.toConv antipode * WithConv.toConv LinearMap.id = 1 →
WithConv.toConv LinearMap.id * WithConv.toConv antipode = 1 → Hopf... | Upgrade a bialgebra to a Hopf algebra by specifying a convolution inverse of the identity. | true |
toIcoDiv_add_left' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1 | null | true |
ProbabilityTheory.measure_condCDF_univ | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α),
(ProbabilityTheory.condCDF ρ a).measure Set.univ = 1 | null | true |
BinaryTree.getOrElse | Mathlib.Data.Tree.Get | {α : Type u_1} → PosNum → BinaryTree α → α → α | Retrieves an element from the tree, or the provided default value
if the index is invalid. See `BinaryTree.get`. | true |
_private.Mathlib.RingTheory.LocalRing.Module.0.IsLocalRing.map_tensorProduct_mk_eq_top._proof_1_4 | Mathlib.RingTheory.LocalRing.Module | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] (b : M ⧸ IsLocalRing.maximalIdeal R • ⊤), 1 • b = b | null | false |
Int8.toNatClampNeg_lt | Init.Data.SInt.Lemmas | ∀ (x : Int8), x.toNatClampNeg < 2 ^ 7 | null | true |
_private.Lean.Meta.ForEachExpr.0.Lean.Meta.forEachExpr'.visit | Lean.Meta.ForEachExpr | {m : Type → Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Bool) →
(x : STWorld IO.RealWorld m) →
MonadLiftT (ST IO.RealWorld) m → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit m Unit | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.one_mod_eq_one.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x | null | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.mu'_apply_self | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (a : α), (IncidenceAlgebra.mu'✝ 𝕜) a a = 1 | null | true |
CategoryTheory.Limits.hasProducts_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasCoproducts C],
CategoryTheory.Limits.HasProducts Cᵒᵖ | null | true |
Module.Flat.instPreservesFiniteLimitsModuleCatTensorRightOfCarrier | Mathlib.RingTheory.Flat.CategoryTheory | ∀ {R : Type u} [inst : CommRing R] (M : ModuleCat R) [Module.Flat R ↑M],
CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.MonoidalCategory.tensorRight M) | null | true |
ProbabilityTheory.covarianceBilin_real | Mathlib.Probability.Moments.CovarianceBilin | ∀ {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsFiniteMeasure μ] (x y : ℝ),
((ProbabilityTheory.covarianceBilin μ) x) y = x * y * ProbabilityTheory.variance id μ | null | true |
MeasureTheory.Egorov.notConvergentSeqLTIndex | Mathlib.MeasureTheory.Function.Egorov | {α : Type u_1} →
{β : Type u_2} →
{ι : Type u_3} →
{m : MeasurableSpace α} →
[inst : PseudoEMetricSpace β] →
{μ : MeasureTheory.Measure α} →
{s : Set α} →
{ε : ℝ} →
{f : ι → α → β} →
{g : α → β} →
[inst_1 : Sem... | Given some `ε > 0`, `notConvergentSeqLTIndex` provides the index such that
`notConvergentSeq` (intersected with a set of finite measure) has measure less than
`ε * 2⁻¹ ^ n`.
This definition is useful for Egorov's theorem. | true |
Std.Http.CustomStatus.casesOn | Std.Http.Data.Status | {motive : Std.Http.CustomStatus → Sort u} →
(t : Std.Http.CustomStatus) →
((code : UInt16) →
(phrase : String) →
(validReasonPhrase : Std.Http.IsValidReasonPhrase phrase) →
(validCode : 100 ≤ code ∧ code ≤ 999) →
(validUnknown : ¬Std.Http.isKnownStatusCode code = true) ... | null | false |
Std.Roi.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roi α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxi.IsAlwaysFinite α] {pref suff : List α} {cur : α} (h : r.toList = pref ++ cur :: suff),
cu... | null | true |
Mathlib.TacticAnalysis.ComplexConfig.test | Mathlib.Tactic.TacticAnalysis | (self : Mathlib.TacticAnalysis.ComplexConfig) →
Lean.Elab.ContextInfo → Lean.Elab.TacticInfo → self.ctx → Lean.MVarId → Lean.Elab.Command.CommandElabM self.out | Code to run in the context of the tactic, for example an alternative tactic. | true |
Lean.Meta.MVarRenaming.map | Lean.Meta.Match.MVarRenaming | Lean.Meta.MVarRenaming → Lean.MVarIdMap Lean.MVarId | null | true |
SemidirectProduct.inr | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} → {G : Type u_2} → [inst : Group N] → [inst_1 : Group G] → {φ : G →* MulAut N} → G →* N ⋊[φ] G | The canonical map `G →* N ⋊[φ] G` sending `g` to `⟨1, g⟩` | true |
GroupSeminorm.coe_sSup_apply' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] {s : Set (GroupSeminorm E)},
BddAbove s → ∀ {x : E}, (sSup s) x = sSup ((fun x_1 => x_1 x) '' s) | null | true |
Metric.Snowflaking.preimage_toSnowflaking_eball | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : Metric.Snowflaking X α hα₀ hα₁)
(d : ENNReal),
⇑Metric.Snowflaking.toSnowflaking ⁻¹' Metric.eball x d = Metric.eball (Metric.Snowflaking.ofSnowflaking x) (d ^ α⁻¹) | null | true |
Algebra.IsPushout.cancelBaseChangeAux.congr_simp | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) (S : Type v₃) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_8)
(B : Type u_9) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsSc... | null | true |
List.Shortlex.cons | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Irrefl r] {a : α} {s t : List α},
List.Shortlex r s t → List.Shortlex r (a :: s) (a :: t) | **Alias** of the reverse direction of `List.shortlex_cons_iff`. | true |
_private.Lean.Server.GoTo.0.Lean.Server.getInstanceProjectionArg?.reduceToProjection?._sparseCasesOn_6 | Lean.Server.GoTo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Array.merge.go._unary | Batteries.Data.Array.Merge | {α : Type u_1} → (α → α → Bool) → Array α → Array α → (_ : Array α) ×' (_ : ℕ) ×' ℕ → Array α | Auxiliary definition for `merge`. | false |
Min.casesOn | Init.Prelude | {α : Type u} → {motive : Min α → Sort u_1} → (t : Min α) → ((min : α → α → α) → motive { min := min }) → motive t | null | false |
RingSeminormClass.mk._flat_ctor | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} [inst : NonUnitalNonAssocRing α]
[inst_1 : Semiring β] [inst_2 : PartialOrder β] [inst_3 : FunLike F α β],
(∀ (f : F) (a b : α), f (a + b) ≤ f a + f b) →
(∀ (f : F), f 0 = 0) →
(∀ (f : F) (a : α), f (-a) = f a) → (∀ (f : F) (a b : α), f ... | null | false |
CFC.neg_negPart_le | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [inst_2 : SMulCommClass ℝ A A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : StarRing A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_7 : PartialOrder A] [StarOrderedRing A]
{a : A}, autoParam (IsS... | null | true |
_private.Init.Data.Fin.Basic.0.Fin.exists_iff.match_1_1 | Init.Data.Fin.Basic | ∀ {n : ℕ} {p : Fin n → Prop} (motive : (∃ i, p i) → Prop) (x : ∃ i, p i),
(∀ (i : ℕ) (hi : i < n) (hpi : p ⟨i, hi⟩), motive ⋯) → motive x | null | false |
LieModule.Cohomology.twoCocycle.eq_1 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_1) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M],
LieModule.Cohomology.twoCocycle R L M = (LieModule.Cohomology.d₂₃ R L M).ker | null | true |
Convex.norm_image_sub_le_of_norm_fderiv_le | Mathlib.Analysis.Calculus.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {𝕜 : Type u_3} {G : Type u_4}
[inst_2 : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → G} {C : ℝ} {s : Set E} {x y : E},
(∀ x ∈ s, Diffe... | The mean value theorem on a convex set: if the derivative of a function is bounded by `C`,
then the function is `C`-Lipschitz. Version with `fderiv`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.