name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Linter.whenLinterActivated | Mathlib.Lean.Linter | Lean.Option Bool → Lean.Elab.Command.CommandElab → optParam Bool true → Lean.Elab.Command.CommandElab | true |
SpecialLinearGroup.SL2Z_generators | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | Subgroup.closure {ModularGroup.S, ModularGroup.T} = ⊤ | true |
Int64.toUInt64_neg | Init.Data.SInt.Lemmas | ∀ (a : Int64), (-a).toUInt64 = -a.toUInt64 | true |
Multipliable.tprod_subtype_mul_tprod_subtype_compl | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : CommGroup α] [IsUniformGroup α] [CompleteSpace α]
[T2Space α] {f : β → α}, Multipliable f → ∀ (s : Set β), (∏' (x : ↑s), f ↑x) * ∏' (x : ↑sᶜ), f ↑x = ∏' (x : β), f x | true |
ContinuousAffineMap.comp_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] {W₂ : Type u_6} {... | true |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_of_le_of_ne._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | false |
DyckWord.ctorIdx | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → ℕ | false |
Std.IterM.toIter_mk | Init.Data.Iterators.Basic | ∀ {α β : Type u_1} {it : α}, { internalState := it }.toIter = { internalState := it } | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.markRhss.match_1 | Lean.Elab.Quotation | (motive : Lean.TSyntax `term × Lean.TSyntax `term → Sort u_1) →
(__discr : Lean.TSyntax `term × Lean.TSyntax `term) →
((idx rhs : Lean.TSyntax `term) → motive (idx, rhs)) → motive __discr | false |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ_of_pos._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {xs : List α} {i : ℕ} {a : α},
p a = true → List.countPBefore p (a :: xs) (i + 1) = List.countPBefore p xs i + 1 | false |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'.congr_simp | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n),
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd' C a b n h =
CategoryThe... | true |
IsLocalization.exists_mk'_eq | 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] (z : S), ∃ x y, IsLocalization.mk' S x y = z | true |
MeasureTheory.SimpleFunc.instNonAssocRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocRing β],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | false |
Mathlib.Tactic.Push.elabHead | Mathlib.Tactic.Push | Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.Push.Head | true |
_private.Init.Data.List.Nat.BEq.0.List.beq_eq_isEqv._simp_1_2 | Init.Data.List.Nat.BEq | ∀ {n : ℕ} {p : (m : ℕ) → m < n + 1 → Prop},
(∀ (m : ℕ) (h : m < n + 1), p m h) = (p 0 ⋯ ∧ ∀ (m : ℕ) (h : m < n), p (m + 1) ⋯) | false |
Char.toUpper_toUpper_eq_toUpper | Batteries.Data.Char.AsciiCasing | ∀ (c : Char), c.toUpper.toUpper = c.toUpper | true |
Aesop.Frontend.RuleExpr.rec_1 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.... | false |
LinearEquiv.toSpanNonzeroSingleton._proof_4 | Mathlib.LinearAlgebra.Span.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.IsTorsionFree R M] (x : M), x ≠ 0 → Function.Injective ⇑(LinearMap.toSpanSingleton R M x) | false |
Polynomial.algebra | Mathlib.RingTheory.PolynomialAlgebra | (R : Type u_1) →
(A : Type u_3) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra (Polynomial R) (Polynomial A) | true |
ContinuousMulEquiv.trans.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {L : Type u_3} [inst_4 : Mul L] [inst_5 : TopologicalSpace L] (cme1 : M ≃ₜ* N) (cme2 : N ≃ₜ* L),
cme1.trans cme2 = { toMulEquiv := cme1.trans cme2.toMulEquiv, continuous_toFun := ⋯, continuous... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.three_le_length.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V}
(motive : (p : G.Walk v v) → p.IsCycle → p.IsTrail → p ≠ SimpleGraph.Walk.nil → p.support.tail.Nodup → Prop)
(p : G.Walk v v) (hp : p.IsCycle) (hp_1 : p.IsTrail) (hp' : p ≠ SimpleGraph.Walk.nil)
(support_nodup : p.support.tail.Nodup),
(∀ (hp : SimpleGraph.Walk.nil.Is... | false |
_private.Mathlib.Data.Int.Interval.0.Finset.Ico_succ_succ._simp_1_2 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
OrderMonoidIso.instEquivLike.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β],
OrderMonoidIso.instEquivLike =
{ coe := fun f => f.toFun, inv := fun f => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ } | true |
isOpen_iff_ultrafilter | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ nhds x → s ∈ l | true |
AddCommGrpCat.Forget₂.createsLimit._proof_7 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections)
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp
((Category... | false |
Hyperreal.infinitePos_mul_of_not_infinitesimal_pos_infinitePos | Mathlib.Analysis.Real.Hyperreal | ∀ {x y : ℝ*}, ¬x.Infinitesimal → 0 < x → y.InfinitePos → (x * y).InfinitePos | true |
Lean.Grind.IntInterval.isFinite.eq_4 | Init.Grind.ToInt | Lean.Grind.IntInterval.ii.isFinite = false | true |
Complex.cderiv._proof_1 | Mathlib.Analysis.Complex.LocallyUniformLimit | (1 + 1).AtLeastTwo | false |
Fin.castSucc_eq_zero_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, (a.castSucc = 0) = (a = 0) | false |
_private.Init.Data.String.Decode.0.parseFirstByte_eq_oneMore_of_utf8DecodeChar?_eq_some._proof_1_3 | Init.Data.String.Decode | ∀ {b : ByteArray} {i : ℕ} {c : Char}, c.utf8Size = 2 → c.utf8Size = 3 → False | false |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.degree_comp._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R},
(p.comp q = 0) = (p = 0 ∨ Polynomial.eval (q.coeff 0) p = 0 ∧ q = Polynomial.C (q.coeff 0)) | false |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_convRing_nf!__1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | false |
SimpleGraph.UnitDistEmbedding.subsingleton._proof_2 | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | ∀ {V : Type u_1} {E : Type u_2} [Subsingleton V] (x : E), Function.Injective fun x_1 => x | false |
hasSum_fourier_series_of_summable | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} [hT : Fact (0 < T)] {f : C(AddCircle T, ℂ)},
Summable (fourierCoeff ⇑f) → HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f | true |
CategoryTheory.PreGaloisCategory.IsNaturalSMul.casesOn | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
{G : Type u_1} →
[inst_1 : Group G] →
[inst_2 : (X : C) → MulAction G (F.obj X).obj] →
{motive : CategoryTheory.PreGaloisCategory.IsNaturalSMul F G → Sort u} →
... | false |
CategoryTheory.Functor.FullyFaithful.homNatIsoMaxRight | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{max v₁ v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
F.FullyFaithful →
(X : C) → F.op.comp (CategoryTheory.yoneda.obj (F.obj X)) ≅ CategoryTheory.uliftYoneda.{v₂, ... | true |
_private.Mathlib.Analysis.Polynomial.CauchyBound.0.Polynomial.IsRoot.norm_lt_cauchyBound._simp_1_10 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Finset.Nonempty.of_image | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α},
(Finset.image f s).Nonempty → s.Nonempty | true |
CategoryTheory.surjective_up_to_refinements_of_epi | Mathlib.CategoryTheory.Abelian.Refinements | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Epi f] {A : C} (y : A ⟶ Y),
∃ A' π,
∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f | true |
SimpleGraph.Hom.injective_of_top_hom | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G' : SimpleGraph W} (f : ⊤ →g G'), Function.Injective ⇑f | true |
CategoryTheory.Sheaf.instAddCommGroupH._aux_4 | Mathlib.CategoryTheory.Sites.SheafCohomology.Basic | {C : Type u_4} →
[inst : CategoryTheory.Category.{u_3, u_4} C] →
{J : CategoryTheory.GrothendieckTopology C} →
(F : CategoryTheory.Sheaf J AddCommGrpCat) →
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat] →
[inst_2 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)] → (n :... | false |
Std.Do.WP.liftWith_refl | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {α : Type u} {Q : Std.Do.PostCond α ps} [inst : Std.Do.WP m ps]
[inst_1 : Pure m] (f : ({β : Type u} → m β → m β) → m α),
(Std.Do.wp (liftWith f)).apply Q = (Std.Do.wp (f fun {β} x => x)).apply Q | true |
ENat.LEInfty.out | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {m : WithTop ℕ∞} [self : ENat.LEInfty m], m ≤ ↑⊤ | true |
Lean.Compiler.LCNF.TraverseFVar.forFVarM | Lean.Compiler.LCNF.FVarUtil | {α : Type} →
[self : Lean.Compiler.LCNF.TraverseFVar α] → {m : Type → Type} → [Monad m] → (Lean.FVarId → m Unit) → α → m Unit | true |
Lean.Meta.initFn._@.Lean.Meta.Tactic.Intro.3089346791._hygCtx._hyg.4 | Lean.Meta.Tactic.Intro | IO (Lean.Option Bool) | false |
isClosed_of_mem_irreducibleComponents | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X], ∀ s ∈ irreducibleComponents X, IsClosed s | true |
Subgroup.instDistribMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Group.Subgroup.Actions | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : AddMonoid α] [inst_2 : DistribMulAction G α] (S : Subgroup G)
(r : ↥S.toSubmonoid) (b₁ b₂ : α), ↑r • (b₁ + b₂) = ↑r • b₁ + ↑r • b₂ | false |
Std.DHashMap.containsThenInsertIfNew_fst | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {k : α} {v : β k},
(m.containsThenInsertIfNew k v).1 = m.contains k | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.lratChecker.match_3.eq_3 | Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound | ∀ {α : Type u_1} {β : Type u_2} (motive : List (Std.Tactic.BVDecide.LRAT.Action β α) → Sort u_3) (id : ℕ) (c : β)
(rupHints : Array ℕ) (restPrf : List (Std.Tactic.BVDecide.LRAT.Action β α)) (h_1 : Unit → motive [])
(h_2 :
(id : ℕ) →
(rupHints : Array ℕ) →
(tail : List (Std.Tactic.BVDecide.LRAT.Act... | true |
le_of_forall_neg_add_le | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] [DenselyOrdered α] {a b : α},
(∀ ε < 0, a + ε ≤ b) → a ≤ b | true |
IsCompact.closedBall_zero_add | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {δ : ℝ} {s : Set E},
IsCompact s → 0 ≤ δ → Metric.closedBall 0 δ + s = Metric.cthickening δ s | true |
IsUpperSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsUpperSet s → IsLowerSet sᶜ | true |
HomotopicalAlgebra.CofibrantObject.toHoCatLocalizerMorphism | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.CofibrantObject C))
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.CofibrantObject.HoCa... | true |
PowerBasis.trace_gen_eq_nextCoeff_minpoly | Mathlib.RingTheory.Trace.Basic | ∀ {S : Type u_2} [inst : CommRing S] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra K S] [Nontrivial S]
(pb : PowerBasis K S), (Algebra.trace K S) pb.gen = -(minpoly K pb.gen).nextCoeff | true |
Lean.Level.hash | Lean.Level | Lean.Level → UInt64 | true |
Real.Angle.two_zsmul_eq_zero_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑Real.pi | true |
Int.toList_rcc_eq_cons_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {xs : List ℤ} {m n a : ℤ}, ((m...=n).toList = a :: xs) = (m = a ∧ m ≤ n ∧ ((m + 1)...=n).toList = xs) | false |
CategoryTheory.Functor.mapIso_hom | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y), (F.mapIso i).hom = F.map i.hom | true |
inner_map_complex | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {G : Type u_4} [inst : SeminormedAddCommGroup G] [inst_1 : InnerProductSpace ℝ G] (f : G ≃ₗᵢ[ℝ] ℂ) (x y : G),
inner ℝ x y = (f y * (starRingEnd ℂ) (f x)).re | true |
LinearMap.toContinuousBilinearMap._proof_11 | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {G : Type u_2} [inst_1 : AddCommGroup G] [inst_2 : Module 𝕜 G]
[inst_3 : TopologicalSpace G] [ContinuousSMul 𝕜 G], ContinuousConstSMul 𝕜 G | false |
OpenPartialHomeomorph.IsImage.iff_symm_preimage_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e : OpenPartialHomeomorph X Y} {s : Set X} {t : Set Y}, e.IsImage s t ↔ e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t | true |
Submodule.prod_comap_inr | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (q : Submodule R M₂),
Submodule.comap (LinearMap.inr R M M₂) (p.prod q) = q | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {P : Sort u} →
{c₁ c₂ c₁' c₂' : Lean.Meta.Grind.Arith.Linear.IneqCnstr} →
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine c₁ c₂ =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine c₁' c₂' →
(c₁ = c₁' → c₂ = c₂' → P) → P | false |
MeasureTheory.Integrable.congr' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
MeasureTheory.Integrable f μ →
MeasureTheory.AEStronglyMeasurable g μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ = ‖g a‖) → MeasureTheory.Integ... | true |
CategoryTheory.ShortComplex.SnakeInput.v₂₃ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] → (self : CategoryTheory.ShortComplex.SnakeInput C) → self.L₂ ⟶ self.L₃ | true |
Nat.factorization_centralBinom_eq_zero_of_two_mul_lt | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n : ℕ}, 2 * n < p → n.centralBinom.factorization p = 0 | true |
isCompact_Ioo_iff._simp_1 | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] [DenselyOrdered α] {a b : α},
IsCompact (Set.Ioo a b) = (b ≤ a) | false |
Lean.Elab.Structural.RecArgInfo.fixedParamPerm | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → Lean.Elab.FixedParamPerm | true |
Lean.Elab.Term.elabLetRec._regBuiltin.Lean.Elab.Term.elabLetRec.declRange_3 | Lean.Elab.LetRec | IO Unit | false |
IntermediateField.sum_mem | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{ι : Type u_4} {t : Finset ι} {f : ι → L}, (∀ c ∈ t, f c ∈ S) → ∑ i ∈ t, f i ∈ S | true |
AugmentedSimplexCategory.equivAugmentedSimplicialObjectFunctorCompDropIso | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
AugmentedSimplexCategory.equivAugmentedSimplicialObject.functor.comp
CategoryTheory.SimplicialObject.Augmented.drop ≅
(CategoryTheory.Functor.whiskeringLeft SimplexCategoryᵒᵖ AugmentedSimplexCategoryᵒᵖ C).obj
AugmentedSimplexCa... | true |
CategoryTheory.EnrichedCat.bicategory._proof_4 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} (f : CategoryTheory.EnrichedFunctor V ↑a ↑b)
{g h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (η : g ⟶ h) (θ : h ⟶ i),
CategoryTheory.EnrichedCat.whiskerLeft f (Catego... | false |
HomologicalComplex.extend_d_to_eq_zero | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : 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.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) (e : c.Embedding c') (i' j' : ι')
(j : ι), e.f... | true |
MeasureTheory.SimpleFunc.setToSimpleFunc_mono | Mathlib.MeasureTheory.Integral.FinMeasAdditive | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G' : Type u_7} {G'' : Type u_8}
[inst : NormedAddCommGroup G''] [inst_1 : PartialOrder G''] [IsOrderedAddMonoid G''] [inst_3 : NormedSpace ℝ G'']
[inst_4 : NormedAddCommGroup G'] [inst_5 : PartialOrder G'] [inst_6 : NormedSpace ℝ G'] [IsOrdered... | true |
Matrix.SpecialLinearGroup.instPowNat | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] → {R : Type v} → [inst_2 : CommRing R] → Pow (Matrix.SpecialLinearGroup n R) ℕ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
ENNReal.ofNNReal_add_natCast | Mathlib.Data.ENNReal.Basic | ∀ (r : NNReal) (n : ℕ), ↑(r + ↑n) = ↑r + ↑n | true |
WithZero.not_lt_zero | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LT α] (a : WithZero α), ¬a < 0 | true |
Std.ExtDTreeMap.Const.get! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{β : Type v} → [Std.TransCmp cmp] → [Inhabited β] → Std.ExtDTreeMap α (fun x => β) cmp → α → β | true |
Filter.Realizer.cofinite | Mathlib.Data.Analysis.Filter | {α : Type u_1} → [DecidableEq α] → Filter.cofinite.Realizer | true |
CategoryTheory.IsPushout.isVanKampen_iff | Mathlib.CategoryTheory.Adhesive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z}
(H : CategoryTheory.IsPushout f g h i),
H.IsVanKampen ↔ CategoryTheory.IsVanKampenColimit (CategoryTheory.Limits.PushoutCocone.mk h i ⋯) | true |
CochainComplex.mappingConeCompTriangle._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ : CochainComplex C ℤ} (f : X₁ ⟶ X₂),
HomologicalComplex.HasHomotopyCofiber f | false |
sup_eq_of_isMaxOn | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α} {a : α},
a ∈ s → IsMaxOn D (↑s) a → s.sup D = D a | true |
Lean.Lsp.CompletionClientCapabilities.rec | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.CompletionClientCapabilities → Sort u} →
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) → motive { completionItem? := completionItem? }) →
(t : Lean.Lsp.CompletionClientCapabilities) → motive t | false |
ULift.normedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : NormedRing α] (x y : ULift.{u_1, u_2} α), dist x y = ‖-x + y‖ | false |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.instIsLeftKanExtensionProdDiscretePUnitExternalProductExtensionUnitLeftφ | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(U : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolutionUnit U]
(F : Ca... | true |
Std.Broadcast.Sync.Receiver.recv | Std.Sync.Broadcast | {α : Type} → [Inhabited α] → Std.Broadcast.Sync.Receiver α → BaseIO (Option α) | true |
Lean.Lsp.InlayHintOptions.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{toWorkDoneProgressOptions : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider? : Option Bool} →
{toWorkDoneProgressOptions' : Lean.Lsp.WorkDoneProgressOptions} →
{resolveProvider?' : Option Bool} →
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions, resolveProvider... | false |
CategoryTheory.ShiftedHom.homEquiv | 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} → (m₀ : M) → m₀ = 0 → (X ⟶ Y) ≃ CategoryTheory.ShiftedHom X Y m₀ | true |
_private.Mathlib.Order.Filter.Cofinite.0.Filter.coprodᵢ_cofinite._simp_1_1 | Mathlib.Order.Filter.Cofinite | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : Set ((i : ι) → α i)},
(sᶜ ∈ Filter.coprodᵢ f) = ∀ (i : ι), (Function.eval i '' s)ᶜ ∈ f i | false |
DerivedCategory.instIsTriangulated | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], CategoryTheory.IsTriangulated (DerivedCategory C) | true |
EuclideanGeometry.concyclic_singleton | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (p : P), EuclideanGeometry.Concyclic {p} | true |
_private.Mathlib.Logic.Denumerable.0.Nat.Subtype.le_succ_of_forall_lt_le._proof_1_2 | Mathlib.Logic.Denumerable | ∀ {s : Set ℕ} [inst : DecidablePred fun x => x ∈ s] {y : ↑s} (hx : ∃ m, ↑y + m + 1 ∈ s), ↑y < ↑y + Nat.find hx + 1 | false |
Perfection.instCommRing | Mathlib.RingTheory.Perfection | (R : Type u_1) → [inst : CommRing R] → (p : ℕ) → [hp : Fact (Nat.Prime p)] → [CharP R p] → CommRing (Perfection R p) | true |
_private.Mathlib.Data.ZMod.Basic.0.Nat.range_mul_add._simp_1_6 | Mathlib.Data.ZMod.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) | false |
sInf_add | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sInf (s + t) = sInf s + sInf t | true |
SSet.RelativeMorphism.botEquiv | Mathlib.AlgebraicTopology.SimplicialSet.Homotopy | {X Y : SSet} → SSet.RelativeMorphism ⊥ ⊥ (SSet.Subcomplex.isInitialBot.to ⊥.toSSet) ≃ (X ⟶ Y) | true |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt.match_1_1 | Init.Data.Range.Polymorphic.SInt | ∀ (motive : (n : ℕ) → {lo hi : BitVec n} → n > 0 → Prop) (n : ℕ) {lo hi : BitVec n} (h : n > 0),
(∀ (lo hi : BitVec 0) (h : 0 > 0), motive 0 h) →
(∀ (n : ℕ) (lo hi : BitVec (n + 1)) (h : n + 1 > 0), motive n.succ h) → motive n h | false |
_private.Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor.0.CategoryTheory.MonoidalCategory.DayFunctor.hom_ext._proof_1_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {V : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {F G : CategoryTheory.MonoidalCategory.DayFunctor C V}
(natTrans natTrans_1 : F.functor ⟶ G.functo... | false |
CategoryTheory.Adjunction.mkOfUnitCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : CategoryTheory.Adjunction.CoreUnitCounit F G) (Y : D),
CategoryTheory.CategoryStruct.comp (adj.unit.app (G.obj Y)) ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.