name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Filter.liminf_bot | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α), Filter.liminf f ⊥ = ⊤ | null | true |
_private.Mathlib.Analysis.Analytic.Within.0.analyticWithinAt_of_singleton_mem._simp_1_3 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn.eq_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] (f : α → β) (y : α) (ys : List α)
(h_2 : y :: ys ≠ []), List.minIdxOn f (y :: ys) h_2 = List.minIdxOn.go✝ f y 0 1 ys | null | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.LocallyCompactSpace.of_hasBasis.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {ι : X → Type u_1} {p : (x : X) → ι x → Prop} {s : (x : X) → ι x → Set X} (x : X) (_t : Set X)
(motive : (∃ i, p x i ∧ s x i ⊆ _t) → Prop) (x_1 : ∃ i, p x i ∧ s x i ⊆ _t),
(∀ (i : ι x) (hp : p x i) (ht : s x i ⊆ _t), motive ⋯) → motive x_1 | null | false |
Lean.Grind.toInt_bitVec | Init.GrindInstances.ToInt | ∀ {v : ℕ} (x : BitVec v), ↑x = ↑x.toNat | null | true |
Int.natAbs_dvd_natAbs._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ}, (a.natAbs ∣ b.natAbs) = (a ∣ b) | null | false |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_5, u_4} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
{X Y : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} (f : X ⟶ Y)
(X' : PresheafOf... | null | false |
Std.Http.Protocol.H1.Reader.State.ctorElim | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} →
{motive : Std.Http.Protocol.H1.Reader.State dir → Sort u} →
(ctorIdx : ℕ) →
(t : Std.Http.Protocol.H1.Reader.State dir) →
ctorIdx = t.ctorIdx → Std.Http.Protocol.H1.Reader.State.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.StructuredArrow.pre_obj_hom | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : D) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S)... | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), n + m = 0 → m = -n | null | false |
ModelWithCorners.continuousOn_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {s : Set E},
ContinuousOn (↑I.symm) s | null | true |
Group.IsFinitelyPresented.instMultiplicativeInt | Mathlib.GroupTheory.FinitelyPresentedGroup | Group.IsFinitelyPresented (Multiplicative ℤ) | `Multiplicative ℤ` is finitely presented. | true |
_private.Mathlib.Topology.DiscreteSubset.0.discreteTopology_iUnion_finite._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_5} [inst : TopologicalSpace X] {s : Set X}, DiscreteTopology ↑s = IsDiscrete s | null | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM.computeCoefficients.go._sunfold | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap →
Lean.Expr →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting_0_CategoryTheory_Limits_termI₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.Macro | null | false |
Prod.Lex.uniqueProd | Mathlib.Order.Hom.Lex | (α : Type u_2) → (β : Type u_3) → [inst : Preorder α] → [Unique α] → [inst_2 : LE β] → Lex (α × β) ≃o β | Lexicographic product type with `Unique` type on the left is `OrderIso` to the right. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
AnalyticOn.contDiff | 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] {f : E → F}
{n : WithTop ℕ∞}, AnalyticOn 𝕜 f Set.univ → ContDiff 𝕜 n f | null | true |
AlgebraicIndependent.matroid.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ (R : Type u_1) (A : Type w) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : NoZeroDivisors A],
AlgebraicIndependent.matroid R A = AlgebraicIndependent.matroid R A | null | true |
CategoryTheory.Functor.additive_of_comp_faithful | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : CategoryTheory.Preadditive D]
[inst_5 : CategoryTheory.Preadditive E] (F : ... | null | true |
WithLp.prodContinuousLinearEquiv_symm_apply_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Semiring 𝕜] [inst_3 : AddCommGroup α] [inst_4 : AddCommGroup β] [inst_5 : Module 𝕜 α] [inst_6 : Module 𝕜 β]
(a : α × β), ((WithLp.prodContinuousLinearEquiv p 𝕜 α β).symm a).ofLp = a | null | true |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.quotientInfEquivProdNormalizerQuotient._simp_4 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ H.subgroupOf K) = (↑h ∈ H) | null | false |
AddOpposite.instRightCancelSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [RightCancelSemigroup α] → RightCancelSemigroup αᵃᵒᵖ | null | true |
Algebra.intNorm_eq_of_isLocalization | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ {A : Type u_1} {B : Type u_6} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {Aₘ : Type u_9}
{Bₘ : Type u_10} [inst_3 : CommRing Aₘ] [inst_4 : CommRing Bₘ] [inst_5 : Algebra Aₘ Bₘ] [inst_6 : Algebra A Aₘ]
[inst_7 : Algebra B Bₘ] [inst_8 : Algebra A Bₘ] [IsScalarTower A Aₘ Bₘ] [IsScalarTower A B ... | null | true |
Lean.Elab.Term.LetRecToLift.termination | Lean.Elab.Term.TermElabM | Lean.Elab.Term.LetRecToLift → Lean.Elab.TerminationHints | null | true |
Vector.toArray_reverse | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), xs.reverse.toArray = xs.toArray.reverse | null | true |
Lean.Elab.FieldInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.FieldInfo} → t = t' → Lean.Elab.FieldInfo.noConfusionType P t t' | null | false |
MvPolynomial.eval₂_const_uniqueAlgEquiv | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Unique σ]
{f : MvPolynomial σ R} {φ : R →+* S} {a : S},
Polynomial.eval₂ φ a ((MvPolynomial.uniqueAlgEquiv R σ) f) = MvPolynomial.eval₂ φ (fun x => a) f | null | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.drop.match_1.eq_1 | Mathlib.Data.WSeq.Basic | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
GromovHausdorff.instMetricSpaceOptimalGHCoupling._proof_22 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ (X : Type u_1) (Y : Type u_2) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
[inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y],
GromovHausdorff.instMetricSpaceOptimalGHCoupling._aux_20 X Y ≤ Filter.cofinite | null | false |
_private.Mathlib.Topology.Order.LowerUpperTopology.0.Topology.IsLower.isTopologicalSpace_basis._simp_1_6 | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
TypeVec.prod.diag.eq_1 | Mathlib.Data.TypeVec | ∀ (n : ℕ) (α : TypeVec.{u} n.succ) (a : Fin2 n) (x_4 : α a.fs), TypeVec.prod.diag a.fs x_4 = TypeVec.prod.diag a x_4 | null | true |
CategoryTheory.SimplicialObject.σ_δ₀Iter'._auto_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | Lean.Syntax | null | false |
FreeMonoid.of_injective | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, Function.Injective FreeMonoid.of | null | true |
Lean.Grind.instCommRingBitVec._proof_1 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ), OfNat.ofNat n = ↑n | null | false |
_private.Mathlib.Data.Finset.Defs.0.Finset.forall_mem_not_eq._proof_1_1 | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s : Finset α} {a : α}, (∀ b ∈ s, ¬a = b) ↔ a ∉ s | null | false |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exists_closedBall_covering_tsum_measure_le._simp_1_16 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} {s : Set α} {p : ↑s → Prop}, (∀ (x : ↑s), p x) = ∀ (x : α) (h : x ∈ s), p ⟨x, h⟩ | null | false |
_private.Mathlib.Data.List.Sym.0.List.Nodup.sym2._simp_1_8 | Mathlib.Data.List.Sym | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
UniformEquiv.piCongrRight_symm | Mathlib.Topology.UniformSpace.Equiv | ∀ {ι : Type u_4} {β₁ : ι → Type u_5} {β₂ : ι → Type u_6} [inst : (i : ι) → UniformSpace (β₁ i)]
[inst_1 : (i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i),
(UniformEquiv.piCongrRight F).symm = UniformEquiv.piCongrRight fun i => (F i).symm | null | true |
Disjoint.isCompl_sup_right_of_isCompl_sup_left | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} {a b c : α} [inst : Lattice α] [inst_1 : BoundedOrder α] [IsModularLattice α],
Disjoint a b → IsCompl (a ⊔ b) c → IsCompl a (b ⊔ c) | null | true |
SimplexCategoryGenRel.δ_comp_δ_assoc | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 2)},
i ≤ j →
∀ {Z : SimplexCategoryGenRel} (h : SimplexCategoryGenRel.mk (n + 1 + 1) ⟶ Z),
CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.δ i)
(CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.δ j.succ) h) =
CategoryTheory.CategoryStruct.comp (... | null | true |
CauSeq.Completion.ofRat_injective | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv], Function.Injective CauSeq.Completion.ofRat | null | true |
CategoryTheory.Abelian.Ext.mono_postcomp_mk₀_of_mono | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (L : C) {M N : C} (f : M ⟶ N) [hf : CategoryTheory.Mono f],
CategoryTheory.Mono (AddCommGrpCat.ofHom ((CategoryTheory.Abelian.Ext.mk₀ f).postcomp L ⋯)) | null | true |
PNat.XgcdType.instSizeOf | Mathlib.Data.PNat.Xgcd | SizeOf PNat.XgcdType | null | true |
ConvexCone.instCompleteLattice._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] (a b : ConvexCone R M), a ≤ SemilatticeSup.sup a b | null | false |
Lean.Elab.Info.ofOptionInfo.inj | Lean.Elab.InfoTree.Types | ∀ {i i_1 : Lean.Elab.OptionInfo}, Lean.Elab.Info.ofOptionInfo i = Lean.Elab.Info.ofOptionInfo i_1 → i = i_1 | null | true |
Lean.InductiveType.noConfusionType | Lean.Declaration | Sort u → Lean.InductiveType → Lean.InductiveType → Sort u | null | false |
_private.Mathlib.Order.LiminfLimsup.0.limsup_finset_sup'._simp_1_4 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a ≤ s.sup' H f) = ∃ b ∈ s, a ≤ f b | null | false |
DecompositionMonoid | Mathlib.Algebra.Divisibility.Basic | (α : Type u_1) → [Semigroup α] → Prop | A monoid is a decomposition monoid if every element is primal. An integral domain whose
multiplicative monoid is a decomposition monoid, is called a pre-Schreier domain; it is a
Schreier domain if it is moreover integrally closed. | true |
IsLocalization.mk'_eq_mk' | Mathlib.Algebra.Module.LocalizedModule.IsLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_2) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] (x : R) (s : ↥S),
IsLocalization.mk' A x s = IsLocalizedModule.mk' (Algebra.linearMap R A) x s | `IsLocalization.mk'` agrees with `IsLocalizedModule.mk'`. | true |
Submodule.ker_inl | 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₂], (LinearMap.inl R M M₂).ker = ⊥ | null | true |
Batteries.Tactic.DiscrTreeCache.getMatch | Batteries.Util.Cache | {α : Type} → Batteries.Tactic.DiscrTreeCache α → Lean.Expr → Lean.MetaM (Array α) | Get matches from both the discrimination tree for declarations in the current file,
and for the imports.
Note that if you are calling this multiple times with the same environment,
it will rebuild the discrimination tree for the current file multiple times,
and it would be more efficient to call `c.get` once,
and then... | true |
Lean.Lsp.DeclarationParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.DeclarationParams} → t = t' → Lean.Lsp.DeclarationParams.noConfusionType P t t' | null | false |
Nat.factorial_pos | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ), 0 < n.factorial | null | true |
Inter.inter | Init.Core | {α : Type u} → [self : Inter α] → α → α → α | `a ∩ b` is the intersection of `a` and `b`.
Conventions for notations in identifiers:
* The recommended spelling of `∩` in identifiers is `inter`. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_concat_succ._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {k n m : ℕ}, (n + k < m + k) = (n < m) | null | false |
IsAddCyclic.index_nsmulAddMonoidHom_range | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (G : Type u_2) [inst : AddCommGroup G] [IsAddCyclic G] [Finite G] (d : ℕ),
(nsmulAddMonoidHom d).range.index = (Nat.card G).gcd d | null | true |
CategoryTheory.Functor.mapAddGrp._proof_2 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X : CategoryTheory.AddGrp ... | null | false |
Algebra.tensorH1CotangentOfIsLocalization_toLinearMap | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_1) {S : Type u_2} (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (M : Submonoid S)
[inst_7 : IsLocalization M T],
↑(Algebra.tensorH1CotangentOfIsLocalization R T M) = L... | null | true |
_private.Mathlib.Probability.StrongLaw.0.ProbabilityTheory.strong_law_aux1._simp_1_10 | Mathlib.Probability.StrongLaw | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
Lean.Meta.Grind.Arith.CommRing.State.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (rings : Array Lean.Meta.Grind.Arith.CommRing.CommRing) (typeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToRingId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (semirings : Array Lean.Meta.Grind.Arith.CommRing.CommSemiring)
(stypeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToSemiringI... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.cos_arg._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
_private.Std.Sync.Semaphore.0.Std.SemaphoreState | Std.Sync.Semaphore | Type | null | true |
ValuativeRel.inv_vle_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {K : Type u_2} [inst : DivisionRing K] [inst_1 : ValuativeRel K] {x : K}, x ≠ 0 → (x⁻¹ ≤ᵥ 1 ↔ 1 ≤ᵥ x) | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Sort u → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u | null | false |
_private.Init.Data.List.Basic.0.List.getLast?.match_1.eq_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | null | true |
_private.Mathlib.SetTheory.ZFC.VonNeumann.0.ZFSet.mem_vonNeumann_succ._simp_1_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {o : Ordinal.{u}} {x : ZFSet.{u}}, (x ∈ ZFSet.vonNeumann o) = (x.rank < o) | null | false |
TannakaDuality.FiniteGroup.equiv._proof_2 | Mathlib.RepresentationTheory.Tannaka | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G] [Finite G] [IsDomain k],
Function.Injective ⇑(TannakaDuality.FiniteGroup.equivHom k G) ∧
Function.Surjective ⇑(TannakaDuality.FiniteGroup.equivHom k G) | null | false |
Std.ExtDTreeMap.maxKeyD_alter_eq_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} {f : Option (β k) → Option (β k)},
t.alter k f ≠ ∅ →
∀ {fallback : α},
(t.alter k f).maxKeyD fallback = k ↔ (f (t.get? k)).isSome = true ∧ ∀ k' ∈ t, (cmp ... | null | true |
_private.Mathlib.Geometry.Manifold.PartitionOfUnity.0.exists_contMDiff_support_eq_eq_one_iff._simp_1_2 | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a = a + b) = (b = 0) | null | false |
Lean.Util.ParamMinimizer.Result._sizeOf_inst | Lean.Util.ParamMinimizer | SizeOf Lean.Util.ParamMinimizer.Result | null | false |
CategoryTheory.Triangulated.SpectralObject._sizeOf_inst | Mathlib.CategoryTheory.Triangulated.SpectralObject | (C : Type u_1) →
(ι : Type u_2) →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} ι} →
{inst_2 : CategoryTheory.Limits.HasZeroObject C} →
{inst_3 : CategoryTheory.HasShift C ℤ} →
{inst_4 : CategoryTheory.Preadditive C} →
... | null | false |
_private.Mathlib.Algebra.MvPolynomial.Variables.0.MvPolynomial.mem_vars_iff_mem_support._simp_1_2 | Mathlib.Algebra.MvPolynomial.Variables | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {i : σ},
(i ∈ p.degrees) = ∃ d, MvPolynomial.coeff d p ≠ 0 ∧ i ∈ d.support | null | false |
TopPair.HomologyPretheory.inv_hom_iso_homₚ | Mathlib.AlgebraicTopology.EilenbergSteenrod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {HP HP' : TopPair.HomologyPretheory C c} (f : HP ⟶ HP') (i : ι),
CategoryTheory.CategoryStruct.comp (HP.iso i).inv (CategoryTheory.CategoryStruct.comp (f.hom i) (HP'... | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int16.toBitVec_minValueSealed_eq_intMinSealed | Init.Data.Range.Polymorphic.SInt | Int16.minValueSealed✝.toBitVec = BitVec.Signed.intMinSealed✝ 16 | null | true |
LinearEquiv.mem_transvections_iff_mem_dilatransvections_and_fixedReduce_eq_one | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {V : Type u_2} [inst : AddCommGroup V] {K : Type u_3} [inst_1 : DivisionRing K] [inst_2 : Module K V]
[Module.Finite K V] (e : V ≃ₗ[K] V),
e ∈ LinearEquiv.transvections K V ↔ e ∈ LinearEquiv.dilatransvections K V ∧ e.fixedReduce = 1 | Characterization of transvections within dilatransvections. | true |
Array.mergeSort._auto_1 | Init.Data.Array.Sort.Basic | Lean.Syntax | null | false |
CategoryTheory.Functor.CoconeTypes.isColimit_iff | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)} (c : F.CoconeTypes),
c.IsColimit ↔ Nonempty (CategoryTheory.Limits.IsColimit (F.coconeTypesEquiv c)) | null | true |
List.traverse.eq_2 | Mathlib.Control.Traversable.Instances | ∀ {F : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Applicative F] (f : α → F β) (a : α) (l : List α),
List.traverse f (a :: l) = List.cons <$> f a <*> List.traverse f l | null | true |
ENNReal.tendsto_nhds_zero | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {f : Filter α} {u : α → ENNReal}, Filter.Tendsto u f (nhds 0) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ≤ ε | null | true |
Lean.Lsp.DiagnosticTag.deprecated | Lean.Data.Lsp.Diagnostics | Lean.Lsp.DiagnosticTag | Deprecated or obsolete code. Rendered with a strike-through. | true |
Polynomial.ofFinsupp_pow | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : AddMonoidAlgebra R ℕ) (n : ℕ), { toFinsupp := a ^ n } = { toFinsupp := a } ^ n | null | true |
CategoryTheory.Limits.colimMap | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor J C} →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
[inst_3 : CategoryTheory.Limits.HasColimit G] →
(F ⟶ G) ... | Functoriality of colimits.
Usually this morphism should be accessed through `colim.map`,
but may be needed separately when you have specified colimits for the source and target functors,
but not necessarily for all functors of shape `J`.
| true |
HahnSeries.instIsOrderedAddMonoidLex | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid R]
[AddLeftStrictMono R], IsOrderedAddMonoid (Lex (HahnSeries Γ R)) | null | true |
LucasLehmer.norm_num_ext.sModNat._f | Mathlib.NumberTheory.LucasLehmer | ℕ → (x : ℕ) → Nat.below x → ℕ | null | false |
Multiset.map_subset_map | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} {f : α → β} {s t : Multiset α}, s ⊆ t → Multiset.map f s ⊆ Multiset.map f t | null | true |
CategoryTheory.Functor.IsCoverDense.Types.sheafIso_inv_hom | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} [inst_2 : G.IsCoverDense K] [inst_3 : G.IsLocallyFull K]
{ℱ ℱ' : CategoryTheory.Sheaf K (Type v)} (i : G.op.com... | null | true |
MeasureTheory.OuterMeasure.comap._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (m : MeasureTheory.OuterMeasure β), m (f '' ∅) = 0 | null | false |
_private.Mathlib.Data.Multiset.Powerset.0.Multiset.powersetCard_le_powerset._simp_1_1 | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ ≤ ↑l₂) = l₁.Subperm l₂ | null | false |
CategoryTheory.Limits.coend.hom_ext_iff | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} [inst_2 : CategoryTheory.Limits.HasCoend F] {X : C}
{f g : CategoryTheory.Limits.coend F ⟶ X},
f = g ↔
∀ (j : J),
CategoryThe... | null | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal.associator_naturality₃._simp_1_1 | Mathlib.CategoryTheory.Localization.Monoidal.Basic | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} (ε : ... | null | false |
Lean.IR.Expr.lit.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 11 → ((v : Lean.IR.LitVal) → motive (Lean.IR.Expr.lit v)) → motive t | null | false |
List.mapAccumr₂.eq_3 | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β → γ → γ × δ) (x : γ) (x_3 : α) (xr : List α)
(y : β) (yr : List β),
List.mapAccumr₂ f (x_3 :: xr) (y :: yr) x =
((f x_3 y (List.mapAccumr₂ f xr yr x).1).1,
(f x_3 y (List.mapAccumr₂ f xr yr x).1).2 :: (List.mapAccumr₂ f xr yr x).2) | null | true |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.init.loop._unary | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) →
(_ : BitVec cfg.wordSize) ×' (v : Array (BitVec cfg.wordSize)) ×' v.size ≤ cfg.stateSize →
Vector (BitVec cfg.wordSize) cfg.stateSize | Inner loop for Mersenne Twister initalization. | false |
CategoryTheory.CommGrpObj.noConfusion | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
{X : C} →
{t : CategoryTheory.CommGrpObj X} →
{C' : Type u} →
{inst' :... | null | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert_of_ne._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, a ≠ b → (insert a s).erase b = insert a (s.erase b) | null | false |
ExistsAndEq.instInhabitedGoTo.default | Mathlib.Tactic.Simproc.ExistsAndEq | ExistsAndEq.GoTo | null | true |
CategoryTheory.Adjunction.Quadruple.op_adj₂ | Mathlib.CategoryTheory.Adjunction.Quadruple | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {G : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor D C} (q : CategoryTheory.Adjunction.Quadruple L F G R), q.op.adj₂ = q... | null | true |
Finset.prod_le_one | Mathlib.Algebra.Order.BigOperators.GroupWithZero.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommMonoidWithZero R] [inst_1 : Preorder R] [ZeroLEOneClass R] [PosMulMono R]
{f : ι → R} {s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → (∀ i ∈ s, f i ≤ 1) → ∏ i ∈ s, f i ≤ 1 | If each `f i`, `i ∈ s` belongs to `[0, 1]`, then their product is less than or equal to one.
See also `Finset.prod_le_one'` for the case of an ordered commutative multiplicative monoid. | true |
GradedTensorProduct.instRing._proof_15 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.