name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Hyperreal.isSt_iff | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, x.IsSt r ↔ 0 ≤ ArchimedeanClass.mk x ∧ ArchimedeanClass.stdPart x = r | null | true |
Lean.Meta.Grind.instBEqCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → Lean.Meta.Grind.CongrKey enodeMap → Bool | null | false |
ContinuousAffineEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(... | null | true |
TensorAlgebra.instRing._proof_14 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ (M : Type u_1) [inst : AddCommMonoid M] {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Module S M],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
_private.Mathlib.Data.Finsupp.Indicator.0.Finsupp.eq_indicator_iff._proof_1_3 | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) (f : (i : ι) → i ∈ s → α) {g : ι → α},
(∀ (i : ι), if hi : i ∈ s then f i hi = g i else g i = 0) ↔ (∀ (i : ι) (hi : i ∈ s), f i hi = g i) ∧ ∀ i ∉ s, g i = 0 | null | false |
«term⅟_» | Mathlib.Algebra.Group.Invertible.Defs | Lean.ParserDescr | The inverse of an `Invertible` element | true |
Sym.cast._proof_4 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ}, n = m → ∀ (s : Sym α m), (↑s).card = n | null | false |
_private.Std.Data.HashSet.RawLemmas.0.Std.HashSet.Raw.Equiv.symm.match_1_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u_1} {m₁ m₂ : Std.HashSet.Raw α} (motive : m₁.Equiv m₂ → Prop) (x : m₁.Equiv m₂),
(∀ (h : m₁.inner.Equiv m₂.inner), motive ⋯) → motive x | null | false |
Lean.Elab.InfoTree | Lean.Elab.InfoTree.Types | Type | The InfoTree is a structure that is generated during elaboration and used
by the language server to look up information about objects at particular points
in the Lean document. For example, tactic information and expected type information in
the infoview and information about completions.
The infotree consists of node... | true |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_zero_iff._simp_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | null | false |
Quiver.Path.vertices_comp_get_length_eq._auto_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | Lean.Syntax | null | false |
Std.HashSet.Equiv.inter_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ ∩ m₂).Equiv (m₁ ∩ m₃) | null | true |
DirectLimit.instAddGroup._proof_12 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → AddGroup (G i)] [∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (n : ℕ) (x x_1 : ι)
(... | null | false |
Ordinal.type_pUnit | Mathlib.SetTheory.Ordinal.Basic | Ordinal.type emptyRelation = 1 | null | true |
LinearEquiv.piCongrRight_trans | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type u_1} {ψ : ι → Type u_2} {χ : ι → Type u_3}
[inst_1 : (i : ι) → AddCommMonoid (φ i)] [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : (i : ι) → AddCommMonoid (ψ i)]
[inst_4 : (i : ι) → Module R (ψ i)] [inst_5 : (i : ι) → AddCommMonoid (χ i)] [inst_6 : (i : ι... | null | true |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_2 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((CategoryTheory.MonoidalCategory.tensoringRight C).map f)
((CategoryTheory... | null | false |
Equicontinuous | Mathlib.Topology.UniformSpace.Equicontinuity | {ι : Type u_1} →
{X : Type u_3} → {α : Type u_6} → [tX : TopologicalSpace X] → [uα : UniformSpace α] → (ι → X → α) → Prop | A family `F : ι → X → α` of functions from a topological space to a uniform space is
*equicontinuous* on all of `X` if it is equicontinuous at each point of `X`. | true |
AlgebraicClosure.instCommRing._proof_46 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
CategoryTheory.ObjectProperty.instSmallUnopOfOpposite | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ)
[CategoryTheory.ObjectProperty.Small.{w, v, u} P], CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop | null | true |
SimpleGraph.binomialRandom_one | Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs | ∀ (V : Type u_1) [Countable V], SimpleGraph.binomialRandom V 1 = MeasureTheory.Measure.dirac ⊤ | null | true |
CommRing.directSumGCommRing | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) → {R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommRing R] → DirectSum.GCommRing fun x => R | A direct sum of copies of a `CommRing` inherits the commutative multiplication structure. | true |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.evariance_def'._simp_1_7 | Mathlib.Probability.Moments.Variance | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
Set.graphOn_univ_inj | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β}, Set.graphOn f Set.univ = Set.graphOn g Set.univ ↔ f = g | null | true |
Std.Packages.LinearOrderOfOrdArgs.min_eq | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearOrderOfOrdArgs α),
let this := self.ord;
let this_1 := self.le;
let this_2 := self.min;
have this_3 := ⋯;
∀ (a b : α), a ⊓ b = if (compare a b).isLE = true then a else b | null | true |
CategoryTheory.MorphismProperty.Comma.mapRightEq_hom_app_right | 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) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
ExpGrowth.expGrowthInf_of_eventually_ge | Mathlib.Analysis.Asymptotics.ExpGrowth | ∀ {u v : ℕ → ENNReal} {b : ENNReal},
b ≠ 0 → (∀ᶠ (n : ℕ) in Filter.atTop, b * u n ≤ v n) → ExpGrowth.expGrowthInf u ≤ ExpGrowth.expGrowthInf v | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable.0.mdifferentiableWithinAt_totalSpace._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_6 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
Function.Injective
⇑(QuotientAddGroup.map (AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b))
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) ((zmultiplesHom ↥(AddSubgroup.zmultiples... | null | false |
Submonoid.isMulCommutative_iSup | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : MulOneClass M] {ι : Sort u_4} [Nonempty ι] {S : ι → Submonoid M}
[hS : ∀ (i : ι), IsMulCommutative ↥(S i)], Directed (fun x1 x2 => x1 ≤ x2) S → IsMulCommutative ↥(⨆ i, S i) | null | true |
CochainComplex.HomComplex.Cocycle.coe_sub | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} {n : ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cocycle F G n), ↑(z₁ - z₂) = ↑z₁ - ↑z₂ | null | true |
PadicInt.appr._f | Mathlib.NumberTheory.Padics.RingHoms | {p : ℕ} → [hp_prime : Fact (Nat.Prime p)] → (x : ℕ) → Nat.below (motive := fun x => ℤ_[p] → ℕ) x → ℤ_[p] → ℕ | null | false |
Perfection.quotientMulEquiv._proof_5 | Mathlib.RingTheory.Teichmuller | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] (I : Ideal R) [inst_2 : CharP (R ⧸ I) p]
[inst_3 : IsAdicComplete I R],
(Perfection.liftMonoidHom p (Perfection (R ⧸ I) p) (R ⧸ I)).symm
((Perfection.mapMonoidHom p ↑(Ideal.Quotient.mk I)).comp
((Perfection.liftMonoidHom p (Per... | null | false |
SimpleGraph.Walk.length_dropLast | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.dropLast.length = p.length - 1 | null | true |
toPrev.eq_1 | Mathlib.Algebra.Homology.BifunctorHomotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (j : ι), toPrev j = AddMonoidHom.mk' (fun f => f j (c.prev j)) ⋯ | null | true |
Std.DTreeMap.getKey?_eq_some_getKeyD_of_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
t.contains a = true → t.getKey? a = some (t.getKeyD a fallback) | null | true |
Nat.instCommutativeHMul | Init.Data.Nat.Basic | Std.Commutative fun x1 x2 => x1 * x2 | null | true |
Std.DTreeMap.Internal.Impl.eraseManyEntries! | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{ρ : Type w} → [ForIn Id ρ ((a : α) × β a)] → (t : Std.DTreeMap.Internal.Impl α β) → ρ → t.IteratedSlowErasureFrom | Slower version of `eraseManyEntries` which can be used in absence of balance information but still
assumes the preconditions of `eraseManyEntries`, otherwise might panic.
| true |
DiscreteTiling.Protoset.coe_injective | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X],
Function.Injective DiscreteTiling.Protoset.tiles | null | true |
Std.Do.SPred.Tactic.HasFrame.mk | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs} {P' : outParam (Std.Do.SPred σs)} {φ : outParam Prop},
(P ⊣⊢ₛ P' ∧ ⌜φ⌝) → Std.Do.SPred.Tactic.HasFrame P P' φ | null | true |
CategoryTheory.instCategoryObjOppositeSimplexCategoryNerve._aux_5 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
{Δ : SimplexCategoryᵒᵖ} → {X Y Z : (CategoryTheory.nerve C).obj Δ} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
cauchy_davenport_of_isMulTorsionFree | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : Group G] [IsMulTorsionFree G] {s t : Finset G},
s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card | The **Cauchy-Davenport Theorem** for torsion-free groups. The size of `s * t` is lower-bounded
by `|s| + |t| - 1`. | true |
CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtEquivOfIso' | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} H] →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor C ... | The condition of being a pointwise right Kan extension at an object `Y` is
unchanged by replacing `Y` by an isomorphic object `Y'`. | true |
Std.HashMap.Raw.beq | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → [BEq β] → Std.HashMap.Raw α β → Std.HashMap.Raw α β → Bool | Compares two hash maps using Boolean equality on keys and values.
Returns `true` if the maps contain the same key-value pairs, `false` otherwise.
| true |
HEq.ndrecOn | Init.Core | {α : Sort u2} → {a : α} → {motive : {β : Sort u2} → β → Sort u1} → {β : Sort u2} → {b : β} → a ≍ b → motive a → motive b | `HEq.ndrec` variant | true |
CategoryTheory.Idempotents.Karoubi.comp_proof | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q R : CategoryTheory.Idempotents.Karoubi C}
(g : Q.Hom R) (f : P.Hom Q),
CategoryTheory.CategoryStruct.comp P.p
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.f g.f) R.p) =
CategoryTheory.CategoryStruct.comp f.f g... | null | true |
Finset.Nontrivial.ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, s.Nontrivial → s ≠ {a} | null | true |
CategoryTheory.Bicategory.associatorNatIsoRightCat_inv_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c) (d : B) (X : c ⟶ d),
(CategoryTheory.Bicategory.associatorNatIsoRightCat f g d).inv.toNatTrans.app X =
(CategoryTheory.Bicategory.associator f g X).inv | null | true |
conjneg_ne_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 1 ↔ f ≠ 1 | null | true |
RestrictedProduct.mulSingle_eq_one_iff._simp_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} {S : ι → Type u_3} {G : ι → Type u_4} [inst : (i : ι) → SetLike (S i) (G i)] (A : (i : ι) → S i)
[inst_1 : DecidableEq ι] [inst_2 : (i : ι) → One (G i)] [inst_3 : ∀ (i : ι), OneMemClass (S i) (G i)] (i : ι)
{x : G i}, (RestrictedProduct.mulSingle A i x = 1) = (x = 1) | null | false |
IsOpen.nhdsWithin_eq | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, IsOpen s → a ∈ s → nhdsWithin a s = nhds a | null | true |
lTensor.inverse_of_rightInverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | true |
CategoryTheory.ObjectProperty.instNonemptyPair | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (X Y : C),
(CategoryTheory.ObjectProperty.pair X Y).Nonempty | null | true |
CategoryTheory.cartesianClosedOfReflective'._proof_3 | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (i : CategoryTheory.Functor D C)
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.Reflective i]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] (B : D) ... | null | false |
_private.Init.Data.List.Impl.0.List.eraseP_eq_erasePTR.go.match_1 | Init.Data.List.Impl | ∀ (α : Type u_1) (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (x : α) (xs : List α), motive (x :: xs)) → motive x | null | false |
Lean.Lsp.DiagnosticSeverity.error.sizeOf_spec | Lean.Data.Lsp.Diagnostics | sizeOf Lean.Lsp.DiagnosticSeverity.error = 1 | null | true |
LTSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (p : LTSeries α) (f : α → β)
(hf : StrictMono f), RelSeries.last (p.map f hf) = f (RelSeries.last p) | null | true |
Lean.Meta.Match.Extension.Entry.mk | Lean.Meta.Match.MatcherInfo | Lean.Name → Lean.Meta.MatcherInfo → Lean.Meta.Match.Extension.Entry | null | true |
Asymptotics.isLittleO_const_id_atTop | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {E'' : Type u_9} [inst : NormedAddCommGroup E''] (c : E''), (fun _x => c) =o[Filter.atTop] id | null | true |
Lean.Lsp.ReferenceContext.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → ℕ | null | false |
CategoryTheory.effectiveEpiFamilyStructOfIsIsoDesc | Mathlib.CategoryTheory.EffectiveEpi.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{B : C} →
{α : Type u_2} →
(X : α → C) →
(π : (a : α) → X a ⟶ B) →
[inst_1 : CategoryTheory.Limits.HasCoproduct X] →
[CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc π)] → CategoryTheory.Effec... | A family of morphisms with the same target inducing an isomorphism from the coproduct to the target
is an `EffectiveEpiFamily`.
| true |
StarSubsemiring.ofClass._proof_3 | Mathlib.Algebra.Star.Subsemiring | ∀ {S : Type u_2} {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : SetLike S R] [SubsemiringClass S R] (s : S)
{a b : R}, a ∈ s → b ∈ s → a + b ∈ s | null | false |
NonUnitalStarSubalgebra.prod | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : StarRing A] →
[inst_3 : Module R A] →
[inst_4 : NonUnitalSemiring B] →
[inst_5 : StarRing B] →
[inst_6 : Module R B]... | The product of two non-unital star subalgebras is a non-unital star subalgebra. | true |
Orientation.volumeForm_def | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {n : ℕ}
[_i : Fact (Module.finrank ℝ E = n)] (o : Orientation ℝ E (Fin n)),
o.volumeForm =
Nat.casesAuxOn (motive := fun a => n = a → E [⋀^Fin n]→ₗ[ℝ] ℝ) n
(fun h =>
Eq.ndrec (motive := fun {n} =>
[_i : Fact ... | null | true |
Std.DTreeMap.Raw.maxKey?_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {km : α}, t.maxKey? = some km → km ∈ t | null | true |
NonUnitalCommCStarAlgebra.toIsScalarTower | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : NonUnitalCommCStarAlgebra A], IsScalarTower ℂ A A | null | true |
exists_stronglyMeasurable_limit_of_tendsto_ae | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[TopologicalSpace.PseudoMetrizableSpace β] {f : ℕ → α → β},
(∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ) →
(∀ᵐ (x : α) ∂μ, ∃ l, Filter.Tendsto (fun n => f n x) Filter.atTop (nhds l)) →
... | If a sequence of almost everywhere strongly measurable functions converges almost everywhere,
one can select a strongly measurable function as the almost everywhere limit. | true |
Lean.Elab.HoverableInfoPrio.mk.injEq | Lean.Server.InfoUtils | ∀ (isHoverPosOnStop : Bool) (size : ℕ) (isVariableInfo isPartialTermInfo isHoverPosOnStop_1 : Bool) (size_1 : ℕ)
(isVariableInfo_1 isPartialTermInfo_1 : Bool),
({ isHoverPosOnStop := isHoverPosOnStop, size := size, isVariableInfo := isVariableInfo,
isPartialTermInfo := isPartialTermInfo } =
{ isHoverP... | null | true |
SimpleGraph.maximumIndepSet_exists | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} [inst : Finite α], ∃ s, G.IsMaximumIndepSet s | null | true |
CategoryTheory.Functor.instAdditiveObjPostcompose₂ | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : CategoryTheory.Preadditive E] {E' : Type u_4}
[inst_5 : CategoryTheory.Cate... | null | true |
VitaliFamily.ae_eventually_measure_zero_of_singular | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [SecondCountableTopology α] [BorelSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ]
{ρ : MeasureTheory.Measure α} [MeasureTheory.IsLocallyFiniteMeasure ρ],
ρ.MutuallySingular μ → ∀ᵐ (x : α) ∂μ... | If a measure `ρ` is singular with respect to `μ`, then for `μ` almost every `x`, the ratio
`ρ a / μ a` tends to zero when `a` shrinks to `x` along the Vitali family. This makes sense
as `μ a` is eventually positive by `ae_eventually_measure_pos`. | true |
PosMulReflectLE.toPosMulStrictMono | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLE α], PosMulStrictMono α | null | true |
PolynomialModule.eval_apply | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r : R)
(p : PolynomialModule R M), (PolynomialModule.eval r) p = Finsupp.sum p fun i m => r ^ i • m | null | true |
Quiver.Path.weight | Mathlib.Combinatorics.Quiver.Path.Weight | {V : Type u_1} →
[inst : Quiver V] → {R : Type u_2} → [Monoid R] → ({i j : V} → (i ⟶ j) → R) → {i j : V} → Quiver.Path i j → R | The weight of a path is the product of the weights of its edges. | true |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData_iso_hom | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
[i... | null | true |
Lean.Elab.Tactic.evalWithAnnotateState | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
_private.Mathlib.GroupTheory.Coset.Basic.0.QuotientGroup.orbit_mk_eq_smul._simp_1_2 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, (x⁻¹ * y ∈ s) = (QuotientGroup.leftRel s) x y | null | false |
Int16.or_self | Init.Data.SInt.Bitwise | ∀ {a : Int16}, a ||| a = a | null | true |
List.zip_eq_nil_iff._simp_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β}, (l₁.zip l₂ = []) = (l₁ = [] ∨ l₂ = []) | null | false |
Set.OrdConnected.predOrder._proof_10 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Set α} [inst_1 : PredOrder α] (x : α) (hx : x ∈ s),
(if h : Order.pred ↑⟨x, hx⟩ ∈ s then ⟨Order.pred ↑⟨x, hx⟩, h⟩ else ⟨x, hx⟩) ≤ ⟨x, hx⟩ | null | false |
Nat.factorial_coe_dvd_prod | Mathlib.Data.Nat.Factorial.BigOperators | ∀ (k : ℕ) (n : ℤ), ↑k.factorial ∣ ∏ i ∈ Finset.range k, (n + ↑i) | `k!` divides the product of any `k` consecutive integers. | true |
TrivialLieModule.instLieRingModule._proof_2 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x : L) (m n : TrivialLieModule R L M), 0 = 0 + 0 | null | false |
Finset.coe_insert | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑(insert a s) = insert a ↑s | null | true |
_private.Mathlib.Data.List.SplitBy.0.List.getLast?.match_1.eq_2 | Mathlib.Data.List.SplitBy | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | null | true |
ContinuousMap.notMem_idealOfSet | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {s : Set X} {f : C(X, R)}, f ∉ ContinuousMap.idealOfSet R s ↔ ∃ x ∈ sᶜ, f x ≠ 0 | null | true |
List.dropSlice.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (x x_1 : ℕ), List.dropSlice x x_1 [] = [] | null | true |
RelIso.sumLexComplLeft_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // r x_1 x } ⊕ { x_1 // ¬r x_1 x }), (RelIso.sumLexComplLeft r x) a = (Equiv.sumCompl fun x_1 => r x_1 x) a | null | true |
_private.Mathlib.Logic.Equiv.List.0.Encodable.encodeList.match_1.splitter | Mathlib.Logic.Equiv.List | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (l : List α) → motive (a :: l)) → motive x | null | true |
Shrink.continuousLinearEquiv | Mathlib.Topology.Algebra.Module.TransferInstance | (R : Type u_1) →
(α : Type u_2) →
[inst : Small.{v, u_2} α] →
[inst_1 : AddCommMonoid α] →
[inst_2 : TopologicalSpace α] → [inst_3 : Semiring R] → [inst_4 : Module R α] → Shrink.{v, u_2} α ≃L[R] α | Shrinking `α` to a smaller universe preserves the continuous module structure. | true |
_private.Init.Internal.Order.Basic.0.Lean.Order.implication_order_monotone_or.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} (f₁ f₂ : α → Lean.Order.ImplicationOrder) (x : α) (motive : f₁ x ∨ f₂ x → Prop) (h : f₁ x ∨ f₂ x),
(∀ (hfx₁ : f₁ x), motive ⋯) → (∀ (hfx₂ : f₂ x), motive ⋯) → motive h | null | false |
AffineMap.comp | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_1} →
{V1 : Type u_2} →
{P1 : Type u_3} →
{V2 : Type u_4} →
{P2 : Type u_5} →
{V3 : Type u_6} →
{P3 : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : Module k V1] →
[inst_3 : Add... | Composition of affine maps. | true |
Std.Sat.AIG.Decl.relabel.match_1 | Std.Sat.AIG.Relabel | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((a : α) → motive (Std.Sat.AIG.Decl.atom a)) →
((lhs rhs : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate lhs rhs)) → motive decl | null | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_isBasis_iff._simp_1_10 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (s ⊆ f ⁻¹' t) = (f '' s ⊆ t) | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_34 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls_1 lls : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (lrl lrr : Std.DTreeMap.Internal.Impl α β),
3 * (ll.size + 1 + lr.size) < l.size + 1 + r.size + 1 + (lrl.size + 1 + lrr.size) →
ll.Balanced ∧
lr.Balanced ... | null | false |
OrderMonoidIso.val_inv_unitsCongr_symm_apply | Mathlib.Algebra.Order.Hom.Units | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Monoid α] [inst_2 : Preorder β] [inst_3 : Monoid β]
(e : α ≃*o β) (a : βˣ), ↑(e.unitsCongr.symm a)⁻¹ = (↑e).symm ↑a⁻¹ | null | true |
Lean.Meta.instReprCoeFnType | Lean.Meta.CoeAttr | Repr Lean.Meta.CoeFnType | null | true |
CategoryTheory.enrichedFunctorTypeEquivFunctor._proof_2 | Mathlib.CategoryTheory.Enriched.Basic | ∀ {C : Type u_2} [𝒞 : CategoryTheory.EnrichedCategory (Type u_1) C] {D : Type u_3}
[𝒟 : CategoryTheory.EnrichedCategory (Type u_1) D] (F : CategoryTheory.Functor C D) (X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp (Type u_1) X Y Z) (TypeCat.ofHom fun f => F.map f) =
CategoryTheory.Categ... | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_3.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond (Std... | null | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabWaitIfTypeMVar._regBuiltin.Lean.Elab.Term.elabWaitIfTypeMVar_1 | Lean.Elab.BuiltinTerm | IO Unit | null | false |
Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convIntro____1 | Init.Conv | Lean.Macro | `intro` traverses into binders. Synonym for `ext`. | false |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.glued | Mathlib.AlgebraicGeometry.RelativeGluing | {S : AlgebraicGeometry.Scheme} →
{𝒰 : S.OpenCover} →
[inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀] →
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] →
AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰 →
[Small.{u, u_1} 𝒰.I₀] → [Quiver.IsThin 𝒰.I₀] → AlgebraicGeometry... | The glued scheme of a relative gluing datum is the colimit over the `Xᵢ`. For the
structure map, see `AlgebraicGeometry.Scheme.Cover.RelativeGluingData.toBase` and the isomorphisms
with the preimages `AlgebraicGeometry.Scheme.Cover.RelativeGluingData.isPullback_natTrans_ι_toBase`.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.