name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
DFinsupp.addMonoid₂ | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{α : ι → Type u_2} →
{δ : (i : ι) → α i → Type v} →
[inst : (i : ι) → (j : α i) → AddMonoid (δ i j)] → AddMonoid (Π₀ (i : ι) (j : α i), δ i j) | 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) | true |
Nat.instCommutativeHMul | Init.Data.Nat.Basic | Std.Commutative fun x1 x2 => x1 * x2 | 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 | 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 | 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' φ | 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 ... | 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... | 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) | false |
IsOpen.nhdsWithin_eq | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, IsOpen s → a ∈ s → nhdsWithin a s = nhds a | true |
_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 | false |
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 | true |
Lean.Lsp.ReferenceContext.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → ℕ | 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... | 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 | false |
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 ... | 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 | 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)) →
... | 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... | 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 | 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 | true |
Lean.Elab.Tactic.evalWithAnnotateState | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | 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 | false |
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 | false |
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 | 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] α | 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 | 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... | true |
_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) | 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⁻¹ | true |
Lean.Meta.instReprCoeFnType | Lean.Meta.CoeAttr | Repr Lean.Meta.CoeFnType | true |
Lean.IR.Sorry.State.mk.inj | Lean.Compiler.IR.Sorry | ∀ {localSorryMap : Lean.NameMap Lean.Name} {modified : Bool} {localSorryMap_1 : Lean.NameMap Lean.Name}
{modified_1 : Bool},
{ localSorryMap := localSorryMap, modified := modified } =
{ localSorryMap := localSorryMap_1, modified := modified_1 } →
localSorryMap = localSorryMap_1 ∧ modified = modified_1 | true |
Mathlib.Tactic.Monoidal.evalWhiskerLeft_comp | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {f g h i : C}
{η : h ⟶ i}
{η₁ : CategoryTheory.MonoidalCategoryStruct.tensorObj g h ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj g i}
{η₂ :
CategoryTheory.MonoidalCategoryStruct.tensorObj f (CategoryTheo... | true |
normalizationMonoidOfMonoidHomRightInverse._proof_5 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : DecidableEq α] (f : Associates α →* α)
(hinv : Function.RightInverse (⇑f) Associates.mk), (if 0 = 0 then 1 else Classical.choose ⋯) = 1 | false |
Lean.Elab.Term.tryPostponeIfHasMVars | Lean.Elab.Term.TermElabM | Option Lean.Expr → String → Lean.Elab.TermElabM Lean.Expr | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_11 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (guess : ℕ) (hg : guess < table.size) (this : table[guess - 1] < guess),
¬table[guess - 1] < table.size → False | false |
Primrec.list_flatten | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec List.flatten | true |
Turing.ToPartrec.Code.succ | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code | true |
CategoryTheory.IsHomLift.eq_of_isHomLift | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) {a b : 𝒳} (f : p.obj a ⟶ p.obj b) (φ : a ⟶ b) [p.IsHomLift f φ], f = p.map φ | true |
RootPairing.InvariantForm.isOrthogonal_reflection | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N}
(self : P.InvariantForm) (i : ι), LinearMap.IsOrthogonal self.form ⇑(P.reflection i) | true |
PresheafOfModules.presheaf.eq_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Free | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R),
M.presheaf =
{ obj := fun X => (CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X),
map := fun {X Y} f => AddCommGrpCat.ofHom (AddMonoidHom.mk' ⇑(CategoryTheory.Conc... | true |
GenContFract.of_s_head | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] {v : K},
Int.fract v ≠ 0 → (GenContFract.of v).s.head = some { a := 1, b := ↑⌊(Int.fract v)⁻¹⌋ } | true |
Associates.is_pow_of_dvd_count | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α]
[inst_2 : DecidableEq (Associates α)] [inst_3 : (p : Associates α) → Decidable (Irreducible p)] {a : Associates α},
a ≠ 0 → ∀ {k : ℕ}, (∀ (p : Associates α), Irreducible p → k ∣ p.count a.factors) → ∃ b, a = b ^ k | true |
Quaternion.dualNumberEquiv._proof_2 | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R],
Function.RightInverse
(fun d =>
{ re := ((TrivSqZeroExt.fst d).re, (TrivSqZeroExt.snd d).re),
imI := ((TrivSqZeroExt.fst d).imI, (TrivSqZeroExt.snd d).imI),
imJ := ((TrivSqZeroExt.fst d).imJ, (TrivSqZeroExt.snd d).imJ),
imK := ((TrivSqZeroExt.fst... | false |
_private.Mathlib.Util.CompileInductive.0.Mathlib.Util.replaceConst.match_1 | Mathlib.Util.CompileInductive | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | false |
CategoryTheory.Bicategory.associator_naturality_middle_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g' h) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheo... | true |
differentiableOn_pi'' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i},
(∀ (i : ι), Differenti... | true |
Monoid.End.instInhabited | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_4) → [inst : MulOne M] → Inhabited (Monoid.End M) | true |
DFinsupp.subtypeSupportEqEquiv._proof_5 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (s : Finset ι) (f : (i : ↥s) → { x // x ≠ 0 }) (i : ι),
i ∈ (DFinsupp.mk s fun i => ↑(f i)).support ↔ i ∈ s | false |
CategoryTheory.Grp.instMonoidalMonForget₂Mon._proof_6 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : CategoryTheory.Grp C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Catego... | false |
ne_zero_and_ne_zero_of_mul | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] {a b : M₀}, a * b ≠ 0 → a ≠ 0 ∧ b ≠ 0 | true |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_6 | Mathlib.Analysis.MellinInversion | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
DivisionSemiring.mk.noConfusion | Mathlib.Algebra.Field.Defs | {K : Type u_2} →
{P : Sort u} →
{toSemiring : Semiring K} →
{toInv : Inv K} →
{toDiv : Div K} →
{div_eq_mul_inv : autoParam (∀ (a b : K), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam} →
{zpow : ℤ → K → K} →
{zpow_zero' : autoParam (∀ (a : K), zpow 0 a =... | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.gaussianPDFReal_inv_mul._simp_1_4 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
getElem?_eq_none_iff._simp_1 | Init.GetElem | ∀ {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [inst : GetElem? cont idx elem dom]
[LawfulGetElem cont idx elem dom] (c : cont) (i : idx) [Decidable (dom c i)], (c[i]? = none) = ¬dom c i | false |
lowerCentralSeries_pi_of_finite | Mathlib.GroupTheory.Nilpotent | ∀ {η : Type u_2} {Gs : η → Type u_3} [inst : (i : η) → Group (Gs i)] [Finite η] (n : ℕ),
lowerCentralSeries ((i : η) → Gs i) n = Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) n | true |
_private.Init.Data.String.Decode.0.Char.utf8Size_eq_four_iff._proof_1_5 | Init.Data.String.Decode | ∀ {c : Char}, 127 < c.val.toNat → c.val.toNat ≤ 2047 → ¬c.val.toNat ≤ 65535 → False | false |
Std.PRange.UpwardEnumerable.succMany?_succ?_eq_succ?_bind_succMany? | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] (n : ℕ) (a : α),
Std.PRange.succMany? (n + 1) a = (Std.PRange.succ? a).bind fun x => Std.PRange.succMany? n x | true |
Nat.add_le_add_iff_left._simp_1 | Init.Data.Nat.Basic | ∀ {m k n : ℕ}, (n + m ≤ n + k) = (m ≤ k) | false |
Subfield.mk.congr_simp | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (toSubring toSubring_1 : Subring K) (e_toSubring : toSubring = toSubring_1)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier),
{ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := ⋯ } | true |
Polynomial.smeval_assoc_X_pow | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Semiring R] (p : Polynomial R) {S : Type u_2} [inst_1 : NonAssocSemiring S]
[inst_2 : Module R S] [inst_3 : Pow S ℕ] (x : S) [NatPowAssoc S] [IsScalarTower R S S] (m n : ℕ),
p.smeval x * x ^ m * x ^ n = p.smeval x * (x ^ m * x ^ n) | true |
smul_mem_asymptoticCone_iff._simp_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] [inst_6 : TopologicalSpace k]
[OrderTopology k] [IsStrictOrderedRing k] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : ... | false |
CategoryTheory.Limits.CokernelCofork.isColimitMapBifunctor.exists_desc | Mathlib.CategoryTheory.Limits.Preserves.BifunctorCokernel | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
[inst_5 : Categ... | true |
CompleteOrthogonalIdempotents.lift_of_isNilpotent_ker | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) {I : Type u_3} [inst_2 : Fintype I],
(∀ x ∈ RingHom.ker f, IsNilpotent x) →
∀ {e : I → S},
CompleteOrthogonalIdempotents e →
(∀ (i : I), e i ∈ f.range) → ∃ e', CompleteOrthogonalIdempotents e' ∧ ⇑f ∘ e' = e | true |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.casesMatch.match_6 | Lean.Meta.Tactic.Grind.CasesMatch | (motive : Lean.Expr × Array Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Array Lean.Expr) →
((motive_1 : Lean.Expr) → (eqRefls : Array Lean.Expr) → motive (motive_1, eqRefls)) → motive __discr | false |
AddAction.instElemOrbit_1._proof_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_2} {α : Type u_1} [inst : AddGroup G] [inst_1 : AddAction G α] (x : AddAction.orbitRel.Quotient G α)
(g g' : G) (a' : ↑x.orbit), (g + g') +ᵥ a' = g +ᵥ g' +ᵥ a' | false |
ContractingWith.fixedPoint_unique | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [inst_1 : Nonempty α]
[inst_2 : CompleteSpace α] {x : α}, Function.IsFixedPt f x → x = ContractingWith.fixedPoint f hf | true |
_private.Lean.Parser.Extension.0.Lean.Parser.compileParserDescr.visit.match_3 | Lean.Parser.Extension | (motive : Option Lean.Parser.ParserCategory → Sort u_1) →
(x : Option Lean.Parser.ParserCategory) →
((val : Lean.Parser.ParserCategory) → motive (some val)) → (Unit → motive none) → motive x | false |
Lean.PrettyPrinter.Delaborator.State.mk._flat_ctor | Lean.PrettyPrinter.Delaborator.Basic | ℕ →
Lean.SubExpr.PosMap Lean.Elab.Info →
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator → Lean.PrettyPrinter.Delaborator.State | false |
LocalizedModule.instRing._proof_9 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Submonoid R},
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | false |
MeasureTheory.Measure.rnDeriv_add_right_of_absolutelyContinuous_of_mutuallySingular | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν ν' : MeasureTheory.Measure α} [μ.HaveLebesgueDecomposition ν]
[μ.HaveLebesgueDecomposition (ν + ν')] [MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → ν.MutuallySingular ν' → μ.rnDeriv (ν + ν') =ᵐ[ν] μ.rnDeriv ν | true |
Multiset.foldl_zero | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β), Multiset.foldl f b 0 = b | true |
Finset.bipartiteBelow.eq_1 | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteBelow r s b = {a ∈ s | r a b} | true |
Batteries.AssocList.findEntryP?._unsafe_rec | Batteries.Data.AssocList | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → Batteries.AssocList α β → Option (α × β) | false |
not_fermatLastTheoremFor_two | Mathlib.NumberTheory.FLT.Basic | ¬FermatLastTheoremFor 2 | true |
FreeLieAlgebra.liftAux_map_mul | Mathlib.Algebra.Lie.Free | ∀ (R : Type u) {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(a b : FreeNonUnitalNonAssocAlgebra R X),
(FreeLieAlgebra.liftAux R f) (a * b) = ⁅(FreeLieAlgebra.liftAux R f) a, (FreeLieAlgebra.liftAux R f) b⁆ | true |
selfAdjointPart_apply_coe | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) {A : Type u_2} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (x : A), ↑((selfAdjointPart R) x) = ⅟2 • (x + star x) | true |
Set.uIoo_subset_Ioo | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
a₁ ∈ Set.Icc a₂ b₂ → b₁ ∈ Set.Icc a₂ b₂ → Set.uIoo a₁ b₁ ⊆ Set.Ioo a₂ b₂ | true |
AddSubgroup.unop_injective | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_2} [inst : AddGroup G], Function.Injective AddSubgroup.unop | true |
_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) →
((a : Lean.Level) → motive a.succ) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.valuedCompletion_surjective_iff._simp_1_1 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | false |
List.flatten_nil | Init.Data.List.Basic | ∀ {α : Type u}, [].flatten = [] | true |
CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf_obj_a | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(V : CategoryTheory.Endofunctor.Coalgebra G),
((CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf adj).obj V).a = V.V | true |
Submodule.mul_iSup | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {ι : Sort uι} (t : Submodule R A) (s : ι → Submodule R A), t * ⨆ i, s i = ⨆ i, t * s i | true |
Finset.univ_val_map_subtype_restrict | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] (f : α → β) (p : α → Prop) [inst_1 : DecidablePred p]
[inst_2 : Fintype { a // p a }],
Multiset.map (Subtype.restrict p f) Finset.univ.val = Multiset.map f (Finset.filter p Finset.univ).val | true |
Nat.orderEmbeddingOfSet_range | Mathlib.Order.OrderIsoNat | ∀ (s : Set ℕ) [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s], Set.range ⇑(Nat.orderEmbeddingOfSet s) = s | true |
Filter.HasBasis.forall_mem_mem | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ∀ {x : α}, (∀ t ∈ l, x ∈ t) ↔ ∀ (i : ι), p i → x ∈ s i | true |
HasCompactMulSupport.uniformContinuous_of_continuous | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} [inst_2 : One β],
HasCompactMulSupport f → Continuous f → UniformContinuous f | true |
PresheafOfModules.sections.eval | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} → {M : PresheafOfModules R} → M.sections → (X : Cᵒᵖ) → ↑(M.obj X) | true |
Lean.OptionDecl.mk.injEq | Lean.Data.Options | ∀ (name : Lean.Name) (declName : autoParam Lean.Name Lean.OptionDecl.declName._autoParam) (defValue : Lean.DataValue)
(descr : String) (name_1 : Lean.Name) (declName_1 : autoParam Lean.Name Lean.OptionDecl.declName._autoParam)
(defValue_1 : Lean.DataValue) (descr_1 : String),
({ name := name, declName := declName... | true |
Cardinal.zero_lt_lift_iff | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{u}}, 0 < Cardinal.lift.{v, u} a ↔ 0 < a | true |
Lean.Lsp.SymbolKind.boolean | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind | true |
Cube.insertAt_boundary | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : DecidableEq N] (i : N) {t₀ : ↑unitInterval} {t : { j // j ≠ i } → ↑unitInterval},
(t₀ = 0 ∨ t₀ = 1) ∨ t ∈ Cube.boundary { j // j ≠ i } → (Cube.insertAt i) (t₀, t) ∈ Cube.boundary N | true |
CategoryTheory.Limits.Cofork.π.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Cofork f g),
t.π = t.ι.app CategoryTheory.Limits.WalkingParallelPair.one | true |
Std.Iterators.Types.DropWhile.recOn | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} →
{motive : Std.Iterators.Types.DropWhile α m β P → Sort u} →
(t : Std.Iterators.Types.DropWhile α m β P) →
((dropping : Bool) → (inner : Std.IterM m β) → motive ... | false |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_mul_left_lt | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LT α] [DenselyOrdered α] [MulRightStrictMono α] {a b c : α},
a * b < c → ∃ a' > a, a' * b < c | true |
CategoryTheory.Limits.CategoricalPullback.comp_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{X Y Z : CategoryTheory.Limits.CategoricalPullback F G} (f : X.Hom Y... | true |
TensorProduct.Algebra.module._proof_7 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | false |
Lean.Compiler.LCNF.instInhabitedFunDecl.default_1 | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.FunDecl a | true |
CategoryTheory.Bicategory.InducedBicategory.forget._proof_9 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η g).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheo... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.