name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.Measure.OuterRegular.of_restrict | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [OpensMeasurableSpace α]
{μ : MeasureTheory.Measure α} {s : ℕ → Set α},
(∀ (n : ℕ), (μ.restrict (s n)).OuterRegular) → (∀ (n : ℕ), IsOpen (s n)) → Set.univ ⊆ ⋃ n, s n → μ.OuterRegular | If the restrictions of a measure to countably many open sets covering the space are
outer regular, then the measure itself is outer regular. | true |
Field.rank_mul_sepDegree_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type v) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsSeparable F E],
Module.rank F E * Field.sepDegree E K = Field.sepDegree F K | The same-universe version of `Field.lift_rank_mul_lift_sepDegree_of_isSeparable`. | true |
MulOpposite.instSemiring._proof_4 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (x : Rᵐᵒᵖ), x ^ 0 = 1 | null | false |
CategoryTheory.ReflPrefunctor._aux_Mathlib_Combinatorics_Quiver_ReflQuiver___unexpand_CategoryTheory_ReflPrefunctor_comp_1 | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.PrettyPrinter.Unexpander | null | false |
WeakFEPair.hg_top | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (self : WeakFEPair E) (r : ℝ),
(fun x => self.g x - self.g₀) =O[Filter.atTop] fun x => x ^ r | null | true |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.range_mapBaseChange._simp_1_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.find?_toList_eq_none_iff_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
pow_eq_pow_iff_of_ne_zero | Mathlib.Algebra.Order.Ring.Abs | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a b : R} {n : ℕ},
n ≠ 0 → (a ^ n = b ^ n ↔ a = b ∨ a = -b ∧ Even n) | null | true |
TypeCat.Hom.ext_iff | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} {x y : TypeCat.Hom X Y}, x = y ↔ x.hom' = y.hom' | null | true |
Lean.Widget.UserWidgetDefinition.noConfusion | Lean.Widget.UserWidget | {P : Sort u} →
{t t' : Lean.Widget.UserWidgetDefinition} → t = t' → Lean.Widget.UserWidgetDefinition.noConfusionType P t t' | null | false |
Std.DTreeMap.Raw.Const.size_ofList | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] {l : List (α × β)},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l → (Std.DTreeMap.Raw.Const.ofList l cmp).size = l.length | null | true |
CategoryTheory.Limits.cospanExt_hom_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Z} {g : Y ⟶ Z} {f' : X' ⟶ Z'} {g' : Y' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iZ.hom)
(wg : CategoryTheory.CategoryStruct.comp i... | null | true |
CondensedMod.LocallyConstant.functor._proof_6 | Mathlib.Condensed.Discrete.Module | 3 ≠ 0 | null | false |
Cardinal.mk_congr_lift | Mathlib.SetTheory.Cardinal.Defs | ∀ {α : Type u} {β : Type v} (e : α ≃ β), Cardinal.lift.{v, u} (Cardinal.mk α) = Cardinal.lift.{u, v} (Cardinal.mk β) | null | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.remainingGoals.sizeOf_spec | Mathlib.Tactic.TacticAnalysis.Declarations | ∀ (stx : Lean.TSyntax `tactic) (goals : List Lean.MessageData),
sizeOf (Mathlib.TacticAnalysis.TerminalReplacementOutcome.remainingGoals✝ stx goals) = 1 + sizeOf stx + sizeOf goals | null | true |
Mathlib.Tactic.FieldSimp.DenomCondition._sizeOf_inst | Mathlib.Tactic.FieldSimp | {v : Lean.Level} → {M : Q(Type v)} → (iM : Q(GroupWithZero «$M»)) → SizeOf (Mathlib.Tactic.FieldSimp.DenomCondition iM) | null | false |
_private.Lean.LoadDynlib.0.Lean.loadPlugin.match_10 | Lean.LoadDynlib | (dynlib : Lean.Dynlib) →
(motive : Option dynlib.Symbol → Sort u_1) →
(x : Option dynlib.Symbol) →
((sym : dynlib.Symbol) → motive (some sym)) → ((x : Option dynlib.Symbol) → motive x) → motive x | null | false |
Measurable.isGLB | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} {δ : Type u_4} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [BorelSpace α]
{mδ : MeasurableSpace δ} [inst_2 : LinearOrder α] [OrderTopology α] [SecondCountableTopology α] {ι : Sort u_5}
[Countable ι] {f : ι → δ → α} {g : δ → α},
(∀ (i : ι), Measurable (f i)) → (∀ (b : δ), IsGLB {a | ∃ i, ... | If a function is the greatest lower bound of countably many measurable functions,
then it is measurable. | true |
ONote.cmp._sunfold | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote → Ordering | null | false |
Int.sign.eq_3 | Init.Data.Int.Order | ∀ (a : ℕ), (Int.negSucc a).sign = -1 | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction._aux_Mathlib_CategoryTheory_Monoidal_Action_Basic___unexpand_CategoryTheory_MonoidalCategory_MonoidalRightActionStruct_actionUnitIso_2 | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.PrettyPrinter.Unexpander | null | false |
PSigma.noConfusionType | Init.Core | Sort u_1 → {α : Sort u} → {β : α → Sort v} → PSigma β → {α' : Sort u} → {β' : α' → Sort v} → PSigma β' → Sort u_1 | null | false |
CategoryTheory.Hom.addGroup | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] → {G X : C} → [CategoryTheory.AddGrpObj G] → AddGroup (X ⟶ G) | If `G` is an additive group object, then `Hom(X, G)` has an additive group structure. | true |
_private.Mathlib.GroupTheory.HNNExtension.0.HNNExtension.NormalWord.unitsSMul_neg._simp_1_6 | Mathlib.GroupTheory.HNNExtension | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt16.toUInt8_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Nonneg.coe_nsmul._simp_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : AddMonoid α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] (n : ℕ) (a : Nonneg α),
n • ↑a = ↑(n • a) | null | false |
CategoryTheory.Limits.IsCofiltered.sequentialFunctor_initial_aux | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ (J : Type u_2) [inst : Countable J] [inst_1 : Preorder J] [inst_2 : CategoryTheory.IsCofiltered J] (j : J),
∃ n, CategoryTheory.Limits.IsCofiltered.sequentialFunctor_obj J n ≤ j | null | true |
SemilatticeSup.le_sup_left | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [self : SemilatticeSup α] (a b : α), a ≤ SemilatticeSup.sup a b | The supremum is an upper bound on the first argument | true |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.exists_mem_isCircuit_of_not_isColoop._simp_1_2 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
NonUnitalSubsemiring.eq_top_iff' | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (A : NonUnitalSubsemiring R), A = ⊤ ↔ ∀ (x : R), x ∈ A | null | true |
_private.Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject.0.CategoryTheory.SimplicialObject.Splitting.σ_comp_πSummand_id_eq_zero._proof_1_1 | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {n : ℕ} (A : CategoryTheory.SimplicialObject.Splitting.IndexSet (Opposite.op { len := n })),
(Opposite.unop A.fst).len ≤ n → ¬(Opposite.unop A.fst).len = n + 1 | null | false |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.StronglyMeasurable.inv₀._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop}, MeasurableSet {a | p a} = Measurable p | null | false |
AlgebraicGeometry.Scheme.instFieldCarrierResidueField._aux_19 | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → ℚ≥0 → ↑(X.residueField x) → ↑(X.residueField x) | null | false |
log_deriv_riemannZeta_eq_neg_inv_sub_add | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ᶠ (s : ℂ) in nhdsWithin 1 {1}ᶜ,
deriv riemannZeta s / riemannZeta s = -(s - 1)⁻¹ + deriv riemannZeta₁ s / riemannZeta₁ s | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.IsPrimitiveRoot.arg._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioc a b) = (a < x ∧ x ≤ b) | null | false |
OreLocalization.universalHom._proof_2 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_2} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {T : Type u_1}
[inst_2 : Semiring T] (f : R →+* T) (fS : ↥S →* Tˣ) (hf : ∀ (s : ↥S), f ↑s = ↑(fS s)) (x y : OreLocalization S R),
(↑(OreLocalization.universalMulHom (↑f) fS hf)).toFun (x + y) =
(↑(OreLocalization.universa... | null | false |
PolynomialLaw.instZero | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → {N : Type u_2} → [inst_3 : AddCommMonoid N] → [inst_4 : Module R N] → Zero (M →ₚₗ[R] N) | null | true |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.serreTheorem_im_eq | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fd → g • z ∈ ModularGroup.fd → (g • z).im = z.im | null | true |
Order.PFilter.IsPrime.rec | Mathlib.Order.PrimeIdeal | {P : Type u_1} →
[inst : Preorder P] →
{F : Order.PFilter P} →
{motive : F.IsPrime → Sort u} → ((compl_ideal : Order.IsIdeal (↑F)ᶜ) → motive ⋯) → (t : F.IsPrime) → motive t | null | false |
toColex | Mathlib.Order.Lex | {α : Type u_1} → α ≃ Colex α | `toColex` is the identity function to the `Colex` of a type. | true |
IntermediateField.inclusion_injective | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {E F : IntermediateField K L}
(hEF : E ≤ F), Function.Injective ⇑(IntermediateField.inclusion hEF) | null | true |
IsSelfAdjoint.add_star_self | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : AddCommMonoid R] [inst_1 : StarAddMonoid R] (x : R), IsSelfAdjoint (x + star x) | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile.0.Std.IterM.step_takeWhileWithPostcondition.match_1.splitter | Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} →
(out : β) →
(motive : Subtype (P out).Property → Sort u_3) →
(__do_lift : Subtype (P out).Property) →
((h' : (P out).Property { down := true }) → motive ⟨{ down := true... | null | true |
SlashInvariantForm.instAddCommGroup._proof_11 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (a b : SlashInvariantForm Γ k), a + b = b + a | null | false |
AEMeasurable.leOnePart | Mathlib.MeasureTheory.Order.Group.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : MeasurableSpace α] [inst_2 : MeasurableSpace β] {f : β → α}
[inst_3 : DivInvMonoid α] [MeasurableSup α] [MeasurableInv α] {μ : MeasureTheory.Measure β},
AEMeasurable f μ → AEMeasurable f⁻ᵐ μ | null | true |
AddCommMonCat.instCoeMonCat | Mathlib.Algebra.Category.MonCat.Basic | Coe AddCommMonCat AddMonCat | null | true |
_private.Mathlib.Algebra.Order.Disjointed.0.partialSups_add_one_eq_sup_disjointed._simp_1_3 | Mathlib.Algebra.Order.Disjointed | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a \ b ≤ c) = (a ≤ b ⊔ c) | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Skeleton.0.SSet.relativeCellComplexOfMono.isPushout_aux._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {n m : SimplexCategory} {f : n ⟶ m}, CategoryTheory.Epi f = Function.Surjective ⇑(SimplexCategory.Hom.toOrderHom f) | null | false |
SetRel.IsCover.mono_entourage | Mathlib.Basic.Rel.Cover | ∀ {X : Type u_1} {U V : SetRel X X} {s N : Set X}, U ⊆ V → U.IsCover s N → V.IsCover s N | null | true |
CategoryTheory.ShrinkHoms.equivalence._proof_4 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.LocallySmall.{u_2, u_3, u_1} C]
{X Y : CategoryTheory.ShrinkHoms.{u_1} C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.ShrinkHoms.inverse C).comp (CategoryTheory.ShrinkHoms.functor C)).map f)
(Ca... | null | false |
PowerSeries.evalNegHom | Mathlib.RingTheory.PowerSeries.Basic | {A : Type u_2} → [inst : CommRing A] → PowerSeries A →+* PowerSeries A | The ring homomorphism taking a power series `f(X)` to `f(-X)`. | true |
Std.DTreeMap.Internal.instIteratorRxoIteratorIdSigma._proof_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (it : Std.IterM Id ((a : α) × β a)),
it.internalState.step = it.internalState.step | null | false |
Set.mulIndicator_self_mul_compl_apply | Mathlib.Algebra.Group.Indicator | ∀ {α : Type u_1} {M : Type u_4} [inst : MulOneClass M] (s : Set α) (f : α → M) (a : α),
s.mulIndicator f a * sᶜ.mulIndicator f a = f a | null | true |
Std.DHashMap.Raw.isEmpty_iff_forall_not_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → (m.isEmpty = true ↔ ∀ (a : α), a ∉ m) | null | true |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.Context.ctorIdx | Lean.Compiler.LCNF.Specialize | Lean.Compiler.LCNF.Specialize.Context✝ → ℕ | null | false |
List.signVariations_singleton | Mathlib.Data.List.SignVariations | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] (a : α), [a].signVariations = 0 | null | true |
Lean.Elab.Command.InductiveElabStep2.noConfusionType | Lean.Elab.MutualInductive | Sort u → Lean.Elab.Command.InductiveElabStep2 → Lean.Elab.Command.InductiveElabStep2 → Sort u | null | false |
SimpleGraph.Walk.instDecidableNil._proof_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (w v_1 : V) (h : G.Adj v v_1) (p : G.Walk v_1 w),
(SimpleGraph.Walk.cons h p).Nil → False | null | false |
SemimoduleCat.Hom.hom₂_apply | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ {R : Type u_1} [inst : CommSemiring R] {M N P : SemimoduleCat R} (f : M ⟶ ↧(N ⟶ P)) (x : ↑M),
(SemimoduleCat.Hom.hom₂ f) x = (SemimoduleCat.ofHom ↑SemimoduleCat.homLinearEquiv).hom' (f.hom' x) | null | true |
ContinuousMultilinearMap.compContinuousLinearMapL._proof_4 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {F : Type u_1} [inst : AddCommGroup F] [inst_1 : TopologicalSpace F] [IsTopologicalAddGroup F], ContinuousAdd F | null | false |
AddMagmaCat.instConcreteCategoryAddHomCarrier._proof_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : AddMagmaCat} (f : ↑X →ₙ+ ↑Y), { hom' := f }.hom' = f | null | false |
AlgebraicGeometry.Scheme.PartialIso.restrictTarget_iso | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.PartialIso Y) (U : Y.Opens) (hU : Dense ↑U) (hU' : U ≤ f.target),
(f.restrictTarget U hU hU').iso = (f.symm.restrictSource U hU hU').iso.symm | null | true |
Lean.Lsp.LeanClientCapabilities | Lean.Data.Lsp.Capabilities | Type | null | true |
Set.prod_eq_prod_iff_of_nonempty | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β}, (s ×ˢ t).Nonempty → (s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁) | null | true |
Std.DTreeMap.Internal.Impl.WF.union | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t₁ : Std.DTreeMap.Internal.Impl α β} {h₁ : t₁.WF}
{t₂ : Std.DTreeMap.Internal.Impl α β} {h₂ : t₂.WF}, (t₁.union t₂ ⋯ ⋯).WF | null | true |
Polynomial.separable_def | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] (f : Polynomial R), f.Separable ↔ IsCoprime f (Polynomial.derivative f) | null | true |
One.gOne | Mathlib.Algebra.GradedMonoid | (ι : Type u_1) → {R : Type u_2} → [inst : Zero ι] → [One R] → GradedMonoid.GOne fun x => R | null | true |
MvPolynomial.optionEquivRight._proof_4 | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u_1) (S₁ : Type u_2) [inst : CommSemiring R],
(MvPolynomial.aevalTower (Polynomial.aeval (MvPolynomial.X none)) fun i => MvPolynomial.X (some i)).comp
(MvPolynomial.aeval fun o => o.elim (MvPolynomial.C Polynomial.X) MvPolynomial.X) =
AlgHom.id R (MvPolynomial (Option S₁) R) | null | false |
Lean.AttributeKind | Lean.Attributes | Type | You can tag attributes with the 'local' or 'scoped' kind.
For example: `attribute [local myattr, scoped yourattr, theirattr]`.
This is used to indicate how an attribute should be scoped.
- local means that the attribute should only be applied in the current scope and forgotten once the current section, namespace, or f... | true |
CountableSupClosed.isLUB_mem | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} [inst : LE α] {s : Set α},
CountableSupClosed s → ∀ t ⊆ s, t.Nonempty → t.Countable → ∀ (x : α), IsLUB t x → x ∈ s | null | true |
CategoryTheory.CostructuredArrow.ofCommaFstEquivalenceFunctor_obj_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) (X : CategoryTheory.CostructuredArrow (CategoryTheory.Comma.fs... | null | true |
Set.bounded_ge_of_bounded_gt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : Preorder α],
Set.Bounded (fun x1 x2 => x1 > x2) s → Set.Bounded (fun x1 x2 => x1 ≥ x2) s | null | true |
_private.Init.Data.String.Iterator.0.String.Pos.Raw.get?.match_1.splitter | Init.Data.String.Iterator | (motive : String → String.Pos.Raw → Sort u_1) →
(x : String) → (x_1 : String.Pos.Raw) → ((s : String) → (p : String.Pos.Raw) → motive s p) → motive x x_1 | null | true |
CategoryTheory.LocalizerMorphism.RightResolution.mk.injEq | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂} {X₁ : C₁}
(w : X₂ ⟶ Φ.functor.obj X₁) (hw : W... | null | true |
NumberField.abs_discr_gt_two | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K], 1 < Module.finrank ℚ K → 2 < |NumberField.discr K| | **Hermite-Minkowski Theorem**. A nontrivial number field has discriminant greater than `2`. | true |
Lean.Meta.LibrarySearch.DeclMod.mpr | Lean.Meta.Tactic.LibrarySearch | Lean.Meta.LibrarySearch.DeclMod | the backward direction of an `iff` | true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.reverse_balLeft._proof_1_8 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (l : RBTree.RBNode α) (v : α) (l' : RBTree.RBNode α),
l' = l.reverse →
∀ (a : RBTree.RBNode α) (y : α) (b a_1 : RBTree.RBNode α) (x : α) (b_1 : RBTree.RBNode α),
RBTree.RBNode.node RBTree.RBColor.black a_1 x b_1 = (RBTree.RBNode.node RBTree.RBColor.black a y b).reverse →
(l.balance2... | null | false |
Order.Icc_subset_Ioc_pred_left_of_not_isMin | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, ¬IsMin b → Set.Icc b a ⊆ Set.Ioc (Order.pred b) a | null | true |
PiTensorProduct.congr._proof_2 | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_4} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i ≃ₗ[R] t i),
((PiTensorProduct.map fun i => ↑(f ... | null | false |
MeasureTheory.aestronglyMeasurable_of_eLpNorm_ne_top | Mathlib.MeasureTheory.Function.LpSeminorm.Defs | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} [inst : ENorm ε] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace ε] {f : α → ε} {p : ENNReal},
MeasureTheory.eLpNorm f p μ ≠ ⊤ → MeasureTheory.AEStronglyMeasurable f μ | null | true |
ClassGroup.mulEquiv._proof_1 | Mathlib.RingTheory.ClassGroup.ExtendedHom | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : CommRing B] (g : A ≃+* B)
(x : ClassGroup A), (ClassGroup.map ((↑g.symm).comp ↑g) ⋯) x = x | null | false |
Commute.span_right | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_6} {A : Type u_7} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[IsScalarTower R A A] [SMulCommClass R A A] {s : Set A} {x : A},
(∀ y ∈ s, Commute x y) → ∀ y ∈ Submodule.span R s, Commute x y | In a non-unital algebra, if `x` commutes with every element of a set `s`, then `x` commutes
with every element of `Submodule.span R s`. | true |
CategoryTheory.Limits.isLimitOfUnop.eq_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F.op} (P : CategoryTheory.Limits.IsColimit t.unop),
CategoryTheory.Limits.isLimitOfUnop P = P.op | null | true |
Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_5 | Mathlib.Geometry.Euclidean.Circumcenter | (n : ℕ) →
(motive : Affine.Simplex.PointsWithCircumcenterIndex n → Sort u_1) →
(x : Affine.Simplex.PointsWithCircumcenterIndex n) →
((a : Fin (n + 1)) → motive (Affine.Simplex.PointsWithCircumcenterIndex.pointIndex a)) →
(Unit → motive Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex) → ... | null | false |
ProofWidgets.instRpcEncodableExprPresentationData.dec._@.ProofWidgets.Presentation.Expr.2260322628._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) ProofWidgets.ExprPresentationData | null | false |
LinearEquiv.toLinearEquiv_toContinuousLinearEquiv_symm | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F : Type w}
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜 F] [inst_7 : TopologicalSpace F] [inst_8 : IsTop... | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.Tangent.0.contMDiffAt_vectorSpace_iff_contDiffAt._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : 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} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
Lean.Meta.DiagSummary.mk.sizeOf_spec | Lean.Meta.Diagnostics | ∀ (data : Array Lean.MessageData) (max : ℕ), sizeOf { data := data, max := max } = 1 + sizeOf data + sizeOf max | null | true |
Stream'.WSeq.bind.eq_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β), s.bind f = (Stream'.WSeq.map f s).join | null | true |
_private.Mathlib.Topology.Spectral.Prespectral.0.PrespectralSpace.exists_isClosed_of_not_isPreirreducible._simp_1_8 | Mathlib.Topology.Spectral.Prespectral | ∀ {a : Prop}, (¬¬a) = a | null | false |
forall_le_imp_ne_iff_lt | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ c ≤ a, c ≠ b) ↔ a < b | null | true |
CategoryTheory.HasSplitEqualizer.rec | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.HasSplitEqualizer f g → Sort u_1} →
((splittable : ∃ W h, Nonempty (CategoryTheory.IsSplitEqualizer f g h)) → motive ⋯) →
(t : CategoryTheory.HasSplitEqualizer f g) →... | null | false |
FourierTransform.fourierInvₗ | Mathlib.Analysis.Fourier.Notation | (R : Type u_2) →
(E : Type u_3) →
{F : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid E] →
[inst_2 : AddCommMonoid F] →
[inst_3 : Module R E] →
[inst_4 : Module R F] →
[inst_5 : FourierTransformInv E F] → [FourierInvAdd E F] → [FourierIn... | The inverse Fourier transform as a linear map. | true |
IsDedekindDomain.FiniteAdeleRing.algebraMap._proof_9 | 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] (x y : K),
⟨fun i =>
IsDedekindDomain.HeightOneSpectrum.adicCompletion.ofCompletion
↑(WithVal.toVal (IsDedekindDomain.HeightOneSpectrum.valuation K ... | null | false |
Std.Roo.toArray_succ_succ_eq_map | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LinearlyUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.PRange.InfinitelyUpwardEnumerable α] [inst_6 : Std.Rxo.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {lo h... | null | true |
LieSubmodule.noConfusionType | Mathlib.Algebra.Lie.Submodule | Sort u_1 →
{R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : LieRingModule L M] →
LieSubmodule R L M →
{R' :... | null | false |
Lean.Elab.InlayHintLinkLocation.noConfusion | Lean.Elab.InfoTree.InlayHints | {P : Sort u} →
{t t' : Lean.Elab.InlayHintLinkLocation} → t = t' → Lean.Elab.InlayHintLinkLocation.noConfusionType P t t' | null | false |
CategoryTheory.shrinkYonedaMonObjObjEquiv | Mathlib.CategoryTheory.Monoidal.Cartesian.ShrinkYoneda | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] →
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] →
{M : CategoryTheory.Mon C} →
{Y : Cᵒᵖ} → ↑((CategoryTheory.shrinkYonedaMon.{w, v, u}.obj M).obj Y) ≃* (Opposite.unop Y ⟶ M... | The type `(shrinkYonedaMon.obj M).obj Y` is equivalent to `Y.unop ⟶ M.X`. | true |
CategoryTheory.Limits.HasKernels.rec | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{motive : CategoryTheory.Limits.HasKernels C → Sort u_1} →
((has_limit : ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasKernel f) → motive ⋯) →
(t : CategoryTheory.Limits.Has... | null | false |
AddSubmonoid.nsmulSaturated_iff_nsmul | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : AddMonoid G] {H : AddSubmonoid G},
H.NSMulSaturated ↔ ∀ (n : ℕ) (g : G), n • g ∈ H → n = 0 ∨ g ∈ H | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.