name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.getLast_tail | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (h : l.tail ≠ []), l.tail.getLast h = l.getLast ⋯ | null | true |
CategoryTheory.IsSplitCoequalizer.isCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{Z : C} →
{h : Y ⟶ Z} → (t : CategoryTheory.IsSplitCoequalizer f g h) → CategoryTheory.Limits.IsColimit t.asCofork | The cofork induced by a split coequalizer is a coequalizer, justifying the name. In some cases it
is more convenient to show a given cofork is a coequalizer by showing it is split.
| true |
Lean.Elab.Term.instToStringArg.match_1 | Lean.Elab.Arg | (motive : Lean.Elab.Term.Arg → Sort u_1) →
(x : Lean.Elab.Term.Arg) →
((stx : Lean.Syntax) → motive (Lean.Elab.Term.Arg.stx stx)) →
((e : Lean.Expr) → motive (Lean.Elab.Term.Arg.expr e)) → motive x | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith_mk_mul._proof_1_10 | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u_1} [inst : DecidableEq α] {w : α × Bool} (g : FreeGroup α) (hC : 0 < g.toWord.length),
(g.toWord[0].1 = w.1 → g.toWord[0].2 = w.2) →
(List.rec [w] (fun head tail tail_ih => if w.1 = head.1 ∧ w.2 = !head.2 then tail else w :: head :: tail)
(g.toWord.head ⋯ :: g.toWord.tail))[0]? =
som... | null | false |
fintypeToFinBoolAlgOp._proof_5 | Mathlib.Order.Category.FinBoolAlg | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (a b : Set Y.obj),
{ toFun := ⇑(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)), map_sup' := ⋯,
map_inf' := ⋯ }.toFun
(a ⊔ b) =
{ toFun := ⇑(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)), map_sup' := ⋯,
... | null | false |
_private.Mathlib.Tactic.Explode.Pretty.0.Mathlib.Explode.rowToMessageData.match_1 | Mathlib.Tactic.Explode.Pretty | (motive : Mathlib.Explode.Status → Sort u_1) →
(x : Mathlib.Explode.Status) →
(Unit → motive Mathlib.Explode.Status.sintro) →
(Unit → motive Mathlib.Explode.Status.intro) →
(Unit → motive Mathlib.Explode.Status.cintro) →
(Unit → motive Mathlib.Explode.Status.lam) → (Unit → motive Mathlib.E... | null | false |
meromorphicTrailingCoeffAt_fun_neg | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : 𝕜} {f : 𝕜 → E},
meromorphicTrailingCoeffAt (fun z => -f z) x = -meromorphicTrailingCoeffAt f x | Taking the negative commutes with taking `meromorphicTrailingCoeffAt`.
| true |
AddUnits.val_zsmul_eq_zsmul_val._simp_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (u : AddUnits α) (n : ℤ), n • ↑u = ↑(n • u) | null | false |
AddSubgroup.IsSubnormal.normal_of_isSimpleAddGroup | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, IsSimpleAddGroup G → H.IsSubnormal → H.Normal | A subnormal additive subgroup of a simple additive group is normal. | true |
WithBot.ofDual_le_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x : WithBot αᵒᵈ} {y : WithTop α}, WithBot.ofDual x ≤ y ↔ WithTop.toDual y ≤ x | null | true |
AlgebraicGeometry.Scheme.instIsOpenImmersionMapOfHomAwayAlgebraMap | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {R : Type u_1} [inst : CommRing R] (f : R),
AlgebraicGeometry.IsOpenImmersion
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R (Localization.Away f)))) | null | true |
uniformEquicontinuousOn_empty | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {α : Type u_6} {β : Type u_8} [uα : UniformSpace α] [uβ : UniformSpace β] [h : IsEmpty ι]
(F : ι → β → α) (S : Set β), UniformEquicontinuousOn F S | null | true |
MeasureTheory.AEEqFun.toGermMonoidHom_apply | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Monoid γ] [inst_3 : ContinuousMul γ] (f : α →ₘ[μ] γ), MeasureTheory.AEEqFun.toGermMonoidHom f = f.toGerm | null | true |
isRelLowerSet_empty | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α], IsRelLowerSet ∅ P | null | true |
Matrix.adjugate_conjTranspose | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : Matrix n n α), A.adjugate.conjTranspose = A.conjTranspose.adjugate | null | true |
CategoryTheory.GradedNatTrans.naturality_assoc | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{A : CategoryTheory.Center V} {F G : CategoryTheory.EnrichedFunctor V C D}
(self : Categor... | `app` is a natural transformation. | true |
Rat.ceil_intCast | Init.Data.Rat.Lemmas | ∀ (a : ℤ), (↑a).ceil = a | null | true |
Submodule.smithNormalFormOfLE._proof_7 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(N O : Submodule R M) (n : ℕ)
(x : ∃ o, ∃ (hno : n ≤ o), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i))),
∃ (hno : n ≤ Classical.choose x), ∃ bO bN a, ∀ (i : Fin n), ↑(bN i) = a i • ↑(bO (Fin.ca... | null | false |
DyckWord.le_add_self | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p q : DyckWord), q ≤ p + q | null | true |
FirstOrder.Language.Term.varFinset._unsafe_rec | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [DecidableEq α] → L.Term α → Finset α | null | false |
Lean.Lsp.ClientCapabilities.mk.injEq | Lean.Data.Lsp.Capabilities | ∀ (textDocument? : Option Lean.Lsp.TextDocumentClientCapabilities) (window? : Option Lean.Lsp.WindowClientCapabilities)
(workspace? : Option Lean.Lsp.WorkspaceClientCapabilities) (lean? : Option Lean.Lsp.LeanClientCapabilities)
(textDocument?_1 : Option Lean.Lsp.TextDocumentClientCapabilities)
(window?_1 : Option... | null | true |
CategoryTheory.Over.postEquiv._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (X : T) (F : T ≌ D) (A : CategoryTheory.Over (F.functor.obj X)),
CategoryTheory.CategoryStruct.comp (F.counitIso.app A.left).hom
((CategoryTheory.Functor.id (CategoryTheory.Over (F.fun... | null | false |
CategoryTheory.Bicategory.Adj.Bicategory.associator_hom_τl | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : CategoryTheory.Bicategory.Adj B} (α : a ⟶ b) (β : b ⟶ c)
(γ : c ⟶ d),
(CategoryTheory.Bicategory.Adj.Bicategory.associator α β γ).hom.τl =
(CategoryTheory.Bicategory.associator α.l β.l γ.l).hom | null | true |
NonAssocRing.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀... | null | false |
upperSemicontinuousOn_iff_restrict._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
UpperSemicontinuous (s.restrict f) = UpperSemicontinuousOn f s | null | false |
Matrix.nonsing_inv_apply_not_isUnit | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
¬IsUnit A.det → A⁻¹ = 0 | null | true |
_private.Init.Core.0.if_neg.match_1_1 | Init.Core | ∀ {c : Prop} (motive : Decidable c → Prop) (h : Decidable c),
(∀ (hc : c), motive (isTrue hc)) → (∀ (h : ¬c), motive (isFalse h)) → motive h | null | false |
CategoryTheory.Limits.Types.TypeMax.colimitCoconeIsColimit | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type (max v u))) →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.TypeMax.colimitCocone F) | (internal implementation) the fact that the proposed colimit cocone is the colimit | true |
NonUnitalStarSubalgebra.ofClass._proof_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : SetLike S A]
[NonUnitalSubsemiringClass S A] (s : S), 0 ∈ s | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage.0.circleAverage_log_norm_sub_const_eq_log_radius_add_posLog._simp_1_10 | Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] {a b : E} {r : ℝ}, (b ∈ Metric.sphere a r) = (‖b - a‖ = r) | null | false |
_private.Mathlib.Order.KrullDimension.0.Order.height_eq_krullDim_Iic._simp_1_3 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
Subgroup.commutator_le_focalSubgroupOf | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), commutator ↥H ≤ H.focalSubgroupOf | null | true |
instDecidableEqNzsNum | Mathlib.Data.Num.Bitwise | DecidableEq NzsNum | null | true |
BumpCovering.locallyFinite | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : BumpCovering ι X s),
LocallyFinite fun i => Function.support ⇑(f i) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Mathlib.Meta.NormNum.evalRPow.match_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | (motive :
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Lean.MetaM (Mathlib.Meta.NormNum.Result e) → Sort u_1) →
(u : Lean.Level) →
{αR : Q(Type u)} →
(e : Q(«$αR»)) →
(__alt __alt_1 : Lean.MetaM (Mathlib.Meta.NormNum.... | null | false |
tendsto_mul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M] {a b : M},
Filter.Tendsto (fun p => p.1 * p.2) (nhds (a, b)) (nhds (a * b)) | null | true |
IsHausdorff.of_isTorsionFree | Mathlib.RingTheory.AdicCompletion.Noetherian | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsNoetherianRing R] [Module.Finite R M] [IsDomain R] [Module.IsTorsionFree R M], I ≠ ⊤ → IsHausdorff I M | null | true |
Mathlib.Tactic.Peel.eventually_imp | Mathlib.Tactic.Peel | ∀ {α : Type u_1} {p q : α → Prop} {f : Filter α}, (∀ (x : α), p x → q x) → (∀ᶠ (x : α) in f, p x) → ∀ᶠ (x : α) in f, q x | null | true |
Fintype.prod_fiberwise | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} {κ : Type u_6} {ι : Type u_7} [inst : Fintype ι] [inst_1 : Fintype κ] [inst_2 : CommMonoid M]
[inst_3 : DecidableEq κ] (g : ι → κ) (f : ι → M), ∏ j, ∏ i, f ↑i = ∏ i, f i | null | true |
CategoryTheory.Abelian.mono_inr_of_isColimit | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C]
[CategoryTheory.Limits.HasPushouts C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Mono f]
{s : CategoryTheory.Limits.PushoutCocone f g} (hs : CategoryTheory.Limits.IsColimit s), CategoryTheory.Mono s.inr | null | true |
_private.Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule.0.HomogeneousSubmodule.toSubmodule_injective.match_1_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule | ∀ {ιA : Type u_1} {ιM : Type u_2} {σA : Type u_3} {σM : Type u_4} {A : Type u_5} {M : Type u_6} [inst : Semiring A]
[inst_1 : AddCommMonoid M] [inst_2 : Module A M] (𝒜 : ιA → σA) (ℳ : ιM → σM) [inst_3 : DecidableEq ιA]
[inst_4 : AddMonoid ιA] [inst_5 : SetLike σA A] [inst_6 : AddSubmonoidClass σA A] [inst_7 : Grad... | null | false |
_private.Mathlib.Analysis.Normed.Affine.Simplex.0.Affine.Simplex.scalene_reindex_iff._proof_1_4 | Mathlib.Analysis.Normed.Affine.Simplex | ∀ {m n : ℕ} (e : Fin (m + 1) ≃ Fin (n + 1)) (fst snd : Fin (m + 1)) (property : fst < snd),
e fst < e snd → e (↑⟨(fst, snd), property⟩).1 < e (↑⟨(fst, snd), property⟩).2 | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.unop._regBuiltin.Lean.Parser.Term.unop_1 | Lean.Parser.Term | IO Unit | null | false |
MeasureTheory.measure_symmDiff_eq_zero_iff | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, μ (symmDiff s t) = 0 ↔ s =ᵐ[μ] t | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor_obj | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ (Y : AlgebraicGeometry.Scheme) (I : Y.IdealSheafDataᵒᵖ),
(AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor Y).obj I =
CategoryTheory.Over.mk (Opposite.unop I).subschemeι | null | true |
HomotopicalAlgebra.FibrantObject.HoCat.localizerMorphismResolution | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences C)
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.FibrantObject.HoCat C)) | The fibrant resolution functor `HoCat.resolution`, as a localizer morphism. | true |
List.recOn.eq._@.Mathlib.Util.CompileInductive.1590845460._hygCtx._hyg.6 | Mathlib.Util.CompileInductive | @List.recOn = @List.recOn✝ | null | false |
Aesop.popGoal? | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q (Option Aesop.GoalRef) | null | true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.norm_herglotzLogIntegrand_circleMap_le | Mathlib.Analysis.Complex.JensenFormula | ∀ {w ρ : ℂ} {R r₀ r : ℝ},
0 < R →
‖ρ‖ = R →
0 < r₀ →
‖w‖ < r₀ →
r₀ ≤ r →
r ≤ R →
∀ (θ : ℝ),
0 < ‖circleMap 0 R θ - ρ‖ →
‖herglotzLogIntegrand✝ w ρ (circleMap 0 r θ)‖ ≤
(R + ‖w‖) / (r₀ - ‖w‖) *
... | null | true |
Algebra.SubmersivePresentation.ofHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : Finite σ] →
(P : Algebra.SubmersivePresentation R S ι σ) →
(R₀ : Type u_5) →
... | The submersive presentation on `P.ModelOfHasCoeffs R₀` provided `P.HasCoeffs R₀`. | true |
Lean.Meta.instReprConfig_1 | Init.Meta.Defs | Repr Lean.Meta.Simp.Config | null | true |
_private.Mathlib.Algebra.Homology.ShortComplex.PreservesHomology.0.CategoryTheory.ShortComplex.mapOpcyclesIso_hom_naturality._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃) (h₁ : S₁.RightHomologyData)
(h₂ : S₂.RightHomologyData) (h₃ : S₃.RightHomologyData),
CategoryTheory.CategoryStruct.comp (Categ... | null | false |
Valuation.ltSubmodule_monotone | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀),
Monotone v.ltSubmodule | null | true |
OrthonormalBasis.coe_equiv_euclideanSpace | 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 ι] (b : OrthonormalBasis ι 𝕜 E),
⇑((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) = fun x => ∑ i, x.ofLp i • b i | null | true |
SModEq.symm | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x y : M}, x ≡ y [SMOD U] → y ≡ x [SMOD U] | null | true |
IsMinFilter.comp_mono | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {l : Filter α} {a : α},
IsMinFilter f l a → ∀ {g : β → γ}, Monotone g → IsMinFilter (g ∘ f) l a | null | true |
_private.Mathlib.Data.Nat.Choose.Lucas.0.Choose.choose_modEq_choose_mod_mul_choose_div.match_1_4 | Mathlib.Data.Nat.Choose.Lucas | ∀ (motive : ℕ × ℕ → Prop) (h : ℕ × ℕ), (∀ (x₁ x₂ : ℕ), motive (x₁, x₂)) → motive h | null | false |
one_div_mul_eq_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), 1 / a * b = b / a | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Basic.0.MeasureTheory.Measure.zero_le_toSignedMeasure._simp_1_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, (0 ≤ μ.real s) = True | null | false |
Units.add._proof_1 | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (x : Rˣ) (t : R) (h : ‖t‖ < ‖↑x⁻¹‖⁻¹),
↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ = ↑(x * Units.oneSub (-(↑x⁻¹ * t)) ⋯)⁻¹ | null | false |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.mk.injEq | Mathlib.CategoryTheory.Localization.Predicate | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {L : CategoryTheory.Functor C D}
{W : CategoryTheory.MorphismProperty C} {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(inverts : W.IsInvertedBy L) (lift : (F : CategoryTh... | null | true |
Bifunctor.snd | Mathlib.Control.Bifunctor | {F : Type u₀ → Type u₁ → Type u₂} → [Bifunctor F] → {α : Type u₀} → {β β' : Type u₁} → (β → β') → F α β → F α β' | Right map of a bifunctor. | true |
Ideal.exists_smith_normal_form | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] [IsDomain R] [IsPrincipalIdealRing R] {S : Type u_4}
[inst_3 : CommRing S] [IsDomain S] [inst_5 : Algebra R S] [Finite ι] (b : Module.Basis ι R S) (I : Ideal S),
I ≠ ⊥ → ∃ b' a ab', ∀ (i : ι), ↑(ab' i) = a i • b' i | If `S` a finite-dimensional ring extension of a PID `R` which is free as an `R`-module,
then any nonzero `S`-ideal `I` is free as an `R`-submodule of `S`, and we can
find a basis for `S` and `I` such that the inclusion map is a square diagonal
matrix.
See also `Ideal.smithNormalForm` for a version of this theorem that... | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyPartition_eq._simp_1_2 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
Rat.instEncodable.match_5 | Mathlib.Data.Rat.Encodable | ∀ (motive : (n : ℤ) × { d // 0 < d ∧ n.natAbs.Coprime d } → Prop) (x : (n : ℤ) × { d // 0 < d ∧ n.natAbs.Coprime d }),
(∀ (fst : ℤ) (val : ℕ) (left : 0 < val) (right : fst.natAbs.Coprime val), motive ⟨fst, ⟨val, ⋯⟩⟩) → motive x | null | false |
Lean.mkAppRange | Lean.Expr | Lean.Expr → ℕ → ℕ → Array Lean.Expr → Lean.Expr | `mkAppRange f i j #[a_1, ..., a_i, ..., a_j, ... ]` ==> the expression `f a_i ... a_{j-1}` | true |
Std.TreeSet.Raw.size_le_size_erase | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.size ≤ (t.erase k).size + 1 | null | true |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.of_isStableUnderColimitsOfShape.mem_map_bot_le | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {J : Type w}
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J] {X Y : C} {f : X ⟶ Y}
(hf : W.TransfiniteCompositionOfShape J f) [W.IsMultiplicative],
(∀ (J : Type w) [ins... | null | true |
MeasureTheory.UniformIntegrable.memLp_of_ae_tendsto | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{p : ENNReal} {κ : Type u_4} {u : Filter κ} [u.NeBot] [u.IsCountablyGenerated] {f : κ → α → β} {g : α → β},
MeasureTheory.UniformIntegrable f p μ →
(∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun n => f n x) ... | Suppose `f` is a sequence of functions that converges a.e. to `g`. If `f` is
`UniformIntegrable`, then `g` is in `Lp`. | true |
_private.Aesop.Builder.Forward.0.Aesop.RuleBuilder.getImmediatePremises._sparseCasesOn_1 | Aesop.Builder.Forward | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) → motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
Std.DTreeMap.Raw.Const.mem_insertManyIfNewUnit_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α (fun x => Unit) cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp],
t.WF → ∀ {l : List α} {k : α}, k ∈ Std.DTreeMap.Raw.Const.insertManyIfNewUnit t l ↔ k ∈ t ∨ l.contains k = true | null | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.asymptoticCone_closure._simp_1_2 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (x ∈ closure s) = ∃ᶠ (x : X) in nhds x, x ∈ s | null | false |
Set.infinite_of_injective_forall_mem | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} [Infinite α] {s : Set β} {f : α → β},
Function.Injective f → (∀ (x : α), f x ∈ s) → s.Infinite | null | true |
Vector.findSome?_isSome_iff | Init.Data.Vector.Find | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → Option β} {xs : Vector α n},
(Vector.findSome? f xs).isSome = true ↔ ∃ x ∈ xs, (f x).isSome = true | null | true |
IntCast.rec | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → ((intCast : ℤ → R) → motive { intCast := intCast }) → (t : IntCast R) → motive t | null | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_isClosed_diagonal._simp_1_4 | Mathlib.Topology.Separation.Hausdorff | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
CategoryTheory.Comon.comp_hom' | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N K : CategoryTheory.Comon C} (f : M ⟶ N) (g : N ⟶ K),
(CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom | null | true |
Set.Icc.coeMonoidWithZeroHom._proof_2 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R], ↑1 = ↑1 | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doNested._regBuiltin.Lean.Parser.Term.doNested.declRange_3 | Lean.Parser.Do | IO Unit | null | false |
QuadraticForm.radical_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {𝕜 : Type u_1} {ι : Type u_2} [inst : Field 𝕜] [NeZero 2] [inst_2 : Fintype ι] {w : ι → 𝕜},
(QuadraticMap.weightedSumSquares 𝕜 w).radical = Pi.spanSubset 𝕜 {i | w i = 0} | Over a field of characteristic different from `2`,
the radical of a weighted-sum-of-squares quadratic form is the number of zero weights. | true |
Std.Rxi.HasSize.rec | Init.Data.Range.Polymorphic.Basic | {α : Type u} →
{motive : Std.Rxi.HasSize α → Sort u_1} →
((size : α → ℕ) → motive { size := size }) → (t : Std.Rxi.HasSize α) → motive t | null | false |
MeasureTheory.IsAddFundamentalDomain.integral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α]
[MeasureTheory.VAddInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureT... | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.mk | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
(φQ : h₁.Q ⟶ h₂.Q) →
... | null | true |
AlgebraicGeometry.Scheme.affineOpenCoverOfSpanRangeEqTop._proof_3 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {R : CommRingCat} {ι : Type u_1} (s : ι → ↑R),
Ideal.span (Set.range s) = ⊤ → ∀ (x : ↥(AlgebraicGeometry.Spec R)), ∃ i, s i ∉ x.asIdeal | null | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.rotate_eq_iff | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {n : ℕ} {x y : BitVec n}, BitVec.Signed.rotate✝ x = y ↔ x = BitVec.Signed.rotate✝ y | null | true |
Submodule.starProjection_inj | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E} [inst_3 : U.HasOrthogonalProjection] [inst_4 : V.HasOrthogonalProjection],
U.starProjection = V.starProjection ↔ U = V | `U.starProjection = V.starProjection` iff `U = V`. | true |
BiheytingHom.id_comp | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (f : BiheytingHom α β),
(BiheytingHom.id β).comp f = f | null | true |
_private.Batteries.Data.String.Lemmas.0.String.foldlAux_of_valid.match_1_1 | Batteries.Data.String.Lemmas | ∀ {α : Type u_1} (motive : List Char → List Char → List Char → α → Prop) (x x_1 x_2 : List Char) (x_3 : α),
(∀ (l r : List Char) (a : α), motive l [] r a) →
(∀ (l : List Char) (c : Char) (m r : List Char) (a : α), motive l (c :: m) r a) → motive x x_1 x_2 x_3 | null | false |
BoundedLatticeHom.toInfTopHom | Mathlib.Order.Hom.BoundedLattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Lattice α] →
[inst_1 : Lattice β] →
[inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedLatticeHom α β → InfTopHom α β | null | true |
SSet.Edge.map_id | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X Y : SSet} (x₀ : X.obj (Opposite.op { len := 0 })) (f : X ⟶ Y),
(SSet.Edge.id x₀).map f = SSet.Edge.id ((CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op { len := 0 }))) x₀) | null | true |
_private.Std.Data.String.ToNat.0.noRepetition_iff | Std.Data.String.ToNat | ∀ {α : Type u} {a : α} {l : List α}, NoRepetition✝ a l ↔ ¬[a, a] <:+: l | null | true |
Convexity.convexCombPair_one | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R : Type u_1} {M : Type u_3} [inst : PartialOrder R] [inst_1 : Semiring R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : Convexity.ConvexSpace R M] {x y : M}, Convexity.convexCombPair 1 0 ⋯ ⋯ ⋯ x y = x | A binary convex combination with weight 1 on the first point returns the first point. | true |
GroupExtension.Equiv.ofMonoidHom._proof_6 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_4} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_1} [inst_2 : Group E]
{S : GroupExtension N E G} {E' : Type u_3} [inst_3 : Group E'] {S' : GroupExtension N E' G} (f : E →* E'),
S'.rightHom.comp f = S.rightHom → ⇑(S'.rightHom.comp f) = ⇑S.rightHom | null | false |
EisensteinSeries.r1.eq_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), EisensteinSeries.r1 z = z.im ^ 2 / (z.re ^ 2 + z.im ^ 2) | null | true |
Std.DHashMap.Internal.Raw₀.equiv_emptyWithCapacity_iff_isEmpty | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {c : ℕ}, (↑m).Equiv ↑(Std.DHashMap.Internal.Raw₀.emptyWithCapacity c) ↔ (↑m).isEmpty = true | null | true |
LinearEquiv.automorphismGroup.toLinearMapMonoidHom._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x x_1 : M ≃ₗ[R] M), ↑(x * x_1) = ↑(x * x_1) | null | false |
Mathlib.Tactic.ClickSuggestions.ApplyKey._sizeOf_1 | Mathlib.Tactic.ClickSuggestions.Apply | Mathlib.Tactic.ClickSuggestions.ApplyKey → ℕ | null | false |
CategoryTheory.Limits.Cofork.IsColimit.homIso_natural | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Cofork f g}
{Z Z' : C} (q : Z ⟶ Z') (ht : CategoryTheory.Limits.IsColimit t) (k : t.pt ⟶ Z),
↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp k q)) =
CategoryThe... | The bijection of `Cofork.IsColimit.homIso` is natural in `Z`. | true |
continuousWithinAt_iff_continuous_left'_right'._to_dual_1 | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace β]
{s : Set α} {a : α} {f : α → β},
ContinuousWithinAt f s a ↔ ContinuousWithinAt f (s ∩ Set.Ioi a) a ∧ ContinuousWithinAt f (s ∩ Set.Iio a) a | null | false |
_private.Mathlib.Tactic.Lift.0.Mathlib.Tactic.Lift.main.match_3 | Mathlib.Tactic.Lift | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(newVarName : Option (Lean.TSyntax `ident)) →
((v : Lean.TSyntax `ident) → motive (some v)) → (Unit → motive none) → motive newVarName | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.