name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AddSubgroup.coe_pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
↑(AddSubgroup.pathComponentZero G) = pathComponent 0 |
spectrum.spectralRadius_le_liminf_pow_nnnorm_pow_one_div | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
[CompleteSpace A] (a : A), spectralRadius 𝕜 a ≤ Filter.liminf (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply._proof_1 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {p : ℕ} [Fact (Nat.Prime p)], Ideal.span {↑p} ≠ ⊥ |
CategoryTheory.BraidedCategory.ofCartesianMonoidalCategory._proof_10 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStruct.comp
{
hom :=
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.SemiCartesianMonoidalCategory.snd X
(CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))
(CategoryTheory.SemiCartesianMonoidalCategory.fst X
(CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)),
inv :=
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.SemiCartesianMonoidalCategory.snd (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)
X)
(CategoryTheory.SemiCartesianMonoidalCategory.fst (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)
X),
hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom
(CategoryTheory.MonoidalCategoryStruct.associator Y Z X).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
{
hom :=
CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.SemiCartesianMonoidalCategory.snd X Y)
(CategoryTheory.SemiCartesianMonoidalCategory.fst X Y),
inv :=
CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.SemiCartesianMonoidalCategory.snd Y X)
(CategoryTheory.SemiCartesianMonoidalCategory.fst Y X),
hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom
Z)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Y X Z).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y
{
hom :=
CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.SemiCartesianMonoidalCategory.snd X Z)
(CategoryTheory.SemiCartesianMonoidalCategory.fst X Z),
inv :=
CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.SemiCartesianMonoidalCategory.snd Z X)
(CategoryTheory.SemiCartesianMonoidalCategory.fst Z X),
hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom)) |
LatticeHom.snd | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) β |
Lean.Linter.MissingDocs.mkHandler | Lean.Linter.MissingDocs | Lean.Name → Lean.ImportM Lean.Linter.MissingDocs.Handler |
CategoryTheory.ComposableArrows.isoMk₅._proof_14 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_441✝ ≅ g.obj' 0 _proof_441✝¹) (app₁ : f.obj' 1 _proof_442✝ ≅ g.obj' 1 _proof_442✝¹)
(app₂ : f.obj' 2 _proof_443✝ ≅ g.obj' 2 _proof_443✝¹) (app₃ : f.obj' 3 _proof_444✝ ≅ g.obj' 3 _proof_444✝¹)
(app₄ : f.obj' 4 _proof_445✝ ≅ g.obj' 4 _proof_445✝¹) (app₅ : f.obj' 5 _proof_446✝ ≅ g.obj' 5 _proof_446✝¹)
(w₀ :
CategoryTheory.CategoryStruct.comp (f.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_442✝²)
app₁.hom =
CategoryTheory.CategoryStruct.comp app₀.hom
(g.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_442✝³))
(w₁ :
CategoryTheory.CategoryStruct.comp (f.map' 1 2 _proof_238✝ _proof_443✝²) app₂.hom =
CategoryTheory.CategoryStruct.comp app₁.hom (g.map' 1 2 _proof_238✝¹ _proof_443✝³))
(w₂ :
CategoryTheory.CategoryStruct.comp (f.map' 2 3 _proof_291✝ _proof_444✝²) app₃.hom =
CategoryTheory.CategoryStruct.comp app₂.hom (g.map' 2 3 _proof_291✝¹ _proof_444✝³))
(w₃ :
CategoryTheory.CategoryStruct.comp (f.map' 3 4 _proof_356✝ _proof_445✝²) app₄.hom =
CategoryTheory.CategoryStruct.comp app₃.hom (g.map' 3 4 _proof_356✝¹ _proof_445✝³))
(w₄ :
CategoryTheory.CategoryStruct.comp (f.map' 4 5 _proof_445✝⁴ _proof_446✝²) app₅.hom =
CategoryTheory.CategoryStruct.comp app₄.hom (g.map' 4 5 _proof_445✝⁵ _proof_446✝³)),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ComposableArrows.homMk₅ app₀.inv app₁.inv app₂.inv app₃.inv app₄.inv app₅.inv ⋯ ⋯ ⋯ ⋯ ⋯)
(CategoryTheory.ComposableArrows.homMk₅ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom app₅.hom w₀ w₁ w₂ w₃ w₄) =
CategoryTheory.CategoryStruct.id g |
SimpleGraph.Coloring.sumEquiv | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_1} →
{W : Type u_2} →
{γ : Type u_4} → {G : SimpleGraph V} → {H : SimpleGraph W} → (G ⊕g H).Coloring γ ≃ G.Coloring γ × H.Coloring γ |
Std.Net.AddressFamily.ipv4.sizeOf_spec | Std.Net.Addr | sizeOf Std.Net.AddressFamily.ipv4 = 1 |
Std.IterM.toArray_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Option γ} (it : Std.IterM m β),
(Std.IterM.filterMap f it).toArray = (fun x => Array.filterMap f x) <$> it.toArray |
Rep.indResHomEquiv._proof_8 | Mathlib.RepresentationTheory.Induced | ∀ {k G H : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H) (A : Rep k G) (B : Rep k H)
(x x_1 : Rep.ind φ A ⟶ B) (g : G),
CategoryTheory.CategoryStruct.comp (A.ρ g)
(ModuleCat.ofHom (ModuleCat.Hom.hom (x + x_1).hom ∘ₗ Representation.IndV.mk φ A.ρ 1)) =
CategoryTheory.CategoryStruct.comp
(ModuleCat.ofHom (ModuleCat.Hom.hom (x + x_1).hom ∘ₗ Representation.IndV.mk φ A.ρ 1))
(((Action.res (ModuleCat k) φ).obj B).ρ g) |
Nat.nonempty_of_pos_sInf | Mathlib.Data.Nat.Lattice | ∀ {s : Set ℕ}, 0 < sInf s → s.Nonempty |
Subtype.mk_eq_bot_iff | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ∀ {x : α} (hx : p x), ⟨x, hx⟩ = ⊥ ↔ x = ⊥ |
AlgebraicGeometry.PresheafedSpace.restrict_presheaf | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {U : TopCat} (X : AlgebraicGeometry.PresheafedSpace C)
{f : U ⟶ ↑X} (h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
(X.restrict h).presheaf = h.functor.op.comp X.presheaf |
IsLocalRing.finrank_cotangentSpace_eq_zero_iff | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] [IsNoetherianRing R],
Module.finrank (IsLocalRing.ResidueField R) (IsLocalRing.CotangentSpace R) = 0 ↔ IsField R |
String.Slice.Pos.offset_str_le_offset_endExclusive | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, pos.str.offset ≤ s.endExclusive.offset |
Std.TreeMap.minKey?_eq_some_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.minKey? = some t.minKey! |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.base | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {pat s : String.Slice} →
{needlePos stackPos : String.Pos.Raw} →
String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants✝ pat s needlePos stackPos → s.Pos |
ENNReal.tsum_biUnion_le | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {ι : Type u_4} (f : α → ENNReal) (s : Finset ι) (t : ι → Set α),
∑' (x : ↑(⋃ i ∈ s, t i)), f ↑x ≤ ∑ i ∈ s, ∑' (x : ↑(t i)), f ↑x |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Three.0.IsCyclotomicExtension.Rat.Three.lambda_dvd_or_dvd_sub_one_or_dvd_add_one._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) |
mulActionClosedBallBall._proof_5 | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ} (_c₂ : ↑(Metric.ball 0 r)), 1 • _c₂ = _c₂ |
TensorPower.gmonoid._proof_3 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : GradedMonoid fun i => TensorPower R i M), 1 * x = x |
Std.Internal.IO.Async.BaseAsync.toRawBaseIO | Std.Internal.Async.Basic | {α : Type} → Std.Internal.IO.Async.BaseAsync α → BaseIO (Std.Internal.IO.Async.MaybeTask α) |
AddMonoid.End.mulRight | Mathlib.Algebra.Ring.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocSemiring R] → R →+ AddMonoid.End R |
_private.Mathlib.Data.NNReal.Defs.0.Real.toNNReal_le_toNNReal_iff._simp_1_1 | Mathlib.Data.NNReal.Defs | ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) |
TensorProduct.assoc_tensor' | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} {Q : Type u_8} {S : Type u_9}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid Q] [inst_4 : AddCommMonoid S]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R Q] [inst_8 : Module R S],
TensorProduct.assoc R M (TensorProduct R N Q) S =
LinearEquiv.rTensor S (TensorProduct.assoc R M N Q).symm ≪≫ₗ TensorProduct.assoc R (TensorProduct R M N) Q S ≪≫ₗ
TensorProduct.assoc R M N (TensorProduct R Q S) ≪≫ₗ
LinearEquiv.lTensor M (TensorProduct.assoc R N Q S).symm |
Std.TreeMap.Raw.insertMany_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {l : List (α × β)} {k : α} {v : β},
t.insertMany ((k, v) :: l) = (t.insert k v).insertMany l |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic.cancelDenominatorsTarget | Mathlib.Tactic.CancelDenoms.Core | Lean.Elab.Tactic.TacticM Unit |
MvQPF.Fix.ind | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (p : MvQPF.Fix F α → Prop),
(∀ (x : F (α ::: MvQPF.Fix F α)), MvFunctor.LiftP (α.PredLast p) x → p (MvQPF.Fix.mk x)) → ∀ (x : MvQPF.Fix F α), p x |
Fin.val_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), ↑(i.addNat m) = ↑i + m |
HasProd.nat_mul_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℤ → M},
HasProd f m → HasProd (fun n => f ↑n * f (-(↑n + 1))) m |
dvd_of_mul_right_eq | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b |
one_le_pow_mul_abs_eval_div | Mathlib.Algebra.Polynomial.DenomsClearable | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {f : Polynomial ℤ} {a b : ℤ},
0 < b →
Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f) ≠ 0 →
1 ≤ ↑b ^ f.natDegree * |Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f)| |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_add_top_coe._simp_1_2 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x y : ℝ), ↑x + ↑y = ↑(x + y) |
Std.DHashMap.Internal.AssocList.map | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ |
Matroid.IsCircuit | Mathlib.Combinatorics.Matroid.Circuit | {α : Type u_1} → Matroid α → Set α → Prop |
Submodule.IsMinimalPrimaryDecomposition.mem_associatedPrimes | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {t : Finset (Submodule R M)},
N.IsMinimalPrimaryDecomposition t → ∀ {q : Submodule R M}, q ∈ t → (q.colon Set.univ).radical ∈ N.associatedPrimes |
CategoryTheory.SingleObj.toEnd | Mathlib.CategoryTheory.SingleObj | (M : Type u) → [inst : Monoid M] → M ≃* CategoryTheory.End (CategoryTheory.SingleObj.star M) |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.Module.Free.rank_eq_mk_of_infinite_lt._simp_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [StrongRankCondition R] [inst_2 : AddCommMonoid M] [inst_3 : Module R M]
[inst_4 : Module.Free R M], Cardinal.mk (Module.Free.ChooseBasisIndex R M) = Module.rank R M |
UInt32.ofBitVec_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin (2 ^ 32)), { toBitVec := { toFin := n } } = UInt32.ofFin n |
ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {X : ModuleCat R}
{Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y)
(a a_1 : TensorProduct R ↑((ModuleCat.restrictScalars f).obj (ModuleCat.of S S)) ↑X),
(TensorProduct.lift
{ toFun := fun s => ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt f s g, map_add' := ⋯, map_smul' := ⋯ })
(a + a_1) =
(TensorProduct.lift
{ toFun := fun s => ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt f s g, map_add' := ⋯, map_smul' := ⋯ })
a +
(TensorProduct.lift
{ toFun := fun s => ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt f s g, map_add' := ⋯, map_smul' := ⋯ })
a_1 |
Turing.TM0.Stmt.noConfusion | Mathlib.Computability.TuringMachine.PostTuringMachine | {P : Sort u} →
{Γ : Type u_1} →
{t : Turing.TM0.Stmt Γ} →
{Γ' : Type u_1} → {t' : Turing.TM0.Stmt Γ'} → Γ = Γ' → t ≍ t' → Turing.TM0.Stmt.noConfusionType P t t' |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.Tape.write_nth.match_1_1 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : Turing.Tape Γ → ℤ → Prop) (x : Turing.Tape Γ) (x_1 : ℤ),
(∀ (x : Turing.Tape Γ), motive x 0) →
(∀ (x : Turing.Tape Γ) (n : ℕ), motive x (Int.ofNat n.succ)) →
(∀ (x : Turing.Tape Γ) (a : ℕ), motive x (Int.negSucc a)) → motive x x_1 |
HomologicalComplex₂.ofGradedObject | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(X : CategoryTheory.GradedObject (I₁ × I₂) C) →
(d₁ : (i₁ i₁' : I₁) → (i₂ : I₂) → X (i₁, i₂) ⟶ X (i₁', i₂)) →
(d₂ : (i₁ : I₁) → (i₂ i₂' : I₂) → X (i₁, i₂) ⟶ X (i₁, i₂')) →
(∀ (i₁ i₁' : I₁), ¬c₁.Rel i₁ i₁' → ∀ (i₂ : I₂), d₁ i₁ i₁' i₂ = 0) →
(∀ (i₁ : I₁) (i₂ i₂' : I₂), ¬c₂.Rel i₂ i₂' → d₂ i₁ i₂ i₂' = 0) →
(∀ (i₁ i₁' i₁'' : I₁) (i₂ : I₂),
CategoryTheory.CategoryStruct.comp (d₁ i₁ i₁' i₂) (d₁ i₁' i₁'' i₂) = 0) →
(∀ (i₁ : I₁) (i₂ i₂' i₂'' : I₂),
CategoryTheory.CategoryStruct.comp (d₂ i₁ i₂ i₂') (d₂ i₁ i₂' i₂'') = 0) →
(∀ (i₁ i₁' : I₁) (i₂ i₂' : I₂),
CategoryTheory.CategoryStruct.comp (d₁ i₁ i₁' i₂) (d₂ i₁' i₂ i₂') =
CategoryTheory.CategoryStruct.comp (d₂ i₁ i₂ i₂') (d₁ i₁ i₁' i₂')) →
HomologicalComplex₂ C c₁ c₂ |
accPt_iff_frequently | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {C : Set X},
AccPt x (Filter.principal C) ↔ ∃ᶠ (y : X) in nhds x, y ≠ x ∧ y ∈ C |
_private.Init.Data.SInt.Lemmas.0.Int16.toNatClampNeg_ofNat_of_lt._proof_1_2 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2 ^ 15 → ¬-2 ^ 15 ≤ ↑n → False |
FirstOrder._aux_Mathlib_ModelTheory_LanguageMap___unexpand_FirstOrder_Language_withConstants_1 | Mathlib.ModelTheory.LanguageMap | Lean.PrettyPrinter.Unexpander |
CategoryTheory.Limits.colimit.ι_desc_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F)
(j : J) {F_1 : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_3 : CategoryTheory.ConcreteCategory C F_1]
(x : carrier (F.obj j)),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.colimit.desc F c))
((CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.colimit.ι F j)) x) =
(CategoryTheory.ConcreteCategory.hom (c.ι.app j)) x |
Lean.Elab.Term.elabOmission | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab |
_private.Lean.Compiler.IR.ToIR.0.Lean.IR.ToIR.lowerDecl.match_1 | Lean.Compiler.IR.ToIR | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.impure) →
((code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.DeclValue.code code)) →
((externAttrData : Lean.ExternAttrData) → motive (Lean.Compiler.LCNF.DeclValue.extern externAttrData)) → motive x |
CategoryTheory.Limits.CoconeMorphism.inv_hom_id | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c d : CategoryTheory.Limits.Cocone F} (f : c ≅ d),
CategoryTheory.CategoryStruct.comp f.inv.hom f.hom.hom = CategoryTheory.CategoryStruct.id d.pt |
Pi.Function.module | Mathlib.Algebra.Module.Pi | (I : Type u) →
(α : Type u_1) → (β : Type u_2) → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α (I → β) |
Ideal.sup_height_eq_ringKrullDim | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R], ↑(⨆ I, ⨆ (_ : I ≠ ⊤), I.height) = ringKrullDim R |
Std.DTreeMap.foldlM_eq_foldlM_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {δ : Type w} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : δ → α → m δ} {init : δ},
Std.DTreeMap.foldlM (fun d a x => f d a) init t = List.foldlM f init t.keys |
ExistsAndEq.withExistsElimAlongPathImp._unsafe_rec | Mathlib.Tactic.Simproc.ExistsAndEq | {u : Lean.Level} →
{α : Q(Sort u)} →
{P goal : Q(Prop)} →
Q(«$P») →
{a a' : Q(«$α»)} →
List ExistsAndEq.VarQ →
ExistsAndEq.Path →
List ExistsAndEq.HypQ →
(Q(«$a» = «$a'») → List ExistsAndEq.HypQ → Lean.MetaM Q(«$goal»)) → Lean.MetaM Q(«$goal») |
Commute.self_pow | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), Commute a (a ^ n) |
bilinearIteratedFDerivTwo.eq_1 | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
(x : E), bilinearIteratedFDerivTwo 𝕜 f x = (fderiv 𝕜 (fderiv 𝕜 f) x).toLinearMap₁₂ |
Std.TreeMap.get!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], (t₁ ∪ t₂).get! k = t₂.getD k (t₁.get! k) |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.tendsto_addHaar_inter_smul_zero_of_density_zero_aux2._simp_1_1 | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a : α} [AddRightMono α],
(|a| ≤ 0) = (a = 0) |
_private.Lean.Elab.DocString.0.Lean.Doc.instMonadLiftTermElabMDocM.match_1 | Lean.Elab.DocString | (motive : Lean.Doc.State → Sort u_1) →
(__do_lift : Lean.Doc.State) →
((scopes : List Lean.Elab.Command.Scope) →
(openDecls : List Lean.OpenDecl) →
(lctx : Lean.LocalContext) →
(localInstances : Lean.LocalInstances) →
(options : Lean.Options) →
motive
{ scopes := scopes, openDecls := openDecls, lctx := lctx, localInstances := localInstances,
options := options }) →
motive __do_lift |
Lean.InternalExceptionId.toString | Lean.InternalExceptionId | Lean.InternalExceptionId → String |
Polynomial.isMonicOfDegree_sub_add_two | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Ring R] [Nontrivial R] (a b : R),
(Polynomial.X ^ 2 - Polynomial.C a * Polynomial.X + Polynomial.C b).IsMonicOfDegree 2 |
Booleanisation.instTop | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → Top (Booleanisation α) |
Asymptotics.isLittleO_abs_right | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
(f =o[l] fun x => |u x|) ↔ f =o[l] u |
Cubic.disc_eq_prod_three_roots | Mathlib.Algebra.CubicDiscriminant | ∀ {F : Type u_3} {K : Type u_4} {P : Cubic F} [inst : Field F] [inst_1 : Field K] {φ : F →+* K} {x y z : K},
P.a ≠ 0 → (Cubic.map φ P).roots = {x, y, z} → φ P.discr = (φ P.a * φ P.a * (x - y) * (x - z) * (y - z)) ^ 2 |
Lean.Firefox.ThreadWithCollideMaps.toThreadWithMaps | Lean.Util.Profiler | Lean.Firefox.ThreadWithCollideMaps → Lean.Firefox.ThreadWithMaps |
ContinuousLinearMap.toContinuousAffineMap._proof_2 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_3} {V : Type u_1} {W : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
(f : V →L[R] W), Continuous (↑f).toFun |
Dynamics.netEntropyEntourage_le_coverEntropyEntourage | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {U : SetRel X X} (T : X → X) (F : Set X),
Dynamics.netEntropyEntourage T F U ≤ Dynamics.coverEntropyEntourage T F U |
CategoryTheory.PreZeroHypercover.interFst._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S)
[inst_1 : ∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] (x : (E.inter F).I₀),
CategoryTheory.Limits.HasPullback (E.f ((Equiv.sigmaEquivProd E.I₀ F.1).symm x).fst)
(F.f ((Equiv.sigmaEquivProd E.I₀ F.1).symm x).snd) |
CategoryTheory.PreZeroHypercover.sumInl._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.PreZeroHypercover S) (i : E.I₀),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (E.X i)) ((E.sum F).f (Sum.inl i)) = E.f i |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevBetaS'.visit.match_1 | Lean.Meta.Sym.InstantiateS | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((a : Lean.Literal) → e = Lean.Expr.lit a → motive (Lean.Expr.lit a)) →
((mvarId : Lean.MVarId) → e = Lean.Expr.mvar mvarId → motive (Lean.Expr.mvar mvarId)) →
((fvarId : Lean.FVarId) → e = Lean.Expr.fvar fvarId → motive (Lean.Expr.fvar fvarId)) →
((declName : Lean.Name) →
(us : List Lean.Level) → e = Lean.Expr.const declName us → motive (Lean.Expr.const declName us)) →
((u : Lean.Level) → e = Lean.Expr.sort u → motive (Lean.Expr.sort u)) →
((bidx : ℕ) → e = Lean.Expr.bvar bidx → motive (Lean.Expr.bvar bidx)) →
((f a : Lean.Expr) → e = f.app a → motive (f.app a)) →
((data : Lean.MData) →
(a : Lean.Expr) → e = Lean.Expr.mdata data a → motive (Lean.Expr.mdata data a)) →
((typeName : Lean.Name) →
(idx : ℕ) →
(a : Lean.Expr) →
e = Lean.Expr.proj typeName idx a → motive (Lean.Expr.proj typeName idx a)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
e = Lean.Expr.forallE binderName d b binderInfo →
motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
e = Lean.Expr.lam binderName d b binderInfo →
motive (Lean.Expr.lam binderName d b binderInfo)) →
((declName : Lean.Name) →
(t v b : Lean.Expr) →
(nondep : Bool) →
e = Lean.Expr.letE declName t v b nondep →
motive (Lean.Expr.letE declName t v b nondep)) →
motive e |
Lean.Meta.Sym.Simp.Context | Lean.Meta.Sym.Simp.SimpM | Type |
BitVec.getLsb | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → Fin w → Bool |
SheafOfModules.freeFunctor._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] {I J_1 K : Type u_2} (f : I ⟶ J_1)
(g : J_1 ⟶ K),
(SheafOfModules.free K).freeHomEquiv (SheafOfModules.freeMap (CategoryTheory.CategoryStruct.comp f g)) =
(SheafOfModules.free K).freeHomEquiv
(CategoryTheory.CategoryStruct.comp (SheafOfModules.freeMap f) (SheafOfModules.freeMap g)) |
CategoryTheory.Pseudofunctor.ObjectProperty.noConfusionType | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | Sort u_1 →
{B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
F.ObjectProperty →
{B' : Type u} →
[inst' : CategoryTheory.Bicategory B'] →
{F' : CategoryTheory.Pseudofunctor B' CategoryTheory.Cat} → F'.ObjectProperty → Sort u_1 |
LinearIsometryEquiv.conjStarAlgEquiv._proof_8 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_2} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H],
ContinuousConstSMul 𝕜 H |
Std.Tactic.BVDecide.BoolExpr.toString._unsafe_rec | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | {α : Type} → [ToString α] → Std.Tactic.BVDecide.BoolExpr α → String |
Int.Linear.Poly.coeff_k.eq_1 | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly) (x : Int.Linear.Var),
p.coeff_k x = Int.Linear.Poly.rec (fun x => 0) (fun a y x_1 ih => Bool.rec ih a (Nat.beq x y)) p |
ENat.coe_ne_top._simp_2 | Mathlib.Tactic.ENatToNat | ∀ (a : ℕ), (↑a = ⊤) = False |
CategoryTheory.Discrete.productEquiv._proof_15 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_2} {K : Type u_1} (X : CategoryTheory.Discrete (J × K)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Discrete.functor fun x =>
match x with
| (j, k) => ({ as := j }, { as := k })).map
((CategoryTheory.NatIso.ofComponents
(fun x => CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Discrete (J × K))).obj x))
⋯).hom.app
X))
((CategoryTheory.NatIso.ofComponents
(fun x =>
CategoryTheory.Iso.refl
(({
obj := fun x =>
match x with
| (x, y) => { as := (x.as, y.as) },
map := fun {X Y} x =>
match x with
| (f₁, f₂) => CategoryTheory.eqToHom ⋯,
map_id := ⋯, map_comp := ⋯ }.comp
(CategoryTheory.Discrete.functor fun x =>
match x with
| (j, k) => ({ as := j }, { as := k }))).obj
x))
⋯).hom.app
((CategoryTheory.Discrete.functor fun x =>
match x with
| (j, k) => ({ as := j }, { as := k })).obj
X)) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Discrete.functor fun x =>
match x with
| (j, k) => ({ as := j }, { as := k })).obj
X) |
CategoryTheory.MonoidalCategory.ofTensorHom._auto_9 | Mathlib.CategoryTheory.Monoidal.Category | Lean.Syntax |
CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso_hom_app_snd_fst | Mathlib.CategoryTheory.Sums.Products | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {A' : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] {B : Type u} [inst_2 : CategoryTheory.Category.{v, u} B]
(T : Type u_3) [inst_3 : CategoryTheory.Category.{v_3, u_3} T] (X : CategoryTheory.Functor ((A ⊕ A') ⊕ T) B),
((CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso T).hom.app X).2.1 =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Sum.inl_ A' T).whiskerLeft
((CategoryTheory.Sum.inr_ A (A' ⊕ T)).associator (CategoryTheory.sum.inverseAssociator A A' T) X).inv)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Sum.inl_ A' T).associator
((CategoryTheory.Sum.inr_ A (A' ⊕ T)).comp (CategoryTheory.sum.inverseAssociator A A' T)) X).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight (CategoryTheory.sum.inlCompInrCompInverseAssociator A A' T).hom X)
((CategoryTheory.Sum.inr_ A A').associator (CategoryTheory.Sum.inl_ (A ⊕ A') T) X).hom)) |
Equiv.sumEmpty | Mathlib.Logic.Equiv.Sum | (α : Type u_9) → (β : Type u_10) → [IsEmpty β] → α ⊕ β ≃ α |
AlgebraicGeometry.IsReduced.mk | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsReduced.component_reduced._autoParam →
AlgebraicGeometry.IsReduced X |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord._sparseCasesOn_2 | Lean.Meta.ExprLens | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t |
HomologicalComplex.mapBifunctor₂₃.D₂ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₂₃ : Type u_4} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_6} C₄] →
[inst_4 : CategoryTheory.Category.{v_6, u_4} C₂₃] →
[inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁] →
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] →
[inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃] →
[inst_8 : CategoryTheory.Preadditive C₂₃] →
[inst_9 : CategoryTheory.Preadditive C₄] →
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)) →
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) →
[inst_10 : G₂₃.PreservesZeroMorphisms] →
[inst_11 : ∀ (X₂ : C₂), (G₂₃.obj X₂).PreservesZeroMorphisms] →
[inst_12 : F.PreservesZeroMorphisms] →
[inst_13 : ∀ (X₁ : C₁), (F.obj X₁).Additive] →
{ι₁ : Type u_7} →
{ι₂ : Type u_8} →
{ι₃ : Type u_9} →
{ι₁₂ : Type u_10} →
{ι₂₃ : Type u_11} →
{ι₄ : Type u_12} →
[inst_14 : DecidableEq ι₄] →
{c₁ : ComplexShape ι₁} →
{c₂ : ComplexShape ι₂} →
{c₃ : ComplexShape ι₃} →
(K₁ : HomologicalComplex C₁ c₁) →
(K₂ : HomologicalComplex C₂ c₂) →
(K₃ : HomologicalComplex C₃ c₃) →
(c₁₂ : ComplexShape ι₁₂) →
(c₂₃ : ComplexShape ι₂₃) →
(c₄ : ComplexShape ι₄) →
[inst_15 : TotalComplexShape c₁ c₂ c₁₂] →
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] →
[inst_17 : TotalComplexShape c₂ c₃ c₂₃] →
[inst_18 :
TotalComplexShape c₁ c₂₃ c₄] →
[inst_19 :
K₂.HasMapBifunctor K₃ G₂₃ c₂₃] →
[inst_20 :
c₁.Associative c₂ c₃ c₁₂ c₂₃
c₄] →
[inst_21 : DecidableEq ι₂₃] →
[inst_22 :
K₁.HasMapBifunctor
(K₂.mapBifunctor K₃ G₂₃
c₂₃)
F c₄] →
(j j' : ι₄) →
[HomologicalComplex.HasGoodTrifunctor₂₃Obj
F G₂₃ K₁ K₂ K₃ c₁₂ c₂₃
c₄] →
(K₁.mapBifunctor
(K₂.mapBifunctor
K₃ G₂₃ c₂₃)
F c₄).X
j ⟶
(K₁.mapBifunctor
(K₂.mapBifunctor
K₃ G₂₃ c₂₃)
F c₄).X
j' |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.SimpleFunc.memLp_approxOn._simp_1_2 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b |
ENNReal.HolderTriple.inv_le_inv | Mathlib.Data.ENNReal.Holder | ∀ (p q r : ENNReal) [p.HolderTriple q r], p⁻¹ ≤ r⁻¹ |
CovBy.coe_fin | Mathlib.Data.Nat.SuccPred | ∀ {n : ℕ} {a b : Fin n}, a ⋖ b → ↑a ⋖ ↑b |
List.isSome_max?_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} {l : List α} [inst : Max α] {a : α}, a ∈ l → l.max?.isSome = true |
_private.Lean.Server.CodeActions.UnknownIdentifier.0.Lean.Server.FileWorker.handleUnknownIdentifierCodeAction.match_1 | Lean.Server.CodeActions.UnknownIdentifier | (motive : Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw) →
((headerTailPos : String.Pos.Raw) → motive (some headerTailPos)) → (Unit → motive none) → motive x |
instSetLikeSubRootedTreeα._proof_3 | Mathlib.Order.SuccPred.Tree | ∀ (t : RootedTree) (a₁ a₂ : SubRootedTree t), (fun v => Set.Ici v.root) a₁ = (fun v => Set.Ici v.root) a₂ → a₁ = a₂ |
IsCentralVAdd.mk._flat_ctor | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_9} {α : Type u_10} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α],
(∀ (m : M) (a : α), AddOpposite.op m +ᵥ a = m +ᵥ a) → IsCentralVAdd M α |
Lean.Elab.TermInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.TermInfo → Sort u} →
(t : Lean.Elab.TermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
(expr : Lean.Expr) →
(isBinder isDisplayableTerm : Bool) →
motive
{ toElabInfo := toElabInfo, lctx := lctx, expectedType? := expectedType?, expr := expr,
isBinder := isBinder, isDisplayableTerm := isDisplayableTerm }) →
motive t |
_private.Mathlib.RingTheory.Localization.NumDen.0.IsFractionRing.isUnit_den_zero._simp_1_2 | Mathlib.RingTheory.Localization.NumDen | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsLocalization.IsInteger R 0 = True |
IsAlgebraic.algebraMap | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [IsScalarTower R S A] {a : S},
IsAlgebraic R a → IsAlgebraic R ((algebraMap S A) a) |
CategoryTheory.Precoverage.ZeroHypercover.Small.casesOn | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} →
{S : C} →
{E : J.ZeroHypercover S} →
{motive : E.Small → Sort u_1} →
(t : E.Small) →
((exists_restrictIndex_mem : ∃ ι f, (E.restrictIndex f).presieve₀ ∈ J.coverings S) → motive ⋯) → motive t |
CategoryTheory.Limits.epi_image_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f] [E : CategoryTheory.Epi f],
CategoryTheory.Epi (CategoryTheory.Limits.image.ι f) |
Nat.infinite_odd_deficient | Mathlib.NumberTheory.FactorisationProperties | {n | Odd n ∧ n.Deficient}.Infinite |
Ordinal.nfp_zero | Mathlib.SetTheory.Ordinal.FixedPoint | Ordinal.nfp 0 = id |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.