name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_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 |
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 | BatteriesRecycling.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.Lean.Meta.Tactic.Cbv.Main.0.Lean.Meta.Tactic.Cbv.cbvDecideGoal.match_3 | Lean.Meta.Tactic.Cbv.Main | (motive : Except Lean.Exception Unit → Sort u_1) →
(x : Except Lean.Exception Unit) →
(Unit → motive (Except.ok PUnit.unit)) → ((err : Lean.Exception) → motive (Except.error err)) → motive x | 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 |
_private.Mathlib.Tactic.CongrExclamation.0.Congr!.plausiblyEqualTypes.match_5 | Mathlib.Tactic.CongrExclamation | (motive : ℕ → Sort u_1) → (maxDepth : ℕ) → (Unit → motive 0) → ((maxDepth : ℕ) → motive maxDepth.succ) → motive maxDepth | null | false |
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 |
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 |
Lean.Parser.Tactic.Grind.«grind_filterGen≤_» | Init.Grind.Interactive | Lean.ParserDescr | null | true |
CategoryTheory.Comonad.Coalgebra.isoMk | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{G : CategoryTheory.Comonad C} →
{A B : G.Coalgebra} →
(h : A.A ≅ B.A) →
autoParam
(CategoryTheory.CategoryStruct.comp A.a (G.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom B.a)
CategoryTheory.... | To construct an isomorphism of coalgebras, it suffices to give an isomorphism of the carriers which
commutes with the structure morphisms.
| true |
CategoryTheory.AddMon.instCartesianMonoidalCategory.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.AddMon.instCartesianMonoidalCategory =
{ toMonoidalCategory := CategoryTheory.AddMon.monMonoidal,
isTerminalTensorUnit :=
C... | null | true |
SkewMonoidAlgebra.noConfusion | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {P : Sort u} →
{k : Type u_1} →
{G : Type u_2} →
{inst : Zero k} →
{t : SkewMonoidAlgebra k G} →
{k' : Type u_1} →
{G' : Type u_2} →
{inst' : Zero k'} →
{t' : SkewMonoidAlgebra k' G'} →
k = k' → G = G' → inst ≍ inst' → t ≍ t' → Sk... | null | false |
Matrix.mul_right_inj_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
(A : Matrix n n α) [Invertible A] {x y : Matrix n m α}, A * x = A * y ↔ x = y | null | true |
Vector.getElem?_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m i : ℕ} {xs : Vector α n} {ys : Vector α m}, n ≤ i → (xs ++ ys)[i]? = ys[i - n]? | null | true |
Std.ExtHashSet.size_diff_le_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size ≤ m₁.size | null | true |
ProperConstVAdd.mk._flat_ctor | Mathlib.Topology.Algebra.ProperConstSMul | ∀ {M : Type u_1} {X : Type u_2} [inst : VAdd M X] [inst_1 : TopologicalSpace X],
(∀ (c : M), IsProperMap fun x => c +ᵥ x) → ProperConstVAdd M X | null | false |
Bundle.Trivialization.coe_linearMapAt | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R... | null | true |
ENNReal.instCompleteLinearOrder._aux_26 | Mathlib.Data.ENNReal.Basic | DecidableLT ENNReal | null | false |
Std.Roo.mk.inj | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {lower upper lower_1 upper_1 : α},
((lower<...upper) = lower_1<...upper_1) → lower = lower_1 ∧ upper = upper_1 | null | true |
CategoryTheory.MonoidalCategory.monoidalOfLawfulDayConvolutionMonoidalCategoryStruct._proof_3 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_6, u_3} C] (V : Type u_5)
[inst_1 : CategoryTheory.Category.{u_4, u_5} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCa... | null | false |
AlgebraicGeometry.Scheme.affineOverMk | Mathlib.AlgebraicGeometry.Sites.Affine | {S : AlgebraicGeometry.Scheme} →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{R : CommRingCat} → (f : AlgebraicGeometry.Spec R ⟶ S) → P f → P.CostructuredArrow ⊤ AlgebraicGeometry.Scheme.Spec S | Construct an object of affine `P`-schemes over `S` by giving a morphism `Spec R ⟶ S`. | true |
Lean.Level.collectMVars | Lean.Level | Lean.Level → optParam Lean.LMVarIdSet ∅ → Lean.LMVarIdSet | null | true |
WithLp.instUnitizationNormedAddCommGroup | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | (𝕜 : Type u_1) →
(A : Type u_2) →
[inst : NormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] → [NormedSpace 𝕜 A] → NormedAddCommGroup (WithLp 1 (Unitization 𝕜 A)) | null | true |
CategoryTheory.Limits.Bicone.ι_π._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | Lean.Syntax | null | false |
NormedAddTorsor | Mathlib.Analysis.Normed.Group.AddTorsor | (V : outParam (Type u_1)) → (P : Type u_2) → [SeminormedAddCommGroup V] → [PseudoMetricSpace P] → Type (max u_1 u_2) | A `NormedAddTorsor V P` is a torsor of an additive seminormed group
action by a `SeminormedAddCommGroup V` on points `P`. We bundle the pseudometric space
structure and require the distance to be the same as results from the
norm (which in fact implies the distance yields a pseudometric space, but
bundling just the dis... | true |
Multiset.Subset.ndinter_eq_left | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ⊆ t → s.ndinter t = s | null | true |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.effectiveEpiFamily_tfae._simp_1_3 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C]
{α : Type} [inst_2 : Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B),
CategoryTheory.EffectiveEpiFamily X π = CategoryTheory.EffectiveEpi (CategoryTheory.Limits.Sigma.desc π) | null | false |
BoundedContinuousFunction.hasNatPow._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_2} [inst : TopologicalSpace α] {R : Type u_1} [inst_1 : SeminormedRing R]
(f : BoundedContinuousFunction α R) (n : ℕ),
∃ C, ∀ (x y : α), dist ((f.toContinuousMap ^ n).toFun x) ((f.toContinuousMap ^ n).toFun y) ≤ C | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.MonObj.one_associator._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (g : Y ≅ Z) (f f' : Y ⟶ X),
(CategoryTheory.CategoryStruct.comp g.inv f = CategoryTheory.CategoryStruct.comp g.inv f') = (f = f') | null | false |
Lean.DefinitionVal.all | Lean.Declaration | Lean.DefinitionVal → List Lean.Name | List of all (including this one) declarations in the same mutual block.
Note that this information is not used by the kernel, and is only used
to save the information provided by the user when using mutual blocks.
Recall that the Lean kernel does not support recursive definitions and they
are compiled using recursors a... | true |
SubMulAction.instSMulSubtypeMem._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : ↥p), c • ↑x ∈ p | null | false |
ωCPO._sizeOf_1 | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ | null | false |
IsAlgebraic.smul | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → ∀ (r : R), IsAlgebraic R (r • a) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.