name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TrivSqZeroExt.isNilpotent_inr | Mathlib.RingTheory.DualNumber | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x : M), IsNilpotent (TrivSqZeroExt.inr x) | null | true |
WithCStarModule.instNormedAddCommGroupProd._proof_18 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
(x : WithCStarModule A (E × F)),
nhds x =
Filter.comap (Prod.mk x)
(Filter.comap (fun p => ((WithCStarModule.equiv A (E × F)) p.1, (WithCStarModule.equiv A (E × F)) p.2))
(uniformity (E × F... | null | false |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1 | Lean.Meta.Sym.Offset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceFrom_ne_startPos._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} (p : s.Pos), (p ≠ s.startPos) = (s.startPos < p) | null | false |
Summable.tsum_of_nat_of_neg | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{f : ℤ → G},
(Summable fun n => f ↑n) →
(Summable fun n => f (-↑n)) → ∑' (n : ℤ), f n = ∑' (n : ℕ), f ↑n + ∑' (n : ℕ), f (-↑n) - f 0 | null | true |
Lean.Elab.Command.CtorView.modifiers | Lean.Elab.MutualInductive | Lean.Elab.Command.CtorView → Lean.Elab.Modifiers | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchAt?_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt c pos pos' =
∃ (h : pos' ≠ s.startPos), pos = pos'.prev h ∧ (pos'.prev h).get ⋯ = c | null | false |
Algebra.IsAlgebraic.mk._flat_ctor | Mathlib.RingTheory.Algebraic.Defs | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
(∀ (x : A), IsAlgebraic R x) → Algebra.IsAlgebraic R A | null | false |
CategoryTheory.Functor.LaxMonoidal.ofBifunctor.bottomMapᵣ | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u_2} →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj
... | The bottom map in the right unitality square.
| true |
_private.Mathlib.Algebra.MvPolynomial.SchwartzZippel.0.MvPolynomial.schwartz_zippel_sup_sum._simp_1_5 | Mathlib.Algebra.MvPolynomial.SchwartzZippel | ∀ {a b c d : Prop}, ((a ∧ b) ∧ c ∧ d) = ((a ∧ c) ∧ b ∧ d) | null | false |
NonUnitalStarAlgHom.mk | Mathlib.Algebra.Star.StarAlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction R B] →
... | null | true |
SSet.prodStdSimplex.pairingCore.IsType₂.simplex.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x x_1 : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
(e_x : x = x_1) (hx : SSet.prodStdSimplex.pairingCore.IsType₂ x) {d : ℕ} (hd : x.dim = d), hx.simplex hd = ⋯.simplex ⋯ | null | true |
Subarray.mkSlice_roi_eq_mkSlice_rco | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Rco.Sliceable.mkSlice xs (lo + 1)...Std.Slice.size xs | null | true |
LinearEquiv.cast_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_14} {M : ι → Type u_15} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {i j : ι} (h : i = j) (a : M j), (LinearEquiv.cast h).symm a = cast ⋯ a | null | true |
ContinuousOrderHom._sizeOf_inst | Mathlib.Topology.Order.Hom.Basic | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : TopologicalSpace α} → {inst_3 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →Co β) | null | false |
MeasureTheory.MemLp.integrable_enorm_pow | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε} {p : ℕ},
MeasureTheory.MemLp f (↑p) μ → p ≠ 0 → MeasureTheory.Integrable (fun x => ‖f x‖ₑ ^ p) μ | null | true |
Std.DTreeMap.isEmpty_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.toList.isEmpty = t.isEmpty | null | true |
SkewMonoidAlgebra.liftNCRingHom._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} [inst : Semiring k] {R : Type u_2} [inst_1 : Semiring R], AddMonoidHomClass (k →+* R) k R | null | false |
HahnModule.instAddCommGroup._proof_9 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommGroup V],
autoParam (∀ (n : ℕ) (a : HahnModule Γ R V), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
Nat.recOnPrimePow._proof_5 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), (k + 2) / (k + 2).minFac ^ (k + 2).factorization (k + 2).minFac < k + 2 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.toTriangle._simp_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
Real.geom_mean_le_arith_mean3_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ p₁ p₂ p₃ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ → 0 ≤ p₁ → 0 ≤ p₂ → 0 ≤ p₃ → w₁ + w₂ + w₃ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ | null | true |
AddMonCat.HasLimits.limitConeIsLimit._proof_5 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat)
(s : CategoryTheory.Limits.Cone F) (x y : ↑s.1) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone s).π.app j)
... | null | false |
AddMonoidHom.mulOp._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (x y : Mᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x + y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x + (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | null | false |
CategoryTheory.comp_eqToHom_iff | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Y' : C} (p : Y = Y') (f : X ⟶ Y) (g : X ⟶ Y'),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.eqToHom p) = g ↔
f = CategoryTheory.CategoryStruct.comp g (CategoryTheory.eqToHom ⋯) | null | true |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.foundLine | Init.Data.Format.Basic | Std.Format.SpaceResult✝ → Bool | null | true |
CategoryTheory.LocalizerMorphism.RightResolution.mk_surjective | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
(R : Φ.RightResolution X₂), ∃ X₁ w, ∃ (hw : W... | null | true |
AffineMap.map_midpoint | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : Ring R] [inst_1 : Invertible 2]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup V']
[inst_6 : Module R V'] [inst_7 : AddTorsor V' P'] (f : P →ᵃ[R] P') (a b : P),
f (midpoint R a b... | null | true |
Std.DHashMap.getKey?_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k | null | true |
Ordinal.isNormal_veblen_zero | Mathlib.SetTheory.Ordinal.Veblen | Order.IsNormal fun x => Ordinal.veblen x 0 | null | true |
instContinuousSMulTangentSpace | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] (_x : M), ContinuousSMul 𝕜 (TangentSpa... | null | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (x : R) (motive : (∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1) → Prop)
(x_1 : ∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1),
(∀ (p : R) (hpi : p ∈ I) (q : R) (hq : q ∈ Ideal.span {x}) (hpq : p + q = 1), motive ⋯) → motive x_1 | null | false |
Std.ExtDHashMap.Const.insertManyIfNewUnit_list_eq_empty_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α}, (Std.ExtDHashMap.Const.insertManyIfNewUnit m l = ∅) = (m = ∅ ∧ l = []) | null | false |
Cardinal.lift_sSup | Mathlib.SetTheory.Cardinal.Basic | ∀ {s : Set Cardinal.{u_1}}, BddAbove s → Cardinal.lift.{u, u_1} (sSup s) = sSup (Cardinal.lift.{u, u_1} '' s) | The lift of a supremum is the supremum of the lifts. | true |
CommGroupWithZero.instStrongNormalizedGCDMonoid._proof_5 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] {a b c : G₀},
a ∣ c → a ∣ b → a ∣ if c = 0 ∧ b = 0 then 0 else 1 | null | false |
Lean.Meta.DiagSummary.data._default | Lean.Meta.Diagnostics | Array Lean.MessageData | null | false |
_private.Mathlib.Order.ModularLattice.0.strictMono_inf_prod_sup.match_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] {z : α} (_x _y : α)
(motive : (fun x => (x ⊓ z, x ⊔ z)) _y ≤ (fun x => (x ⊓ z, x ⊔ z)) _x → Prop)
(x : (fun x => (x ⊓ z, x ⊔ z)) _y ≤ (fun x => (x ⊓ z, x ⊔ z)) _x),
(∀ (inf_le : ((fun x => (x ⊓ z, x ⊔ z)) _y).1 ≤ ((fun x => (x ⊓ z, x ⊔ z)) _x).1)
(sup_le : ((fun x => (x ⊓... | null | false |
Bundle.TotalSpace.recOn | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_4} →
{E : B → Type u_5} →
{motive : Bundle.TotalSpace F E → Sort u} →
(t : Bundle.TotalSpace F E) → ((proj : B) → (snd : E proj) → motive ⟨proj, snd⟩) → motive t | null | false |
_private.Batteries.Data.List.Scan.0.List.take_flatten | Batteries.Data.List.Scan | {α : Type u_1} →
(L : List (List α)) →
(i : ℕ) →
ProofWanted
(have j := List.findIdx (fun x => decide (x > i)) (List.map List.length L).partialSums - 1;
have k := i - (List.take j L).flatten.length;
List.take i L.flatten = (List.take j L).flatten ++ List.take k (L[j]?.getD [])) | null | true |
Lean.Parser.Term.letOpts.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
LieAlgebra.SemiDirectSum.inl | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → K →ₗ⁅R⁆ K ⋊⁅ψ⁆ L | The canonical inclusion of K into the semi-direct sum K ⋊⁅ψ⁆ G. | true |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapPreimage | Mathlib.RingTheory.AdicCompletion.Exactness | {R : Type u} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{N : Type w} →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{f : M →ₗ[R] N} →
Funct... | Inductively construct preimage of Cauchy sequence. | true |
ENNReal.finsetSum_iSup | Mathlib.Data.ENNReal.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} {s : Finset α} {f : α → ι → ENNReal},
(∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k) → ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i | null | true |
CategoryTheory.Cat.equivOfIso._proof_3 | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} (γ : C ≅ D), γ.inv.toFunctor.comp γ.hom.toFunctor = CategoryTheory.Functor.id ↑D | null | false |
Lean.SubExpr.Pos.pushAppArg | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos | null | true |
Finsupp.subtypeDomain_sub | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {G : Type u_8} [inst : AddGroup G] {p : α → Prop} {v v' : α →₀ G},
Finsupp.subtypeDomain p (v - v') = Finsupp.subtypeDomain p v - Finsupp.subtypeDomain p v' | null | true |
Std.HashMap.Raw.WF.filterMap | Std.Data.HashMap.AdditionalOperations | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β}
{f : α → β → Option γ}, m.WF → (Std.HashMap.Raw.filterMap f m).WF | null | true |
RBTree.RBNode.Slow.instDecidableOrdered._unsafe_rec | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
(cmp : α → α → Ordering) → [Std.TransCmp cmp] → (t : RBTree.RBNode α) → Decidable (RBTree.RBNode.Ordered cmp t) | null | false |
Std.TreeMap.getKey_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{hc : t.minKey! ∈ t}, t.getKey t.minKey! hc = t.minKey! | null | true |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.bindMutVarsFromTuple.go._sunfold | Lean.Elab.Do.Basic | Lean.Elab.Do.DoElabM Lean.Expr →
List Lean.Name → Lean.FVarId → Lean.Expr → Array Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr | null | false |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSome?_eq_some_iff._simp_1_1 | Batteries.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True | null | false |
MonoidHom.toOneHom_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N] (f : M →* N), ⇑↑f = ⇑f | null | true |
PUnit.instLinearOrderedAddCommMonoidWithTop._proof_3 | Mathlib.Algebra.Order.PUnit | ∀ (x : PUnit.{1}), x ≤ x | null | false |
IsAddUnit.add_right_cancel | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M] {a b c : M}, IsAddUnit b → a + b = c + b → a = c | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.ofArray.go._unsafe_rec | Batteries.Data.MLList.Basic | {m : Type → Type} → {α : Type} → Array α → ℕ → MLList m α | null | false |
Lean.Meta.DiscrTree.getSubexpressionMatches._unsafe_rec | Mathlib.Lean.Meta.DiscrTree | {α : Type} → Lean.Meta.DiscrTree α → Lean.Expr → Lean.MetaM (Array α) | null | false |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.isMulCommutative_iSup._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
_aux_Mathlib_Algebra_Group_Units_Defs___unexpand_Units_1 | Mathlib.Algebra.Group.Units.Defs | Lean.PrettyPrinter.Unexpander | null | false |
OrderDual.ofDual_le_ofDual | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [inst : LE α] {a b : αᵒᵈ}, OrderDual.ofDual a ≤ OrderDual.ofDual b ↔ b ≤ a | null | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processImplicitArg._unsafe_rec | Lean.Elab.PatternVar | Bool →
Lean.Elab.Term.CollectPatternVars.Context →
Lean.Elab.Term.CollectPatternVars.M Lean.Elab.Term.CollectPatternVars.Context | null | false |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_nat._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ} {x : M}, (x ∈ (f.genEigenspace μ) ↑k) = (x ∈ ((f - μ • 1) ^ k).ker) | null | false |
IsAddUnit.of_add_eq_zero_right | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] [IsDedekindFiniteAddMonoid M] {b : M} (a : M), a + b = 0 → IsAddUnit b | null | true |
List.append_eq | Init.Data.List.Basic | ∀ {α : Type u} {as bs : List α}, as.append bs = as ++ bs | null | true |
fderivWithin_of_mem_nhds | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s : Set E}, s ∈ nhds x → fderivWithin 𝕜 f s x = fder... | null | true |
MeasureTheory.VectorMeasure.dirac._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {β : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : MeasurableSpace β] (x : β) (v : M) ⦃i : Set β⦄,
¬MeasurableSet i → (if MeasurableSet i ∧ x ∈ i then v else 0) = 0 | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_9 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {ι : Sort u_5} (a : α) (f : ι → β),
(Set.range fun i => a • f i) = a • Set.range f | null | false |
UniqueFactorizationMonoid.radical_ne_zero._simp_1 | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M} [Nontrivial M], (UniqueFactorizationMonoid.radical a = 0) = False | null | false |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_integral_remainder_aux._proof_1_11 | Mathlib.Analysis.Calculus.Taylor | ∀ {x : ℝ} (n : ℕ) (t : ℝ), (x - t) ^ n * ↑(n.succ * n.factorial) = ↑n.factorial * ↑(n + 1) * (x - t) ^ (n + 1 - 1) | null | false |
DirectSum.IsInternal.exists_subordinateOrthonormalBasisIndex_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
(hV' : ... | null | true |
RingHom.Finite.finiteType | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] {f : A →+* B}, f.Finite → f.FiniteType | null | true |
_private.Mathlib.Algebra.DirectSum.Internal.0.listProd_apply_eq_zero._simp_1_2 | Mathlib.Algebra.DirectSum.Internal | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → LinearOrderedCommMonoidWithZero α | null | true |
CochainComplex.isKProjective_shift_iff | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).obj K).IsKProjective ↔ K.IsKProjective | null | true |
_private.Mathlib.GroupTheory.Coset.Basic.0.Subgroup.quotientiInfSubgroupOfEmbedding._simp_3 | Mathlib.GroupTheory.Coset.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ H.subgroupOf K) = (↑h ∈ H) | null | false |
CategoryTheory.EffectiveEquivalenceRelation | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → {R A : C} → (R ⟶ A) → (R ⟶ A) → Type (max u_1 v_1) | An effective equivalence relation is an equivalence relation `p₁, p₂ : R ⟶ A` together with a
morphism `π : A ⟶ B` such that the resulting square is both a pullback square and a pushout
square. | true |
_private.Mathlib.AlgebraicGeometry.Cover.Sigma.0.AlgebraicGeometry.Scheme.Cover.presieve₀_sigma.match_1_1 | Mathlib.AlgebraicGeometry.Cover.Sigma | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : UnivLE.{u_2, u_1}]
{S : AlgebraicGeometry.Scheme} (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S)
(motive :
(T : AlgebraicGeometry.Scheme) →
(g : T ⟶ S) → CategoryTheory.Presieve.singleton (CategoryTh... | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkSize.go.match_1 | Lean.Meta.Tactic.Grind.EMatch | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(binderType b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_fst_toList_eq_keys._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Hyperreal.coe_add | Mathlib.Analysis.Real.Hyperreal | ∀ (x y : ℝ), ↑(x + y) = ↑x + ↑y | null | true |
Bundle.Prod.contMDiffVectorBundle | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB B] (F₁ : Type u_... | The direct sum of two `C^n` vector bundles over the same base is a `C^n` vector bundle. | true |
Std.DHashMap.Raw.Const.get?_inter_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → Std.DHashMap.Raw.Const.get? (m₁ ∩ m₂) k = none | null | true |
CategoryTheory.ProjectiveResolution.liftFOne._proof_3 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Y : C}
(P : CategoryTheory.ProjectiveResolution Y), CategoryTheory.Projective (P.complex.X 1) | null | false |
Std.DTreeMap.Raw.Equiv.of_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp},
t₁.toList.Perm t₂.toList → t₁.Equiv t₂ | null | true |
instFreeQuotientIdealSpanSingletonSetQuotSMulTop | Mathlib.RingTheory.Regular.Free | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Free R M]
(x : R), Module.Free (R ⧸ Ideal.span {x}) (QuotSMulTop x M) | null | true |
PEquiv.ofSet_eq_refl._simp_1 | Mathlib.Data.PEquiv | ∀ {α : Type u} {s : Set α} [inst : DecidablePred fun x => x ∈ s], (PEquiv.ofSet s = PEquiv.refl α) = (s = Set.univ) | null | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_aux._proof_1 | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2) (k : ℕ),
ih_gen✝ k ↑(newton_seq_aux✝ hnorm k) | null | false |
Subalgebra.perfectClosure | Mathlib.FieldTheory.PurelyInseparable.Basic | (R : Type u_1) →
(A : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → (p : ℕ) → [ExpChar A p] → Subalgebra R A | The perfect closure of `R` in `A` are the elements `x : A` such that `x ^ p ^ n`
is in `R` for some `n`, where `p` is the exponential characteristic of `R`. | true |
_private.Mathlib.Geometry.Convex.Cone.Face.Basic.0.PointedCone.IsFaceOf.fst._simp_1_2 | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Int.modEq_sub_modulus_mul_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a ≡ b - n * c [ZMOD n] ↔ a ≡ b [ZMOD n] | null | true |
ProbabilityTheory.Kernel.iIndepFun.comp₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
Probability... | null | true |
ContDiffMapSupportedIn.seminorm._proof_3 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) (F : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | null | false |
JordanHolderLattice.rec | Mathlib.Order.JordanHolder | {X : Type u} →
[inst : Lattice X] →
{motive : JordanHolderLattice X → Sort u_1} →
((IsMaximal : X → X → Prop) →
(lt_of_isMaximal : ∀ {x y : X}, IsMaximal x y → x < y) →
(sup_eq_of_isMaximal : ∀ {x y z : X}, IsMaximal x z → IsMaximal y z → x ≠ y → x ⊔ y = z) →
(isMaximal_i... | null | false |
Submodule.map._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[RingHomSurjective σ₁₂] (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) (c : R₂) {x : M₂}, x ∈ ⇑f '... | null | false |
descPochhammer | Mathlib.RingTheory.Polynomial.Pochhammer | (R : Type u) → [inst : Ring R] → ℕ → Polynomial R | `descPochhammer R n` is the polynomial `X * (X - 1) * ... * (X - n + 1)`,
with coefficients in the ring `R`.
| true |
Std.Do.Spec.forIn'_list._proof_5 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : List α}, xs ++ [] = xs | null | false |
Std.TreeMap.Raw.minKeyD_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β} {fallback : α},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | null | true |
hasFDerivWithinAt_pi' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : 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}
{Φ' : E →L[𝕜] ... | null | true |
Functor.map_unit | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} [inst : Functor f] [LawfulFunctor f] {a : f PUnit.{u_1 + 1}},
(fun x => PUnit.unit) <$> a = a | null | true |
Sym.filterNe._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (m : Sym α n), (↑m).card < n + 1 | null | false |
Lean.IR.Expr.proj.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 3 → ((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.proj i x)) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.