name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.PrivateName.0.Lean.isPrivateName.match_1 | Lean.PrivateName | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((n p : Lean.Name) → (str : String) → (h : n = p.str str) → motive (namedPattern n (p.str str) h)) →
((p : Lean.Name) → (i : ℕ) → motive (p.num i)) → ((x : Lean.Name) → motive x) → motive x | null | false |
Lean.Elab.Level.Context.recOn | Lean.Elab.Level | {motive : Lean.Elab.Level.Context → Sort u} →
(t : Lean.Elab.Level.Context) →
((options : Lean.Options) →
(ref : Lean.Syntax) →
(autoBoundImplicit : Bool) →
motive { options := options, ref := ref, autoBoundImplicit := autoBoundImplicit }) →
motive t | null | false |
WeakFEPair.mk.congr_simp | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (f f_1 : ℝ → E) (e_f : f = f_1)
(g g_1 : ℝ → E) (e_g : g = g_1) (k k_1 : ℝ) (e_k : k = k_1) (ε ε_1 : ℂ) (e_ε : ε = ε_1) (f₀ f₀_1 : E)
(e_f₀ : f₀ = f₀_1) (g₀ g₀_1 : E) (e_g₀ : g₀ = g₀_1)
(hf_int : MeasureTheory.LocallyIntegrableOn f (Set.Ioi... | null | true |
LinearMap.injective_of_linearIndependent | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_6}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} {ι : Type u_7} {v : ι → M},
Submodule.span R (Set.range v) = ⊤ → LinearIndependent R (⇑f ∘ v) → Function.Injective ⇑f | null | true |
MeasureTheory.integral_mono_of_nonneg | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_2 : PartialOrder E] [IsOrderedAddMonoid E] [IsOrderedModule ℝ E]
[ClosedIciTopology E] {f g : α → E},
0 ≤ᵐ[μ] f → MeasureTheory.Integrable g μ → f ≤ᵐ[μ] g → ∫ (a : α... | null | true |
perfect_def | Mathlib.Topology.Perfect | ∀ {α : Type u_1} [inst : TopologicalSpace α] (C : Set α), Perfect C ↔ IsClosed C ∧ Preperfect C | null | true |
CategoryTheory.Subgroupoid.instTop._proof_2 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] {c d e : C} {p : c ⟶ d},
p ∈ Set.univ → ∀ {q : d ⟶ e}, q ∈ Set.univ → CategoryTheory.CategoryStruct.comp p q ∈ Set.univ | null | false |
CategoryTheory.Functor.addGrpObjObj._proof_4 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.Monoidal] {G : C} [inst_5 : CategoryT... | null | false |
RingHom.snd_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
[inst_2 : NonAssocSemiring T] (f : R →+* S) (g : R →+* T), (RingHom.snd S T).comp (f.prod g) = g | null | true |
AlgebraicGeometry.instIsIntegralPullbackSchemeOfGeometricallyIntegralOfFlatOfUniversallyOpenOfIsLocallyNoetherian_1 | Mathlib.AlgebraicGeometry.Geometrically.Integral | ∀ {X Y S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [AlgebraicGeometry.GeometricallyIntegral g]
[AlgebraicGeometry.Flat g] [AlgebraicGeometry.UniversallyOpen g] [AlgebraicGeometry.IsIntegral X]
[AlgebraicGeometry.IsLocallyNoetherian X], AlgebraicGeometry.IsIntegral (CategoryTheory.Limits.pullback f g) | null | true |
Pi.dim_spanSubset | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u} {ι : Type w} [inst : Semiring R] [StrongRankCondition R] [inst_2 : Finite ι] {s : Set ι},
Module.finrank R ↥(Pi.spanSubset R s) = s.ncard | null | true |
WeierstrassCurve.Jacobian.dblU_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.dblU P = -3 * P 0 ^ 2 | null | true |
TopologicalSpace.UpgradedIsCompletelyMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | Type u_3 → Type u_3 | A convenience class, for a completely metrizable space endowed with a complete metric.
No instance of this class should be registered: It should be used as
`letI := upgradeIsCompletelyMetrizable X` to endow a completely metrizable
space with a complete metric. | true |
CategoryTheory.Limits.Cone.extend.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F) {X : C} (f : X ⟶ c.pt),
c.extend f = { pt := X, π := CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.const J).map f)... | null | true |
Real.artanh_lt_artanh_iff | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x y : ℝ}, x ∈ Set.Ioo (-1) 1 → y ∈ Set.Ioo (-1) 1 → (Real.artanh x < Real.artanh y ↔ x < y) | null | true |
_private.Init.ShareCommon.0.ShareCommon.StateFactory.mkImpl.match_1 | Init.ShareCommon | (motive : ShareCommon.StateFactoryBuilder → Sort u_1) →
(x : ShareCommon.StateFactoryBuilder) →
((Map : (α : Type) → Type → [BEq α] → [Hashable α] → Type) →
(mkMap : {α β : Type} → [inst : BEq α] → [inst_1 : Hashable α] → ℕ → Map α β) →
(mapFind? : {α β : Type} → [inst : BEq α] → [inst_1 : Hasha... | null | false |
_private.Lean.Meta.SizeOf.0.Lean.Meta.ignoreField | Lean.Meta.SizeOf | Lean.Expr → Lean.MetaM Bool | null | true |
Lean.Parser.ParserExtension.State._sizeOf_inst | Lean.Parser.Extension | SizeOf Lean.Parser.ParserExtension.State | null | false |
Filter.bot_smul | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {g : Filter β}, ⊥ • g = ⊥ | null | true |
CategoryTheory.StrictPseudofunctorPreCore.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{t : CategoryTheory.StrictPseudofunctorPreCore B C} →
{B' : Type u₁} →
{inst' : CategoryTheory.Bicategory B'} →
{C' : Typ... | null | false |
LinearPMap.orderBot | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Ring R] →
[inst_1 : Ring S] →
{σ : R →+* S} →
{E : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module R E] →
{F : Type u_5} → [inst_4 : AddCommGroup F] → [inst_5 : Module S F] → OrderBot (E →ₛₗ.[σ] F) | null | true |
Action.mkIso._auto_1 | Mathlib.CategoryTheory.Action.Basic | Lean.Syntax | null | false |
Inclusion.Interval.orderRelFalse.eq_1 | Mathlib.Tactic.Inclusion.Extension.Interval | ∀ {α : Type u_1} (r : α → α → Prop) [inst : DecidableRel r] (I J : Inclusion.Interval α),
Inclusion.Interval.orderRelFalse r I J =
match I.lb, J.ub with
| some il, some ju => if r il ju then Inclusion.IntervalBool.undetermined else Inclusion.IntervalBool.false
| x, x_1 => Inclusion.IntervalBool.undetermin... | null | true |
LowerSet.Iio.eq_1 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] (a : α), LowerSet.Iio a = { carrier := Set.Iio a, lower' := ⋯ } | null | true |
IsRCLikeNormedField.rclike._proof_1 | Mathlib.Analysis.RCLike.Basic | ∀ (𝕜 : Type u_1) [hk : NormedField 𝕜] [h : IsRCLikeNormedField 𝕜], hk = (Classical.choose ⋯).toNormedField | null | false |
Filter.isScalarTower'' | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SMul α β] [inst_1 : SMul α γ] [inst_2 : SMul β γ]
[IsScalarTower α β γ], IsScalarTower (Filter α) (Filter β) (Filter γ) | null | true |
RelSeries.fromListIsChain_cons._proof_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (l : List α) (x : α), x :: l ≠ [] | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk₂_app_two'._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬2 < 2 + 1 → False | null | false |
Cubic.toPoly_injective | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} [inst : Semiring R] (P Q : Cubic R), P.toPoly = Q.toPoly ↔ P = Q | null | true |
Equiv.Perm.mul_mem_alternatingGroup_of_isSwap | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {g g' : Equiv.Perm α},
g.IsSwap → g'.IsSwap → g * g' ∈ alternatingGroup α | null | true |
Mathlib.Tactic.Choose.ElimStatus.success | Mathlib.Tactic.Choose | Mathlib.Tactic.Choose.ElimStatus | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.infer | Lean.Compiler.LCNF.InferBorrow | Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.ParamMap✝ | Infer the borrowing annotations in a SCC through dataflow analysis.
| true |
CategoryTheory.Limits.Cofork.isoCoforkOfπ._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : Y ⟶ X}
(c : CategoryTheory.Limits.Cofork f g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.ofπ c.π ⋯).π (CategoryTheory.Iso.refl c.pt).inv = c.π | null | false |
CategoryTheory.Functor.curry_map_app_app | Mathlib.CategoryTheory.Functor.Currying | ∀ {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 Y : CategoryTheory.Functor (C × D) E} (T : X ⟶ Y)
(X_1 : C) (Y_1 : D), ((CategoryTheory.Functor.curry.map T).app X_1).app Y_1 = T.app... | null | true |
RatFunc.inftyValued.def | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] {x : RatFunc F},
Valued.v x = RatFunc.inftyValuationDef F x | null | true |
ModuleCat.restrictScalarsComp'._proof_1 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R₁ : Type u_3} {R₂ : Type u_4} {R₃ : Type u_2} [inst : Ring R₁] [inst_1 : Ring R₂] [inst_2 : Ring R₃] (f : R₁ →+* R₂)
(g : R₂ →+* R₃) (gf : R₁ →+* R₃) (hgf : gf = g.comp f) {X Y : ModuleCat R₃} (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars gf).map f_1)
(ModuleCat.restrictSca... | null | false |
CategoryTheory.MonoidalCategory.id_whiskerLeft_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCat... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_getKey?_eq_some_and_get?_eq_some._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
OreLocalization.neg_def | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddGroup X] [inst_3 : DistribMulAction R X] (r : X) (s : ↥S), -(r /ₒ s) = -r /ₒ s | null | true |
ofDual_eq_zero._simp_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Zero α] {a : αᵒᵈ}, (OrderDual.ofDual a = 0) = (a = 0) | null | false |
Affine.Triangle.angle_excenter_singleton_eq_angle_add_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ →
i₁ ≠ i₃ →
i₂ ≠ i₃ →
EuclideanGeometry.angle (t.points i₁) (t.points i₂) (Affine.Simplex.exc... | The excenter of a triangle opposite a vertex bisects the angle at another vertex. | true |
Valuation.extension.congr_simp | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} {Γ₀ : Type u_3} [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K]
[inst_3 : IsValuativeTopology K] [inst_4 : LinearOrderedCommGroupWithZero Γ₀] (v v_1 : Valuation K Γ₀) (e_v : v = v_1)
[inst_5 : v.Compatible] [inst_6 : IsUniformAddGroup K], v.extension = v_1.extension | null | true |
RingAut | Mathlib.Algebra.Ring.Aut | (R : Type u_1) → [Mul R] → [Add R] → Type u_1 | The group of ring automorphisms. | true |
Mathlib.Tactic.Order.instBEqOrderType.beq | Mathlib.Tactic.Order.Preprocessing | Mathlib.Tactic.Order.OrderType → Mathlib.Tactic.Order.OrderType → Bool | null | true |
CategoryTheory.Square.toArrowArrowFunctor'_obj_left_right | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C),
(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.right = sq.X₂ | null | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.main.match_1 | Lean.Elab.App | (motive : Lean.BinderInfo → Sort u_1) →
(__do_lift : Lean.BinderInfo) →
(Unit → motive Lean.BinderInfo.implicit) →
(Unit → motive Lean.BinderInfo.instImplicit) →
(Unit → motive Lean.BinderInfo.strictImplicit) → (Unit → motive Lean.BinderInfo.default) → motive __do_lift | null | false |
Pi.nonUnitalSeminormedCommRing | Mathlib.Analysis.Normed.Ring.Lemmas | {ι : Type u_2} →
{R : ι → Type u_3} →
[Fintype ι] → [(i : ι) → NonUnitalSeminormedCommRing (R i)] → NonUnitalSeminormedCommRing ((i : ι) → R i) | Non-unital seminormed commutative ring structure on the product of finitely many non-unital
seminormed commutative rings, using the sup norm. | true |
Equiv.subtypeEquivRight_symm_apply_coe | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {p q : α → Prop} (e : ∀ (x : α), p x ↔ q x) (b : { b // q b }),
↑((Equiv.subtypeEquivRight e).symm b) = ↑b | null | true |
LeftInvariantDerivation.evalAt._proof_3 | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {G : Type u_2}
[inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] (g : G),
SMulCommClass 𝕜 (PointedCon... | null | false |
BitVec.getElem_concat_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {b : Bool} {x : BitVec w}, (x.concat b)[0] = b | null | true |
Manifold.IsImmersion.congr | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] {H : Type u_7}
[inst_5 : TopologicalSpace H] {G : Type u_9} [inst_6 : TopologicalSpace G] {I : ModelWithCorn... | If `f = g` and `f` is an immersion, so is `g`. | true |
Prod.seminormedRing._proof_7 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (a : α × β), 0 * a = 0 | null | false |
BoundingSieve.inv_selbergTerms_eq_sum_divisors_moebius_nu | Mathlib.NumberTheory.SelbergSieve | ∀ {s : BoundingSieve} {l : ℕ},
Squarefree l →
s.nu l ≠ 0 →
(BoundingSieve.selbergTerms l)⁻¹ =
∑ x ∈ l.divisorsAntidiagonal,
match x with
| (d, e) => ↑(ArithmeticFunction.moebius d) * (s.nu e)⁻¹ | null | true |
RestrictedProduct.instContinuousConstVAddCoe | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} (R : ι → Type u_2) {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)] {B : (i : ι) → S i}
{𝓕 : Filter ι} [inst_1 : (i : ι) → TopologicalSpace (R i)] {G : Type u_4} [inst_2 : (i : ι) → VAdd G (R i)]
[inst_3 : ∀ (i : ι), VAddMemClass (S i) G (R i)] [∀ (i : ι), ContinuousConstVAdd G (R i)],
... | null | true |
NonUnitalStarSubalgebra.nonUnitalCStarAlgebra._proof_4 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A], IsScalarTower ℂ ℂ A | null | false |
TensorProduct.tensorQuotMapSMulEquivTensorQuot._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S] (I : Ideal R),
SMulCommClass R S (TensorProduct R S (R ⧸ I)) | null | false |
Lean.Lsp.SemanticTokensLegend.mk.injEq | Lean.Data.Lsp.LanguageFeatures | ∀ (tokenTypes tokenModifiers tokenTypes_1 tokenModifiers_1 : Array String),
({ tokenTypes := tokenTypes, tokenModifiers := tokenModifiers } =
{ tokenTypes := tokenTypes_1, tokenModifiers := tokenModifiers_1 }) =
(tokenTypes = tokenTypes_1 ∧ tokenModifiers = tokenModifiers_1) | null | true |
AlgebraicGeometry.QuasiSeparated.quasiCompact_diagonal | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.QuasiSeparated f],
AlgebraicGeometry.QuasiCompact (CategoryTheory.Limits.pullback.diagonal f) | A morphism is `QuasiSeparated` if diagonal map is quasi-compact. | true |
Set.Finite.eventuallyLE_iUnion | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {l : Filter α} {ι : Type u_1} {s : Set ι},
s.Finite → ∀ {f g : ι → Set α}, (∀ i ∈ s, f i ≤ᶠ[l] g i) → ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i | **Alias** of `Set.Finite.eventuallySubset_iUnion`. | true |
CategoryTheory.Limits.createsLimitsOfSizeOfLeftOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {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.CreatesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.leftOp] →
CategoryTheory.CreatesLimitsOfSize.{w, w'... | If `F.leftOp : Cᵒᵖ ⥤ D` creates colimits, then `F : C ⥤ Dᵒᵖ` creates limits. | true |
Std.DHashMap.getKey!_diff_of_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited α] {k : α}, k ∈ m₂ → (m₁ \ m₂).getKey! k = default | null | true |
CategoryTheory.Triangulated.TStructure.isGE_iff_isIso_truncGTπ_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
instNormalCommutatorClosure | Mathlib.Topology.Algebra.Group.TopologicalAbelianization | ∀ (G : Type u_1) [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G],
(commutator G).topologicalClosure.Normal | null | true |
Lean.Lsp.instToJsonShowMessageRequestParams.toJson | Lean.Data.Lsp.Window | Lean.Lsp.ShowMessageRequestParams → Lean.Json | null | true |
IsUnital.toNonAssocCommRing._proof_1 | Mathlib.Algebra.Ring.Defs | ∀ {A : Type u_1} [inst : NonUnitalNonAssocCommRing A] [inst_1 : IsUnital A], Nat.unaryCast 0 = 0 | null | false |
_private.Mathlib.Algebra.Order.Floor.Semifield.0.Mathlib.Meta.NormNum.IsRat.natFloor._simp_1_1 | Mathlib.Algebra.Order.Floor.Semifield | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b : α} [inst_1 : Preorder α] [PosMulMono α],
0 ≤ a → 0 ≤ b → (0 ≤ a * b) = True | null | false |
SSet.Edge.InvStruct.ext_iff | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X : SSet} {x₀ x₁ : X.obj (Opposite.op { len := 0 })} {hom : SSet.Edge x₀ x₁} {x y : hom.InvStruct},
x = y ↔ x.inv = y.inv ∧ x.homInvId ≍ y.homInvId ∧ x.invHomId ≍ y.invHomId | null | true |
CategoryTheory.ShortComplex.SnakeInput.functorL₁ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
CategoryTheory.Functor (CategoryTheory.ShortComplex.SnakeInput C) (CategoryTheory.ShortComplex C) | The functor which sends `S : SnakeInput C` to its zeroth line `S.L₁`. | true |
Mathlib.Tactic.ModCases.IntMod.modCases | Mathlib.Tactic.ModCases | Lean.TSyntax `Lean.binderIdent → Q(ℤ) → ℕ → Lean.Elab.Tactic.TacticM Unit | Int case of `mod_cases h : e % n`.
| true |
LieModule.posFittingCompOf._proof_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_1) [inst : CommRing R], RingHomSurjective (RingHom.id R) | null | false |
List.unzip.match_3 | Init.Data.List.Basic | {α : Type u_2} →
{β : Type u_1} →
(motive : List (α × β) → Sort u_3) →
(x : List (α × β)) →
(Unit → motive []) → ((a : α) → (b : β) → (t : List (α × β)) → motive ((a, b) :: t)) → motive x | null | false |
CategoryTheory.GrothendieckTopology.Point.sheafFiber.eq_1 | Mathlib.CategoryTheory.Sites.Point.Skyscraper | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
[inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A],
Φ.sheafFiber = (CategoryTheory.sheafToPresheaf J A).comp Φ.presheafFib... | null | true |
Module.AEval.mapSubmodule | Mathlib.Algebra.Polynomial.Module.AEval | (R : Type u_1) →
{A : Type u_2} →
(M : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
(a : A) →
[inst_2 : Algebra R A] →
[inst_3 : AddCommMonoid M] →
[inst_4 : Module A M] →
[inst_5 : Module R M] →
... | The natural order isomorphism between the two ways to represent invariant submodules. | true |
SemiconjBy.units_val_iff | Mathlib.Algebra.Group.Semiconj.Units | ∀ {M : Type u_1} [inst : Monoid M] {a x y : Mˣ}, SemiconjBy ↑a ↑x ↑y ↔ SemiconjBy a x y | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHom_def._autoParam | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.Syntax | null | false |
ENNReal.toNNRealHom | Mathlib.Basic.ENNReal.Real | ENNReal →*₀ NNReal | `ENNReal.toNNReal` as a `MonoidHom`. | true |
IsLocalization.mk'.congr_simp | 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] (x x_1 : R),
x = x_1 → ∀ (y y_1 : ↥M), y = y_1 → IsLocalization.mk' S x y = IsLocalization.mk' S x_1 y_1 | null | true |
_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.levelsEqualUpToIdsCore'.match_4 | Aesop.Util.EqualUpToIds | (motive : Option Bool → Sort u_1) →
(__do_lift : Option Bool) →
((result : Bool) → motive (some result)) → ((x : Option Bool) → motive x) → motive __do_lift | null | false |
_private.Mathlib.Topology.ContinuousMap.CompactlySupported.0.CompactlySupportedContinuousMap.«term_→co_» | Mathlib.Topology.ContinuousMap.CompactlySupported | Lean.TrailingParserDescr | null | true |
ComplexShape.Embedding.AreComplementary.Boundary.equiv.match_1 | Mathlib.Algebra.Homology.Embedding.AreComplementary | {ι : Type u_2} →
{ι₁ : Type u_1} →
{c : ComplexShape ι} →
{c₁ : ComplexShape ι₁} →
{e₁ : c₁.Embedding c} →
(motive : Subtype e₁.BoundaryLE → Sort u_3) →
(x : Subtype e₁.BoundaryLE) → ((i₁ : ι₁) → (h : e₁.BoundaryLE i₁) → motive ⟨i₁, h⟩) → motive x | null | false |
HomologicalComplex.instIsStrictlySupportedTruncGE | Mathlib.Algebra.Homology.Embedding.TruncGE | ∀ {ι : 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.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncGE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 :... | null | true |
Sum.Lex.locallyFiniteOrder | Mathlib.Data.Sum.Interval | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[LocallyFiniteOrder α] →
[LocallyFiniteOrder β] → [LocallyFiniteOrderTop α] → [LocallyFiniteOrderBot β] → LocallyFiniteOrder (α ⊕ₗ β) | null | true |
nsmul_left_comm | Mathlib.Algebra.Group.Monoid | ∀ {M : Type u_2} [inst : AddMonoid M] (a : M) (m n : ℕ), n • m • a = m • n • a | null | true |
Metric.infEDist_image | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {x : α} {t : Set α}
{Φ : α → β}, Isometry Φ → Metric.infEDist (Φ x) (Φ '' t) = Metric.infEDist x t | The infimum edistance is invariant under isometries | true |
ProofWidgets.HtmlEval.casesOn | ProofWidgets.Component.HtmlDisplay | {α : Type u} →
{motive : ProofWidgets.HtmlEval α → Sort u_1} →
(t : ProofWidgets.HtmlEval α) →
((eval : α → Lean.Elab.Command.CommandElabM ProofWidgets.Html) → motive { eval := eval }) → motive t | null | false |
IsDedekindDomain.FiniteAdeleRing.ofAdicCompletion_apply_coe | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
(x : IsDedekindDomain.HeightOneSpectrum.adicCompletion K v) (j : IsDedekindDomain.HeightOneSpectrum R),
↑((IsDedekind... | null | true |
IsLocalizedModule.map.congr_simp | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S S_1 : Submonoid R) (e_S : S = S_1) {M : Type u_2} {M' : Type u_3}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M']
(f f_1 : M →ₗ[R] M') (e_f : f = f_1) [inst_5 : IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7}
[in... | null | true |
SubsemiringClass.toIsStrictOrderedRing | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ {R : Type u_1} {S : Type u_2} [inst : SetLike S R] (s : S) [inst_1 : Semiring R] [inst_2 : PartialOrder R]
[IsStrictOrderedRing R] [inst_4 : SubsemiringClass S R], IsStrictOrderedRing ↥s | A subsemiring of a strict ordered semiring is a strict ordered semiring. | true |
DivisionSemiring.noConfusion | Mathlib.Algebra.Field.Defs | {P : Sort u} →
{K : Type u_2} →
{t : DivisionSemiring K} →
{K' : Type u_2} → {t' : DivisionSemiring K'} → K = K' → t ≍ t' → DivisionSemiring.noConfusionType P t t' | null | false |
Monoid.PushoutI.NormalWord.mk.noConfusion | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
{inst : (i : ι) → Group (G i)} →
{inst_1 : Group H} →
{φ : (i : ι) → H →* G i} →
{d : Monoid.PushoutI.NormalWord.Transversal φ} →
{P : Sort u} →
{toWord : Monoid.CoprodI.Word G} →
... | null | false |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.pushMsg | Lean.Meta.Tactic.Grind.PP | Lean.MessageData → Lean.Meta.Grind.M✝ Unit | null | true |
Lean.LibrarySuggestions.Selector.intersperse._proof_6 | Lean.LibrarySuggestions.Basic | ∀ (c : Lean.LibrarySuggestions.Config) (suggestions₁ : Array Lean.LibrarySuggestions.Suggestion)
(__s : Array Lean.LibrarySuggestions.Suggestion × ℕ),
__s.2 < suggestions₁.size ∧ __s.1.size < c.maxSuggestions → __s.2 < suggestions₁.size | null | false |
IsFractionRing.nontrivial | Mathlib.RingTheory.Localization.FractionRing | ∀ (R : Type u_8) (S : Type u_9) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[h : IsFractionRing R S] [hR : Nontrivial R], Nontrivial S | null | true |
SupBotHom.id._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ (α : Type u_1) [inst : Max α] [inst_1 : Bot α], (SupHom.id α).toFun ⊥ = (SupHom.id α).toFun ⊥ | null | false |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat)
{a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (X : ↑(F.obj a)) {Z : ↑(F.obj d)}
(h_1 : (F.map h).toFunctor.obj ((F.map g).toFunctor.obj ((F.map f).toFunctor.obj X)) ⟶ Z),
CategoryTheory.CategoryStruct... | null | true |
inv_ball | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x : E), (Metric.ball x δ)⁻¹ = Metric.ball x⁻¹ δ | null | true |
Padic.valuation_zero | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], Padic.valuation 0 = 0 | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitAlt._unsafe_rec | Lean.Compiler.LCNF.ToLCNF | Lean.CasesAltInfo →
Lean.Expr → ℕ → Lean.Compiler.LCNF.ToLCNF.M✝ (Lean.Expr × Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure) | null | false |
Inclusion.InclusionParamDecl.mk.sizeOf_spec | Mathlib.Tactic.Inclusion.Core.Extensions | ∀ (name : Lean.Name) (type : Lean.Expr) (defaultValue? : Option Lean.Expr),
sizeOf { name := name, type := type, defaultValue? := defaultValue? } =
1 + sizeOf name + sizeOf type + sizeOf defaultValue? | null | true |
Lex.instNonAssocSemiring._proof_1 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (a : Lex R), 1 * a = a | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.