name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Polynomial.Sequence.elems' | Mathlib.Algebra.Polynomial.Sequence | {R : Type u_1} → [inst : Semiring R] → Polynomial.Sequence R → ℕ → Polynomial R | The `i`-th element in the sequence. Use `S i` instead, defined via `CoeFun`. | true |
Std.Internal.instLawfulMemForInIdRangeNat | Std.Internal.ForIn.Lemmas | Std.Internal.LawfulMemForInId Std.Legacy.Range ℕ | null | true |
CategoryTheory.Grothendieck.isoMk._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.Cat... | null | false |
CategoryTheory.Reflective | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor D C → Type (max (max (max u₁ u₂) v₁) v₂) | A functor is *reflective*, or *a reflective inclusion*, if it is fully faithful and right adjoint.
| true |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso._proof_1 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover) (i : 𝒰.affineRefinement.openCover.I₀),
CategoryTheory.Limits.HasPullback f (𝒰.affineRefinement.openCover.f i) | null | false |
Finset.coe_pimage | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, ↑(Finset.pimage f s) = f.image ↑s | null | true |
Set.singletonMulHom_apply | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] (a : α), Set.singletonMulHom a = {a} | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme___macroRules__private_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme_0_AlgebraicGeometry_termSpec.T__1» | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.Macro | null | false |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mrevertError_1 | Std.Tactic.Do.Syntax | Lean.Macro | null | false |
MvPolynomial.zeroLocus_span | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3}
(S : Set (MvPolynomial σ k)), MvPolynomial.zeroLocus K (Ideal.span S) = {x | ∀ p ∈ S, (MvPolynomial.aeval x) p = 0} | null | true |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.elabPushTree._sparseCasesOn_3 | Mathlib.Tactic.Push | {motive : Mathlib.Tactic.Push.Head → Sort u} →
(t : Mathlib.Tactic.Push.Head) →
motive Mathlib.Tactic.Push.Head.lambda → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
MeasureTheory.Integrable.measure_gt_lt_top | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β} [inst_1 : Lattice β] [HasSolidNorm β] [AddLeftMono β],
MeasureTheory.Integrable f μ → ∀ {ε : β}, 0 < ε → μ {a | ε < f a} < ⊤ | If `f` is integrable, then for any `c > 0` the set `{x | f x > c}` has finite
measure. | true |
iteratedDeriv_fun_mul | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {x : 𝕜} {𝔸 : Type u_5} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f g : 𝕜 → 𝔸},
ContDiffAt 𝕜 (↑n) f x →
ContDiffAt 𝕜 (↑n) g x →
iteratedDeriv n (fun i => f i * g i) x =
∑ i ∈ Finset.range (n + 1), ↑(n.choose i) * ite... | Eta-expanded form of `iteratedDeriv_mul` | true |
HomologicalComplex.mk._flat_ctor | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} →
(X : ι → V) →
(d : (i j : ι) → X i ⟶ X j) →
autoParam (∀ (i j : ι), ¬c.Rel i j → d i j = 0) HomologicalComplex.... | null | false |
Std.TreeMap.Raw.getKey!_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂).getKey! k = default | null | true |
CategoryTheory.CosimplicialObject.Truncated.trunc._auto_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.Syntax | null | false |
Std.Internal.USquash.inflate.inj | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v} {x : Std.Internal.Small α} {x_1 y : Std.Internal.USquash α}, x_1.inflate = y.inflate → x_1 = y | null | true |
instFunLikeMulActionHom._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} {N : Type u_4} (φ : M → N) (X : Type u_1) [inst : SMul M X] (Y : Type u_2) [inst_1 : SMul N Y]
(f g : X →ₑ[φ] Y), f.toFun = g.toFun → f = g | null | false |
_private.Mathlib.RingTheory.Multiplicity.0.emultiplicity_eq_of_dvd_of_not_dvd._simp_1_4 | Mathlib.RingTheory.Multiplicity | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
AddGroupSeminorm.apply_one | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] [inst_1 : DecidableEq E] (x : E), 1 x = if x = 0 then 0 else 1 | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.append_append_left_iff._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} (p : α × Bool), FreeGroup.Red (p :: L₁) (p :: L₂) = FreeGroup.Red L₁ L₂ | null | false |
LinearMap.convSemiring._proof_6 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_3} {A : Type u_1} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C] (n : ℕ) (x : WithConv (C →ₗ[R] A)),
x ^ (n + 1) = x ^ n * x | null | false |
Subring.inclusion._proof_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] {S T : Subring R}, S ≤ T → ∀ (x : ↥S), S.subtype x ∈ T | null | false |
_private.Mathlib.CategoryTheory.Simple.0.CategoryTheory.instNontrivialEndOfSimple._simp_1 | Mathlib.CategoryTheory.Simple | ∀ {C : Type u} {inst : CategoryTheory.CategoryStruct.{v, u} C} {X : C} {x y : CategoryTheory.End X},
(x = y) = (x.asHom = y.asHom) | null | false |
List.pmap_attachWith._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {q : α → Prop} {l : List α} (H₁ : ∀ x ∈ l, q x) (a : α) (h : a ∈ l), ⟨a, ⋯⟩ ∈ l.attachWith q H₁ | null | false |
Polynomial.logMahlerMeasure.eq_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (p : Polynomial ℂ), p.logMahlerMeasure = Real.circleAverage (fun x => Real.log ‖Polynomial.eval x p‖) 0 1 | null | true |
BialgHom.instCommMonoidWithConv._proof_5 | Mathlib.RingTheory.Bialgebra.Convolution | ∀ {R : Type u_3} {A : Type u_1} {C : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Semiring C]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R C] [inst_5 : Coalgebra.IsCocomm R C],
autoParam (∀ (n : ℕ) (x : WithConv (C →ₐc[R] A)), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._autoParam | null | false |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.root.eq_1 | Batteries.Data.UnionFind.Basic | ∀ (self : Batteries.UnionFind) (x : Fin self.size),
self.root x =
if h : self.arr[↑x].parent = ↑x then x
else
have this := ⋯;
self.root ⟨self.arr[↑x].parent, ⋯⟩ | null | true |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.singleton_dep._proof_1_2 | Mathlib.Combinatorics.Matroid.Loop | 1 ≠ 0 | null | false |
FirstOrder.«_aux_Mathlib_ModelTheory_Semantics___macroRules_FirstOrder_term_≅[_]__1» | Mathlib.ModelTheory.Semantics | Lean.Macro | null | false |
String.Pos.slice_le_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos} {h₀ : p₀ ≤ q} {h₁ : q ≤ p₁},
q.slice p₀ p₁ h₀ h₁ ≤ p ↔ q ≤ String.Pos.ofSlice p | null | true |
MvPolynomial.coeff_expand_zero | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ),
p ≠ 0 → ∀ (φ : MvPolynomial σ R), ((MvPolynomial.expand p) φ).coeff 0 = φ.coeff 0 | null | true |
Algebra.adjoin_singleton_eq_range_aeval | Mathlib.RingTheory.Adjoin.Polynomial.Basic | ∀ (R : Type u) {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
R[x] = (Polynomial.aeval x).range | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.saveAppOf._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Types | {motive : Lean.HeadIndex → Sort u} →
(t : Lean.HeadIndex) →
((constName : Lean.Name) → motive (Lean.HeadIndex.const constName)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
LieModule.shiftedGenWeightSpace.instLieRingModuleSubtypeMemLieSubmodule._proof_6 | Mathlib.Algebra.Lie.Weights.Linear | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (χ : L → R) [LieModule.LinearWeights R L M] (x y : L)
(m : ↥(Li... | null | false |
UpperSet.infIrred_iff_of_finite | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : PartialOrder α] {s : UpperSet α} [Finite α], InfIrred s ↔ ∃ a, UpperSet.Ici a = s | null | true |
groupCohomology | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → Rep.{u, u, u} k G → ℕ → ModuleCat k | The group cohomology of a `k`-linear `G`-representation `A`, as the cohomology of its complex
of inhomogeneous cochains. | true |
Monoid.CoprodI.NeWord.inv._f | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{G : ι → Type u_4} →
[inst : (i : ι) → Group (G i)] →
(x x_1 : ι) →
(x_2 : Monoid.CoprodI.NeWord G x x_1) → Monoid.CoprodI.NeWord.below x_2 → Monoid.CoprodI.NeWord G x_1 x | null | false |
Set.mul_subset_range | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Mul β] [inst_2 : FunLike F α β]
[MulHomClass F α β] (m : F) {s t : Set β}, s ⊆ Set.range ⇑m → t ⊆ Set.range ⇑m → s * t ⊆ Set.range ⇑m | null | true |
PartialEquiv.coe_mk | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (s : Set α) (t : Set β) (ml : ∀ ⦃x : α⦄, x ∈ s → f x ∈ t)
(mr : ∀ ⦃x : β⦄, x ∈ t → g x ∈ s) (il : ∀ ⦃x : α⦄, x ∈ s → g (f x) = x) (ir : ∀ ⦃x : β⦄, x ∈ t → f (g x) = x),
↑{ toFun := f, invFun := g, source := s, target := t, map_source' := ml, map_target' := mr,... | null | true |
MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict | Mathlib.MeasureTheory.Measure.Sub | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → (μ - ν).restrict s = μ.restrict s - ν.restrict s | null | true |
LinearMap.exact_zero_iff_surjective._simp_1 | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_8} {N : Type u_9} (P : Type u_10) [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommMonoid P] [inst_4 : Module R N] [inst_5 : Module R M] [inst_6 : Module R P]
(f : M →ₗ[R] N), Function.Exact ⇑f ⇑0 = Function.Surjective ⇑f | null | false |
Lean.Meta.Hint.Suggestion.casesOn | Lean.Meta.Hint | {motive : Lean.Meta.Hint.Suggestion → Sort u} →
(t : Lean.Meta.Hint.Suggestion) →
((toTryThisSuggestion : Lean.Meta.Tactic.TryThis.Suggestion) →
(span? previewSpan? : Option Lean.Syntax) →
(diffGranularity : Lean.Meta.Hint.DiffGranularity) →
motive
{ toTryThisSuggestion... | null | false |
_private.Mathlib.Data.List.Defs.0.List.headI.match_1.splitter | Mathlib.Data.List.Defs | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (tail : List α) → motive (a :: tail)) → motive x | null | true |
Lean.Environment.getModuleIdxFor? | Lean.Environment | Lean.Environment → Lean.Name → Option Lean.ModuleIdx | null | true |
CategoryTheory.Grp.mk.injEq | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) [grp : CategoryTheory.GrpObj X] (X_1 : C) (grp_1 : CategoryTheory.GrpObj X_1),
({ X := X, grp := grp } = { X := X_1, grp := grp_1 }) = (X = X_1 ∧ grp ≍ grp_1) | null | true |
Complex.hasSum_deriv_of_summable_norm | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {E : Type u_1} {ι : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {U : Set ℂ} {z : ℂ}
{F : ι → ℂ → E} [CompleteSpace E] {u : ι → ℝ},
Summable u →
(∀ (i : ι), DifferentiableOn ℂ (F i) U) →
IsOpen U →
(∀ (i : ι), ∀ w ∈ U, ‖F i w‖ ≤ u i) →
z ∈ U → HasSum (fun i => der... | If the terms in the sum `∑' (i : ι), F i` are uniformly bounded on `U` by a
summable function, then the sum of `deriv F i` at a point in `U` is the derivative of the
sum. | true |
Submodule.exists_finset_of_mem_iSup | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_3}
(p : ι → Submodule R M) {m : M}, m ∈ ⨆ i, p i → ∃ s, m ∈ ⨆ i ∈ s, p i | null | true |
IsLeast.bddBelow | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, IsLeast s a → BddBelow s | If `s` has a least element, then it is bounded below. | true |
Algebra.GrothendieckGroup.instFG | Mathlib.GroupTheory.MonoidLocalization.Finite | ∀ {M : Type u_1} [inst : CommMonoid M] [Monoid.FG M], Monoid.FG (Algebra.GrothendieckGroup M) | The Grothendieck group of a finitely generated monoid is finitely generated. | true |
_private.Mathlib.Basic.ENNReal.Inv.0.ENNReal.mulRightOrderIso._simp_1 | Mathlib.Basic.ENNReal.Inv | ∀ {a b c : ENNReal}, c ≠ 0 → c ≠ ⊤ → (a * c ≤ b * c) = (a ≤ b) | null | false |
Std.DHashMap.Raw.get?_inter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∩ m₂).get? k = if k ∈ m₂ then m₁.get? k else none | null | true |
SSet.stdSimplex.finSuccAboveOrderIsoFinset._proof_7 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (i : Fin (n + 2)),
Function.LeftInverse
(fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩)
fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩ | null | false |
groupHomology.cyclesMk₂_eq._proof_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G)
(x : ↥(groupHomology.cycles₂ A)),
(CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains A).d 2 1))
((CategoryTheory.ConcreteCategory.hom (groupHomology.chainsIso₂ A).inv) ↑x) =
0 | null | false |
LightCondSet.sequentialAdjunction | Mathlib.Condensed.Light.TopCatAdjunction | LightCondSet.lightCondSetToSequential ⊣ LightCondSet.sequentialToLightCondSet | The adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` restricted to sequential
spaces.
| true |
UInt8.neg_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), -a * b = -(a * b) | null | true |
CommSemiRingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier._proof_7 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommSemiRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections]
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp (CategoryTheory.forget... | null | false |
Std.Time.Year.instLTOffset._aux_1 | Std.Time.Date.Unit.Year | Std.Time.Year.Offset → Std.Time.Year.Offset → Prop | null | false |
Lean.Linter.CodeQuality.Source.recOn | Lean.Linter.CodeQuality.Basic | {motive : Lean.Linter.CodeQuality.Source → Sort u} →
(t : Lean.Linter.CodeQuality.Source) →
((name : Lean.Name) → motive (Lean.Linter.CodeQuality.Source.module name)) →
((module name : Lean.Name) → motive (Lean.Linter.CodeQuality.Source.declaration module name)) → motive t | null | false |
RingNorm._sizeOf_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → {inst : NonUnitalNonAssocRing R} → [SizeOf R] → RingNorm R → ℕ | null | false |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.simp._sparseCasesOn_11 | Lean.Compiler.LCNF.Simp.Main | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((type : Lean.Expr) → motive_4 (Lean.Compiler.LCNF.Code.unreach type)) →
(Nat.hasNotBit 64 t.ctorIdx → motive_4 t) → motive_4 t | null | false |
_private.Mathlib.Tactic.ApplyAt.0.Mathlib.Tactic._aux_Mathlib_Tactic_ApplyAt___elabRules_Mathlib_Tactic_tacticApply_At__1.match_3 | Mathlib.Tactic.ApplyAt | (motive : Lean.FVarId × Lean.MVarId → Sort u_1) →
(x : Lean.FVarId × Lean.MVarId) → ((fst : Lean.FVarId) → (mainGoal : Lean.MVarId) → motive (fst, mainGoal)) → motive x | null | false |
String.Slice.Pos.Splits.nextn | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {t₁ t₂ : String} {p : s.Pos},
p.Splits t₁ t₂ →
∀ (n : ℕ), (p.nextn n).Splits (t₁ ++ String.ofList (List.take n t₂.toList)) (String.ofList (List.drop n t₂.toList)) | null | true |
Lean.instInhabitedLevelMetavarDecl.default | Lean.MetavarContext | Lean.LevelMetavarDecl | null | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.AlgHom.«_aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_AlgHom_term↑ₐ_1_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro | null | false |
Complex.neg_iff | Mathlib.Analysis.Complex.Order | ∀ {z : ℂ}, z < 0 ↔ z.re < 0 ∧ z.im = 0 | null | true |
FirstOrder.Language.DirectLimit.lift._proof_4 | Mathlib.ModelTheory.DirectLimit | ∀ (L : FirstOrder.Language) (ι : Type u_2) [inst : Preorder ι] (G : ι → Type u_3) [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [inst_4 : Nonempty ι] {P : Type u_1} [inst_5 : L.Structure P]
... | null | false |
Std.ExtDTreeMap.get_union_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | null | true |
eq_iff_eq_cancel_left | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {b c : α}, (∀ {a : α}, a = b ↔ a = c) ↔ b = c | null | true |
CategoryTheory.FreeGroupoid.strictUniversalPropertyFixedTarget | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : Type u₁} →
[inst_1 : CategoryTheory.Groupoid G] →
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget (CategoryTheory.FreeGroupoid.of C) ⊤ G | The universal property of the free groupoid. | true |
CategoryTheory.ShortComplex.HasRightHomology.hasKernel | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [S.HasRightHomology] [inst_3 : CategoryTheory.Limits.HasCokernel S.f],
CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.cokernel.desc S.f S.g ⋯) | null | true |
UInt8.ofNatLT_add | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (hab : a + b < 2 ^ 8), UInt8.ofNatLT (a + b) hab = UInt8.ofNatLT a ⋯ + UInt8.ofNatLT b ⋯ | null | true |
WithBot.subtypeOrderIso._proof_6 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : DecidablePred fun x => x = ⊥],
(fun a => if h : a = ⊥ then ⊥ else ↑⟨a, h⟩) ((fun a => WithBot.unbotD ⊥ (WithBot.map Subtype.val a)) ⊥) = ⊥ | null | false |
SimpleGraph.completeAtomicBooleanAlgebra._proof_16 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V ι : Type u_1} {κ : ι → Type u_1} (f : (a : ι) → κ a → SimpleGraph V), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a) | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.none.elim | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitCandidate✝ → Sort u} →
(t : Lean.Meta.Grind.SplitCandidate✝) →
Lean.Meta.Grind.SplitCandidate.ctorIdx✝ t = 0 → motive Lean.Meta.Grind.SplitCandidate.none✝ → motive t | null | false |
Aesop.instInhabitedNormalizationState | Aesop.Tree.Data | Inhabited Aesop.NormalizationState | null | true |
Set.univ_pi_ite | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) [inst : DecidablePred fun x => x ∈ s] (t : (i : ι) → Set (α i)),
(Set.univ.pi fun i => if i ∈ s then t i else Set.univ) = s.pi t | null | true |
Lean.Parser.ParserState.stxStack._default | Lean.Parser.Types | Lean.Parser.SyntaxStack | null | false |
RingHom.FiniteType.comp | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : CommRing C]
{g : B →+* C} {f : A →+* B}, g.FiniteType → f.FiniteType → (g.comp f).FiniteType | null | true |
CategoryTheory.Functor.additive_of_iso | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {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] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] {F : CategoryTheory.Functor C D} [F.Additive] {G : CategoryTheory.Functor C D}
(e : F ≅ G), G.Additive | null | true |
Lean.Meta.Grind.SavedState.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SavedState → Sort u} →
(t : Lean.Meta.Grind.SavedState) →
((«meta» : Lean.Meta.SavedState) → (grind : Lean.Meta.Grind.State) → motive { «meta» := «meta», grind := grind }) →
motive t | null | false |
_private.Batteries.Lean.Meta.DiscrTree.0.Lean.Meta.DiscrTree.Trie.mergePreservingDuplicates.mergeChildren | Batteries.Lean.Meta.DiscrTree | {α : Type} →
Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) →
Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) →
Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) | Auxiliary definition for `mergePreservingDuplicates`. | true |
Lean.Elab.Tactic.RCases.RCasesPatt.ctorIdx | Lean.Elab.Tactic.RCases | Lean.Elab.Tactic.RCases.RCasesPatt → ℕ | null | false |
DividedPowers.mk.injEq | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (dpow : ℕ → A → A)
(dpow_null : ∀ {n : ℕ} {x : A}, x ∉ I → dpow n x = 0) (dpow_zero : ∀ {x : A}, x ∈ I → dpow 0 x = 1)
(dpow_one : ∀ {x : A}, x ∈ I → dpow 1 x = x) (dpow_mem : ∀ {n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow n x ∈ I)
(dpow_add :
∀ {n : ℕ} {x y : A... | null | true |
DomAddAct.instIsCancelAddOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Add Mᵃᵒᵖ] [IsCancelAdd Mᵃᵒᵖ], IsCancelAdd Mᵈᵃᵃ | null | true |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarAlgebra.coe_bot._simp_1_2 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {x : A}, (x ∈ ⊥) = (x = 0) | null | false |
Lean.Meta.Grind.AC.modify' | Lean.Meta.Tactic.Grind.AC.Util | (Lean.Meta.Grind.AC.State → Lean.Meta.Grind.AC.State) → Lean.Meta.Grind.GoalM Unit | null | true |
rTensor.toFun.congr_simp | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g g_1 : N →ₗ[R] P} (e_g : g = g_1) (Q : Type u_5) [inst_7 : AddCommGroup ... | null | true |
Multiset.disjSum_mono_left | Mathlib.Data.Multiset.Sum | ∀ {α : Type u_1} {β : Type u_2} (t : Multiset β), Monotone fun s => s.disjSum t | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Types.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.Types.1820690160._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | IO (Lean.Meta.Grind.SolverExtension Lean.Meta.Grind.Arith.Cutsat.State) | null | false |
MulAction.subsingleton_orbit_iff_mem_fixedPoints | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u} [inst : Monoid M] {α : Type v} [inst_1 : MulAction M α] {a : α},
(MulAction.orbit M a).Subsingleton ↔ a ∈ MulAction.fixedPoints M α | null | true |
_private.Mathlib.Algebra.Lie.Loop.0.LieAlgebra.LoopAlgebra.twoCocycleOfBilinear._proof_5 | Mathlib.Algebra.Lie.Loop | ∀ (A : Type u_1) [inst : CommRing A] (a b c : A), a + b + c = 0 → a + b = -c | null | false |
RingHom.kerLift._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Semiring S] (f : R →+* S), (RingHom.ker f).IsTwoSided | null | false |
MonoidHom.snd._proof_2 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : MulOneClass M] [inst_1 : MulOneClass N] (x x_1 : M × N),
(x * x_1).2 = (x * x_1).2 | null | false |
Lean.Lsp.SemanticTokensParams.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokensParams → Sort u} →
(t : Lean.Lsp.SemanticTokensParams) →
((textDocument : Lean.Lsp.TextDocumentIdentifier) → motive { textDocument := textDocument }) → motive t | null | false |
Colex.instSub.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Sub α], Colex.instSub = Colex.instSub._aux_1 | null | true |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk | Lean.Language.Basic | Lean.MessageLog → Option (IO.Ref (Option Dynamic)) → Lean.Language.Snapshot.Diagnostics | null | true |
HSub.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HSub α β γ | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.primitiveTriangle._simp_33 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
Pi.instKleeneAlgebraForall._proof_4 | Mathlib.Algebra.Order.Kleene | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → KleeneAlgebra (π i)] (x x_1 : (i : ι) → π i),
x_1 * x ≤ x_1 → ∀ (x_2 : ι), x_1 x_2 * KStar.kstar (x x_2) ≤ x_1 x_2 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.