name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UInt32.toFin_ofNatClamp_of_le._proof_1 | Init.Data.UInt.Lemmas | UInt32.size - 1 < UInt32.size | null | false |
Algebra.subset_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A},
s ⊆ ↑(Algebra.adjoin R s) | null | true |
TopologicalSpace.CompactOpens.coe_himp._simp_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α]
(s t : TopologicalSpace.CompactOpens α), ↑s ⇨ ↑t = ↑(s ⇨ t) | null | false |
floorDiv_of_nonpos | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : SMulZeroClass α β] [inst_5 : FloorDiv α β] {a : α}, a ≤ 0 → ∀ (b : β), b ⌊/⌋ a = 0 | null | true |
Std.ExtTreeMap.getElem_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α}
{f : β → β} {hc : k' ∈ t.modify k f}, (t.modify k f)[k'] = if heq : cmp k k' = Ordering.eq then f t[k] else t[k'] | null | true |
hasDerivAtFilter_iff_tendsto | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {L : Filter (𝕜 × 𝕜)},
HasDerivAtFilter f f' L ↔ Filter.Tendsto (fun p => ‖p.1 - p.2‖⁻¹ * ‖f p.1 - f p.2 - (p.1 - p.2) • f'‖) L (nhds 0) | null | true |
_private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.dickson.match_1.eq_1 | Mathlib.RingTheory.Polynomial.Dickson | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ.succ => h_3 n) =
h_1 () | null | true |
MeasureTheory.Measure.restrict_toOuterMeasure_eq_toOuterMeasure_restrict | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → (μ.restrict s).toOuterMeasure = (MeasureTheory.OuterMeasure.restrict s) μ.toOuterMeasure | This lemma shows that `restrict` and `toOuterMeasure` commute. Note that the LHS has a
restrict on measures and the RHS has a restrict on outer measures. | true |
Lean.LOption.some.sizeOf_spec | Lean.Data.LOption | ∀ {α : Type u} [inst : SizeOf α] (a : α), sizeOf (Lean.LOption.some a) = 1 + sizeOf a | null | true |
_private.Mathlib.Algebra.Notation.Support.0.Function.mulSupport_curry._simp_1_1 | Mathlib.Algebra.Notation.Support | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
IsLocalization.isRegular_mk'._simp_1 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S],
(∀ m ∈ M, IsRegular m) → ∀ {r : R} {m : ↥M}, IsRegular (IsLocalization.mk' S r m) = IsRegular r | null | false |
Lean.Meta.Sym.Arith.instInhabitedSemiring.default | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.Semiring | null | true |
Set.insert_prod | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α}, insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t | null | true |
CategoryTheory.InjectiveResolution.instInjectiveXIntCochainComplex | Mathlib.CategoryTheory.Abelian.Injective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {X : C} (R : CategoryTheory.InjectiveResolution X) (n : ℤ),
CategoryTheory.Injective (R.cochainComplex.X n) | null | true |
SheafOfModules.GeneratingSections.IsFiniteType.mk | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R} {σ : M.GeneratingSections},
autoParam (Fi... | null | true |
CategoryTheory.GrothendieckTopology.diagramFunctor_map | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (D : Type w)
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(X : C) {X_1 Y : CategoryT... | null | true |
OrderSupSet.choose | Mathlib.Order.Bounds.Basic | {α : Type u_1} → [inst : Preorder α] → α → OrderSupSet α | Noncomputably constructs an `OrderSupSet` using the axiom of choice,
where `sSup s` returns `d` if a least upper bound does not exist. | true |
ProfiniteAddGrp.recOn | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {motive : ProfiniteAddGrp.{u} → Sort u_1} →
(t : ProfiniteAddGrp.{u}) →
((toProfinite : Profinite) →
[addGroup : AddGroup ↑toProfinite.toTop] →
[topologicalAddGroup : IsTopologicalAddGroup ↑toProfinite.toTop] →
motive { toProfinite := toProfinite, addGroup := addGroup, topologicalAdd... | null | false |
ContinuousEval.toContinuousEvalConst | Mathlib.Topology.Hom.ContinuousEval | ∀ {F : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : FunLike F X Y] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [inst_3 : TopologicalSpace Y] [ContinuousEval F X Y], ContinuousEvalConst F X Y | null | true |
Perfection.coeffMonoidHom_pow_p_pow_self | Mathlib.RingTheory.Perfection | ∀ {M : Type u_1} [inst : CommMonoid M] {p : ℕ} (f : Perfection M p) (n : ℕ),
(Perfection.coeffMonoidHom M p n) f ^ p ^ n = (Perfection.coeffMonoidHom M p 0) f | null | true |
AddSubmonoid.mk._flat_ctor | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
(carrier : Set M) → (∀ {a b : M}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) → 0 ∈ carrier → AddSubmonoid M | null | false |
MulAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {N : Subgroup G} [N.Normal] (a : X),
MulAction.IsBlock G (MulAction.orbit (↥N) a) | An orbit of a normal subgroup is a block | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.append_eq_append_iff_of_size_eq_left._simp_1_1 | Init.Data.ByteArray.Lemmas | ∀ {x y : ByteArray}, (x = y) = (x.data = y.data) | null | false |
Lean.instHashableFVarId.hash | Lean.Expr | Lean.FVarId → UInt64 | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceUnary.match_1 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | (motive : Option BitVec.Literal✝ → Sort u_1) →
(__x : Option BitVec.Literal✝) →
((v : BitVec.Literal✝) → motive (some v)) → ((x : Option BitVec.Literal✝) → motive x) → motive __x | null | false |
isStrongAntichain_insert | Mathlib.Order.Antichain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
IsStrongAntichain r (insert a s) ↔ IsStrongAntichain r s ∧ ∀ ⦃b : α⦄, b ∈ s → a ≠ b → ∀ (c : α), ¬r a c ∨ ¬r b c | null | true |
instCoeLieSubalgebraSubmodule | Mathlib.Algebra.Lie.Subalgebra | (R : Type u) →
(L : Type v) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → Coe (LieSubalgebra R L) (Submodule R L) | null | true |
AlgebraicGeometry.PresheafedSpace.GlueData._sizeOf_inst | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | (C : Type u) →
{inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (AlgebraicGeometry.PresheafedSpace.GlueData C) | null | false |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.flipFunctor._proof_5 | Mathlib.CategoryTheory.Functor.Category | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (D : Type u_6)
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (E : Type u_2) [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
(X : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (x : D) (x_1 : C),
({ app := fun Y => { app := fun X_1 => ((Categ... | null | false |
_private.Init.Data.List.Lemmas.0.List.flatten.match_1.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List (List α) → Sort u_2) (l : List α) (L : List (List α)) (h_1 : Unit → motive [])
(h_2 : (l : List α) → (L : List (List α)) → motive (l :: L)),
(match l :: L with
| [] => h_1 ()
| l :: L => h_2 l L) =
h_2 l L | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.noErrorIfUnused._regBuiltin.Lean.Parser.Term.noErrorIfUnused.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
equicontinuousAt_iff_range | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] {F : ι → X → α} {x₀ : X},
EquicontinuousAt F x₀ ↔ EquicontinuousAt Subtype.val x₀ | A family `𝓕 : ι → X → α` is equicontinuous at `x₀` iff `range 𝓕` is equicontinuous at `x₀`,
i.e the family `(↑) : range F → X → α` is equicontinuous at `x₀`. | true |
AddCommGroup.modEq_iff_natModEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [PMOD n] ↔ a ≡ b [MOD n] | null | true |
iteratedDerivWithin_fun_sum | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {ι : Type u_7} {n : ℕ} {x : 𝕜} {f : ι → 𝕜 → F} {I : Finset ι} {s : Set 𝕜},
x ∈ s →
UniqueDiffOn 𝕜 s →
(∀ i ∈ I, ContDiffWithinAt 𝕜 (↑n) (f i) s x) →
iteratedDerivWi... | null | true |
List.mapDiagM'.match_1 | Mathlib.Data.List.Defs | (motive : List Unit → Sort u_1) → (x : List Unit) → ((x : List Unit) → motive x) → motive x | null | false |
Std.DHashMap.getD_modify | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k k' : α}
{fallback : β k'} {f : β k → β k},
(m.modify k f).getD k' fallback =
if heq : (k == k') = true then (Option.map (cast ⋯) (Option.map f (m.get? k))).getD fallback else m.getD k' fallback | null | true |
AddSubgroup.isComplement_iff_bijective | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} [inst_1 : SetLike S G] (s t : S),
AddSubgroup.IsComplement ↑s ↑t ↔ Function.Bijective fun x => ↑x.1 + ↑x.2 | The correct way to unfold `IsComplement` for `SetLike`s such as `AddSubgroup`s | true |
instToStringFormat | Init.Data.ToString.Basic | ToString Std.Format | null | true |
Vector.mem_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {a : α} (xs : Vector α n) {ys : Vector α m}, a ∈ ys → a ∈ xs ++ ys | null | true |
NonUnitalSubsemiring.closure_mono | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] ⦃s t : Set R⦄,
s ⊆ t → NonUnitalSubsemiring.closure s ≤ NonUnitalSubsemiring.closure t | Subsemiring closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`. | true |
Aesop.GoalKind.recOn | Aesop.Stats.Basic | {motive : Aesop.GoalKind → Sort u} →
(t : Aesop.GoalKind) → motive Aesop.GoalKind.preNorm → motive Aesop.GoalKind.postNorm → motive t | null | false |
FreeAddGroup.Red.negRev | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)},
FreeAddGroup.Red L₁ L₂ → FreeAddGroup.Red (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂) | null | true |
CategoryTheory.BinaryCofan.isVanKampen_iff | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (c : CategoryTheory.Limits.BinaryCofan X Y),
CategoryTheory.IsVanKampenColimit c ↔
∀ {X' Y' : C} (c' : CategoryTheory.Limits.BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
CategoryTheory.CategoryStruct.comp αX c.inl = Cat... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.summable_weierstrassPExceptSummand._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Submodule.projectionL_add_projectionL_eq_id | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : Submodule R M} [inst_4 : IsTopologicalAddGroup M] (h : Submodule.IsTopCompl p q),
p.projectionL q h + q.projectionL p ⋯ = ContinuousLinearMap.id R M | null | true |
_private.Batteries.Data.String.Lemmas.0.String.utf8GetAux_of_valid._simp_1_3 | Batteries.Data.String.Lemmas | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
ImportGraph.Shake.DeclNeeds.insertFixedDeclFor | ImportGraph.Shake.DeclNeeds | Lean.Name →
ImportGraph.Shake.DeclDeclNeedsKind →
Lean.Name → Lean.Name → ImportGraph.Shake.DeclNeeds → ImportGraph.Shake.DeclNeeds | null | true |
Std.ExtTreeMap.getD_eq_fallback_of_contains_eq_false | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α}
{fallback : β}, t.contains a = false → t.getD a fallback = fallback | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.IsImage.ofArrowIso._simp_2 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) = (f = CategoryTheory.CategoryStruct.comp g α) | null | false |
Polynomial.supNorm_eq_zero_iff | Mathlib.Analysis.Polynomial.Norm | ∀ {A : Type u_1} [inst : NormedRing A] (p : Polynomial A), p.supNorm = 0 ↔ p = 0 | null | true |
UpperSet.instAddAction._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : Preorder α], Function.Injective SetLike.coe | null | false |
CategoryTheory.GrothendieckTopology.toPlus_comp_plusCompIso_inv | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.Multicospan... | null | true |
Int.tdiv.eq_4 | Init.Data.Int.DivMod.Lemmas | ∀ (m n : ℕ), (Int.negSucc m).tdiv (Int.negSucc n) = Int.ofNat (m.succ / n.succ) | null | true |
closedBall_rpow_sub_one_eq_empty_aux | Mathlib.Analysis.SpecialFunctions.JapaneseBracket | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] {r t : ℝ}, 0 < r → 1 < t → Metric.closedBall 0 (t ^ (-r⁻¹) - 1) = ∅ | null | true |
Vector.mapFinIdx._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i < xs.toArray.size, i < n | null | false |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_liminf._simp_1_8 | Mathlib.Order.Filter.ENNReal | ∀ {p : NNReal → Prop}, (∀ (x : NNReal), p x) = ∀ (x : ℝ) (hx : 0 ≤ x), p (NNReal.mk x hx) | null | false |
Lean.ElabInline.custom.sizeOf_spec | Lean.DocString.Extension | ∀ (val : Dynamic), sizeOf (Lean.ElabInline.custom val) = 1 + sizeOf val | null | true |
Array.eraseIdx_insertIdx_self | Init.Data.Array.InsertIdx | ∀ {α : Type u} {a : α} {i : ℕ} {xs : Array α} (h : i ≤ xs.size), (xs.insertIdx i a h).eraseIdx i ⋯ = xs | null | true |
OrderDual.instDivisionRing | Mathlib.Algebra.Field.Basic | {K : Type u_1} → [DivisionRing K] → DivisionRing Kᵒᵈ | null | true |
Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get? (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)) k =
if k ∈ t ∨ l.contains k = true then so... | null | true |
Lean.Compiler.LCNF.Simp.DiscrM.Context.mk.sizeOf_spec | Lean.Compiler.LCNF.Simp.DiscrM | ∀ (discrCtorMap : Lean.FVarIdMap Lean.Compiler.LCNF.Simp.CtorInfo) (ctorDiscrMap : Lean.PersistentExprMap Lean.FVarId),
sizeOf { discrCtorMap := discrCtorMap, ctorDiscrMap := ctorDiscrMap } = 1 + sizeOf discrCtorMap + sizeOf ctorDiscrMap | null | true |
MeasureTheory.Measure.MeasurableSet.nullMeasurableSet_subtype_coe | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {t : Set ↑s},
MeasureTheory.NullMeasurableSet s μ → MeasurableSet t → MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ | null | true |
Ideal.uniqueUnits | Mathlib.RingTheory.Ideal.Operations | {R : Type u} → [inst : CommSemiring R] → Unique (Ideal R)ˣ | null | true |
Complex.range_sin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Set.range Complex.sin = Set.univ | null | true |
instAssociativeMinOnOfIsLinearPreorder | Init.Data.Order.MinMaxOn | ∀ {β : Type u_1} {α : Sort u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β},
Std.Associative (minOn f) | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.mk.noConfusion | Std.Http.Data.Body.Stream | {P : Sort u} →
{pendingProducer : Option Std.Http.Body.Channel.Producer✝} →
{pendingConsumer : Option Std.Http.Body.Channel.Consumer✝} →
{interestWaiter : Option (Std.Async.Waiter Bool)} →
{closed : Bool} →
{knownSize : Option Std.Http.Body.Length} →
{pendingIncompleteChunk : O... | null | false |
AddOpposite.instDecidableEq | Mathlib.Algebra.Opposites | {α : Type u_1} → [DecidableEq α] → DecidableEq αᵃᵒᵖ | null | true |
Lean.Grind.AC.Context.vars | Init.Grind.AC | {α : Sort u} → Lean.Grind.AC.Context α → Lean.RArray (PLift α) | null | true |
ContinuousMap.instRing._proof_8 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : Ring β] [IsTopologicalRing β], ContinuousNeg β | null | false |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass._proof_6 | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)).IsCompatibleWithShift ℤ | null | false |
Filter.EventuallyEq.mapClusterPt_iff | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {F : Filter α} {u : α → X} {x : X} {v : α → X},
u =ᶠ[F] v → (MapClusterPt x F u ↔ MapClusterPt x F v) | null | true |
sbtw_const_vsub_iff | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P), Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z | null | true |
CategoryTheory.sum.inrCompInrCompInverseAssociator_hom_app_down | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : E),
((CategoryTheory.sum.inrCompInrCompInverseAssociator C D E).hom.app X).down =
CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
Lean.Parser.Tactic.Grind.finishTrace | Init.Grind.Interactive | Lean.ParserDescr | `finish?` tries to close the current goal using `grind`'s default strategy and suggests a tactic script. | true |
CategoryTheory.Limits.pasteVertIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
{t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂... | Given
```
Y₃ - i₃ -> X₃
| |
g₂ f₂
∨ ∨
Y₂ - i₂ -> X₂
| |
g₁ f₁
∨ ∨
Y₁ - i₁ -> X₁
```
The big square is a pushout if both the small squares are.
| true |
CategoryTheory.MonoidalClosed.curry.eq_1 | Mathlib.CategoryTheory.LocallyCartesianClosed.Sections | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X Y : C}
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry = ⇑((CategoryTheory.ihom.adjunction A).homEquiv Y X) | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalClear._regBuiltin.Lean.Elab.Tactic.evalClear.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | null | false |
Lean.Server.Completion.EligibleDecl.recOn | Lean.Server.Completion.EligibleHeaderDecls | {motive : Lean.Server.Completion.EligibleDecl → Sort u} →
(t : Lean.Server.Completion.EligibleDecl) →
((info : Lean.ConstantInfo) →
(kind : Lean.MetaM Lean.Lsp.CompletionItemKind) →
(tags : Lean.MetaM (Array Lean.Lsp.CompletionItemTag)) →
motive { info := info, kind := kind, tags := ... | null | false |
Vector.zip_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} {n : ℕ},
(Vector.replicate n a).zip (Vector.replicate n b) = Vector.replicate n (a, b) | null | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) ⦃X_1 Y_1 : CategoryTheory.Over Y⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
(({ obj := fun Z => CategoryTheory.Over.mk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X Z... | null | false |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instBEqInsertReplaceEdit.beq.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InsertReplaceEdit → Lean.Lsp.InsertReplaceEdit → Sort u_1) →
(x x_1 : Lean.Lsp.InsertReplaceEdit) →
((a : String) →
(a_1 a_2 : Lean.Lsp.Range) →
(b : String) →
(b_1 b_2 : Lean.Lsp.Range) →
motive { newText := a, insert := a_1, replace := a_2 } { newTe... | null | false |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.definition._simp_6._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.1878421158._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u} {x : α} {S : Set (Set α)}, (x ∈ ⋃₀ S) = ∃ t ∈ S, x ∈ t | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_incenter_eq._proof_1_1 | Mathlib.Geometry.Euclidean.Angle.Incenter | NeZero (1 + 1) | null | false |
ContinuousMap.HomotopicRel.equivalence | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X},
Equivalence fun f g => f.HomotopicRel g S | null | true |
CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_I | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q),
(CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.coimage f | null | true |
_private.Mathlib.Lean.Meta.DiscrTree.0.Lean.Meta.DiscrTree.getSubexpressionMatches.match_1 | Mathlib.Lean.Meta.DiscrTree | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(... | null | false |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.correspondence._simp_5 | Mathlib.RingTheory.Congruence.Hom | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (x ≤ y) = (↑x ≤ ↑y) | null | false |
SimpleGraph.Subgraph.IsMatching | Mathlib.Combinatorics.SimpleGraph.Matching | {V : Type u_1} → {G : SimpleGraph V} → G.Subgraph → Prop | The subgraph `M` of `G` is a matching if every vertex of `M` is incident to exactly one edge in `M`.
We say that the vertices in `M.support` are *matched* or *saturated*.
| true |
Partition.Rel.trans | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {x y z : α} {u : Set α} {P : Partition u}, P.Rel x y → P.Rel y z → P.Rel x z | null | true |
Std.Time.WallTime.addSeconds | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Second.Offset → Std.Time.WallTime | Adds a `Second.Offset` to the given `WallTime`.
| true |
FiniteAddGrp.instConcreteCategoryAddMonoidHomCarrierToAddGrp._aux_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | {X Y : FiniteAddGrp.{u_1}} → (X ⟶ Y) → ↑X.toAddGrp →+ ↑Y.toAddGrp | null | false |
Finset.le_truncatedSup | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeSup α] {s : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : OrderTop α],
a ≤ s.truncatedSup a | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.nonsingular_some._simp_1_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.quot._regBuiltin.Lean.Parser.Command.quot.declRange_5 | Lean.Parser.Command | IO Unit | null | false |
contDiffPointwiseHolderAt_iff | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k : ℕ) (α : ↑unitInterval) (f : E → F) (a : E),
ContDiffPointwiseHolderAt k α f a ↔
ContDiffAt ℝ (↑k) f a ∧ (fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.next_eq_iff.match_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} (motive : (p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q') → Prop)
(x : p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q'),
(∀ (h₁ : p < q) (h₂ : ∀ (q' : s.Pos), p < q' → q ≤ q'), motive ⋯) → motive x | null | false |
Set.singleton_union | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, {a} ∪ s = insert a s | null | true |
Trunc.nonempty | Mathlib.Data.Quot | ∀ {α : Sort u_1} (q : Trunc α), Nonempty α | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mctxBefore | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.TacticData✝ → Lean.MetavarContext | MetavarContext before the tactic | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.addIncBeforeAux | Lean.Compiler.LCNF.ExplicitRC | Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) →
(ℕ → Bool) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure →
Lean.Compiler.LCNF.RcM✝ (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.