name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MonoidalCategory.monoidalOfLawfulDayConvolutionMonoidalCategoryStruct._proof_3 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_6, u_3} C] (V : Type u_5)
[inst_1 : CategoryTheory.Category.{u_4, u_5} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCategoryStruct D]
[CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct C V D] (x : D) {y₁ : D} {y₂ : x ⟶ y₁}
(f : D),
CategoryTheory.MonoidalCategoryStruct.tensorHom y₂ (CategoryTheory.CategoryStruct.id f) =
CategoryTheory.MonoidalCategoryStruct.whiskerRight y₂ f | false |
WithLp.instUnitizationNormedAddCommGroup | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | (𝕜 : Type u_1) →
(A : Type u_2) →
[inst : NormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] → [NormedSpace 𝕜 A] → NormedAddCommGroup (WithLp 1 (Unitization 𝕜 A)) | true |
CategoryTheory.Limits.Bicone.ι_π._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | Lean.Syntax | false |
Multiset.Subset.ndinter_eq_left | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ⊆ t → s.ndinter t = s | true |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.effectiveEpiFamily_tfae._simp_1_3 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C]
{α : Type} [inst_2 : Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B),
CategoryTheory.EffectiveEpiFamily X π = CategoryTheory.EffectiveEpi (CategoryTheory.Limits.Sigma.desc π) | false |
BoundedContinuousFunction.hasNatPow._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_2} [inst : TopologicalSpace α] {R : Type u_1} [inst_1 : SeminormedRing R]
(f : BoundedContinuousFunction α R) (n : ℕ),
∃ C, ∀ (x y : α), dist ((f.toContinuousMap ^ n).toFun x) ((f.toContinuousMap ^ n).toFun y) ≤ C | false |
Lean.DefinitionVal.all | Lean.Declaration | Lean.DefinitionVal → List Lean.Name | true |
SpecialLinearGroup.coe_div | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(A B : SpecialLinearGroup R V), ↑(A / B) = ↑A / ↑B | true |
Lean.Parser.Tactic.MCasesPat | Std.Tactic.Do.Syntax | Type | true |
NonUnitalSubsemiring.inclusion._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {S : NonUnitalSubsemiring R},
NonUnitalRingHomClass (↥S →ₙ+* R) (↥S) R | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabMatchTypeAndDiscrs.elabDiscrs._unsafe_rec | Lean.Elab.Match | Array Lean.Syntax →
Array Lean.Elab.Term.TermMatchAltView →
Lean.Expr → ℕ → Array Lean.Elab.Term.Discr → Lean.Elab.TermElabM Lean.Elab.Term.ElabMatchTypeAndDiscrsResult | false |
Std.TreeMap.Raw.equiv_iff_keys_unit_perm | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α Unit cmp}, t₁.Equiv t₂ ↔ t₁.keys.Perm t₂.keys | true |
Array.forM_append | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] [LawfulMonad m] {xs ys : Array α}
{f : α → m PUnit.{u_1 + 1}},
forM (xs ++ ys) f = do
forM xs f
forM ys f | true |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(X : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.ComposableArrows.homMk₅ (CategoryTheory.CategoryStruct.id X).f₀.τ₁
(CategoryTheory.CategoryStruct.id X).f₀.τ₂ (CategoryTheory.CategoryStruct.id X).f₀.τ₃
(CategoryTheory.CategoryStruct.id X).f₃.τ₁ (CategoryTheory.CategoryStruct.id X).f₃.τ₂
(CategoryTheory.CategoryStruct.id X).f₃.τ₃ ⋯ ⋯ ⋯ ⋯ ⋯ =
CategoryTheory.CategoryStruct.id X.composableArrows | false |
Ordinal.max_zero_right | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : Ordinal.{u_1}), max a 0 = a | true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_inter_Ioc._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Set.Ioc b₁ a₁ ∩ Set.Ioc b₂ a₂ = Set.Ioc (max b₁ b₂) (min a₁ a₂) | false |
Algebra.IsPushout.symm | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
{S' : Type u_7} [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' S'] [inst_10 : IsScalarTower R S S'],
Algebra.IsPushout R S R' S' → Algebra.IsPushout R R' S S' | true |
Interval._aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_termΙ_1 | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro | false |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew? | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
α → β → t.Balanced → Option β × Std.DTreeMap.Internal.Impl α fun x => β | true |
CategoryTheory.ObjectProperty.homMk_surjective | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C}
{X Y : P.FullSubcategory}, Function.Surjective CategoryTheory.ObjectProperty.homMk | true |
Lean.CollectMVars.State.result | Lean.Util.CollectMVars | Lean.CollectMVars.State → Array Lean.MVarId | true |
Module.Basis.constrL._proof_1 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
{ι : Type u_3} [Finite ι] (v : Module.Basis ι 𝕜 E), FiniteDimensional 𝕜 E | false |
Substring.Raw.str | Init.Prelude | Substring.Raw → String | true |
DirectLimit.instCommGroupWithZeroOfMonoidWithZeroHomClass._proof_7 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → CommGroupWithZero (G i)]
[inst_6 : ∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (n : ℕ) (a : DirectLimit G f),
GroupWithZero.zpow (↑n.succ) a = GroupWithZero.zpow (↑n) a * a | false |
Lean.Meta.NormCast.normCastExt | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension | true |
TopCat.isoOfHomeo._proof_1 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat}, ContinuousMapClass (↑X ≃ₜ ↑Y) ↑X ↑Y | false |
LocallyFinite.exists_finset_support | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {X : Type u_5} [inst : TopologicalSpace X] {M : Type u_6} [inst_1 : Zero M] {f : ι → X → M},
(LocallyFinite fun i => Function.support (f i)) →
∀ (x₀ : X), ∃ I, ∀ᶠ (x : X) in nhds x₀, (Function.support fun i => f i x) ⊆ ↑I | true |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.go.match_3 | Lean.Server.Completion.CompletionInfoSelection | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((completionInfo : Lean.Elab.CompletionInfo) → motive (Lean.Elab.Info.ofCompletionInfo completionInfo)) →
((x : Lean.Elab.Info) → motive x) → motive info | false |
CategoryTheory.Limits.image.compIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Y Z : C} (g : Y ⟶ Z) [CategoryTheory.IsIso g],
CategoryTheory.Mono g | false |
Mathlib.Tactic.ToDual.data | Mathlib.Tactic.Translate.ToDual | Mathlib.Tactic.Translate.TranslateData | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.containsBadMax._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.Level) → motive a.succ) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Analysis.Fourier.ZMod.0.ZMod.auxDFT_smul | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module ℂ E] (c : ℂ) (Φ : ZMod N → E),
ZMod.auxDFT✝ (c • Φ) = c • ZMod.auxDFT✝¹ Φ | true |
cantorToTernary_ne_one | Mathlib.Topology.Instances.CantorSet | ∀ {x : ℝ} {n : ℕ}, (cantorToTernary x).get n ≠ 1 | true |
CategoryTheory.Tor._proof_4 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.leftDerived
((CategoryTheory.MonoidalCategory.tensoringLeft C).map (CategoryTheory.CategoryStruct.comp f g)) n =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.leftDerived ((CategoryTheory.MonoidalCategory.tensoringLeft C).map f) n)
(CategoryTheory.NatTrans.leftDerived ((CategoryTheory.MonoidalCategory.tensoringLeft C).map g) n) | false |
CommAlgCat.inv_hom_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (e : A ≅ B) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | true |
Lean.AssocList.nil.elim | Lean.Data.AssocList | {α : Type u} →
{β : Type v} →
{motive : Lean.AssocList α β → Sort u_1} →
(t : Lean.AssocList α β) → t.ctorIdx = 0 → motive Lean.AssocList.nil → motive t | false |
CategoryTheory.SimplicialObject.Homotopy.mk._flat_ctor | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : CategoryTheory.SimplicialObject C} →
{f g : X ⟶ Y} →
(h :
{n : ℕ} →
Fin (n + 1) →
(X.obj (Opposite.op (SimplexCategory.mk n)) ⟶ Y.obj (Opposite.op (SimplexCategory.mk (n + 1))))) →
(∀ (n : ℕ), CategoryTheory.CategoryStruct.comp (h 0) (Y.δ 0) = g.app (Opposite.op (SimplexCategory.mk n))) →
(∀ (n : ℕ),
CategoryTheory.CategoryStruct.comp (h (Fin.last n)) (Y.δ (Fin.last (n + 1))) =
f.app (Opposite.op (SimplexCategory.mk n))) →
(∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)),
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (h j.succ) (Y.δ i.castSucc) =
CategoryTheory.CategoryStruct.comp (X.δ i) (h j)) →
(∀ {n : ℕ} (j : Fin (n + 1)),
CategoryTheory.CategoryStruct.comp (h j.succ) (Y.δ j.castSucc.succ) =
CategoryTheory.CategoryStruct.comp (h j.castSucc) (Y.δ j.castSucc.succ)) →
(∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)),
j.castSucc < i →
CategoryTheory.CategoryStruct.comp (h j.castSucc) (Y.δ i.succ) =
CategoryTheory.CategoryStruct.comp (X.δ i) (h j)) →
(∀ {n : ℕ} (i j : Fin (n + 1)),
i ≤ j →
CategoryTheory.CategoryStruct.comp (h j) (Y.σ i.castSucc) =
CategoryTheory.CategoryStruct.comp (X.σ i) (h j.succ)) →
(∀ {n : ℕ} (i j : Fin (n + 1)),
j ≤ i →
CategoryTheory.CategoryStruct.comp (h j) (Y.σ i.succ) =
CategoryTheory.CategoryStruct.comp (X.σ i) (h j.castSucc)) →
CategoryTheory.SimplicialObject.Homotopy f g | false |
MeasureTheory.laverage_mul_measure_univ | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ]
(f : α → ENNReal), (⨍⁻ (a : α), f a ∂μ) * μ Set.univ = ∫⁻ (x : α), f x ∂μ | true |
Std.DTreeMap.Internal.Impl.Const.get!ₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : Type v} → [Ord α] → (Std.DTreeMap.Internal.Impl α fun x => β) → α → [Inhabited β] → β | true |
Std.Internal.IO.Async.DNS.NameInfo.mk.injEq | Std.Internal.Async.DNS | ∀ (host service host_1 service_1 : String),
({ host := host, service := service } = { host := host_1, service := service_1 }) =
(host = host_1 ∧ service = service_1) | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁_supportsStmt_mono._simp_1_15 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | false |
Ideal.span_singleton_absNorm_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : Nontrivial S] [inst_2 : IsDedekindDomain S] [inst_3 : Module.Free ℤ S]
(I : Ideal S), Ideal.span {↑(Ideal.absNorm I)} ≤ I | true |
_private.Mathlib.RepresentationTheory.Induced.0.Rep.indResHomEquiv._simp_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tprod τ)) (x ⊗ₜ[k] (τ g) y) =
(Representation.Coinvariants.mk (ρ.tprod τ)) ((ρ g⁻¹) x ⊗ₜ[k] y) | false |
NormalizationMonoid.ofUniqueUnits | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : CommMonoidWithZero α] → [Subsingleton αˣ] → NormalizationMonoid α | true |
MonoidHom.toAdditiveRightMulEquiv._proof_1 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : CommMonoid N] (x x_1 : Multiplicative M →* N),
(MonoidHom.toAdditiveRight.trans Multiplicative.ofAdd).toFun (x * x_1) =
(MonoidHom.toAdditiveRight.trans Multiplicative.ofAdd).toFun (x * x_1) | false |
QuadraticAlgebra.coe_injective | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : Zero R], Function.Injective QuadraticAlgebra.C | true |
_private.Batteries.Classes.SatisfiesM.0.SatisfiesM.imp.match_1_1 | Batteries.Classes.SatisfiesM | {α : Type u_1} →
{p : α → Prop} →
(motive : { a // p a } → Sort u_2) → (x : { a // p a }) → ((val : α) → (h : p val) → motive ⟨val, h⟩) → motive x | false |
Matroid.IsStrictMinor.trans | Mathlib.Combinatorics.Matroid.Minor.Order | ∀ {α : Type u_1} {M M' N : Matroid α}, N <m M → M <m M' → N <m M' | true |
Polynomial.associated_of_dvd_of_natDegree_le_of_leadingCoeff | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] {p q : Polynomial R},
p ∣ q → q.natDegree ≤ p.natDegree → q.leadingCoeff ∣ p.leadingCoeff → Associated p q | true |
Lean.Grind.CommRing.Poly | Init.Grind.Ring.CommSolver | Type | true |
TrivSqZeroExt.addMonoid._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddMonoid R] [inst_1 : AddMonoid M] (a : TrivSqZeroExt R M), 0 + a = a | false |
ContinuousWithinAt.eq_const_of_mem_closure | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T1Space Y] {f : X → Y}
{s : Set X} {x : X} {c : Y}, ContinuousWithinAt f s x → x ∈ closure s → (∀ y ∈ s, f y = c) → f x = c | true |
MeasureTheory.OuterMeasure.trim_zero | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.OuterMeasure.trim 0 = 0 | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'_obj | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) (a : B),
(CategoryTheory.StrictlyUnitaryLaxFunctor.mk' S).obj a = S.obj a | true |
_private.Lean.Compiler.LCNF.Simp.SimpValue.0.Lean.Compiler.LCNF.Simp.simpAppApp?.match_3 | Lean.Compiler.LCNF.Simp.SimpValue | (motive : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__discr : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure)) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → motive (some decl)) →
((x : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure)) → motive x) → motive __discr | false |
Lean.Parser.Term.doLetRec | Lean.Parser.Do | Lean.Parser.Parser | true |
_private.Lean.Data.RArray.0.Lean.RArray.get_ofFn._proof_1_3 | Lean.Data.RArray | ∀ {n : ℕ} (i : Fin n), ∀ lb ≤ ↑i, ↑i < lb + 1 → ¬lb = ↑i → False | false |
CategoryTheory.SpectralSequence.Hom._sizeOf_1 | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} → {E E' : CategoryTheory.SpectralSequence C c r₀} → [SizeOf C] → [SizeOf κ] → E.Hom E' → ℕ | false |
RingHom.FinitePresentation.of_finiteType | Mathlib.RingTheory.FinitePresentation | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [IsNoetherianRing A] {f : A →+* B},
f.FiniteType ↔ f.FinitePresentation | true |
PresentedMonoid.closure_range_of | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_2} (rels : FreeMonoid α → FreeMonoid α → Prop),
Submonoid.closure (Set.range (PresentedMonoid.of rels)) = ⊤ | true |
AddSubgroup.IsSubnormal.below.step | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_2} [inst : AddGroup G] {motive : (a : AddSubgroup G) → a.IsSubnormal → Prop} (H K : AddSubgroup G)
(h_le : H ≤ K) (hSubn : K.IsSubnormal) (hN : (H.addSubgroupOf K).Normal),
AddSubgroup.IsSubnormal.below hSubn → motive K hSubn → AddSubgroup.IsSubnormal.below ⋯ | true |
Setoid.liftEquiv._proof_2 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (r : Setoid α),
Function.LeftInverse (fun f => ⟨f ∘ Quotient.mk'', ⋯⟩) fun f => Quotient.lift ↑f ⋯ | false |
CategoryTheory.BraidedCategory.curriedBraidingNatIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C) {X_1 Y : C} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.MonoidalCategory.curriedTensor C).obj X).map f)
((fun Y => β_ X Y) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun Y => β_ X Y) X_1).hom
(((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj X).map f) | false |
Aesop.EqualUpToIds.MVarValue.ctorIdx | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIds.MVarValue → ℕ | false |
MeasureTheory.eLpNorm'_zero' | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α} {ε : Type u_7}
[inst : TopologicalSpace ε] [inst_1 : ESeminormedAddMonoid ε], q ≠ 0 → μ ≠ 0 → MeasureTheory.eLpNorm' 0 q μ = 0 | true |
Simps.ProjectionRule.add.inj | Mathlib.Tactic.Simps.Basic | ∀ {a : Lean.Name} {a_1 : Lean.Syntax} {a_2 : Lean.Name} {a_3 : Lean.Syntax},
Simps.ProjectionRule.add a a_1 = Simps.ProjectionRule.add a_2 a_3 → a = a_2 ∧ a_1 = a_3 | true |
CategoryTheory.instHasLimitsOfShapeOverOfWithTerminal | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
(X : C) [CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.WithTerminal J) C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Over X) | true |
CategoryTheory.Abelian.SpectralObject.opcyclesIsoH_hom_inv_id._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
Matrix.«_aux_Mathlib_LinearAlgebra_Matrix_ConjTranspose___macroRules_Matrix_term_ᴴ_1» | Mathlib.LinearAlgebra.Matrix.ConjTranspose | Lean.Macro | false |
Set.Ioc_disjoint_Ioi | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] {a b c : α}, b ≤ c → Disjoint (Set.Ioc a b) (Set.Ioi c) | true |
CategoryTheory.ComposableArrows.homMk₄._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | 2 < 4 + 1 | false |
Lean.Meta.Grind.Goal.hasSameRoot | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.Expr → Lean.Expr → Bool | true |
egauge_pi' | Mathlib.Analysis.Convex.EGauge | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} [inst : NormedDivisionRing 𝕜] [inst_1 : (i : ι) → AddCommGroup (E i)]
[inst_2 : (i : ι) → Module 𝕜 (E i)] {I : Set ι},
I.Finite →
∀ {U : (i : ι) → Set (E i)},
(∀ i ∈ I, Balanced 𝕜 (U i)) →
∀ (x : (i : ι) → E i),
I = Set.univ ∨ (∃ i ∈ I, x i ≠ 0) ∨ (nhdsWithin 0 {0}ᶜ).NeBot →
egauge 𝕜 (I.pi U) x = ⨆ i ∈ I, egauge 𝕜 (U i) (x i) | true |
CyclotomicRing.eq_adjoin_primitive_root | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) [NeZero n] (A : Type u) (K : Type w) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K]
{μ : CyclotomicField n K}, IsPrimitiveRoot μ n → CyclotomicRing n A K = ↥(Algebra.adjoin A {μ}) | true |
CategoryTheory.yonedaMon._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : CategoryTheory.Mon C} (ψ : M ⟶ N) {M_1 N_1 : Cᵒᵖ} (φ : M_1 ⟶ N_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yonedaMonObj M.X).map φ)
(MonCat.ofHom { toFun := fun x => CategoryTheory.CategoryStruct.comp x ψ.hom, map_one' := ⋯, map_mul' := ⋯ }) =
CategoryTheory.CategoryStruct.comp
(MonCat.ofHom { toFun := fun x => CategoryTheory.CategoryStruct.comp x ψ.hom, map_one' := ⋯, map_mul' := ⋯ })
((CategoryTheory.yonedaMonObj N.X).map φ) | false |
Std.ExtDHashMap.filterMap_eq_map | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : (a : α) → β a → γ a},
Std.ExtDHashMap.filterMap (fun k v => some (f k v)) m = Std.ExtDHashMap.map f m | true |
_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.addMonoidWithOne._simp_7 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (a : α) (b : β),
Sum.Lex r s (Sum.inl a) (Sum.inr b) = True | false |
ISize.ofIntLE_eq_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : ISize.minValue.toInt ≤ x} {h₂ : x ≤ ISize.maxValue.toInt}, ISize.ofIntLE x h₁ h₂ = ISize.ofIntTruncate x | true |
CategoryTheory.NatTrans.naturality._autoParam | Mathlib.CategoryTheory.NatTrans | Lean.Syntax | false |
CategoryTheory.Limits.HasWidePushouts | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | true |
wbtw_self_iff._simp_1 | Mathlib.Analysis.Convex.Between | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y : P}, Wbtw R x y x = (y = x) | false |
Lean.Compiler.LCNF.Simp.DiscrM | Lean.Compiler.LCNF.Simp.DiscrM | Type → Type | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.casesOn | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {α : ℕ → ℕ → Type} →
{motive : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α → Sort u} →
(t : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α) →
((getElem : {n m : ℕ} → α n m → ℕ → ℕ → ℚ) →
(setElem : {n m : ℕ} → α n m → ℕ → ℕ → ℚ → α n m) →
(getValues : {n m : ℕ} → α n m → List (ℕ × ℕ × ℚ)) →
(ofValues : {n m : ℕ} → List (ℕ × ℕ × ℚ) → α n m) →
(swapRows : {n m : ℕ} → α n m → ℕ → ℕ → α n m) →
(subtractRow : {n m : ℕ} → α n m → ℕ → ℕ → ℚ → α n m) →
(divideRow : {n m : ℕ} → α n m → ℕ → ℚ → α n m) →
motive
{ getElem := getElem, setElem := setElem, getValues := getValues, ofValues := ofValues,
swapRows := swapRows, subtractRow := subtractRow, divideRow := divideRow }) →
motive t | false |
VertexOperator.ncoeff_apply | Mathlib.Algebra.Vertex.VertexOperator | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(A : VertexOperator R V) (n : ℤ), VertexOperator.ncoeff A n = HVertexOperator.coeff A (-n - 1) | true |
Lean.TrailingParserDescr | Init.Prelude | Type | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss.0.Polynomial.Chebyshev.sumZeroes_T_of_not_dvd._proof_1_9 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.ChebyshevGauss | ∀ {n : ℕ} {k : ℤ},
¬2 * ↑n ∣ k →
n ≠ 0 →
Complex.exp (↑k / ↑n * ↑Real.pi * Complex.I) = Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 →
¬Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 - 1 = 0 ∧
¬1 - Complex.exp (↑k / (2 * ↑n) * ↑Real.pi * Complex.I) ^ 2 = 0 | false |
Asymptotics.instTransForallIsBigOIsTheta | Mathlib.Analysis.Asymptotics.Theta | {α : Type u_1} →
{E : Type u_3} →
{G : Type u_5} →
{F' : Type u_7} →
[inst : Norm E] →
[inst_1 : Norm G] →
[inst_2 : SeminormedAddCommGroup F'] →
{l : Filter α} → Trans (Asymptotics.IsBigO l) (Asymptotics.IsTheta l) (Asymptotics.IsBigO l) | true |
FreeGroup.Red.eq_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u}, FreeGroup.Red = Relation.ReflTransGen FreeGroup.Red.Step | true |
String.utf8Len.eq_def | Batteries.Data.String.Lemmas | ∀ (x : List Char),
String.utf8Len x =
match x with
| [] => 0
| c :: cs => String.utf8Len cs + c.utf8Size | true |
_private.Mathlib.Data.EReal.Operations.0.Mathlib.Meta.Positivity.evalERealAdd._proof_2 | Mathlib.Data.EReal.Operations | ∀ (α : Q(Type)) (pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$pα» =Q instPartialOrderEReal)),
«$pα» =Q instPartialOrderEReal | false |
Std.Tactic.BVDecide.BVExpr.WithCache.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} → {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} → Std.Tactic.BVDecide.BVExpr.WithCache α aig → ℕ | false |
PrincipalSeg.ofElement_toFun | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} (r : α → α → Prop) (a : α) (self : { x // r x a }), (PrincipalSeg.ofElement r a).toFun self = ↑self | true |
Equiv.Perm.Basis.rec | Mathlib.GroupTheory.Perm.Centralizer | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] →
{g : Equiv.Perm α} →
{motive : g.Basis → Sort u} →
((toFun : ↥g.cycleFactorsFinset → α) →
(mem_support_self' : ∀ (c : ↥g.cycleFactorsFinset), toFun c ∈ (↑c).support) →
motive { toFun := toFun, mem_support_self' := mem_support_self' }) →
(t : g.Basis) → motive t | false |
Nat.dfold_add._proof_16 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i ≤ n, i ≤ n + m | false |
Lean.Grind.CommRing.Mon.revlexFuel.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (motive : ℕ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Ordering → Prop),
(∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), motive 0 m₁ m₂ (m₁.revlexWF m₂)) →
(∀ (fuel : ℕ), motive fuel.succ Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit Ordering.eq) →
(∀ (fuel : ℕ) (p : Lean.Grind.CommRing.Power) (m : Lean.Grind.CommRing.Mon),
motive fuel.succ Lean.Grind.CommRing.Mon.unit (Lean.Grind.CommRing.Mon.mult p m) Ordering.gt) →
(∀ (fuel : ℕ) (p : Lean.Grind.CommRing.Power) (m : Lean.Grind.CommRing.Mon),
motive fuel.succ (Lean.Grind.CommRing.Mon.mult p m) Lean.Grind.CommRing.Mon.unit Ordering.lt) →
(∀ (fuel : ℕ) (pw₁ : Lean.Grind.CommRing.Power) (m₁ : Lean.Grind.CommRing.Mon)
(pw₂ : Lean.Grind.CommRing.Power) (m₂ : Lean.Grind.CommRing.Mon),
(pw₁.x == pw₂.x) = true →
motive fuel m₁ m₂ (Lean.Grind.CommRing.Mon.revlexFuel fuel m₁ m₂) →
motive fuel.succ (Lean.Grind.CommRing.Mon.mult pw₁ m₁) (Lean.Grind.CommRing.Mon.mult pw₂ m₂)
((Lean.Grind.CommRing.Mon.revlexFuel fuel m₁ m₂).then
(Lean.Grind.CommRing.powerRevlex pw₁.k pw₂.k))) →
(∀ (fuel : ℕ) (pw₁ : Lean.Grind.CommRing.Power) (m₁ : Lean.Grind.CommRing.Mon)
(pw₂ : Lean.Grind.CommRing.Power) (m₂ : Lean.Grind.CommRing.Mon),
(pw₁.x == pw₂.x) = false →
Nat.blt pw₁.x pw₂.x = true →
motive fuel m₁ (Lean.Grind.CommRing.Mon.mult pw₂ m₂)
(Lean.Grind.CommRing.Mon.revlexFuel fuel m₁ (Lean.Grind.CommRing.Mon.mult pw₂ m₂)) →
motive fuel.succ (Lean.Grind.CommRing.Mon.mult pw₁ m₁) (Lean.Grind.CommRing.Mon.mult pw₂ m₂)
((Lean.Grind.CommRing.Mon.revlexFuel fuel m₁ (Lean.Grind.CommRing.Mon.mult pw₂ m₂)).then
Ordering.lt)) →
(∀ (fuel : ℕ) (pw₁ : Lean.Grind.CommRing.Power) (m₁ : Lean.Grind.CommRing.Mon)
(pw₂ : Lean.Grind.CommRing.Power) (m₂ : Lean.Grind.CommRing.Mon),
(pw₁.x == pw₂.x) = false →
Nat.blt pw₁.x pw₂.x = false →
motive fuel (Lean.Grind.CommRing.Mon.mult pw₁ m₁) m₂
(Lean.Grind.CommRing.Mon.revlexFuel fuel (Lean.Grind.CommRing.Mon.mult pw₁ m₁) m₂) →
motive fuel.succ (Lean.Grind.CommRing.Mon.mult pw₁ m₁) (Lean.Grind.CommRing.Mon.mult pw₂ m₂)
((Lean.Grind.CommRing.Mon.revlexFuel fuel (Lean.Grind.CommRing.Mon.mult pw₁ m₁) m₂).then
Ordering.gt)) →
∀ (fuel : ℕ) (m₁ m₂ : Lean.Grind.CommRing.Mon),
motive fuel m₁ m₂ (Lean.Grind.CommRing.Mon.revlexFuel fuel m₁ m₂) | true |
_private.Std.Data.Iterators.Lemmas.Producers.Repeat.0.Nat.repeat.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Repeat | {α : Type u_2} →
(motive : ℕ → α → Sort u_1) →
(x : ℕ) → (x_1 : α) → ((a : α) → motive 0 a) → ((n : ℕ) → (a : α) → motive n.succ a) → motive x x_1 | true |
Ideal.span_range_eq_span_range_support | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Type u_1} (x : ι → α),
Ideal.span (Set.range x) = Ideal.span (Set.range fun i => x ↑i) | true |
MulActionHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ (F : Type u_8) (M : Type u_9) (X : Type u_10) (Y : Type u_11) [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y], MulActionHomClass F M X Y = MulActionSemiHomClass F id X Y | true |
Std.DHashMap.Raw.Equiv.constInsertMany_list | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m₁.WF →
m₂.WF →
∀ (l : List (α × β)),
m₁.Equiv m₂ → (Std.DHashMap.Raw.Const.insertMany m₁ l).Equiv (Std.DHashMap.Raw.Const.insertMany m₂ l) | true |
CategoryTheory.Functor.isoWhiskerRight_left_assoc | Mathlib.CategoryTheory.Whiskering | ∀ {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] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C) {G H : CategoryTheory.Functor C D}
(α : G ≅ H) (K : CategoryTheory.Functor D E) {Z : CategoryTheory.Functor B E} (h : (F.comp H).comp K ≅ Z),
CategoryTheory.Functor.isoWhiskerRight (F.isoWhiskerLeft α) K ≪≫ h =
F.associator G K ≪≫ F.isoWhiskerLeft (CategoryTheory.Functor.isoWhiskerRight α K) ≪≫ (F.associator H K).symm ≪≫ h | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.