name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.ExtTreeMap.maxKey?_le | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
(∀ (k' : α), t.maxKey? = some k' → (cmp k' k).isLE = true) ↔ ∀ k' ∈ t, (cmp k' k).isLE = true | null | true |
CategoryTheory.ComposableArrows.Exact.exact'._auto_3 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax | null | false |
TopologicalSpace.secondCountableTopology_iInf | Mathlib.Topology.Bases | ∀ {α : Type u_1} {ι : Sort u_2} [Countable ι] {t : ι → TopologicalSpace α},
(∀ (i : ι), SecondCountableTopology α) → SecondCountableTopology α | null | true |
ENNReal.toReal_lt_toReal | Mathlib.Data.ENNReal.Real | ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal < b.toReal ↔ a < b) | null | true |
Finsupp.lcoeFun._proof_2 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : R) (y : α →₀ M), ⇑(x • y) = (RingHom.id R) x • ⇑y | null | false |
_private.Lean.Expr.0.Lean.instReprExpr.repr.match_1 | Lean.Expr | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((a : ℕ) → motive (Lean.Expr.bvar a)) →
((a : Lean.FVarId) → motive (Lean.Expr.fvar a)) →
((a : Lean.MVarId) → motive (Lean.Expr.mvar a)) →
((a : Lean.Level) → motive (Lean.Expr.sort a)) →
((a : Lean.Name) → (a_1 : List Lean.L... | null | false |
normFromBounded._proof_1 | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ} {c : ℝ} (f_zero : f 0 = 0) (f_nonneg : 0 ≤ f)
(f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y) (f_add : ∀ (a b : R), f (a + b) ≤ f a + f b)
(f_neg : ∀ (x : R), f (-x) = f x),
f ⁻¹' {0} = {0} → ∀ (x : R), (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun... | null | false |
MulOpposite.coe_opLinearEquiv_addEquiv | Mathlib.Algebra.Module.Equiv.Opposite | ∀ (R : Type u) {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
↑(MulOpposite.opLinearEquiv R) = MulOpposite.opAddEquiv | null | true |
ValuativeRel.zero_vlt_coe_posSubmonoid | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (x : ↥(ValuativeRel.posSubmonoid R)), 0 <ᵥ ↑x | null | true |
Set.nontrivial_of_einfsep_ne_top | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α}, s.einfsep ≠ ⊤ → s.Nontrivial | null | true |
Int8.toInt_ofIntLE | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int8.minValue.toInt ≤ x} {h₂ : x ≤ Int8.maxValue.toInt}, (Int8.ofIntLE x h₁ h₂).toInt = x | null | true |
Lean.SMap.rec | Lean.Data.SMap | {α : Type u} →
{β : Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.SMap α β → Sort u_1} →
((stage₁ : Bool) →
(map₁ : Std.HashMap α β) →
(map₂ : Lean.PHashMap α β) → motive { stage₁ := stage₁, map₁ := map₁, map₂ := map₂ }) →
(t : ... | null | false |
contDiffWithinAt_succ_iff_hasFDerivWithinAt | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞},
n ≠ ↑⊤ →
(ContDiffWithinAt 𝕜 (n + 1) f s x ↔
∃ u ∈ nh... | A function is `C^(n + 1)` on a domain iff locally, it has a derivative which is `C^n`
(and moreover the function is analytic when `n = ω`). | true |
PerfectRing.lift_self | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} [inst : CommRing K] [inst_1 : CommRing L] (i : K →+* L) (p : ℕ) [inst_2 : ExpChar K p]
[inst_3 : IsPRadical i p] [inst_4 : ExpChar L p] [inst_5 : PerfectRing L p], PerfectRing.lift i i p = RingHom.id L | null | true |
interior_Iic' | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α},
(Set.Ioi a).Nonempty → interior (Set.Iic a) = Set.Iio a | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.State | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Type | null | true |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(f : CliffordAlgebra.EvenHom Q A) ... | An auxiliary bilinear map that is later passed into `CliffordAlgebra.foldr`. Our desired result
is stored in the `A` part of the accumulator, while auxiliary recursion state is stored in the `S f`
part. | true |
EuclideanGeometry.instNonemptySphere | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] [Nonempty P], Nonempty (EuclideanGeometry.Sphere P) | null | true |
Aesop.CtorNames.mk.noConfusion | Aesop.Script.CtorNames | {P : Sort u} →
{ctor : Lean.Name} →
{args : Array Lean.Name} →
{hasImplicitArg : Bool} →
{ctor' : Lean.Name} →
{args' : Array Lean.Name} →
{hasImplicitArg' : Bool} →
{ ctor := ctor, args := args, hasImplicitArg := hasImplicitArg } =
{ ctor := cto... | null | false |
ContinuousMap.Homotopic.prodMap | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {Z : Type w} {Z' : Type x} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace Z'] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Z, Z')},
f₀.Homotopic f₁ → g₀.Homotopic g₁ → (f₀.prodMap g₀).Homotopic (f₁.prodMap g₁) | null | true |
Std.DHashMap.Internal.Raw₀.Const.getKey?_insertManyIfNewUnit_list_of_contains_eq_false_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α fun x => Unit) [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List α} {k k' : α},
(k == k') = true →
m.contains k = false →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (↑(Std.... | null | true |
Lean.Meta.eqnThmSuffixBase | Lean.Meta.Eqns | String | null | true |
Matrix.vec_mul_eq_vecMul | Mathlib.LinearAlgebra.Matrix.Vec | ∀ {m : Type u_1} {n : Type u_2} {p : Type u_4} {R : Type u_3} [inst : Semiring R] [inst_1 : Fintype m]
[inst_2 : Fintype n] [inst_3 : DecidableEq m] (A : Matrix m n R) (B : Matrix n p R),
(A * B).vec = Matrix.vecMul A.vec (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) B 1) | null | true |
selfAdjoint.instCommRingSubtypeMemAddSubgroup._proof_7 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x * y) = ↑x * ↑y | null | false |
Equiv.addMonoidWithOne._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddMonoidWithOne β], e (e.symm ↑0) = e 0 | null | false |
LeanSearchClient.SearchResult.mk._flat_ctor | LeanSearchClient.Syntax | String → Option String → Option String → Option String → Option String → LeanSearchClient.SearchResult | null | false |
Array.toListRev_iter | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {β : Type w} {array : Array β}, array.iter.toListRev = array.toListRev | null | true |
LocallyConstant.ext | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] ⦃f g : LocallyConstant X Y⦄, (∀ (x : X), f x = g x) → f = g | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.le_sliceTo_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.Total fun x1 x2 => x1 ≤ x2] [Std.LawfulOrderLT α] {a b : α},
(b ≤ a) = ¬a < b | null | false |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.instIsLeftCancelMulZeroOfIsCancelAddOfUniqueProds._simp_2 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M}, (f.support = ∅) = (f = 0) | null | false |
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Finset «$α»)} →
{P : Sort u} →
{pf pf' : Q(«$s» = ∅)} →
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf = Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf' →
(pf = pf' → P) → P | null | false |
IntermediateField.finrank_dvd_of_le_left | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{F E : IntermediateField K L}, F ≤ E → Module.finrank (↥E) L ∣ Module.finrank (↥F) L | null | true |
Set.Ici.boundedOrder | Mathlib.Order.LatticeIntervals | {α : Type u_1} → [inst : Preorder α] → [OrderTop α] → {a : α} → BoundedOrder ↑(Set.Ici a) | null | true |
_private.Mathlib.CategoryTheory.Sites.Continuous.0.CategoryTheory.PreOneHypercover.functorPushforward_sieve₁_of_preservesPullbacks._simp_1_1 | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj._proof_1 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_5} {C₂ : Type u_7} {C₃ : Type u_9} {C₄ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_6, u_7} C₂] [inst_2 : CategoryTheory.Category.{u_8, u_9} C₃]
[inst_3 : CategoryTheory.Category.{u_2, u_3} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | false |
CategoryTheory.Functor.PullbackObjObj.π_iso_of_iso_left_hom | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₃ : CategoryTheory.Arrow C... | null | true |
Std.Internal.List.minKey!_modifyKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
[inst_4 : Std.LawfulEqOrd α] [inst_5 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {f : β k → β k},
Std.Internal.List.minKey! (Std.Internal.List.modifyKe... | null | true |
Mathlib.Tactic.ITauto.instLTIProp | Mathlib.Tactic.ITauto | LT Mathlib.Tactic.ITauto.IProp | null | true |
Std.HashSet.getD_ofList_of_mem | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α} {k k' fallback : α},
(k == k') = true → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.HashSet.ofList l).getD k' fallback = k | null | true |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.ctorIdx | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} → Lean.Meta.RefinedDiscrTree.PreDiscrTree α → ℕ | null | false |
CategoryTheory.Limits.colimMap_eq | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C]
{G : CategoryTheory.Functor J C} (α : F ⟶ G), CategoryTheory.Limits.colimMap α = CategoryTheory.Limits.colim.m... | null | true |
InverseSystem.pEquivOnGlue._proof_5 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {F : ι → Type u_3} {X : ι → Type u_2} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn... | null | false |
Sublattice.coe_sup._simp_1 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L : Sublattice α} (a b : ↥L), ↑a ⊔ ↑b = ↑(a ⊔ b) | null | false |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatStxRange.match_1 | Lean.Elab.InfoTree.Main | (motive : Lean.SourceInfo → Sort u_1) →
(info : Lean.SourceInfo) →
((leading : Substring.Raw) →
(pos : String.Pos.Raw) →
(trailing : Substring.Raw) →
(endPos : String.Pos.Raw) → motive (Lean.SourceInfo.original leading pos trailing endPos)) →
((pos endPos : String.Pos.Raw) → mo... | null | false |
Std.Time.Formats.leanDateTimeWithIdentifier | Std.Time.Format | Std.Time.GenericFormat Std.Time.Awareness.any | The leanDateTimeWithIdentifier format, which follows the pattern `uuuu-MM-dd'T'HH:mm:ss[z]`
for representing date, time, and time zone. It uses the default value that can be parsed with the
notation of dates.
| true |
Submonoid.coe_mul_self_eq | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {M : Type u_3} [inst : Monoid M] (s : Submonoid M), ↑s * ↑s = ↑s | null | true |
LinearMap.curry_uncurryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂]
(f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂), f.uncurryLeft.curryLef... | null | true |
FractionalIdeal.num_zero_eq | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
Function.Injective ⇑(algebraMap R P) → FractionalIdeal.num 0 = 0 | null | true |
measurable_measure_prodMk_left | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {ν : MeasureTheory.Measure β}
[MeasureTheory.SFinite ν] {s : Set (α × β)}, MeasurableSet s → Measurable fun x => ν (Prod.mk x ⁻¹' s) | If `ν` is an s-finite measure, and `s ⊆ α × β` is measurable, then `x ↦ ν { y | (x, y) ∈ s }`
is a measurable function.
Not true without the s-finite assumption: on `ℝ × ℝ` with the product sigma-algebra, let `s` be the
diagonal and let `ν` be an uncountable sum of Dirac measures (all Dirac measures for points in a
se... | true |
Std.DHashMap.getKeyD_diff_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k fallback : α}, k ∉ m₁ → (m₁ \ m₂).getKeyD k fallback = fallback | null | true |
IsPrimitiveRoot.adjoinEquivRingOfIntegersOfPrimePow | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | {p k : ℕ} →
{K : Type u} →
[inst : Field K] →
{ζ : K} →
[hp : Fact (Nat.Prime p)] →
[inst_1 : CharZero K] →
[IsCyclotomicExtension {p ^ k} ℚ K] → IsPrimitiveRoot ζ (p ^ k) → ↥ℤ[ζ] ≃ₐ[ℤ] NumberField.RingOfIntegers K | The algebra isomorphism `adjoin ℤ {ζ} ≃ₐ[ℤ] (𝓞 K)`, where `ζ` is a primitive `p ^ k`-th root of
unity and `K` is a `p ^ k`-th cyclotomic extension of `ℚ`. | true |
smoothingFun_nonneg | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R), μ 1 ≤ 1 → ∀ (x : R), 0 ≤ smoothingFun μ x | If `μ 1 ≤ 1`, then `smoothingFun μ x` is nonnegative. | true |
Pi.measurableNeg | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_4} {α : ι → Type u_5} [inst : (i : ι) → Neg (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableNeg (α i)], MeasurableNeg ((i : ι) → α i) | null | true |
Batteries.OrientedOrd.instLexOrd | Batteries.Classes.Deprecated | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [inst_1 : Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β],
Batteries.OrientedOrd (α × β) | Local instance for `OrientedOrd lexOrd`. | true |
RingEquiv.sumArrowEquivProdArrow_apply | Mathlib.Algebra.Ring.Equiv | ∀ {α : Type u_2} {β : Type u_3} {R : Type u_4} [inst : NonAssocSemiring R] (x : α ⊕ β → R),
(RingEquiv.sumArrowEquivProdArrow α β R) x = (Equiv.sumArrowEquivProdArrow α β R) x | null | true |
AlgEquiv.prodUnique._proof_1 | Mathlib.Algebra.Algebra.Prod | ∀ {A : Type u_1} {B : Type u_2} [inst : Semiring A] [inst_1 : Semiring B] [inst_2 : Unique B],
Function.LeftInverse (RingEquiv.prodZeroRing A B).symm.invFun (RingEquiv.prodZeroRing A B).symm.toFun | null | false |
Mathlib.Tactic.TautoSet.specialize_all | Mathlib.Tactic.TautoSet | Lean.ParserDescr | `specialize_all x` runs `specialize h x` for all hypotheses `h` where this tactic succeeds.
| true |
CategoryTheory.Limits.preservesSmallestCofilteredLimits_of_preservesCofilteredLimits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F | Preserving cofiltered limits at any universe implies preserving cofiltered limits at universe `0`.
| true |
CategoryTheory.Functor.LaxLeftLinear.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Mo... | null | false |
LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___unexpand_LSeries_delta_1 | Mathlib.NumberTheory.LSeries.Basic | Lean.PrettyPrinter.Unexpander | null | false |
instCoeTCMulEquivOfMulEquivClass.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : Mul α] [inst_2 : Mul β]
[inst_3 : MulEquivClass F α β], instCoeTCMulEquivOfMulEquivClass = { coe := MulEquivClass.toMulEquiv } | null | true |
Std.Time.Day.Ordinal.ofNat._auto_1 | Std.Time.Date.Unit.Day | Lean.Syntax | null | false |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula.0.ModularForm.levelOne_weight_two_rank_zero._simp_1_2 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ},
0 < h → h ∈ Γ.strictPeriods → ∀ {k : ℤ} (f : ModularForm Γ k), (UpperHalfPlane.qExpansion h ⇑f = 0) = (f = 0) | null | false |
CategoryTheory.Cat.Hom.isoMk_inv | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v, u} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G),
(CategoryTheory.Cat.Hom.isoMk e).inv = CategoryTheory.NatTrans.toCatHom₂ e.inv | null | true |
ValuationSubring.linearOrderOverring._proof_3 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (a b : { S // A ≤ S }), a ≤ b ∨ b ≤ a | null | false |
continuousAt_prod_of_discrete_right | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {x : α × β},
ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x_1, x.2)) x.1 | null | true |
CategoryTheory.IsCofiltered.minToRight._proof_1 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C]
(j j' : C), ∃ x, True | null | false |
ValuationSubring.instSemilatticeSup | Mathlib.RingTheory.Valuation.ValuationSubring | {K : Type u} → [inst : Field K] → SemilatticeSup (ValuationSubring K) | null | true |
_private.Mathlib.Data.Set.Prod.0.Set.EqOn.right_of_eqOn_prodMap._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_2} {δ : Type u_1} {f f' : α → γ} {g g' : β → δ} (x : α) ⦃x_1 : β⦄,
Prod.map f g (x, x_1) = Prod.map f' g' (x, x_1) → g x_1 = g' x_1 | null | false |
CommRingCat.forget₂Ring_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat RingCat) | null | true |
instReprOrdering | Init.Data.Ord.Basic | Repr Ordering | null | true |
eq_zero_of_neg_eq | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {a : α}, -a = a → a = 0 | null | true |
Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt._proof_3 | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {R : Type u_2} [inst_1 : Ring R] (v : Valuation R Γ)
[hv : v.IsRankOneDiscrete], Infinite ↥(MonoidWithZeroHom.ofClass v).valueGroup | null | false |
Besicovitch.exists_goodδ | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E],
∃ δ,
0 < δ ∧
δ < 1 ∧
∀ (s : Finset E),
(∀ c ∈ s, ‖c‖ ≤ 2) → (∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) → s.card ≤ Besicovitch.multiplicity E | If `δ` is small enough, a `(1-δ)`-separated set in the ball of radius `2` also has cardinality
at most `multiplicity E`. | true |
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {I : Type u_2} [inst : Fintype I] {e : I → R} [inst_1 : Semiring R]
(he : CompleteOrthogonalIdempotents e),
(∀ (i : I), IsMulCentral (e i)) →
∀ (r : R), (fun r => ∑ i, ↑(r i)) ((fun r i => ⟨(fun x => e i * x * e i) r, ⋯⟩) r) = r | null | false |
_private.Mathlib.Tactic.DepRewrite.0.Lean.MVarId.depRewrite.match_3 | Mathlib.Tactic.DepRewrite | (motive : Lean.Expr → Sort u_1) →
(eAbst : Lean.Expr) →
((binderName : Lean.Name) →
(binderType : Lean.Expr) →
(binderName_1 : Lean.Name) →
(binderType_1 eBody : Lean.Expr) →
(binderInfo binderInfo_1 : Lean.BinderInfo) →
motive
(Lean.Ex... | null | false |
RingCon.ringConGen_eq | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R] (r : R → R → Prop),
ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y} | The inductively defined smallest congruence relation containing a binary relation `r` equals
the infimum of the set of congruence relations containing `r`. | true |
AddGroupSeminorm.map_zero' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} [inst : AddGroup G] (self : AddGroupSeminorm G), self.toFun 0 = 0 | The image of zero is zero. | true |
CompleteLatticeHom._sizeOf_1 | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : CompleteLattice α} → {inst_1 : CompleteLattice β} → [SizeOf α] → [SizeOf β] → CompleteLatticeHom α β → ℕ | null | false |
Zsqrtd.isCoprime_of_dvd_isCoprime | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} {a b : ℤ√d}, IsCoprime a.re a.im → b ∣ a → IsCoprime b.re b.im | null | true |
Aesop.mkLocalRuleSet | Aesop.RuleSet | Array (Aesop.GlobalRuleSet × Lean.Name × Lean.Name) → Aesop.Options' → Lean.CoreM Aesop.LocalRuleSet | null | true |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.structuralArg._sparseCasesOn_1 | Lean.Elab.PreDefinition.TerminationMeasure | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
NonUnitalSubsemiring.instBot._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a * b ∈ {0} | null | false |
Finmap.union.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : Finmap β),
s₁.union s₂ = s₁.liftOn₂ s₂ (fun s₁ s₂ => (s₁ ∪ s₂).toFinmap) ⋯ | null | true |
instRingCorner._proof_14 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalRing R] (idem : IsIdempotentElem e) (a b c : idem.Corner),
(a + b) * c = a * c + b * c | null | false |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.mem_insert_self.match_1_3 | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {v : α} {t : RBTree.RBNode α} (v_1 : α)
(motive : (∃ L R, t.toList = L ++ v_1 :: R ∧ (RBTree.RBNode.insert cmp t v).toList = L ++ v :: R) → Prop)
(x : ∃ L R, t.toList = L ++ v_1 :: R ∧ (RBTree.RBNode.insert cmp t v).toList = L ++ v :: R),
(∀ (w w_1 : List α) (left : t.toL... | null | false |
IncidenceAlgebra.instRing._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Ring 𝕜] (n : ℕ) (a : IncidenceAlgebra 𝕜 α),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a | null | false |
Set.definable_finset_sup | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {ι : Type u_2}
{f : ι → Set (α → M)}, (∀ (i : ι), A.Definable L (f i)) → ∀ (s : Finset ι), A.Definable L (s.sup f) | null | true |
SSet.RelativeMorphism.ofSimplex₀._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} (f : X ⟶ Y) (x : X.obj (Opposite.op { len := 0 })) (y : Y.obj (Opposite.op { len := 0 })),
(CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op { len := 0 }))) x = y →
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.ofSimplex x).ι f =
CategoryTheory.CategoryStruct.comp (SSet.const ⟨y,... | null | false |
_private.Init.Data.List.Find.0.List.head_flatten._simp_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {xs : List α} (h : xs ≠ []), (xs.head h = a) = (xs.head? = some a) | null | false |
_private.Mathlib.RingTheory.Flat.Rank.0.PrimeSpectrum.rankAtStalk_pos_iff_comap_surjective._simp_1_3 | Mathlib.RingTheory.Flat.Rank | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
Sum.not_inr_le_inl._simp_1 | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inr b ≤ Sum.inl a) = False | null | false |
CategoryTheory.op_epi_iff | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Epi f.op ↔ CategoryTheory.Mono f | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.Functor.FullyFaithful.isMonHom_preimage._simp_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.MonObj X] {Z : ... | null | false |
Lean.Grind.Ring.OfSemiring.Q.ind | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] {β : Lean.Grind.Ring.OfSemiring.Q α → Prop},
(∀ (a : α × α), β (Lean.Grind.Ring.OfSemiring.Q.mk a)) → ∀ (q : Lean.Grind.Ring.OfSemiring.Q α), β q | null | true |
_private.Batteries.Data.Array.Basic.0.Array.scanrMFast.loop._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (start : USize), start.toNat ≤ as.size → start - 1 < start → (start - 1).toNat < as.size | null | false |
CochainComplex.IsKProjective.homotopyZero_def | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) (hL : HomologicalComplex.Acyclic L) [inst_2 : K.IsKProjective],
CochainComplex.IsKProjective.homotopyZero f hL = ⋯.some | null | true |
CategoryTheory.Limits.spanIsoMk._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | Lean.Syntax | null | false |
List.cyclicPermutations_ne_nil._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α), (l.cyclicPermutations = []) = False | null | false |
Lean.Parser.Command.GrindCnstr.notStrictValue.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.