name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Convex.convex_remove_iff_notMem_convexHull_remove | Mathlib.Analysis.Convex.Hull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s : Set E}, Convex 𝕜 s → ∀ (x : E), Convex 𝕜 (s \ {x}) ↔ x ∉ (convexHull 𝕜) (s \ {x}) | null | true |
_private.Mathlib.Order.Partition.Basic.0.Partition.instSemilatticeInf._proof_17 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} [inst : Order.Frame α] (s : α) (Q R : Partition s) (a q : α),
q ∈ Q ∧ a ≤ q → ∀ (r : α), r ∈ R ∧ a ≤ r → q ⊓ r ∈ {a | ∃ p ∈ Q, ∃ q ∈ R, a = p ⊓ q} | null | false |
Submonoid.fromLeftInv.eq_1 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (x : ↥S.leftInv), S.fromLeftInv x = Exists.choose ⋯ | null | true |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.Entry.import.unsafe_impl_2 | Mathlib.Tactic.TacticAnalysis | Mathlib.TacticAnalysis.Entry → Lean.Environment → Lean.Options → ExceptT String Id Mathlib.TacticAnalysis.Config | null | true |
CategoryTheory.Adjunction.CoreUnitCounit.mk | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
(unit : CategoryTheory.Functor.id C ⟶ F.comp G) →
(counit : G.comp F... | null | true |
Std.WP.WPConjunctive | Std.WP.Conjunctive | {Prog : Type u} →
{Value : outParam (Type v)} →
{Pred : outParam (Type w)} →
{EPred : outParam (Type z)} →
[inst : Std.WP.Assertion Pred] →
[inst_1 : Std.WP.Assertion EPred] → [Std.WP.WP Prog Value Pred EPred] → Prog → Prop | `wp x` is sub-conjunctive: the meet of the weakest preconditions of two postconditions lies
below the weakest precondition of the componentwise meet of the postconditions. A healthiness
condition of the `WP` interpretation for the individual program `x`; it holds for the base
interpretations and lifts through the trans... | true |
GroupSeminorm.instSMul._proof_4 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {E : Type u_2} [inst : Group E] [inst_1 : SMul R ℝ] (r : R) (p : GroupSeminorm E) (x : E),
r • p x⁻¹ = r • p x | null | false |
Continuous.stronglyMeasurableAtFilter | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : TopologicalSpace α] [OpensMeasurableSpace α]
[inst_2 : TopologicalSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [SecondCountableTopologyEither α β]
{f : α → β}, Continuous f → ∀ (μ : MeasureTheory.Measure α) (l : Filter α), StronglyMeasurableAtF... | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.AntitoneOn.summable_of_integrableOn_Ioi._proof_1_2 | Mathlib.Analysis.SumIntegralComparisons | ∀ {f : ℝ → ℝ} {N : ℕ} (M : ℕ), ∑ i ∈ Finset.range M, f ↑(i + (N + 1)) = ∑ k ∈ Finset.range (N + M - N), f ↑(N + k + 1) | null | false |
liminf_eq_top | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [FirstCountableTopology α]
[OrderTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}, Filter.liminf u f = ⊤ ↔ u =ᶠ[f] ⊤ | null | true |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Contraction.0.CliffordAlgebra.«term_⌋__1» | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | Lean.TrailingParserDescr | null | true |
WithLp.instProdNorm | Mathlib.Analysis.Normed.Lp.ProdLp | (p : ENNReal) → (α : Type u_2) → (β : Type u_3) → [Norm α] → [Norm β] → Norm (WithLp p (α × β)) | Endowing the space `WithLp p (α × β)` with the `L^p` norm. We register this instance
separate from `WithLp.instProdSeminormedAddCommGroup` since the latter requires the type class
hypothesis `[Fact (1 ≤ p)]` in order to prove the triangle inequality.
Registering this separately allows for a future norm-like structure ... | true |
CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim._proof_5 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_3} {K : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} J]
[inst_1 : CategoryTheory.Category.{u_2, u_4} K] {C : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [CategoryTheory.Limits.HasColimitsOfShape J C]
[CategoryTheory.Li... | null | false |
AddMonoidHom.surjective_of_surjective_of_injective_of_left_exact | Mathlib.Algebra.FiveLemma | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {M₃ : Type u_3} {N₁ : Type u_6} {N₂ : Type u_7} {N₃ : Type u_8} [inst : AddGroup M₁]
[inst_1 : AddGroup M₂] [inst_2 : AddGroup M₃] [inst_3 : AddGroup N₁] [inst_4 : AddGroup N₂] [inst_5 : AddGroup N₃]
(f₁ : M₁ →+ M₂) (f₂ : M₂ →+ M₃) (g₁ : N₁ →+ N₂) (g₂ : N₂ →+ N₃) (i₁ : M₁ →+ N₁) (i... | A special case of one four lemma such that the left-most term is zero in terms
of additive groups. For a diagram explaining the variables, see the module docstring. | true |
BoundedContinuousFunction.mk.inj | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} {inst : TopologicalSpace α} {inst_1 : PseudoMetricSpace β} {toContinuousMap : C(α, β)}
{map_bounded' : ∃ C, ∀ (x y : α), dist (toContinuousMap.toFun x) (toContinuousMap.toFun y) ≤ C}
{toContinuousMap_1 : C(α, β)}
{map_bounded'_1 : ∃ C, ∀ (x y : α), dist (toContinuousMap_1.toFun x) (toC... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.ncard_incidenceSet._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {α : Type u_1} (s : Set α) [inst : Fintype ↑s], s.ncard = Fintype.card ↑s | null | false |
Subgroup.leftCosetEquivSubgroup._proof_8 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} (g : α) (x : ↥s), ⟨g⁻¹ * ↑⟨g * ↑x, ⋯⟩, ⋯⟩ = x | null | false |
CategoryTheory.Equivalence.preregular_isSheaf_iff | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preregular C] (A : Type u_3)
[inst_3 : CategoryTheory.Category.{v_3, u_3} A] (e : C ≌ D) (F : CategoryTheory.Functor Cᵒᵖ A),
CategoryTheory.Presheaf.IsSheaf (Categ... | The regular sheaf condition can be checked after precomposing with the equivalence.
| true |
Asymptotics.IsBigOWith.congr_left | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {g : α → F} {l : Filter α}
{f₁ f₂ : α → E}, Asymptotics.IsBigOWith c l f₁ g → (∀ (x : α), f₁ x = f₂ x) → Asymptotics.IsBigOWith c l f₂ g | null | true |
T35Space.toT0Space | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} {inst : TopologicalSpace X} [self : T35Space X], T0Space X | null | true |
DistribMulActionHomClass | Mathlib.GroupTheory.GroupAction.Hom | (F : Type u_10) →
(M : outParam (Type u_11)) →
(A : outParam (Type u_12)) →
(B : outParam (Type u_13)) →
[inst : Monoid M] →
[inst_1 : AddMonoid A] →
[inst_2 : AddMonoid B] → [DistribMulAction M A] → [DistribMulAction M B] → [FunLike F A B] → Prop | `DistribMulActionHomClass F M A B` states that `F` is a type of morphisms preserving
the additive monoid structure and equivariant with respect to the action of `M`.
It is an abbreviation to `DistribMulActionHomClass F (MonoidHom.id M) A B`
You should extend this class when you extend `DistribMulActionHom`. | true |
Function.RightInverse.eq | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {g : β → α} {f : α → β}, Function.RightInverse g f → ∀ (x : β), f (g x) = x | null | true |
Lean.Doc.Parser.instOrdUnorderedListType.match_1 | Lean.DocString.Parser | (motive : Lean.Doc.Parser.UnorderedListType → Lean.Doc.Parser.UnorderedListType → Sort u_1) →
(x x_1 : Lean.Doc.Parser.UnorderedListType) →
(Unit → motive Lean.Doc.Parser.UnorderedListType.asterisk Lean.Doc.Parser.UnorderedListType.asterisk) →
((x : Lean.Doc.Parser.UnorderedListType) → motive Lean.Doc.Parse... | null | false |
Polynomial.X_pow_sub_one_eq_prod | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R} {n : ℕ},
0 < n →
IsPrimitiveRoot ζ n → Polynomial.X ^ n - 1 = ∏ ζ ∈ Polynomial.nthRootsFinset n 1, (Polynomial.X - Polynomial.C ζ) | If there is a primitive `n`th root of unity in `K`, then `X ^ n - 1 = ∏ (X - μ)`, where `μ`
varies over the `n`-th roots of unity. | true |
_private.Mathlib.RingTheory.MvPolynomial.Groebner.0.MonomialOrder.degree_reduce_lt._simp_1_5 | Mathlib.RingTheory.MvPolynomial.Groebner | ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, (a ⊔ b ≤ c) = (a ≤ c ∧ b ≤ c) | null | false |
Lean.Elab.Tactic.Grind.SavedState | Lean.Elab.Tactic.Grind.Basic | Type | null | true |
SetRel.isCover_id | Mathlib.Basic.Rel.Cover | ∀ {X : Type u_1} {s N : Set X}, SetRel.id.IsCover s N ↔ s ⊆ N | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_insertManyIfNewUnit_list_of_mem._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
HomologicalComplex.truncGE'.XIso.congr_simp | Mathlib.Algebra.Homology.Embedding.TruncGE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : ∀ (i' : ι'), K.HasHomology i'] {i : ι}
(hi : ¬e.BoundaryGE i), ... | null | true |
ContinuousLinearMap.lTensor_comp_commIsometry | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} (G : Type u_4) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G] (f : E →L[𝕜] F),
ContinuousLinear... | null | true |
MonoidAlgebra.mul_single_apply_of_not_exists_mul | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : Mul M] (r : R) {g g' : M} (x : MonoidAlgebra R M),
(¬∃ d, g' = d * g) → (x * MonoidAlgebra.single g r).coeff g' = 0 | null | true |
IO.Error.noSuchThing | Init.System.IOError | Option String → UInt32 → String → IO.Error | A required resource does not exist.
This corresponds to the POSIX errors `ENXIO`, `EHOSTUNREACH`, `ENETUNREACH`, `ECHILD`,
`ECONNREFUSED`, `ENODATA`, `ENOMSG`, and `ESRCH`.
| true |
Std.Http.Protocol.H1.Writer.rec | Std.Http.Protocol.H1.Writer | {dir : Std.Http.Protocol.H1.Direction} →
{motive : Std.Http.Protocol.H1.Writer dir → Sort u} →
((userData : Array Std.Http.Chunk) →
(outputData : Std.Http.Internal.ChunkedBuffer) →
(state : Std.Http.Protocol.H1.Writer.State) →
(knownSize : Option Std.Http.Body.Length) →
... | null | false |
CentroidHom.copy._proof_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α) (f' : α → α),
f' = ⇑f → ∀ (a b : α), f' (a * b) = a * f' b | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionAssocIso_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (c c' : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.... | null | true |
RingEquiv.ofLeftInverse._proof_4 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {f : R →+* S} (x y : R),
(↑↑f.rangeRestrict).toFun (x + y) = (↑↑f.rangeRestrict).toFun x + (↑↑f.rangeRestrict).toFun y | null | false |
Lean.Meta.DiscrTree.Key.format | Lean.Meta.DiscrTree.Basic | Lean.Meta.DiscrTree.Key → Std.Format | null | true |
CategoryTheory.CommSq.shortComplex'_X₁ | Mathlib.Algebra.Homology.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X₁ X₂ X₃ X₄ : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X₂ X₃] {fst : X₁ ⟶ X₂} {snd : X₁ ⟶ X₃} {f : X₂ ⟶ X₄} {g : X₃ ⟶ X₄}
(sq : CategoryTheory.CommSq fst snd f g), sq.shortComplex'.X₁ = X₁ | null | true |
_private.Mathlib.Algebra.Group.Subsemigroup.Basic.0.MulHom.ofDense._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Lean.Elab.Command.instMonadEvalTermElabMCommandElabM | Lean.Elab.Command | MonadEval Lean.Elab.TermElabM Lean.Elab.Command.CommandElabM | null | true |
CategoryTheory.Iso.hom_inv_id_triangle_hom₂ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{A B : CategoryTheory.Pretriangulated.Triangle C} (e : A ≅ B),
CategoryTheory.CategoryStruct.comp e.hom.hom₂ e.inv.hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ | null | true |
IsSimpleOrder.completeBooleanAlgebra | Mathlib.Order.Atoms | {α : Type u_2} → [inst : Lattice α] → [inst_1 : BoundedOrder α] → [IsSimpleOrder α] → CompleteBooleanAlgebra α | A simple `BoundedOrder` is also a `CompleteBooleanAlgebra`. | true |
Algebra.Extension.toBaseChange._proof_2 | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Extension R S} (T : Type u_4) [inst_3 : CommRing T] [inst_4 : Algebra R T] (x : P.Ring),
(algebraMap P.baseChange.Ring (TensorProduct R T S)) (Algebra.TensorProduct.includeRight.toRingHom x) =
(algebraM... | null | false |
_private.Init.Data.List.Perm.0.List.perm_iff_count._simp_1_3 | Init.Data.List.Perm | ∀ {a b : ℕ}, (a.succ = b.succ) = (a = b) | null | false |
LinearEquiv.congrLeft_symm_apply | Mathlib.Algebra.Module.Equiv.Basic | ∀ (M : Type u_5) {M₂ : Type u_7} {M₃ : Type u_8} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] {R : Type u_9} (S : Type u_10) [inst_3 : Semiring R] [inst_4 : Semiring S]
[inst_5 : Module R M₂] [inst_6 : Module R M₃] [inst_7 : Module R M] [inst_8 : Module S M]
[inst_9 : SMulCommC... | null | true |
_private.Init.Data.Array.Lemmas.0.Array.toList_reverse._simp_1_7 | Init.Data.Array.Lemmas | ∀ (n : ℕ), (n ≤ n) = True | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_43 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Comma.isCardinalAccessibleCategory.J.mk._proof_1 | Mathlib.CategoryTheory.Presentable.Comma | ∀ {C₁ : Type u_3} {C₂ : Type u_4} {D : Type u_6} [inst : CategoryTheory.Category.{u_1, u_3} C₁]
[inst_1 : CategoryTheory.Category.{u_2, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{F₁ : CategoryTheory.Functor C₁ D} {F₂ : CategoryTheory.Functor C₂ D} {κ : Cardinal.{u_7}} [inst_3 : Fact κ.IsRegular]
{f... | null | false |
Equiv.embeddingFinSucc_snd | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {ι : Type u_1} (e : Fin (n + 1) ↪ ι), ↑((Equiv.embeddingFinSucc n ι) e).snd = e 0 | null | true |
CommRingCat.HomTopology.precompHomeomorph._proof_4 | Mathlib.Algebra.Category.Ring.Topology | ∀ {R A B : CommRingCat} [inst : TopologicalSpace ↑R] (f : A ≅ B),
Continuous fun x => CategoryTheory.CategoryStruct.comp f.inv x | null | false |
CategoryTheory.Functor.instPreservesEffectiveEpiFamiliesOfIsEquivalence | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) [F.IsEquivalence],
F.PreservesEffectiveEpiFamilies | null | true |
MultipliableLocallyUniformly.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] (f : ι → β → α) [inst_1 : UniformSpace α]
[inst_2 : TopologicalSpace β], MultipliableLocallyUniformly f = ∃ g, HasProdLocallyUniformly f g | null | true |
BoundedContinuousFunction.compContinuousCLM._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} (β : Type u_2) {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
[inst_2 : TopologicalSpace γ] (g : C(γ, α)) (x y : BoundedContinuousFunction α β),
(x + y).compContinuous g = x.compContinuous g + y.compContinuous g | null | false |
_private.Mathlib.RingTheory.RingHom.Locally.0.RingHom.locally_stableUnderComposition._simp_1_8 | Mathlib.RingTheory.RingHom.Locally | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) | null | false |
CategoryTheory.Limits.Cone.extendHom | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(s : CategoryTheory.Limits.Cone F) → {X : C} → (f : X ⟶ s.pt) → s.extend f ⟶ s | There is a morphism from an extended cone to the original cone. | true |
AdjoinRoot.nontrivial_iff_of_monic | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R}, f.Monic → (Nontrivial (AdjoinRoot f) ↔ 0 < f.degree) | null | true |
DirectLimit.instGroup._proof_8 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → Group (G i)] [∀ (i j : ι) (h : i ≤ j), MonoidHomClass (T h) (G i) (G j)] (n : ℤ) (x x_1 : ι)
(x_2 : ... | null | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.NonemptyCompacts.isPreconnected_Icc._simp_1_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α], {⊥}ᶜ = Set.Ioi ⊥ | null | false |
_private.Mathlib.Logic.Relation.0.Relation.reflTransGen_transGen._simp_1_1 | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop}, Relation.ReflTransGen r = Relation.ReflGen (Relation.TransGen r) | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.precheckMatch.match_9 | Lean.Elab.Match | (motive : Option (Array (Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Array (Lean.TSyntax `term) × Lean.TSyntax `term))) →
((tuples : Array (Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → motive (some tuples)) →
(Unit → motive none) → motive x | null | false |
Batteries.Tactic.generalizeProofsElab | Batteries.Tactic.GeneralizeProofs | Lean.ParserDescr | `generalize_proofs ids* [at locs]?` generalizes proofs in the current goal,
turning them into new local hypotheses.
- `generalize_proofs` generalizes proofs in the target.
- `generalize_proofs at h₁ h₂` generalized proofs in hypotheses `h₁` and `h₂`.
- `generalize_proofs at *` generalizes proofs in the entire local co... | true |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.stabilizer_orbit_eq._simp_1_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {a : α} {g : G},
(g • a = a) = (g ∈ MulAction.stabilizer G a) | null | false |
lp.instInvolutiveStar._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)]
[inst_1 : (i : α) → StarAddMonoid (E i)] [inst_2 : ∀ (i : α), NormedStarGroup (E i)] (x : ↥(lp E p)),
star (star x) = x | null | false |
_private.Mathlib.Analysis.CStarAlgebra.Extreme.0.isStarProjection_iff_mem_extremePoints_setOfPred_nonneg_inter_unitClosedBall._simp_1_12 | Mathlib.Analysis.CStarAlgebra.Extreme | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Std.DHashMap.Internal.Raw₀.reinsertAux_eq | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α] (data : { d // 0 < d.size }) (a : α) (b : β a),
↑(Std.DHashMap.Internal.Raw₀.reinsertAux hash data a b) =
Std.DHashMap.Internal.updateBucket ↑data ⋯ a fun l => Std.DHashMap.Internal.AssocList.cons a b l | null | true |
Matrix.linfty_opNorm_replicateCol | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {α : Type u_5} {ι : Type u_7} [inst : Fintype m] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : m → α), ‖Matrix.replicateCol ι v‖ = ‖v‖ | null | true |
Lean.Grind.CommRing.instReprPoly.repr._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Std.Format | null | false |
_private.Init.Data.String.Legacy.0.String.splitAux._unary._proof_1 | Init.Data.String.Legacy | ∀ (s : String) (i : String.Pos.Raw),
¬String.Pos.Raw.atEnd s i = true → s.utf8ByteSize - (String.Pos.Raw.next s i).byteIdx < s.utf8ByteSize - i.byteIdx | null | false |
_private.Batteries.Data.List.Lemmas.0.List.foldlIdx_const._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_2} {α_1 : Type u_1} {f : α_1 → α → α_1} {i : α_1} {s : ℕ},
List.foldlIdx (Function.const ℕ f) i [] s = List.foldl f i [] | null | false |
AbsoluteValue.toNormedRing._proof_7 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_1} [inst : Ring R] (v : AbsoluteValue R ℝ) (x y : R),
ENNReal.ofReal (v (-x + y)) = ENNReal.ofReal (v (-x + y)) | null | false |
Equiv.Finset.prod._proof_7 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_2} {β : Type u_1} (s : Finset α) (t : Finset β) (x : ↥s × ↥t), (↑⟨(↑x.1, ↑x.2), ⋯⟩).2 ∈ t | null | false |
CategoryTheory.Equivalence.faithful_inverse | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {E : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} E]
(e : C ≌ E), e.inverse.Faithful | null | true |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.mk | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} → (base : X.base ⟶ Y.base) → ((F.map base.toLoc).toFunctor.obj X.fiber ⟶ Y.fiber) → X.Hom Y | null | true |
instRingUniversalEnvelopingAlgebra._aux_43 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → ℤ → UniversalEnvelopingAlgebra R L | null | false |
CategoryTheory.Precoverage.Saturate.hcongr_5 | Mathlib.CategoryTheory.Sites.Coverage | ∀ (C C' : Type u_1),
C = C' →
∀ (inst : CategoryTheory.Category.{u_2, u_1} C) (inst' : CategoryTheory.Category.{u_2, u_1} C'),
inst ≍ inst' →
∀ (J : CategoryTheory.Precoverage C) (J' : CategoryTheory.Precoverage C'),
J ≍ J' →
∀ (X : C) (X' : C'),
X ≍ X' →
... | null | true |
_private.Mathlib.Analysis.Calculus.Implicit.0.HasStrictFDerivAt.implicitToOpenPartialHomeomorph._proof_1 | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {F : Type u_1} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace 𝕜 F] [FiniteDimensional 𝕜 F], CompleteSpace F | null | false |
AlgebraicGeometry.Scheme.Modules.pushforwardCongr._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} {f g : X ⟶ Y}, f = g → g.base = f.base | null | false |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.RingCompute.cast.match_3 | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} →
{R : Q(Type u)} →
{sR : Q(CommSemiring «$R»)} →
(r : Q(«$R»)) →
(motive :
Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.Common.ExSum Mathlib.Tactic.Ring.RatCoeff sR)
q(«$r») →
Sort u_1) →
(x :
Mathlib.Tacti... | null | false |
Subgroup.map_map | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {N : Type u_4} [inst_1 : Group N] {P : Type u_5} [inst_2 : Group P]
(g : N →* P) (f : G →* N), Subgroup.map g (Subgroup.map f K) = Subgroup.map (g.comp f) K | null | true |
HasContDiffBump.rec | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{motive : HasContDiffBump E → Sort u} →
((out : Nonempty (ContDiffBumpBase E)) → motive ⋯) → (t : HasContDiffBump E) → motive t | null | false |
AddCommute.on_refl | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} {S : Type u_3} [inst : Add S] {f : G → S}, Std.Refl fun a b => AddCommute (f a) (f b) | null | true |
Std.DTreeMap.Internal.Impl.isEmpty_filter!_key_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] {f : α → Bool},
t.WF →
((Std.DTreeMap.Internal.Impl.filter! (fun a x => f a) t).isEmpty = true ↔
∀ (k : α) (h : Std.DTreeMap.Internal.Impl.contains k t = true), f (t.getKey k h) = false) | null | true |
CategoryTheory.MonoidalCategory.tensor._proof_4 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y Z : C × C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.comp f g).1
(CategoryTheory.CategoryStruct.comp f g).2 =
CategoryTheory.Catego... | null | false |
CategoryTheory.Codiscrete.recOn | Mathlib.CategoryTheory.CodiscreteCategory | {α : Type u} →
{motive : CategoryTheory.Codiscrete α → Sort u_1} →
(t : CategoryTheory.Codiscrete α) → ((as : α) → motive { as := as }) → motive t | null | false |
ImportGraph.Shake.Bitset.instToJson.toJson | ImportGraph.Shake.Basic | ImportGraph.Shake.Bitset → Lean.Json | null | true |
Inclusion.InclusionConfig.paramSettings._default | Mathlib.Tactic.Inclusion.Core.Core | Lean.NameMap Lean.Expr | null | false |
Lean.Meta.DefEqContext.localInstances | Lean.Meta.Basic | Lean.Meta.DefEqContext → Lean.LocalInstances | null | true |
AlgebraicGeometry.instLocallyOfFinitePresentationFstScheme | Mathlib.AlgebraicGeometry.Morphisms.FinitePresentation | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [AlgebraicGeometry.LocallyOfFinitePresentation g],
AlgebraicGeometry.LocallyOfFinitePresentation (CategoryTheory.Limits.pullback.fst f g) | null | true |
_private.Mathlib.Topology.Order.WithTop.0.TopologicalSpace.instSecondCountableTopologyWithTop._proof_2 | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : Preorder ι], (∃ x, Set.Ioi x = ∅) → ∃ x, Set.Ioi x = ∅ | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBSet.upperBoundP?_exists._simp_1_3 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : RBTree.RBSet α cmp},
(x ∈ t) = ∃ y ∈ t.toList, cmp x y = Ordering.eq | null | false |
Lean.Meta.letTelescope | Lean.Meta.Basic | {n : Type → Type u_1} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
{α : Type} →
Lean.Expr →
(Array Lean.Expr → Lean.Expr → n α) → optParam Bool false → optParam Bool true → optParam Bool false → n α | Given `e` of the form `let x₁ := v₁; ...; let xₙ := vₙ; A`, executes `k xs A`,
where `xs` is an array of free variables for the binders.
The `let`s can also be `have`s.
- If `cleanupAnnotations` is `true`, applies `Expr.cleanupAnnotations` to each type in the telescope.
- If `preserveNondep` is `false`, all `have`s ar... | true |
_private.Mathlib.Order.Partition.Basic.0.Partition.instSemilatticeInf.match_15 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} [inst : Order.Frame α] (s : α) (Q : Partition s) (a : α) (motive : (∃ y ∈ Q, a ≤ y) → Prop)
(x : ∃ y ∈ Q, a ≤ y), (∀ (q : α) (hq : q ∈ Q ∧ a ≤ q), motive ⋯) → motive x | null | false |
ImportGraph.Lean.Import.FormatBehavior.ctorElim | ImportGraph.Imports.Pretty | {motive : ImportGraph.Lean.Import.FormatBehavior → Sort u} →
(ctorIdx : ℕ) →
(t : ImportGraph.Lean.Import.FormatBehavior) →
ctorIdx = t.ctorIdx → ImportGraph.Lean.Import.FormatBehavior.ctorElimType ctorIdx → motive t | null | false |
Std.ExtDHashMap.contains_congr | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a b : α}, (a == b) = true → m.contains a = m.contains b | null | true |
Ergodic | Mathlib.Dynamics.Ergodic.Ergodic | {α : Type u_1} → {m : MeasurableSpace α} → (α → α) → autoParam (MeasureTheory.Measure α) Ergodic._auto_1 → Prop | A map `f : α → α` is said to be ergodic with respect to a measure `μ` if it is measure
preserving and pre-ergodic. | true |
Filter.Tendsto.isCompact_insert_range_of_cocompact | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {y : Y},
Filter.Tendsto f (Filter.cocompact X) (nhds y) → Continuous f → IsCompact (insert y (Set.range f)) | null | true |
Fin.rxiHasSize_eq | Init.Data.Range.Polymorphic.Fin | ∀ {n : ℕ}, Std.Rxi.HasSize.size = fun lo => n - ↑lo | null | true |
CategoryTheory.sum_whiskerRight | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C] {Q R : C} {J : Type u_2}
(s : Finset J) (g : J → (Q ⟶ R)) (P : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (∑ j ∈ s,... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_erase_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
IsOpen.isConnected_iff_isPathConnected | Mathlib.Topology.Connected.LocallyPathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocallyPathConnectedSpace X] {U : Set X},
IsOpen U → (IsConnected U ↔ IsPathConnected U) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.