name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Functor.CoconeTypes.precompose_ι | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} (c : F.CoconeTypes)
{G : CategoryTheory.Functor J (Type w₀')} (app : (j : J) → G.obj j → F.obj j)
(naturality :
∀ {j j' : J} (f : j ⟶ j'),
app j' ∘ ⇑(CategoryTheory.ConcreteCategory.hom (G.map f)) =
⇑... | null | true |
MagmaCat.of.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ (M : Type u) [inst : Mul M], MagmaCat.of M = { carrier := M, str := inst } | null | true |
_private.Lean.Environment.0.Lean.RealizationContext | Lean.Environment | Type | Context for `realizeConst` established by `enableRealizationsForConst`. | true |
BoolAlg.hom_id | Mathlib.Order.Category.BoolAlg | ∀ {X : BoolAlg}, BoolAlg.Hom.hom (CategoryTheory.CategoryStruct.id X) = BoundedLatticeHom.id ↑X | null | true |
AddLocalization.addEquivOfQuotient_mk | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
{f : S.LocalizationMap N} (x : M) (y : ↥S),
(AddLocalization.addEquivOfQuotient f) (AddLocalization.mk x y) = f.mk' x y | null | true |
LipschitzWith.mul_edist_le | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x y : α), (↑K)⁻¹ * edist (f x) (f y) ≤ edist x y | null | true |
CompactlySupportedContinuousMap.integralPositiveLinearMap._proof_2 | Mathlib.MeasureTheory.Integral.CompactlySupported | ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOrderedAddMonoid (CompactlySupportedContinuousMap X ℝ) | null | false |
Path.Homotopic.hpath_hext | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} {p₁ : Path x₀ x₁} {p₂ : Path x₂ x₃},
(∀ (t : ↑unitInterval), p₁ t = p₂ t) → ⟦p₁⟧ ≍ ⟦p₂⟧ | null | true |
NonUnitalStarAlgHom.fst_apply | 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] [inst_6 : Star B] (self : A × B), (NonUnitalStarAlgHom.fst R A B) self = self.1 | null | true |
String.Slice.Pattern.Model.CharPred.Decidable.isRevMatch_iff_isRevMatch_decide | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch p pos ↔ String.Slice.Pattern.Model.IsRevMatch (fun x => decide (p x)) pos | null | true |
Lean.Meta.Grind.Arith.Cutsat.reorderVarMap | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | {α : Type u_1} → [Inhabited α] → Lean.PArray α → Array Int.Linear.Var → Lean.PArray α | null | true |
QuadraticModuleCat.Hom._sizeOf_inst | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → {inst : CommRing R} → (V W : QuadraticModuleCat R) → [SizeOf R] → SizeOf (V.Hom W) | null | false |
List.getLast_filterMap | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α} (h : List.filterMap f l ≠ []),
(List.filterMap f l).getLast h = (List.findSome? f l.reverse).get ⋯ | null | true |
PosMulReflectLT.toPosMulMono | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLT α], PosMulMono α | null | true |
MeasureTheory.Measure.Regular.smul | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular]
{x : ENNReal}, x ≠ ⊤ → (x • μ).Regular | null | true |
Ideal.Quotient.mkₐ._proof_5 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_2) {A : Type u_1} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided] (x : R₁),
(↑↑{ toFun := fun a => Submodule.Quotient.mk a, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
((algebraMap R₁ A) x) =
(↑↑{ toFun := fun... | null | false |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_cons_zero._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {a : α},
List.findIdxNth p (a :: xs) 0 = if p a = true then 0 else List.findIdxNth p xs 0 + 1 | null | false |
PiTensorProduct.tprodMonoidHom._proof_1 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_2) {A : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → NonAssocSemiring (A i)]
[inst_2 : (i : ι) → Module R (A i)], (PiTensorProduct.tprod R) 1 = (PiTensorProduct.tprod R) 1 | null | false |
CochainComplex.mkHom_f_succ_succ | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(P Q : CochainComplex V ℕ) (zero : P.X 0 ⟶ Q.X 0) (one : P.X 1 ⟶ Q.X 1)
(one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one)
(succ :
(n... | null | true |
CategoryTheory.LocalizerMorphism.IsLocalizedEquivalence.mk._flat_ctor | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂},
(Φ.localizedFunctor W₁.Q W₂.Q).IsEquivalence → Φ.IsLocalized... | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.checkForInductionWithNoAlts.match_1 | Lean.Elab.Tactic.Induction | (motive : Lean.Syntax → Sort u_1) →
(optInductionAlts : Lean.Syntax) →
((info info_1 info_2 info_3 info_4 : Lean.SourceInfo) →
(var : Lean.Syntax) →
motive
(Lean.Syntax.node info `null
#[Lean.Syntax.node info_1 `Lean.Parser.Tactic.inductionAlts
#[Lean.... | null | false |
CategoryTheory.InducedCategory.isGroupoid | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u} (D : Type u₂) [inst : CategoryTheory.Category.{v, u₂} D] [CategoryTheory.IsGroupoid D] (F : C → D),
CategoryTheory.IsGroupoid (CategoryTheory.InducedCategory D F) | null | true |
CategoryTheory.ShortComplex.QuasiIso.congr_simp | Mathlib.Algebra.Homology.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ φ_1 : S₁ ⟶ S₂),
φ = φ_1 → CategoryTheory.ShortComplex.QuasiIso φ = CategoryTheory.ShortComplex.QuasiIso φ_... | null | true |
PosSMulReflectLT.rec | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero α] →
{motive : PosSMulReflectLT α β → Sort u} →
((lt_of_smul_lt_smul_left : ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b₁ b₂ : β⦄, a • b₁ < a • b₂ → b₁ < b₂) → motive ⋯... | null | false |
Std.Time.PlainDateTime.weekOfMonth | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Internal.Bounded.LE 1 5 | Returns the unaligned week of the month for a `PlainDateTime` (day divided by 7, plus 1).
| true |
_private.Mathlib.MeasureTheory.Measure.SeparableMeasure.0.MeasureTheory.Lp.SecondCountableTopology.match_3 | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_2} {E : Type u_1} [m : MeasurableSpace X] [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure X}
{p : ENNReal} (u : Set E) (a : E) {s : Set X} (ε : ℝ)
(motive : (∃ b ∈ u, ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)))) → Prop)
(x : ∃ b ∈ u, ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.isContained_iff_exists_iso_subgraph.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_1} {β : Type u_2} {A : SimpleGraph α} {B : SimpleGraph β} (motive : A.IsContained B → Prop)
(x : A.IsContained B), (∀ (f : A.Copy B), motive ⋯) → motive x | null | false |
ContinuousGeneratedByCat.instIsIsoFunctorUnitTopCatAdj | Mathlib.Topology.Convenient.Category | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)],
CategoryTheory.IsIso ContinuousGeneratedByCat.adj.unit | null | true |
CategoryTheory.ChosenPullbacksAlong.ofHasPullbacksAlong | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y X : C} → (f : Y ⟶ X) → [CategoryTheory.Limits.HasPullbacksAlong f] → CategoryTheory.ChosenPullbacksAlong f | Relating the existing noncomputable `HasPullbacksAlong` typeclass to `ChosenPullbacksAlong`. | true |
NumberField.RingOfIntegers.coe_mk | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {x : K} (hx : x ∈ integralClosure ℤ K), ↑⟨x, hx⟩ = x | null | true |
IsLocalizedModule.instIsTorsionFreeLocalizationLocalizedModuleOfIsDomain | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [IsDomain R]
(S : Submonoid R) [Module.IsTorsionFree R M], Module.IsTorsionFree (Localization S) (LocalizedModule S M) | null | true |
PNat.instMetricSpace._proof_22 | Mathlib.Topology.Instances.PNat | PNat.instMetricSpace._aux_20 ≤ Filter.cofinite | null | false |
OrderIso.mapSetOfMaximal._proof_9 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t)
(x : ↑{x | Maximal (fun x => x ∈ t) x}), ⟨↑(f ⟨↑⟨↑(f.symm ⟨↑x, ⋯⟩), ⋯⟩, ⋯⟩), ⋯⟩ = x | null | false |
WeierstrassCurve.ΨSq_two | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R), W.ΨSq 2 = W.Ψ₂Sq | null | true |
Filter.map_eq_comap_of_inverse | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {n : β → α},
m ∘ n = id → n ∘ m = id → Filter.map m f = Filter.comap n f | null | true |
NNReal.natCast_iInf | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_4} (f : ι → ℕ), ↑(⨅ i, f i) = ⨅ i, ↑(f i) | null | true |
MeasureTheory.OuterMeasure.instSMul._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_2} {R : Type u_1} [inst : SMul R ENNReal] [IsScalarTower R ENNReal ENNReal] (c : R)
(m : MeasureTheory.OuterMeasure α), c • m ∅ = 0 | null | false |
IsCoprime.divRadical | Mathlib.RingTheory.Radical.Basic | ∀ {E : Type u_1} [inst : EuclideanDomain E] [inst_1 : NormalizationMonoid E] [inst_2 : UniqueFactorizationMonoid E]
{a b : E}, IsCoprime a b → IsCoprime (EuclideanDomain.divRadical a) (EuclideanDomain.divRadical b) | null | true |
Std.DTreeMap.Const.compare_minKey?_modify_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : β → β} {km kmm : α} (hkm : t.minKey? = some km),
(Std.DTreeMap.Const.modify t k f).minKey?.get ⋯ = kmm → cmp kmm km = Ordering.eq | null | true |
Int16.ofIntClamp_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofIntClamp x.toInt = x.toInt16 | null | true |
EST.Out.noConfusion | Init.System.ST | {P : Sort u} →
{ε σ α : Type} →
{t : EST.Out ε σ α} →
{ε' σ' α' : Type} → {t' : EST.Out ε' σ' α'} → ε = ε' → σ = σ' → α = α' → t ≍ t' → EST.Out.noConfusionType P t t' | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanMap.match_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u_4} →
{C : Type u_5} →
[inst : CategoryTheory.Category.{u_2, u_4} C₀] →
[inst_1 : CategoryTheory.Category.{u_3, u_5} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} →
(data : F.PreOneHypercoverDenseData X) →
(motive : CategoryTheory.Limits.WalkingMult... | null | false |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.unwantedUnicode.inj | Mathlib.Tactic.Linter.TextBased | ∀ {c c_1 : Char},
Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c = Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c_1 →
c = c_1 | null | true |
Matrix.addMonoidHomMulLeft | Mathlib.Data.Matrix.Mul | {l : Type u_1} →
{m : Type u_2} →
{n : Type u_3} →
{α : Type v} → [inst : NonUnitalNonAssocSemiring α] → [Fintype m] → Matrix l m α → Matrix m n α →+ Matrix l n α | Left multiplication by a matrix, as an `AddMonoidHom` from matrices to matrices. | true |
Array.range'_eq_append_iff | Init.Data.Array.Range | ∀ {s n : ℕ} {xs ys : Array ℕ},
Array.range' s n = xs ++ ys ↔ ∃ k ≤ n, xs = Array.range' s k ∧ ys = Array.range' (s + k) (n - k) | null | true |
Topology.IsClosedEmbedding.comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsClosedEmbedding g → Topology.IsClosedEmbedding f → Topology.IsClosedEmbedding (g ∘ f) | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstanceImp | Lean.Meta.Basic | {α : Type} → Lean.Name → Lean.Expr → Lean.MetaM α → Lean.MetaM α | null | true |
Multiset.cons_product | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (a : α) (s : Multiset α) (t : Multiset β),
(a ::ₘ s) ×ˢ t = Multiset.map (Prod.mk a) t + s ×ˢ t | null | true |
LinearMap.BilinForm.tensorDistrib._proof_3 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_2) (A : Type u_1) {M₁ : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : Algebra R A] [inst_4 : Module A M₁], SMulCommClass A R (M₁ →ₗ[A] A) | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Util.0.Int.Linear.Poly.pp.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | (motive : Int.Linear.Poly → Sort u_1) →
(p : Int.Linear.Poly) →
((k : ℤ) → motive (Int.Linear.Poly.num k)) →
((x : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add 1 x p)) →
((k : ℤ) → (x : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add k x p)) → motive p | null | false |
Simps.ProjectionData.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {name : Lean.Name} {expr : Lean.Expr} {projNrs : List ℕ} {isDefault isPrefix : Bool} {name_1 : Lean.Name}
{expr_1 : Lean.Expr} {projNrs_1 : List ℕ} {isDefault_1 isPrefix_1 : Bool},
{ name := name, expr := expr, projNrs := projNrs, isDefault := isDefault, isPrefix := isPrefix } =
{ name := name_1, expr := ex... | null | true |
IsLocalRing.map_mkQ_eq | Mathlib.RingTheory.LocalRing.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] {N₁ N₂ : Submodule R M},
N₁ ≤ N₂ →
N₂.FG →
(Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₁ = Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₂ ↔
N₁ = N₂) | null | true |
instContinuousNegElemBallOfNat | Mathlib.Analysis.Normed.Group.BallSphere | ∀ {E : Type u_1} [i : SeminormedAddCommGroup E] {r : ℝ}, ContinuousNeg ↑(Metric.ball 0 r) | null | true |
Std.Time.TimeZone.GMT | Std.Time.Zoned.TimeZone | Std.Time.TimeZone | A zeroed `Timezone` representing GMT (no offset).
| true |
Coalgebra.Repr.mk.sizeOf_spec | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] {a : A} {ι : Type u_1} [inst_4 : SizeOf R] [inst_5 : SizeOf A] [inst_6 : SizeOf ι]
(index : Finset ι) (left right : ι → A) (eq : ∑ i ∈ index, left i ⊗ₜ[R] right i = CoalgebraStruct.com... | null | true |
CategoryTheory.ShiftedHom.id_map | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y : C} {a : M} (f : CategoryTheory.ShiftedHom X Y a),
f.map (CategoryTheory.Functor.id C) = f | null | true |
Action.res._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_4} {H : Type u_3} [inst_1 : Monoid G]
[inst_2 : Monoid H] (f : G →* H) {X Y Z : Action V H} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
{ hom := (CategoryTheory.CategoryStruct.comp f_1 g).hom, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := f_1... | null | false |
CategoryTheory.GrothendieckTopology.le_canonical | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) [J.Subcanonical],
J ≤ CategoryTheory.Sheaf.canonicalTopology C | null | true |
CategoryTheory.ComonObj._aux_Mathlib_CategoryTheory_Monoidal_Comon____unexpand_CategoryTheory_ComonObj_comul_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.PrettyPrinter.Unexpander | null | false |
Algebra.Extension.Hom.algebraMap_toRingHom | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R' S']
{P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S'] (self : P.Hom... | null | true |
_private.Mathlib.Data.Finset.Sups.0.Finset.filter_sups_le._simp_1_2 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ ↑s) | null | false |
Lean.Grind.CutsatConfig.maxSuggestions._inherited_default | Init.Grind.Config | Option ℕ | null | false |
IsUnit.unit_map | Mathlib.Algebra.Group.Units.Hom | ∀ {F : Type u_1} {M : Type u_3} {N : Type u_4} [inst : FunLike F M N] [inst_1 : Monoid M] [inst_2 : Monoid N]
[inst_3 : MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x), ↑⋯.unit = f ↑h.unit | null | true |
Char.succ?_eq | Init.Data.Char.Ordinal | ∀ {c : Char}, c.succ? = Option.map Char.ofOrdinal (c.ordinal.addNat? 1) | null | true |
Submodule.botEquivPUnit_apply | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : ↥⊥),
Submodule.botEquivPUnit x = PUnit.unit | null | true |
Cardinal.IsInaccessible.recOn | Mathlib.SetTheory.Cardinal.Regular | {c : Cardinal.{u_1}} →
{motive : c.IsInaccessible → Sort u} →
(t : c.IsInaccessible) →
((aleph0_lt : Cardinal.aleph0 < c) →
(le_cof_ord : c ≤ c.ord.cof) → (isStrongPrelimit : c.IsStrongPrelimit) → motive ⋯) →
motive t | null | false |
PartialEquiv.transEquiv_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ),
(e.transEquiv f').target = ⇑f'.symm ⁻¹' e.target | null | true |
WeakFEPair.noConfusion | Mathlib.NumberTheory.LSeries.AbstractFuncEq | {P : Sort u} →
{E : Type u_1} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℂ E} →
{t : WeakFEPair E} →
{E' : Type u_1} →
{inst' : NormedAddCommGroup E'} →
{inst'_1 : NormedSpace ℂ E'} →
{t' : WeakFEPair E'} →
E = E' → i... | null | false |
Subalgebra.instCommRingSubtypeMemCenter._proof_14 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
PerfectClosure.lift._proof_3 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (L : Type u_2)
[inst_3 : CommSemiring L] [inst_4 : CharP L p] [inst_5 : PerfectRing L p],
Function.LeftInverse (fun f => f.comp (PerfectClosure.of K p)) fun f =>
{ toFun := fun e => e.liftOn (fun x => (⇑(frobeniusEqu... | null | false |
OrderAddMonoidIso.map_le_map_iff' | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(self : α ≃+o β) {a b : α}, self.toFun a ≤ self.toFun b ↔ a ≤ b | An `OrderAddMonoidIso` respects `≤`. | true |
mul_neg_mem | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : HasDistribNeg R] [inst_2 : SetLike S R] [MulMemClass S R]
{s : S} {x y : R}, x ∈ s → -y ∈ s → -(x * y) ∈ s | This lemma exists for `aesop`, as `aesop` simplifies `x * -y` to `-(x * y)` before applying
unsafe rules like `mul_mem`, leading to a dead end in cases where `neg_mem` does not hold. | true |
Set.Iic_union_Ici | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Iic a ∪ Set.Ici a = Set.univ | null | true |
Subgroup.ofUnits_bot | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M], ⊥.ofUnits = ⊥ | null | true |
Ordinal.uniqueToTypeOne._proof_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : Ordinal.ToType 1), a = (Ordinal.enum fun x1 x2 => x1 < x2) ⟨0, Ordinal.uniqueToTypeOne._proof_2⟩ | null | false |
Real.exp_neg_one_lt_d9 | Mathlib.Analysis.Complex.ExponentialBounds | Real.exp (-1) < 0.3678794412 | null | true |
Std.Time.Month.Ordinal.ofNat | Std.Time.Date.Unit.Month | (data : ℕ) → autoParam (data ≥ 1 ∧ data ≤ 12) Std.Time.Month.Ordinal.ofNat._auto_1 → Std.Time.Month.Ordinal | Creates an `Ordinal` from a `Nat`, ensuring the value is within bounds.
| true |
CauSeq.coe_inf._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs),
↑f ⊓ ↑g = ↑(f ⊓ g) | null | false |
subset_supClosure | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeSup α] {s : Set α}, s ⊆ supClosure s | null | true |
Function.support_mul' | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] (f g : ι → M₀),
Function.support (f * g) = Function.support f ∩ Function.support g | null | true |
Homeomorph.contractibleSpace_iff | Mathlib.Topology.Homotopy.Contractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
ContractibleSpace X ↔ ContractibleSpace Y | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_6 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
j ≤ a.size →
-1 * ↑i + ↑a.size ≤ 0 →
¬-1 * ↑j + ↑a.size ≤ 0 →
¬↑i + -1 * ↑(min j (a ++ b).size) ≤ 0 →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | null | false |
Fin.rec0 | Mathlib.Data.Fin.Basic | {α : Fin 0 → Sort u_1} → (i : Fin 0) → α i | A dependent variant of `Fin.elim0`. | true |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_1.eq_2 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3) (it : Std.IterM m α)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.Iter... | null | true |
List.IsChain.nil._simp_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {R : α → α → Prop}, List.IsChain R [] = True | null | false |
Matrix.GeneralLinearGroup.upperRightHom._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : Ring R] (x : R), !![1, x; 0, 1] * !![1, -x; 0, 1] = 1 | null | false |
Lean.Server.instInhabitedRequestError.default | Lean.Server.Requests | Lean.Server.RequestError | null | true |
AlgebraicGeometry.IsZariskiLocalAtSource.of_iSup_eq_top | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsZariskiLocalAtSource P]
{X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {ι : Sort u_1} (U : ι → X.Opens),
iSup U = ⊤ → (∀ (i : ι), P (CategoryTheory.CategoryStruct.comp (U i).ι f)) → P f | null | true |
IsGaloisGroup.fixedPoints_eq_range_algebraMap | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] (H : Subgroup G) [hGKL : IsGaloisGroup G K L] [Finite G]
(B : Type u_5) [inst_6 : CommSemiring B] [inst_7 : Algebra B L] [IsGaloisGroup (↥H) B L],
↑(FixedPo... | If `G` acts as a Galois group on `L/K` and the subgroup `H` acts as a Galois group on `L/B`,
then the fixed points of `H` equals the range of `algebraMap B L`. | true |
Std.Http.URI.Port.rec | Std.Http.Data.URI.Basic | {motive : Std.Http.URI.Port → Sort u} →
motive Std.Http.URI.Port.omitted →
motive Std.Http.URI.Port.empty →
((port : UInt16) → motive (Std.Http.URI.Port.value port)) → (t : Std.Http.URI.Port) → motive t | null | false |
AddSubmonoid.map_comap_map | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
AddSubmonoid.map f (AddSubmonoid.comap f (AddSubmonoid.map f S)) = AddSubmonoid.map f S | null | true |
List.splitOnP_cons_eq_if_modifyHead | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (x : α) (xs : List α),
List.splitOnP p (x :: xs) =
if p x = true then [] :: List.splitOnP p xs else List.modifyHead (List.cons x) (List.splitOnP p xs) | null | true |
IsMulCentral.left_assoc | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] {z : M}, IsMulCentral z → ∀ (b c : M), z * (b * c) = z * b * c | associative property for left multiplication | true |
Finpartition.parts_subset_extendOfLE | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] [inst_1 : DecidableEq α] {a b : α} (P : Finpartition a)
(hab : a ≤ b), P.parts ⊆ (P.extendOfLE hab).parts | null | true |
QuaternionAlgebra.imIₗ | Mathlib.Algebra.Quaternion | {R : Type u_3} → (c₁ c₂ c₃ : R) → [inst : CommRing R] → QuaternionAlgebra R c₁ c₂ c₃ →ₗ[R] R | `QuaternionAlgebra.imI` as a `LinearMap` | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Rat.padicValuation_le_one_iff._simp_1_4 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.not_isStronglyTranscendental_of_weaklyQuasiFiniteAt._simp_1_3 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A}
{S : Subalgebra R A}, (Algebra.adjoin R s ≤ S) = (s ⊆ ↑S) | null | false |
MeasureTheory.Measure.measure_inv | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : InvolutiveInv G] [MeasurableInv G] (μ : MeasureTheory.Measure G)
[μ.IsInvInvariant] (A : Set G), μ A⁻¹ = μ A | null | true |
Filter.EventuallyLE.isMinFilter | Mathlib.Order.Filter.Extr | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
f ≤ᶠ[l] g → f a = g a → IsMinFilter f l a → IsMinFilter g l a | null | true |
RestrictedProduct.instT2Space | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
[∀ (i : ι), T2Space (R i)], T2Space (RestrictedProduct (fun i => R i) (fun i => A i) 𝓕) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.