name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0.Lean.Meta.Grind.Arith.isNormNatNum | Lean.Meta.Tactic.Grind.Arith.Simproc | Lean.Expr → Lean.Expr → Lean.Expr → Bool | Returns `true`, if `@OfNat.ofNat α n inst` is the standard way we represent `Nat` numerals in Lean.
| true |
tendsto_nhds_unique_of_eventuallyEq | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T2Space X] {f g : Y → X} {l : Filter Y} {a b : X}
[l.NeBot], Filter.Tendsto f l (nhds a) → Filter.Tendsto g l (nhds b) → f =ᶠ[l] g → a = b | null | true |
CategoryTheory.Idempotents.Karoubi.decomposition._proof_2 | Mathlib.CategoryTheory.Idempotents.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift P.decompId_p P.complement.decompId_p)
(CategoryTheory.Limits.biprod.desc P.decompId_i P.compl... | null | false |
Lean.Elab.Tactic.BVDecide.BVDecideConfig.mk.injEq | Std.Tactic.BVDecide.Syntax | ∀ (timeout : ℕ)
(trimProofs binaryProofs acNf andFlattening embeddedConstraintSubst structures fixedInt enums graphviz : Bool)
(maxSteps : ℕ) (shortCircuit : Bool) (solverMode : Lean.Elab.Tactic.BVDecide.SolverMode) (timeout_1 : ℕ)
(trimProofs_1 binaryProofs_1 acNf_1 andFlattening_1 embeddedConstraintSubst_1 stru... | null | true |
CategoryTheory.Iso.inv_ext._to_dual_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : X ⟶ Y},
CategoryTheory.CategoryStruct.comp g f.inv = CategoryTheory.CategoryStruct.id X → f.hom = g | null | false |
sdiff_sdiff_sup_sdiff' | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], z \ (x \ y ⊔ y \ x) = z ⊓ x ⊓ y ⊔ z \ x ⊓ z \ y | null | true |
RingHom.smulOneHom | Mathlib.Algebra.Module.RingHom | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] → [inst_1 : NonAssocSemiring S] → [inst_2 : Module R S] → [IsScalarTower R S S] → R →+* S | If the module action of `R` on `S` is compatible with multiplication on `S`, then
`fun x ↦ x • 1` is a ring homomorphism from `R` to `S`.
This is the `RingHom` version of `MonoidHom.smulOneHom`.
When `R` is commutative, usually `algebraMap` should be preferred. | true |
CategoryTheory.SimplicialObject.equivalenceLeftToRight | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] →
(X : CategoryTheory.SimplicialObject.Augmented C) →
(F : CategoryTheory.Arrow C) →
... | A helper function used in defining the Čech adjunction. | true |
AffineSubspace.mem_perpBisector_iff_dist_eq' | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P}, c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ dist p₁ c = dist p₂ c | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._simp_6 | Init.Data.String.Pattern.String | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
String.length_ofList | Init.Data.String.Length | ∀ {l : List Char}, (String.ofList l).length = l.length | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.recOn | Lean.Util.ParamMinimizer | {m : Type → Type} →
{motive : Lean.Util.ParamMinimizer.Context✝ m → Sort u} →
(t : Lean.Util.ParamMinimizer.Context✝ m) →
((initialMask : Array Bool) →
(test : Array Bool → m Bool) →
(maxCalls : ℕ) → motive { initialMask := initialMask, test := test, maxCalls := maxCalls }) →
m... | null | false |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.instIsDiscreteValuationRingSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._simp_5 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
AddSubsemigroup.instSetLike.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M], AddSubsemigroup.instSetLike = { coe := AddSubsemigroup.carrier, coe_injective := ⋯ } | null | true |
Lean.Elab.Structural.IndGroupInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → ℕ | null | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Bounds.0.BddAbove.range_comp_of_nonneg._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Bounds | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
Lean.Server.StatefulRequestHandler.mk | Lean.Server.Requests | (Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)) →
(Lean.Lsp.DidChangeTextDocumentParams → StateT Dy... | null | true |
NormedAddGroupHom.Equalizer.liftEquiv._proof_4 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_3} {V₁ : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W},
Function.RightInverse (fun ψ => ⟨(NormedAddGroupHom.Equalizer.ι f g).comp ψ, ⋯⟩) fun φ =>
NormedAddGroupHom.Equalizer.lift ↑φ ... | null | false |
ULift.divisionRing._proof_1 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : DivisionRing α] (a b : ULift.{u_1, u_2} α), a / b = a * b⁻¹ | null | false |
Batteries.AssocList.replace._f | Batteries.Data.AssocList.Basic | {α : Type u_1} →
{β : Type u_2} →
[BEq α] → α → β → (x : Batteries.AssocList α β) → Batteries.AssocList.below x → Batteries.AssocList α β | null | false |
ImportGraph.NormImports.«command#norm_imports» | ImportGraph.Tools.NormImports | Lean.ParserDescr | Normalizes the imports of the current file. This removes rendundant imports and formats the
resulting import block in a standard fashion, ensuring that the same modules are available at the
same visibilities and phases. It does **not** take into account the declarations or usages of those
modules in the current file.
... | true |
CategoryTheory.Limits.PushoutCocone.inl | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} → {f : X ⟶ Y} → {g : X ⟶ Z} → (t : CategoryTheory.Limits.PushoutCocone f g) → Y ⟶ t.pt | The first inclusion of a pushout cocone. | true |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.toWord_mul_mk_eq._proof_1_2 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (x : FreeGroup α) (i : ℕ),
i + 1 ≤ (List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord).dropLast.length →
i < (List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord).dropLast.length | null | false |
Std.Tactic.BVDecide.LRAT.Internal.AssignValue.unassigned | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.AssignValue | null | true |
_private.Lean.Environment.0.Lean.RealizationContext | Lean.Environment | Type | Context for `realizeConst` established by `enableRealizationsForConst`. | true |
BoolAlg.hom_id | Mathlib.Order.Category.BoolAlg | ∀ {X : BoolAlg}, BoolAlg.Hom.hom (CategoryTheory.CategoryStruct.id X) = BoundedLatticeHom.id ↑X | null | true |
AddLocalization.addEquivOfQuotient_mk | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
{f : S.LocalizationMap N} (x : M) (y : ↥S),
(AddLocalization.addEquivOfQuotient f) (AddLocalization.mk x y) = f.mk' x y | null | true |
CompactlySupportedContinuousMap.integralPositiveLinearMap._proof_2 | Mathlib.MeasureTheory.Integral.CompactlySupported | ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOrderedAddMonoid (CompactlySupportedContinuousMap X ℝ) | null | false |
NonUnitalStarAlgHom.fst_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : Star B] (self : A × B), (NonUnitalStarAlgHom.fst R A B) self = self.1 | null | true |
QuadraticModuleCat.Hom._sizeOf_inst | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → {inst : CommRing R} → (V W : QuadraticModuleCat R) → [SizeOf R] → SizeOf (V.Hom W) | null | false |
List.getLast_filterMap | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α} (h : List.filterMap f l ≠ []),
(List.filterMap f l).getLast h = (List.findSome? f l.reverse).get ⋯ | null | true |
PosMulReflectLT.toPosMulMono | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLT α], PosMulMono α | null | true |
Ideal.Quotient.mkₐ._proof_5 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_2) {A : Type u_1} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided] (x : R₁),
(↑↑{ toFun := fun a => Submodule.Quotient.mk a, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
((algebraMap R₁ A) x) =
(↑↑{ toFun := fun... | null | false |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_cons_zero._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {a : α},
List.findIdxNth p (a :: xs) 0 = if p a = true then 0 else List.findIdxNth p xs 0 + 1 | null | false |
CategoryTheory.LocalizerMorphism.IsLocalizedEquivalence.mk._flat_ctor | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂},
(Φ.localizedFunctor W₁.Q W₂.Q).IsEquivalence → Φ.IsLocalized... | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.checkForInductionWithNoAlts.match_1 | Lean.Elab.Tactic.Induction | (motive : Lean.Syntax → Sort u_1) →
(optInductionAlts : Lean.Syntax) →
((info info_1 info_2 info_3 info_4 : Lean.SourceInfo) →
(var : Lean.Syntax) →
motive
(Lean.Syntax.node info `null
#[Lean.Syntax.node info_1 `Lean.Parser.Tactic.inductionAlts
#[Lean.... | null | false |
CategoryTheory.InducedCategory.isGroupoid | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u} (D : Type u₂) [inst : CategoryTheory.Category.{v, u₂} D] [CategoryTheory.IsGroupoid D] (F : C → D),
CategoryTheory.IsGroupoid (CategoryTheory.InducedCategory D F) | null | true |
CategoryTheory.ShortComplex.QuasiIso.congr_simp | Mathlib.Algebra.Homology.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ φ_1 : S₁ ⟶ S₂),
φ = φ_1 → CategoryTheory.ShortComplex.QuasiIso φ = CategoryTheory.ShortComplex.QuasiIso φ_... | null | true |
PosSMulReflectLT.rec | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero α] →
{motive : PosSMulReflectLT α β → Sort u} →
((lt_of_smul_lt_smul_left : ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b₁ b₂ : β⦄, a • b₁ < a • b₂ → b₁ < b₂) → motive ⋯... | null | false |
Std.Time.PlainDateTime.weekOfMonth | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → optParam Std.Time.Weekday Std.Time.Weekday.monday → Std.Time.Week.Ordinal | Returns the week of the month for the given `PlainDateTime`, where weeks start on `firstDay`.
The first partial week containing day 1 is week 1, so weeks may span fewer than 7 days.
| true |
_private.Mathlib.MeasureTheory.Measure.SeparableMeasure.0.MeasureTheory.Lp.SecondCountableTopology.match_3 | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_2} {E : Type u_1} [m : MeasurableSpace X] [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure X}
{p : ENNReal} (u : Set E) (a : E) {s : Set X} (ε : ℝ)
(motive : (∃ b ∈ u, ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)))) → Prop)
(x : ∃ b ∈ u, ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)... | null | false |
ContinuousGeneratedByCat.instIsIsoFunctorUnitTopCatAdj | Mathlib.Topology.Convenient.Category | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)],
CategoryTheory.IsIso ContinuousGeneratedByCat.adj.unit | null | true |
PNat.instMetricSpace._proof_22 | Mathlib.Topology.Instances.PNat | PNat.instMetricSpace._aux_20 ≤ Filter.cofinite | null | false |
NNReal.natCast_iInf | Mathlib.Basic.NNReal.Basic | ∀ {ι : Sort u_4} (f : ι → ℕ), ↑(⨅ i, f i) = ⨅ i, ↑(f i) | null | true |
IsCoprime.divRadical | Mathlib.RingTheory.Radical.Basic | ∀ {E : Type u_1} [inst : EuclideanDomain E] [inst_1 : NormalizationMonoid E] [inst_2 : UniqueFactorizationMonoid E]
{a b : E}, IsCoprime a b → IsCoprime (EuclideanDomain.divRadical a) (EuclideanDomain.divRadical b) | null | true |
Std.DTreeMap.Const.compare_minKey?_modify_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : β → β} {km kmm : α} (hkm : t.minKey? = some km),
(Std.DTreeMap.Const.modify t k f).minKey?.get ⋯ = kmm → cmp kmm km = Ordering.eq | null | true |
EST.Out.noConfusion | Init.System.ST | {P : Sort u} →
{ε σ α : Type} →
{t : EST.Out ε σ α} →
{ε' σ' α' : Type} → {t' : EST.Out ε' σ' α'} → ε = ε' → σ = σ' → α = α' → t ≍ t' → EST.Out.noConfusionType P t t' | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanMap.match_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u_4} →
{C : Type u_5} →
[inst : CategoryTheory.Category.{u_2, u_4} C₀] →
[inst_1 : CategoryTheory.Category.{u_3, u_5} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} →
(data : F.PreOneHypercoverDenseData X) →
(motive : CategoryTheory.Limits.WalkingMult... | null | false |
_private.Lean.Compiler.LCNF.Passes.0.Lean.Compiler.LCNF.addPass._sparseCasesOn_3 | Lean.Compiler.LCNF.Passes | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Topology.IsClosedEmbedding.comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsClosedEmbedding g → Topology.IsClosedEmbedding f → Topology.IsClosedEmbedding (g ∘ f) | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstanceImp | Lean.Meta.Basic | {α : Type} → Lean.Name → Lean.Expr → Lean.MetaM α → Lean.MetaM α | null | true |
Simps.ProjectionData.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {name : Lean.Name} {expr : Lean.Expr} {projNrs : List ℕ} {isDefault isPrefix : Bool} {name_1 : Lean.Name}
{expr_1 : Lean.Expr} {projNrs_1 : List ℕ} {isDefault_1 isPrefix_1 : Bool},
{ name := name, expr := expr, projNrs := projNrs, isDefault := isDefault, isPrefix := isPrefix } =
{ name := name_1, expr := ex... | null | true |
instContinuousNegElemBallOfNat | Mathlib.Analysis.Normed.Group.BallSphere | ∀ {E : Type u_1} [i : SeminormedAddCommGroup E] {r : ℝ}, ContinuousNeg ↑(Metric.ball 0 r) | null | true |
Std.Time.TimeZone.GMT | Std.Time.Zoned.TimeZone | Std.Time.TimeZone | A zeroed `Timezone` representing GMT (no offset).
| true |
Coalgebra.Repr.mk.sizeOf_spec | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] {a : A} {ι : Type u_1} [inst_4 : SizeOf R] [inst_5 : SizeOf A] [inst_6 : SizeOf ι]
(index : Finset ι) (left right : ι → A) (eq : ∑ i ∈ index, left i ⊗ₜ[R] right i = CoalgebraStruct.com... | null | true |
Action.res._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_4} {H : Type u_3} [inst_1 : Monoid G]
[inst_2 : Monoid H] (f : G →* H) {X Y Z : Action V H} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
{ hom := (CategoryTheory.CategoryStruct.comp f_1 g).hom, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := f_1... | null | false |
CategoryTheory.ComonObj._aux_Mathlib_CategoryTheory_Monoidal_Comon____unexpand_CategoryTheory_ComonObj_comul_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Data.Finset.Sups.0.Finset.filter_sups_le._simp_1_2 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ ↑s) | null | false |
IsUnit.unit_map | Mathlib.Algebra.Group.Units.Hom | ∀ {F : Type u_1} {M : Type u_3} {N : Type u_4} [inst : FunLike F M N] [inst_1 : Monoid M] [inst_2 : Monoid N]
[inst_3 : MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x), ↑⋯.unit = f ↑h.unit | null | true |
Char.succ?_eq | Init.Data.Char.Ordinal | ∀ {c : Char}, c.succ? = Option.map Char.ofOrdinal (c.ordinal.addNat? 1) | null | true |
Cardinal.IsInaccessible.recOn | Mathlib.SetTheory.Cardinal.Regular | {c : Cardinal.{u_1}} →
{motive : c.IsInaccessible → Sort u} →
(t : c.IsInaccessible) →
((aleph0_lt : Cardinal.aleph0 < c) →
(le_cof_ord : c ≤ c.ord.cof) → (isStrongPrelimit : c.IsStrongPrelimit) → motive ⋯) →
motive t | null | false |
_private.Batteries.Data.List.Basic.0.List.swapTR.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → List α → List α → ℕ → ℕ → Array α → List α | null | false |
PartialEquiv.transEquiv_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ),
(e.transEquiv f').target = ⇑f'.symm ⁻¹' e.target | null | true |
PerfectClosure.lift._proof_3 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (L : Type u_2)
[inst_3 : CommSemiring L] [inst_4 : CharP L p] [inst_5 : PerfectRing L p],
Function.LeftInverse (fun f => f.comp (PerfectClosure.of K p)) fun f =>
{ toFun := fun e => e.liftOn (fun x => (⇑(frobeniusEqu... | null | false |
mul_neg_mem | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : HasDistribNeg R] [inst_2 : SetLike S R] [MulMemClass S R]
{s : S} {x y : R}, x ∈ s → -y ∈ s → -(x * y) ∈ s | This lemma exists for `aesop`, as `aesop` simplifies `x * -y` to `-(x * y)` before applying
unsafe rules like `mul_mem`, leading to a dead end in cases where `neg_mem` does not hold. | true |
Set.Iic_union_Ici | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Iic a ∪ Set.Ici a = Set.univ | null | true |
Real.exp_neg_one_lt_d9 | Mathlib.Analysis.Complex.ExponentialBounds | Real.exp (-1) < 0.3678794412 | null | true |
subset_supClosure | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeSup α] {s : Set α}, s ⊆ supClosure s | null | true |
GenContFract.euler_h | Mathlib.Algebra.ContinuedFractions.Euler | ∀ {K : Type u_1} [inst : Field K] {h : K} {ρ : Stream'.Seq K}, (GenContFract.euler h ρ).h = h | null | true |
Function.support_mul' | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] (f g : ι → M₀),
Function.support (f * g) = Function.support f ∩ Function.support g | null | true |
Homeomorph.contractibleSpace_iff | Mathlib.Topology.Homotopy.Contractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
ContractibleSpace X ↔ ContractibleSpace Y | null | true |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_1.eq_2 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3) (it : Std.IterM m α)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.Iter... | null | true |
List.IsChain.nil._simp_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {R : α → α → Prop}, List.IsChain R [] = True | null | false |
Matrix.GeneralLinearGroup.upperRightHom._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : Ring R] (x : R), !![1, x; 0, 1] * !![1, -x; 0, 1] = 1 | null | false |
Std.Http.URI.Port.rec | Std.Http.Data.URI.Basic | {motive : Std.Http.URI.Port → Sort u} →
motive Std.Http.URI.Port.omitted →
motive Std.Http.URI.Port.empty →
((port : UInt16) → motive (Std.Http.URI.Port.value port)) → (t : Std.Http.URI.Port) → motive t | null | false |
AddSubmonoid.map_comap_map | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
AddSubmonoid.map f (AddSubmonoid.comap f (AddSubmonoid.map f S)) = AddSubmonoid.map f S | null | true |
Lean.Compiler.LCNF.PullLetDecls.State.noConfusion | Lean.Compiler.LCNF.PullLetDecls | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.PullLetDecls.State} → t = t' → Lean.Compiler.LCNF.PullLetDecls.State.noConfusionType P t t' | null | false |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Rat.padicValuation_le_one_iff._simp_1_4 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.not_isStronglyTranscendental_of_weaklyQuasiFiniteAt._simp_1_3 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A}
{S : Subalgebra R A}, (Algebra.adjoin R s ≤ S) = (s ⊆ ↑S) | null | false |
MeasureTheory.Measure.measure_inv | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : InvolutiveInv G] [MeasurableInv G] (μ : MeasureTheory.Measure G)
[μ.IsInvInvariant] (A : Set G), μ A⁻¹ = μ A | null | true |
Filter.EventuallyLE.isMinFilter | Mathlib.Order.Filter.Extr | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
f ≤ᶠ[l] g → f a = g a → IsMinFilter f l a → IsMinFilter g l a | null | true |
NormedAddGroupHom.equalizer | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : SeminormedAddCommGroup W] → NormedAddGroupHom V W → NormedAddGroupHom V W → AddSubgroup V | The equalizer of two morphisms `f g : NormedAddGroupHom V W`. | true |
Std.Tactic.BVDecide.BVBinOp._sizeOf_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp → ℕ | null | false |
_private.Mathlib.Algebra.Homology.ShortComplex.Ab.0.CategoryTheory.ShortComplex.ab_exact_iff._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.«term_→ₛ_» | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | Lean.TrailingParserDescr | null | true |
Numbering.dens_prefixed | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X),
(Numbering.prefixed s).dens = (↑((Fintype.card X).choose s.card))⁻¹ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.keys_filter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.getElem_drop'._simp_1_1 | Init.Data.List.Nat.TakeDrop | ∀ (n k : ℕ), (n ≤ n + k) = True | null | false |
Lex.instMulAction | Mathlib.Algebra.Order.Group.Action.Synonym | {M : Type u_1} → {α : Type u_3} → [inst : Monoid M] → [MulAction M α] → MulAction (Lex M) α | null | true |
Bialgebra.comulBialgHom._proof_3 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
WithBot.isSuccLimit_coe_iff | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : Preorder α] {x : α}, Order.IsSuccLimit ↑x ↔ Order.IsSuccLimit x | null | true |
CategoryTheory.Comma.equivProd_unitIso_inv_app_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (X : CategoryTheory.Comma L R),
((CategoryTheory... | null | true |
OpenNormalSubgroup.instSemilatticeSupOpenNormalSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} →
[inst : Group G] → [inst_1 : TopologicalSpace G] → [SeparatelyContinuousMul G] → SemilatticeSup (OpenNormalSubgroup G) | null | true |
CochainComplex.HomComplex.Cochain.leftShift_rightShift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain K L n) (a n' : ℤ) (hn' : n' + a = n),
(γ.rightShift a n' hn').leftShift a n hn' = (a * n + a * (a - 1) / 2).negOnePow • γ.shift a | null | true |
CliffordAlgebra.ofBaseChange._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_3} (A : Type u_1) {V : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : AddCommGroup V]
[inst_3 : Algebra R A] [inst_4 : Module R V], IsScalarTower A A (TensorProduct R A V) | null | false |
Aesop.Slot.recOn | Aesop.Forward.RuleInfo | {motive : Aesop.Slot → Sort u} →
(t : Aesop.Slot) →
((typeDiscrTreeKeys? : Option (Array Lean.Meta.DiscrTree.Key)) →
(index : Aesop.SlotIndex) →
(premiseIndex : Aesop.PremiseIndex) →
(deps common : Std.HashSet Aesop.PremiseIndex) →
(forwardDeps : Array Aesop.PremiseInde... | null | false |
HilbertBasis.instFunLike._proof_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_2} {𝕜 : Type u_1} [inst : RCLike 𝕜] (i : ι), IsBoundedSMul 𝕜 𝕜 | null | false |
ENNReal.one_lt_two | Mathlib.Basic.ENNReal.Basic | 1 < 2 | null | true |
_private.Batteries.Data.String.Legacy.0.String.Legacy.anyAux._proof_4 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos i : String.Pos.Raw),
i < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s i).byteIdx < stopPos.byteIdx - i.byteIdx | null | false |
groupCohomology.mapShortComplex₂_exact | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)},
X.ShortExact → ∀ (i : ℕ), (groupCohomology.mapShortComplex₂ X i).Exact | Exactness of `Hⁱ(G, X₁) ⟶ Hⁱ(G, X₂) ⟶ Hⁱ(G, X₃)`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.