Datasets:
mathlib-initiative
/
mathlib-types

Dataset card Data Studio Files
xet
Community
1
name
stringlengths
2
347
module
stringlengths
6
90
type
stringlengths
1
5.42M
coe_setBasisOfLinearIndependentOfCardEqFinrank
Mathlib.LinearAlgebra.FiniteDimensional.Lemmas
βˆ€ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V} [inst_3 : Nonempty ↑s] [inst_4 : Fintype ↑s] (lin_ind : LinearIndependent K Subtype.val) (card_eq : s.toFinset.card = Module.finrank K V), ⇑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = Subtype.val
BoxIntegral.BoxAdditiveMap.rec
Mathlib.Analysis.BoxIntegral.Partition.Additive
{ΞΉ : Type u_3} β†’ {M : Type u_4} β†’ [inst : AddCommMonoid M] β†’ {I : WithTop (BoxIntegral.Box ΞΉ)} β†’ {motive : BoxIntegral.BoxAdditiveMap ΞΉ M I β†’ Sort u} β†’ ((toFun : BoxIntegral.Box ΞΉ β†’ M) β†’ (sum_partition_boxes' : βˆ€ (J : BoxIntegral.Box ΞΉ), ↑J ≀ I β†’ βˆ€ (Ο€ : BoxIntegral.Prepartition J), Ο€.IsPartition β†’ βˆ‘ Ji ∈ Ο€.boxes, toFun Ji = toFun J) β†’ motive { toFun := toFun, sum_partition_boxes' := sum_partition_boxes' }) β†’ (t : BoxIntegral.BoxAdditiveMap ΞΉ M I) β†’ motive t
Lean.Environment.containsOnBranch
Lean.Environment
Lean.Environment β†’ Lean.Name β†’ Bool
Std.DTreeMap.Internal.Impl.Balanced.one_le
Std.Data.DTreeMap.Internal.Balanced
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {sz : β„•} {k : Ξ±} {v : Ξ² k} {l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²}, (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced β†’ 1 ≀ sz
TwoSidedIdeal.orderIsoRingCon_apply
Mathlib.RingTheory.TwoSidedIdeal.Basic
βˆ€ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (self : TwoSidedIdeal R), TwoSidedIdeal.orderIsoRingCon self = self.ringCon
CategoryTheory.Limits.HasCountableLimits.mk._flat_ctor
Mathlib.CategoryTheory.Limits.Shapes.Countable
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C], (βˆ€ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J], CategoryTheory.Limits.HasLimitsOfShape J C) β†’ CategoryTheory.Limits.HasCountableLimits C
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.add_mul_ediv_right.match_1_3
Init.Data.Int.DivMod.Bootstrap
βˆ€ (motive : (c : β„€) β†’ (βˆƒ n, c = ↑n + 1) β†’ β„€ β†’ 0 < c β†’ Prop) (c : β„€) (x : βˆƒ n, c = ↑n + 1) (b : β„€) (H : 0 < c), (βˆ€ (w a : β„•) (H : 0 < ↑w + 1), motive (↑w + 1) β‹― (Int.ofNat a) H) β†’ (βˆ€ (k n : β„•) (H : 0 < ↑k + 1), motive (↑k + 1) β‹― (Int.negSucc n) H) β†’ motive c x b H
Matrix.single_apply_of_ne
Mathlib.Data.Matrix.Basis
βˆ€ {m : Type u_2} {n : Type u_3} {Ξ± : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero Ξ±] (i : m) (j : n) (c : Ξ±) (i' : m) (j' : n), Β¬(i = i' ∧ j = j') β†’ Matrix.single i j c i' j' = 0
Lean.Xml.Parser.elementPrefix
Lean.Data.Xml.Parser
Std.Internal.Parsec.String.Parser (Array Lean.Xml.Content β†’ Lean.Xml.Element)
Lean.Lsp.instFromJsonPrepareRenameParams
Lean.Data.Lsp.LanguageFeatures
Lean.FromJson Lean.Lsp.PrepareRenameParams
Std.TreeMap.Raw.maxKey?_eq_none_iff._simp_1
Std.Data.TreeMap.Raw.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp], t.WF β†’ (t.maxKey? = none) = (t.isEmpty = true)
Lean.Elab.Term.ElabElimInfo.ctorIdx
Lean.Elab.App
Lean.Elab.Term.ElabElimInfo β†’ β„•
Polynomial.isSplittingField_C
Mathlib.FieldTheory.SplittingField.IsSplittingField
βˆ€ {K : Type v} [inst : Field K] (a : K), Polynomial.IsSplittingField K K (Polynomial.C a)
RingHom.liftOfRightInverse._proof_5
Mathlib.RingTheory.Ideal.Maps
βˆ€ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A β†’+* B) (Ο† : B β†’+* C), RingHom.ker f ≀ RingHom.ker β†‘βŸ¨Ο†.comp f, β‹―βŸ©
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceR.match_1.congr_eq_1
Std.Data.DTreeMap.Internal.Balancing
βˆ€ {Ξ± : Type u_1} {Ξ² : Ξ± β†’ Type u_2} (motive : (r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ r.Balanced β†’ Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size Std.DTreeMap.Internal.Impl.leaf.size β†’ Sort u_3) (r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) (hrb : r.Balanced) (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size Std.DTreeMap.Internal.Impl.leaf.size) (h_1 : (hrb : Std.DTreeMap.Internal.Impl.leaf.Balanced) β†’ (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond Std.DTreeMap.Internal.Impl.leaf.size Std.DTreeMap.Internal.Impl.leaf.size) β†’ motive Std.DTreeMap.Internal.Impl.leaf hrb hlr) (h_2 : (size : β„•) β†’ (k : Ξ±) β†’ (v : Ξ² k) β†’ (hrb : (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).Balanced) β†’ (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size Std.DTreeMap.Internal.Impl.leaf.size) β†’ motive (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf) hrb hlr) (h_3 : (size : β„•) β†’ (rk : Ξ±) β†’ (rv : Ξ² rk) β†’ (rr : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ (size_1 : β„•) β†’ (k : Ξ±) β†’ (v : Ξ² k) β†’ (l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ rr = Std.DTreeMap.Internal.Impl.inner size_1 k v l r β†’ (hrb : (Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf (Std.DTreeMap.Internal.Impl.inner size_1 k v l r)).Balanced) β†’ (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf (Std.DTreeMap.Internal.Impl.inner size_1 k v l r)).size Std.DTreeMap.Internal.Impl.leaf.size) β†’ motive (Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf (Std.DTreeMap.Internal.Impl.inner size_1 k v l r)) hrb hlr) (h_4 : (size : β„•) β†’ (rk : Ξ±) β†’ (rv : Ξ² rk) β†’ (size_1 : β„•) β†’ (rlk : Ξ±) β†’ (rlv : Ξ² rlk) β†’ (l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ (hrb : (Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r) Std.DTreeMap.Internal.Impl.leaf).Balanced) β†’ (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r) Std.DTreeMap.Internal.Impl.leaf).size Std.DTreeMap.Internal.Impl.leaf.size) β†’ motive (Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r) Std.DTreeMap.Internal.Impl.leaf) hrb hlr) (h_5 : (rs : β„•) β†’ (rk : Ξ±) β†’ (rv : Ξ² rk) β†’ (rls : β„•) β†’ (rlk : Ξ±) β†’ (rlv : Ξ² rlk) β†’ (rll rlr : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ (rrs : β„•) β†’ (k : Ξ±) β†’ (v : Ξ² k) β†’ (l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ (hrb : (Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr) (Std.DTreeMap.Internal.Impl.inner rrs k v l r)).Balanced) β†’ (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr) (Std.DTreeMap.Internal.Impl.inner rrs k v l r)).size Std.DTreeMap.Internal.Impl.leaf.size) β†’ motive (Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr) (Std.DTreeMap.Internal.Impl.inner rrs k v l r)) hrb hlr) (hrb_1 : Std.DTreeMap.Internal.Impl.leaf.Balanced) (hlr_1 : Std.DTreeMap.Internal.Impl.BalanceLPrecond Std.DTreeMap.Internal.Impl.leaf.size Std.DTreeMap.Internal.Impl.leaf.size), r = Std.DTreeMap.Internal.Impl.leaf β†’ hrb ≍ hrb_1 β†’ hlr ≍ hlr_1 β†’ (match r, hrb, hlr with | Std.DTreeMap.Internal.Impl.leaf, hrb, hlr => h_1 hrb hlr | Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf, hrb, hlr => h_2 size k v hrb hlr | Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf rr@h:(Std.DTreeMap.Internal.Impl.inner size_1 k v l r), hrb, hlr => h_3 size rk rv rr size_1 k v l r h hrb hlr | Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_1 rlk rlv l r) Std.DTreeMap.Internal.Impl.leaf, hrb, hlr => h_4 size rk rv size_1 rlk rlv l r hrb hlr | Std.DTreeMap.Internal.Impl.inner rs rk rv (Std.DTreeMap.Internal.Impl.inner rls rlk rlv rll rlr) (Std.DTreeMap.Internal.Impl.inner rrs k v l r), hrb, hlr => h_5 rs rk rv rls rlk rlv rll rlr rrs k v l r hrb hlr) ≍ h_1 hrb_1 hlr_1
AlgebraicTopology.DoldKan.HigherFacesVanish.induction
Mathlib.AlgebraicTopology.DoldKan.Faces
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X : CategoryTheory.SimplicialObject C} {Y : C} {n q : β„•} {Ο† : Y ⟢ X.obj (Opposite.op (SimplexCategory.mk (n + 1)))}, AlgebraicTopology.DoldKan.HigherFacesVanish q Ο† β†’ AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1) (CategoryTheory.CategoryStruct.comp Ο† ((CategoryTheory.CategoryStruct.id (AlgebraicTopology.AlternatingFaceMapComplex.obj X) + AlgebraicTopology.DoldKan.HΟƒ q).f (n + 1)))
Lean.Parser.Term.open.parenthesizer
Lean.Parser.Command
Lean.PrettyPrinter.Parenthesizer
LinearMap.mkContinuous_coe
Mathlib.Analysis.Normed.Operator.ContinuousLinearMap
βˆ€ {π•œ : Type u_1} {π•œβ‚‚ : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Ring π•œ] [inst_1 : Ring π•œβ‚‚] [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module π•œ E] [inst_5 : Module π•œβ‚‚ F] {Οƒ : π•œ β†’+* π•œβ‚‚} (f : E β†’β‚›β‚—[Οƒ] F) (C : ℝ) (h : βˆ€ (x : E), β€–f xβ€– ≀ C * β€–xβ€–), ↑(f.mkContinuous C h) = f
hnot_sup_self
Mathlib.Order.Heyting.Basic
βˆ€ {Ξ± : Type u_2} [inst : CoheytingAlgebra Ξ±] (a : Ξ±), οΏ’a βŠ” a = ⊀
CategoryTheory.NatTrans.mk.injEq
Mathlib.CategoryTheory.NatTrans
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type uβ‚‚} [inst_1 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] {F G : CategoryTheory.Functor C D} (app : (X : C) β†’ F.obj X ⟢ G.obj X) (naturality : autoParam (βˆ€ ⦃X Y : C⦄ (f : X ⟢ Y), CategoryTheory.CategoryStruct.comp (F.map f) (app Y) = CategoryTheory.CategoryStruct.comp (app X) (G.map f)) CategoryTheory.NatTrans.naturality._autoParam) (app_1 : (X : C) β†’ F.obj X ⟢ G.obj X) (naturality_1 : autoParam (βˆ€ ⦃X Y : C⦄ (f : X ⟢ Y), CategoryTheory.CategoryStruct.comp (F.map f) (app_1 Y) = CategoryTheory.CategoryStruct.comp (app_1 X) (G.map f)) CategoryTheory.NatTrans.naturality._autoParam), ({ app := app, naturality := naturality } = { app := app_1, naturality := naturality_1 }) = (app = app_1)
ENormedSpace.instTop._proof_3
Mathlib.Analysis.Normed.Module.ENormedSpace
βˆ€ {π•œ : Type u_2} {V : Type u_1} [inst : NormedField π•œ] [inst_1 : AddCommGroup V] [inst_2 : Module π•œ V] (c : π•œ) (x : V), (if c β€’ x = 0 then 0 else ⊀) ≀ ↑‖cβ€–β‚Š * if x = 0 then 0 else ⊀
fwdDiff_const
Mathlib.Algebra.Group.ForwardDiff
βˆ€ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (g : G), (fwdDiff h fun x => g) = fun x => 0
Nat.sSup_mem
Mathlib.Data.Nat.Lattice
βˆ€ {s : Set β„•}, s.Nonempty β†’ BddAbove s β†’ sSup s ∈ s
Lean.Elab.Term.Do.attachJPs
Lean.Elab.Do.Legacy
Array Lean.Elab.Term.Do.JPDecl β†’ Lean.Elab.Term.Do.Code β†’ Lean.Elab.Term.Do.Code
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.strictOccursMax
Lean.Meta.LevelDefEq
Lean.Level β†’ Lean.Level β†’ Bool
_private.Init.Grind.Ordered.Module.0.Lean.Grind.OrderedAdd.zsmul_le_zsmul._simp_1_1
Init.Grind.Ordered.Module
βˆ€ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommGroup M] [Lean.Grind.OrderedAdd M] {a b : M}, (0 ≀ a - b) = (b ≀ a)
SubAddAction.instInhabited.eq_1
Mathlib.GroupTheory.GroupAction.SubMulAction
βˆ€ {R : Type u} {M : Type v} [inst : VAdd R M], SubAddAction.instInhabited = { default := βŠ₯ }
RingHom.map_iterate_frobenius
Mathlib.Algebra.CharP.Frobenius
βˆ€ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R β†’+* S) (p : β„•) [inst_2 : ExpChar R p] [inst_3 : ExpChar S p] (x : R) (n : β„•), g ((⇑(frobenius R p))^[n] x) = (⇑(frobenius S p))^[n] (g x)
PFunctor.Idx
Mathlib.Data.PFunctor.Univariate.Basic
PFunctor.{uA, uB} β†’ Type (max uA uB)
Lean.Meta.Try.Collector.OrdSet.insert
Lean.Meta.Tactic.Try.Collect
{Ξ± : Type} β†’ {x : Hashable Ξ±} β†’ {x_1 : BEq Ξ±} β†’ Lean.Meta.Try.Collector.OrdSet Ξ± β†’ Ξ± β†’ Lean.Meta.Try.Collector.OrdSet Ξ±
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.transGen_oneStep_of_isDershowitzMannaLT._simp_1_1
Mathlib.Data.Multiset.DershowitzManna
βˆ€ {Ξ± : Type u_1} {p : Ξ± β†’ Prop} [inst : DecidablePred p] {a : Ξ±} {s : Multiset Ξ±}, (a ∈ Multiset.filter p s) = (a ∈ s ∧ p a)
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.discharge?.match_1
Lean.Meta.Tactic.Grind.Main
(motive : Option Lean.Expr β†’ Sort u_1) β†’ (__do_lift : Option Lean.Expr) β†’ ((p : Lean.Expr) β†’ motive (some p)) β†’ ((x : Option Lean.Expr) β†’ motive x) β†’ motive __do_lift
ContinuousMap.instNonUnitalCommCStarAlgebra._proof_6
Mathlib.Analysis.CStarAlgebra.ContinuousMap
βˆ€ {Ξ± : Type u_1} {A : Type u_2} [inst : TopologicalSpace Ξ±] [inst_1 : CompactSpace Ξ±] [inst_2 : NonUnitalCommCStarAlgebra A] (a b c : C(Ξ±, A)), a * (b + c) = a * b + a * c
Mathlib.Tactic.Monoidal.instMkEvalWhiskerLeftMonoidalM.match_1
Mathlib.Tactic.CategoryTheory.Monoidal.Normalize
(ctx : Mathlib.Tactic.Monoidal.Context) β†’ (motive : Option Q(CategoryTheory.MonoidalCategory unknown_1) β†’ Sort u_1) β†’ (x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) β†’ ((_monoidal : Q(CategoryTheory.MonoidalCategory unknown_1)) β†’ motive (some _monoidal)) β†’ ((x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) β†’ motive x) β†’ motive x
isClosed_Ioo_iff
Mathlib.Topology.Order.DenselyOrdered
βˆ€ {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [inst_1 : LinearOrder Ξ±] [OrderTopology Ξ±] [DenselyOrdered Ξ±] {a b : Ξ±}, IsClosed (Set.Ioo a b) ↔ b ≀ a
_private.Mathlib.Algebra.Module.Submodule.Union.0.Submodule.iUnion_ssubset_of_forall_ne_top_of_card_lt._simp_1_1
Mathlib.Algebra.Module.Submodule.Union
βˆ€ {Ξ± : Type u} {s : Set Ξ±}, (s βŠ‚ Set.univ) = (s β‰  Set.univ)
UInt8.mod_eq_of_lt
Init.Data.UInt.Lemmas
βˆ€ {a b : UInt8}, a < b β†’ a % b = a
Aesop.RuleBuilderInput.noConfusion
Aesop.Builder.Basic
{P : Sort u} β†’ {x1 x2 : Aesop.RuleBuilderInput} β†’ x1 = x2 β†’ Aesop.RuleBuilderInput.noConfusionType P x1 x2
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.replace.eq_2
Std.Data.DHashMap.Internal.AssocList.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} [inst : BEq Ξ±] (a : Ξ±) (b : Ξ² a) (a_1 : Ξ±) (b_1 : Ξ² a_1) (es : Std.DHashMap.Internal.AssocList Ξ± Ξ²), Std.DHashMap.Internal.AssocList.replace a b (Std.DHashMap.Internal.AssocList.cons a_1 b_1 es) = bif a_1 == a then Std.DHashMap.Internal.AssocList.cons a b es else Std.DHashMap.Internal.AssocList.cons a_1 b_1 (Std.DHashMap.Internal.AssocList.replace a b es)
CategoryTheory.Dial.rightUnitorImpl._proof_1
Mathlib.CategoryTheory.Dialectica.Monoidal
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C] (X : CategoryTheory.Dial C), CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.pair X.src CategoryTheory.Dial.tensorUnitImpl.src)
NumberField.mixedEmbedding.convexBodySum_volume_eq_zero_of_le_zero
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody
βˆ€ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {B : ℝ}, B ≀ 0 β†’ MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B) = 0
iUnion_Iic_eq_Iio_of_lt_of_tendsto
Mathlib.Topology.Order.OrderClosed
βˆ€ {Ξ± : Type u} {ΞΉ : Type u_1} {F : Filter ΞΉ} [F.NeBot] [inst : ConditionallyCompleteLinearOrder Ξ±] [inst_1 : TopologicalSpace Ξ±] [ClosedIicTopology Ξ±] {a : Ξ±} {f : ΞΉ β†’ Ξ±}, (βˆ€ (i : ΞΉ), f i < a) β†’ Filter.Tendsto f F (nhds a) β†’ ⋃ i, Set.Iic (f i) = Set.Iio a
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim_inv_app
Mathlib.CategoryTheory.Limits.Shapes.Biproducts
βˆ€ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : CategoryTheory.Limits.HasBiproductsOfShape J C] (X : CategoryTheory.Functor (CategoryTheory.Discrete J) C), CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim.inv.app X = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.isoLimit X).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.lift (CategoryTheory.Limits.Pi.Ο€ fun j => X.obj { as := j })) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.desc (CategoryTheory.Limits.Sigma.ΞΉ fun j => X.obj { as := j })) (CategoryTheory.Limits.Sigma.isoColimit X).hom))
MonadControlT
Init.Control.Basic
(Type u β†’ Type v) β†’ (Type u β†’ Type w) β†’ Type (max (max (u + 1) v) w)
Matrix.conjTranspose_reindex
Mathlib.LinearAlgebra.Matrix.ConjTranspose
βˆ€ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {Ξ± : Type v} [inst : Star Ξ±] (eβ‚˜ : m ≃ l) (eβ‚™ : n ≃ o) (M : Matrix m n Ξ±), ((Matrix.reindex eβ‚˜ eβ‚™) M).conjTranspose = (Matrix.reindex eβ‚™ eβ‚˜) M.conjTranspose
UniformFun.uniformEquivProdArrow._proof_1
Mathlib.Topology.UniformSpace.UniformConvergenceTopology
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : UniformSpace Ξ²] [inst_1 : UniformSpace Ξ³], IsUniformInducing ⇑(Equiv.arrowProdEquivProdArrow Ξ± (fun a => Ξ²) fun a => Ξ³)
[email protected]._hygCtx._hyg.13
Mathlib.Combinatorics.Matroid.Dual
Lean.Syntax
Lean.Parser.Attr.tactic_alt.parenthesizer
Lean.Parser.Attr
Lean.PrettyPrinter.Parenthesizer
Sum.map_surjective
Mathlib.Data.Sum.Basic
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type u_1} {Ξ΄ : Type u_2} {f : Ξ± β†’ Ξ³} {g : Ξ² β†’ Ξ΄}, Function.Surjective (Sum.map f g) ↔ Function.Surjective f ∧ Function.Surjective g
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ext.match_1
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
βˆ€ {R : Type u_1} {inst : CommRing R} (motive : ValuativeRel R β†’ Prop) (h : ValuativeRel R), (βˆ€ (Rel : R β†’ R β†’ Prop) (rel_total : βˆ€ (x y : R), Rel x y ∨ Rel y x) (rel_trans : βˆ€ {z y x : R}, Rel x y β†’ Rel y z β†’ Rel x z) (rel_add : βˆ€ {x y z : R}, Rel x z β†’ Rel y z β†’ Rel (x + y) z) (rel_mul_right : βˆ€ {x y : R} (z : R), Rel x y β†’ Rel (x * z) (y * z)) (rel_mul_cancel : βˆ€ {x y z : R}, Β¬Rel z 0 β†’ Rel (x * z) (y * z) β†’ Rel x y) (not_rel_one_zero : Β¬Rel 1 0), motive { Rel := Rel, rel_total := rel_total, rel_trans := rel_trans, rel_add := rel_add, rel_mul_right := rel_mul_right, rel_mul_cancel := rel_mul_cancel, not_rel_one_zero := not_rel_one_zero }) β†’ motive h
Module.Basis.prod_apply_inl_fst
Mathlib.LinearAlgebra.Basis.Prod
βˆ€ {ΞΉ : Type u_1} {ΞΉ' : Type u_2} {R : Type u_3} {M : Type u_5} {M' : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (b : Module.Basis ΞΉ R M) (b' : Module.Basis ΞΉ' R M') (i : ΞΉ), ((b.prod b') (Sum.inl i)).1 = b i
UInt8.toInt8_ofNat'
Init.Data.SInt.Lemmas
βˆ€ {n : β„•}, (UInt8.ofNat n).toInt8 = Int8.ofNat n
GradeOrder.wellFoundedGT
Mathlib.Order.Grade
βˆ€ {Ξ± : Type u_3} [inst : Preorder Ξ±] (𝕆 : Type u_5) [inst_1 : Preorder 𝕆] [GradeOrder 𝕆 Ξ±] [WellFoundedGT 𝕆], WellFoundedGT Ξ±
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimageDiagram.eq_1
Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preregular C] [inst_2 : CategoryTheory.FinitaryExtensive C] {F : CategoryTheory.Functor β„•α΅’α΅– (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))} (hF : βˆ€ (n : β„•), CategoryTheory.Sheaf.IsLocallySurjective (F.map (CategoryTheory.homOfLE β‹―).op)) (X : C) (y : (F.obj (Opposite.op 0)).val.obj (Opposite.op X)), CategoryTheory.coherentTopology.preimageDiagram✝ hF X y = CategoryTheory.Functor.ofOpSequence (CategoryTheory.coherentTopology.struct.map✝ (CategoryTheory.coherentTopology.preimageStruct✝ hF X y))
IsSimpleRing.of_surjective
Mathlib.RingTheory.SimpleRing.Congr
βˆ€ {R : Type u_1} {S : Type u_2} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] [Nontrivial S] (f : R β†’+* S), IsSimpleRing R β†’ Function.Surjective ⇑f β†’ IsSimpleRing S
Std.HashSet.getD_union_of_not_mem_left
Std.Data.HashSet.Lemmas
βˆ€ {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m₁ mβ‚‚ : Std.HashSet Ξ±} [EquivBEq Ξ±] [LawfulHashable Ξ±] {k fallback : Ξ±}, k βˆ‰ m₁ β†’ (m₁ βˆͺ mβ‚‚).getD k fallback = mβ‚‚.getD k fallback
Lean.Parser.Term.set_option.parenthesizer
Lean.Parser.Command
Lean.PrettyPrinter.Parenthesizer
CircularPartialOrder.toCircularPreorder
Mathlib.Order.Circular
{Ξ± : Type u_1} β†’ [self : CircularPartialOrder Ξ±] β†’ CircularPreorder Ξ±
ModuleCon.mk.noConfusion
Mathlib.Algebra.Module.Congruence.Defs
{S : Type u_2} β†’ {M : Type u_3} β†’ [inst : Add M] β†’ [inst_1 : SMul S M] β†’ (P : Sort u) β†’ (toAddCon : AddCon M) β†’ (smul : βˆ€ (s : S) {x y : M}, toAddCon.toSetoid x y β†’ toAddCon.toSetoid (s β€’ x) (s β€’ y)) β†’ (toAddCon' : AddCon M) β†’ (smul' : βˆ€ (s : S) {x y : M}, toAddCon'.toSetoid x y β†’ toAddCon'.toSetoid (s β€’ x) (s β€’ y)) β†’ { toAddCon := toAddCon, smul := smul } = { toAddCon := toAddCon', smul := smul' } β†’ (toAddCon = toAddCon' β†’ P) β†’ P
MonoidHom.compLeftContinuousBounded_apply
Mathlib.Topology.ContinuousMap.Bounded.Basic
βˆ€ {Ξ² : Type v} {Ξ³ : Type w} (Ξ± : Type u_3) [inst : TopologicalSpace Ξ±] [inst_1 : PseudoMetricSpace Ξ²] [inst_2 : Monoid Ξ²] [inst_3 : BoundedMul Ξ²] [inst_4 : ContinuousMul Ξ²] [inst_5 : PseudoMetricSpace Ξ³] [inst_6 : Monoid Ξ³] [inst_7 : BoundedMul Ξ³] [inst_8 : ContinuousMul Ξ³] (g : Ξ² β†’* Ξ³) {C : NNReal} (hg : LipschitzWith C ⇑g) (f : BoundedContinuousFunction Ξ± Ξ²), (MonoidHom.compLeftContinuousBounded Ξ± g hg) f = BoundedContinuousFunction.comp (⇑g) hg f
LinearOrderedAddCommMonoidWithTop.toIsOrderedAddMonoid
Mathlib.Algebra.Order.AddGroupWithTop
βˆ€ {Ξ± : Type u_2} [self : LinearOrderedAddCommMonoidWithTop Ξ±], IsOrderedAddMonoid Ξ±
IsAntichain.sperner
Mathlib.Combinatorics.SetFamily.LYM
βˆ€ {Ξ± : Type u_2} [inst : Fintype Ξ±] {π’œ : Finset (Finset Ξ±)}, IsAntichain (fun x1 x2 => x1 βŠ† x2) β†‘π’œ β†’ π’œ.card ≀ (Fintype.card Ξ±).choose (Fintype.card Ξ± / 2)
Batteries.BinomialHeap.Imp.FindMin.WF.casesOn
Batteries.Data.BinomialHeap.Basic
{Ξ± : Type u_1} β†’ {le : Ξ± β†’ Ξ± β†’ Bool} β†’ {res : Batteries.BinomialHeap.Imp.FindMin Ξ±} β†’ {motive : Batteries.BinomialHeap.Imp.FindMin.WF le res β†’ Sort u} β†’ (t : Batteries.BinomialHeap.Imp.FindMin.WF le res) β†’ ((rank : β„•) β†’ (before : βˆ€ {s : Batteries.BinomialHeap.Imp.Heap Ξ±}, Batteries.BinomialHeap.Imp.Heap.WF le rank s β†’ Batteries.BinomialHeap.Imp.Heap.WF le 0 (res.before s)) β†’ (node : Batteries.BinomialHeap.Imp.HeapNode.WF le res.val res.node rank) β†’ (next : Batteries.BinomialHeap.Imp.Heap.WF le (rank + 1) res.next) β†’ motive { rank := rank, before := before, node := node, next := next }) β†’ motive t
CategoryTheory.uliftFunctor
Mathlib.CategoryTheory.Types.Basic
CategoryTheory.Functor (Type u) (Type (max u v))
Rep.standardComplex.forgetβ‚‚ToModuleCat
Mathlib.RepresentationTheory.Homological.Resolution
(k G : Type u) β†’ [inst : CommRing k] β†’ [Monoid G] β†’ HomologicalComplex (ModuleCat k) (ComplexShape.down β„•)
_private.Mathlib.Analysis.BoxIntegral.Partition.Additive.0.Option.elim'.match_1.eq_2
Mathlib.Analysis.BoxIntegral.Partition.Additive
βˆ€ {Ξ± : Type u_1} (motive : Option Ξ± β†’ Sort u_2) (h_1 : (a : Ξ±) β†’ motive (some a)) (h_2 : Unit β†’ motive none), (match none with | some a => h_1 a | none => h_2 ()) = h_2 ()
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD_eq_getD_entryAtIdx?
Std.Data.DTreeMap.Internal.Model
βˆ€ {Ξ± : Type u} {Ξ² : Type v} {t : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²} {i : β„•} {fallback : Ξ± Γ— Ξ²}, Std.DTreeMap.Internal.Impl.Const.entryAtIdxD t i fallback = (Std.DTreeMap.Internal.Impl.Const.entryAtIdx? t i).getD fallback
Int64.le_minValue_iff
Init.Data.SInt.Lemmas
βˆ€ {a : Int64}, a ≀ Int64.minValue ↔ a = Int64.minValue
TensorProduct.instInner
Mathlib.Analysis.InnerProductSpace.TensorProduct
{π•œ : Type u_1} β†’ {E : Type u_2} β†’ {F : Type u_3} β†’ [inst : RCLike π•œ] β†’ [inst_1 : NormedAddCommGroup E] β†’ [inst_2 : InnerProductSpace π•œ E] β†’ [inst_3 : NormedAddCommGroup F] β†’ [inst_4 : InnerProductSpace π•œ F] β†’ Inner π•œ (TensorProduct π•œ E F)
MeasureTheory.integral_union_ae
Mathlib.MeasureTheory.Integral.Bochner.Set
βˆ€ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : X β†’ E} {s t : Set X} {ΞΌ : MeasureTheory.Measure X}, MeasureTheory.AEDisjoint ΞΌ s t β†’ MeasureTheory.NullMeasurableSet t ΞΌ β†’ MeasureTheory.IntegrableOn f s ΞΌ β†’ MeasureTheory.IntegrableOn f t ΞΌ β†’ ∫ (x : X) in s βˆͺ t, f x βˆ‚ΞΌ = ∫ (x : X) in s, f x βˆ‚ΞΌ + ∫ (x : X) in t, f x βˆ‚ΞΌ
Nat.le.below.refl
Init.Prelude
βˆ€ {n : β„•} {motive : (a : β„•) β†’ n.le a β†’ Prop}, Nat.le.below β‹―
Batteries.PairingHeapImp.Heap.foldTreeM._unsafe_rec
Batteries.Data.PairingHeap
{m : Type u_1 β†’ Type u_2} β†’ {Ξ² : Type u_1} β†’ {Ξ± : Type u_3} β†’ [Monad m] β†’ Ξ² β†’ (Ξ± β†’ Ξ² β†’ Ξ² β†’ m Ξ²) β†’ Batteries.PairingHeapImp.Heap Ξ± β†’ m Ξ²
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_properDivisors._simp_1_5
Mathlib.NumberTheory.Divisors
βˆ€ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c β†’ (a ↔ b))
invMonoidHom.eq_1
Mathlib.Algebra.Group.Hom.Basic
βˆ€ {Ξ± : Type u_1} [inst : DivisionCommMonoid Ξ±], invMonoidHom = { toFun := Inv.inv, map_one' := β‹―, map_mul' := β‹― }
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_iff_not_exists_mul_eq._simp_1_6
Mathlib.Data.Nat.Prime.Defs
βˆ€ {Ξ± : Type u_1} [inst : LinearOrder Ξ±] {a b : Ξ±}, (Β¬a < b) = (b ≀ a)
LeanSearchClient.LoogleResult.recOn
LeanSearchClient.LoogleSyntax
{motive : LeanSearchClient.LoogleResult β†’ Sort u} β†’ (t : LeanSearchClient.LoogleResult) β†’ motive LeanSearchClient.LoogleResult.empty β†’ ((a : Array LeanSearchClient.SearchResult) β†’ motive (LeanSearchClient.LoogleResult.success a)) β†’ ((error : String) β†’ (suggestions : Option (List String)) β†’ motive (LeanSearchClient.LoogleResult.failure error suggestions)) β†’ motive t
Std.Tactic.BVDecide.BVPred.rec
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
{motive : Std.Tactic.BVDecide.BVPred β†’ Sort u} β†’ ({w : β„•} β†’ (lhs : Std.Tactic.BVDecide.BVExpr w) β†’ (op : Std.Tactic.BVDecide.BVBinPred) β†’ (rhs : Std.Tactic.BVDecide.BVExpr w) β†’ motive (Std.Tactic.BVDecide.BVPred.bin lhs op rhs)) β†’ ({w : β„•} β†’ (expr : Std.Tactic.BVDecide.BVExpr w) β†’ (idx : β„•) β†’ motive (Std.Tactic.BVDecide.BVPred.getLsbD expr idx)) β†’ (t : Std.Tactic.BVDecide.BVPred) β†’ motive t
Topology.IsUpperSet.topology_eq_upperSetTopology
Mathlib.Topology.Order.UpperLowerSetTopology
βˆ€ {Ξ± : Type u_4} {t : TopologicalSpace Ξ±} {inst : Preorder Ξ±} [self : Topology.IsUpperSet Ξ±], t = Topology.upperSet Ξ±
_private.Init.Data.UInt.Lemmas.0.USize.pos_iff_ne_zero._simp_1_2
Init.Data.UInt.Lemmas
βˆ€ {Ξ± : Sort u_1} {a b : Ξ±}, (a = b) = (b = a)
Vector.back?
Init.Data.Vector.Basic
{Ξ± : Type u_1} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Option Ξ±
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.merge._sparseCasesOn_1
Lean.Compiler.LCNF.ElimDeadBranches
{motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value β†’ Sort u} β†’ (t : Lean.Compiler.LCNF.UnreachableBranches.Value) β†’ motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot β†’ motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.top β†’ ((vs : List Lean.Compiler.LCNF.UnreachableBranches.Value) β†’ motive_1 (Lean.Compiler.LCNF.UnreachableBranches.Value.choice vs)) β†’ (t.ctorIdx β‰  0 β†’ t.ctorIdx β‰  1 β†’ t.ctorIdx β‰  3 β†’ motive_1 t) β†’ motive_1 t
Int.le_emod_self_add_one_iff
Init.Data.Int.DivMod.Lemmas
βˆ€ {a b : β„€}, 0 < b β†’ (b ≀ a % b + 1 ↔ b ∣ a + 1)
Topology.instIsLowerSet
Mathlib.Topology.Order.UpperLowerSetTopology
βˆ€ {Ξ± : Type u_1} [inst : Preorder Ξ±], Topology.IsLowerSet Ξ±
LinearMap.extendToπ•œ'._proof_3
Mathlib.Analysis.RCLike.Extend
βˆ€ {π•œ : Type u_1} [inst : RCLike π•œ] {F : Type u_2} [inst_1 : AddCommGroup F] [inst_2 : Module ℝ F] [inst_3 : Module π•œ F] (fr : Module.Dual ℝ F), (βˆ€ (c : ℝ) (x : F), ↑(fr (↑c β€’ x)) = ↑c * ↑(fr x)) β†’ βˆ€ (c : ℝ) (x : F), ↑(fr (↑c β€’ x)) - RCLike.I * ↑(fr (RCLike.I β€’ ↑c β€’ x)) = ↑c * (↑(fr x) - RCLike.I * ↑(fr (RCLike.I β€’ x)))
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate.0.PartialOrder.mem_nerve_nonDegenerate_iff_strictMono._simp_1_1
Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate
βˆ€ {X : Type u_1} [inst : PartialOrder X] {n : β„•} (s : (CategoryTheory.nerve X).obj (Opposite.op (SimplexCategory.mk (n + 1)))) (i : Fin (n + 1)), (s ∈ Set.range (CategoryTheory.SimplicialObject.Οƒ (CategoryTheory.nerve X) i)) = (s.obj i.castSucc = s.obj i.succ)
Nat.iSup_le_succ
Mathlib.Data.Nat.Lattice
βˆ€ {Ξ± : Type u_1} [inst : CompleteLattice Ξ±] (u : β„• β†’ Ξ±) (n : β„•), ⨆ k, ⨆ (_ : k ≀ n + 1), u k = (⨆ k, ⨆ (_ : k ≀ n), u k) βŠ” u (n + 1)
ContinuousMap.compMonoidHom'._proof_1
Mathlib.Topology.ContinuousMap.Algebra
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_3} [inst : TopologicalSpace Ξ±] [inst_1 : TopologicalSpace Ξ²] {Ξ³ : Type u_2} [inst_2 : TopologicalSpace Ξ³] [inst_3 : MulOneClass Ξ³] (g : C(Ξ±, Ξ²)), ContinuousMap.comp 1 g = 1
Order.exists_series_of_le_coheight
Mathlib.Order.KrullDimension
βˆ€ {Ξ± : Type u_1} [inst : Preorder Ξ±] (a : Ξ±) {n : β„•}, ↑n ≀ Order.coheight a β†’ βˆƒ p, RelSeries.head p = a ∧ p.length = n
Mathlib.Tactic.Bicategory.evalWhiskerRight_cons_of_of
Mathlib.Tactic.CategoryTheory.Bicategory.Normalize
βˆ€ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g h i : a ⟢ b} {j : b ⟢ c} {Ξ± : f β‰… g} {Ξ· : g ⟢ h} {Ξ·s : h ⟢ i} {Ξ·s₁ : CategoryTheory.CategoryStruct.comp h j ⟢ CategoryTheory.CategoryStruct.comp i j} {η₁ : CategoryTheory.CategoryStruct.comp g j ⟢ CategoryTheory.CategoryStruct.comp h j} {Ξ·β‚‚ : CategoryTheory.CategoryStruct.comp g j ⟢ CategoryTheory.CategoryStruct.comp i j} {η₃ : CategoryTheory.CategoryStruct.comp f j ⟢ CategoryTheory.CategoryStruct.comp i j}, CategoryTheory.Bicategory.whiskerRight Ξ·s j = Ξ·s₁ β†’ CategoryTheory.Bicategory.whiskerRight Ξ· j = η₁ β†’ CategoryTheory.CategoryStruct.comp η₁ Ξ·s₁ = Ξ·β‚‚ β†’ CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRightIso Ξ± j).hom Ξ·β‚‚ = η₃ β†’ CategoryTheory.Bicategory.whiskerRight (CategoryTheory.CategoryStruct.comp Ξ±.hom (CategoryTheory.CategoryStruct.comp Ξ· Ξ·s)) j = η₃
MeasureTheory.tendsto_of_uncrossing_lt_top
Mathlib.Probability.Martingale.Convergence
βˆ€ {Ξ© : Type u_1} {f : β„• β†’ Ξ© β†’ ℝ} {Ο‰ : Ξ©}, Filter.liminf (fun n => ↑‖f n Ο‰β€–β‚Š) Filter.atTop < ⊀ β†’ (βˆ€ (a b : β„š), a < b β†’ MeasureTheory.upcrossings (↑a) (↑b) f Ο‰ < ⊀) β†’ βˆƒ c, Filter.Tendsto (fun n => f n Ο‰) Filter.atTop (nhds c)
Mathlib.Tactic.RingNF.RingMode.recOn
Mathlib.Tactic.Ring.RingNF
{motive : Mathlib.Tactic.RingNF.RingMode β†’ Sort u} β†’ (t : Mathlib.Tactic.RingNF.RingMode) β†’ motive Mathlib.Tactic.RingNF.RingMode.SOP β†’ motive Mathlib.Tactic.RingNF.RingMode.raw β†’ motive t
Polynomial.natDegree_pow_X_add_C
Mathlib.Algebra.Polynomial.Monic
βˆ€ {R : Type u} [inst : Semiring R] [Nontrivial R] (n : β„•) (r : R), ((Polynomial.X + Polynomial.C r) ^ n).natDegree = n
Substring.Raw.ValidFor.isEmpty
Batteries.Data.String.Lemmas
βˆ€ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s β†’ (s.isEmpty = true ↔ m = [])
Batteries.instOrientedCmpCompareOnOfOrientedOrd
Batteries.Classes.Deprecated
βˆ€ {Ξ² : Type u_1} {Ξ± : Sort u_2} [inst : Ord Ξ²] [Batteries.OrientedOrd Ξ²] (f : Ξ± β†’ Ξ²), Batteries.OrientedCmp (compareOn f)
PFun.prodMap_id_id
Mathlib.Data.PFun
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2}, (PFun.id Ξ±).prodMap (PFun.id Ξ²) = PFun.id (Ξ± Γ— Ξ²)
ModularForm.mk.noConfusion
Mathlib.NumberTheory.ModularForms.Basic
{Ξ“ : Subgroup (GL (Fin 2) ℝ)} β†’ {k : β„€} β†’ (P : Sort u) β†’ (toSlashInvariantForm : SlashInvariantForm Ξ“ k) β†’ (holo' : MDifferentiable (modelWithCornersSelf β„‚ β„‚) (modelWithCornersSelf β„‚ β„‚) ⇑toSlashInvariantForm) β†’ (bdd_at_cusps' : βˆ€ {c : OnePoint ℝ}, IsCusp c Ξ“ β†’ c.IsBoundedAt toSlashInvariantForm.toFun k) β†’ (toSlashInvariantForm' : SlashInvariantForm Ξ“ k) β†’ (holo'' : MDifferentiable (modelWithCornersSelf β„‚ β„‚) (modelWithCornersSelf β„‚ β„‚) ⇑toSlashInvariantForm') β†’ (bdd_at_cusps'' : βˆ€ {c : OnePoint ℝ}, IsCusp c Ξ“ β†’ c.IsBoundedAt toSlashInvariantForm'.toFun k) β†’ { toSlashInvariantForm := toSlashInvariantForm, holo' := holo', bdd_at_cusps' := bdd_at_cusps' } = { toSlashInvariantForm := toSlashInvariantForm', holo' := holo'', bdd_at_cusps' := bdd_at_cusps'' } β†’ (toSlashInvariantForm = toSlashInvariantForm' β†’ P) β†’ P
Fin.foldr_congr
Init.Data.Fin.Fold
βˆ€ {Ξ± : Sort u_1} {n k : β„•} (w : n = k) (f : Fin n β†’ Ξ± β†’ Ξ±), Fin.foldr n f = Fin.foldr k fun i => f (Fin.cast β‹― i)
topologicalGroup_of_lieGroup
Mathlib.Geometry.Manifold.Algebra.LieGroup
βˆ€ {π•œ : Type u_1} [inst : NontriviallyNormedField π•œ] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace π•œ E] (I : ModelWithCorners π•œ E H) (n : WithTop β„•βˆž) {G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [LieGroup I n G], IsTopologicalGroup G
_private.Mathlib.Data.Finset.Prod.0.Finset.subset_product_image_fst._simp_1_1
Mathlib.Data.Finset.Prod
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : DecidableEq Ξ²] {f : Ξ± β†’ Ξ²} {s : Finset Ξ±} {b : Ξ²}, (b ∈ Finset.image f s) = βˆƒ a ∈ s, f a = b
Finset.prod_bij'
Mathlib.Algebra.BigOperators.Group.Finset.Defs
βˆ€ {ΞΉ : Type u_1} {ΞΊ : Type u_2} {M : Type u_3} [inst : CommMonoid M] {s : Finset ΞΉ} {t : Finset ΞΊ} {f : ΞΉ β†’ M} {g : ΞΊ β†’ M} (i : (a : ΞΉ) β†’ a ∈ s β†’ ΞΊ) (j : (a : ΞΊ) β†’ a ∈ t β†’ ΞΉ) (hi : βˆ€ (a : ΞΉ) (ha : a ∈ s), i a ha ∈ t) (hj : βˆ€ (a : ΞΊ) (ha : a ∈ t), j a ha ∈ s), (βˆ€ (a : ΞΉ) (ha : a ∈ s), j (i a ha) β‹― = a) β†’ (βˆ€ (a : ΞΊ) (ha : a ∈ t), i (j a ha) β‹― = a) β†’ (βˆ€ (a : ΞΉ) (ha : a ∈ s), f a = g (i a ha)) β†’ ∏ x ∈ s, f x = ∏ x ∈ t, g x