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
Lean.Lsp.instFromJsonResolveSupport
Lean.Data.Lsp.Basic
Lean.FromJson Lean.Lsp.ResolveSupport
Lean.Elab.Term.LValResolution.projIdx
Lean.Elab.App
Lean.Name β†’ β„• β†’ Lean.Elab.Term.LValResolution
pow_succ_pos._simp_1
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic
βˆ€ {Mβ‚€ : Type u_2} [inst : MonoidWithZero Mβ‚€] [inst_1 : PartialOrder Mβ‚€] {a : Mβ‚€} [PosMulStrictMono Mβ‚€], 0 < a β†’ βˆ€ (n : β„•), (0 < a ^ (n + 1)) = True
FirstOrder.Language.Substructure.map_strictMono_of_injective
Mathlib.ModelTheory.Substructures
βˆ€ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {f : L.Hom M N}, Function.Injective ⇑f β†’ StrictMono (FirstOrder.Language.Substructure.map f)
Std.Tactic.BVDecide.BVExpr.bin.injEq
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
βˆ€ {w : β„•} (lhs : Std.Tactic.BVDecide.BVExpr w) (op : Std.Tactic.BVDecide.BVBinOp) (rhs lhs_1 : Std.Tactic.BVDecide.BVExpr w) (op_1 : Std.Tactic.BVDecide.BVBinOp) (rhs_1 : Std.Tactic.BVDecide.BVExpr w), (lhs.bin op rhs = lhs_1.bin op_1 rhs_1) = (lhs = lhs_1 ∧ op = op_1 ∧ rhs = rhs_1)
sdiff_inf_right_comm
Mathlib.Order.BooleanAlgebra.Basic
βˆ€ {Ξ± : Type u} [inst : GeneralizedBooleanAlgebra Ξ±] (x y z : Ξ±), x \ z βŠ“ y = (x βŠ“ y) \ z
ISize.toNatClampNeg_pos_iff
Init.Data.SInt.Lemmas
βˆ€ (n : ISize), 0 < n.toNatClampNeg ↔ 0 < n
Int.fmod_eq_fmod_iff_fmod_sub_eq_zero
Init.Data.Int.DivMod.Lemmas
βˆ€ {m n k : β„€}, m.fmod n = k.fmod n ↔ (m - k).fmod n = 0
_private.Lean.Elab.PreDefinition.WF.PackMutual.0.Lean.Elab.WF.packCalls.match_1
Lean.Elab.PreDefinition.WF.PackMutual
(motive : Option β„• β†’ Sort u_1) β†’ (x : Option β„•) β†’ ((fidx : β„•) β†’ motive (some fidx)) β†’ ((x : Option β„•) β†’ motive x) β†’ motive x
CategoryTheory.ObjectProperty.IsTriangulated.rec
Mathlib.CategoryTheory.Triangulated.Subcategory
{C : Type u_1} β†’ [inst : CategoryTheory.Category.{v_1, u_1} C] β†’ [inst_1 : CategoryTheory.Limits.HasZeroObject C] β†’ [inst_2 : CategoryTheory.HasShift C β„€] β†’ [inst_3 : CategoryTheory.Preadditive C] β†’ [inst_4 : βˆ€ (n : β„€), (CategoryTheory.shiftFunctor C n).Additive] β†’ [inst_5 : CategoryTheory.Pretriangulated C] β†’ {P : CategoryTheory.ObjectProperty C} β†’ {motive : P.IsTriangulated β†’ Sort u} β†’ ([toContainsZero : P.ContainsZero] β†’ [toIsStableUnderShift : P.IsStableUnderShift β„€] β†’ [toIsTriangulatedClosedβ‚‚ : P.IsTriangulatedClosedβ‚‚] β†’ motive β‹―) β†’ (t : P.IsTriangulated) β†’ motive t
Std.Tactic.BVDecide.BVLogicalExpr.eval_ite
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
βˆ€ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {d l r : Std.Tactic.BVDecide.BoolExpr Std.Tactic.BVDecide.BVPred}, Std.Tactic.BVDecide.BVLogicalExpr.eval assign (d.ite l r) = bif Std.Tactic.BVDecide.BVLogicalExpr.eval assign d then Std.Tactic.BVDecide.BVLogicalExpr.eval assign l else Std.Tactic.BVDecide.BVLogicalExpr.eval assign r
TProd.instMeasurableSpace._sunfold
Mathlib.MeasureTheory.MeasurableSpace.Constructions
{Ξ΄ : Type u_4} β†’ (X : Ξ΄ β†’ Type u_6) β†’ [(i : Ξ΄) β†’ MeasurableSpace (X i)] β†’ (l : List Ξ΄) β†’ MeasurableSpace (List.TProd X l)
Set.functorToTypes._proof_4
Mathlib.CategoryTheory.Types.Set
βˆ€ {X : Type u_1} {X_1 Y Z : Set X} (f : X_1 ⟢ Y) (g : Y ⟢ Z), (fun x => match x with | ⟨x, hx⟩ => ⟨x, β‹―βŸ©) = CategoryTheory.CategoryStruct.comp (fun x => match x with | ⟨x, hx⟩ => ⟨x, β‹―βŸ©) fun x => match x with | ⟨x, hx⟩ => ⟨x, β‹―βŸ©
FinBoolAlg._sizeOf_inst
Mathlib.Order.Category.FinBoolAlg
SizeOf FinBoolAlg
Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor.recOn
Mathlib.Tactic.Linarith.Datatypes
{motive : Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor β†’ Sort u} β†’ (t : Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor) β†’ ((toPreprocessorBase : Mathlib.Tactic.Linarith.PreprocessorBase) β†’ (transform : Lean.MVarId β†’ List Lean.Expr β†’ Lean.MetaM (List Mathlib.Tactic.Linarith.Branch)) β†’ motive { toPreprocessorBase := toPreprocessorBase, transform := transform }) β†’ motive t
mdifferentiableWithinAt_congr_set'
Mathlib.Geometry.Manifold.MFDeriv.Basic
βˆ€ {π•œ : Type u_1} [inst : NontriviallyNormedField π•œ] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners π•œ E H} {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E'] [inst_7 : NormedSpace π•œ E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners π•œ E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M β†’ M'} {x : M} {s t : Set M} (y : M), s =αΆ [nhdsWithin x {y}ᢜ] t β†’ (MDifferentiableWithinAt I I' f s x ↔ MDifferentiableWithinAt I I' f t x)
AlgebraicTopology.DoldKan.Ξ“β‚€.Obj.summand
Mathlib.AlgebraicTopology.DoldKan.FunctorGamma
{C : Type u_1} β†’ [inst : CategoryTheory.Category.{v_1, u_1} C] β†’ [inst_1 : CategoryTheory.Preadditive C] β†’ ChainComplex C β„• β†’ (Ξ” : SimplexCategoryα΅’α΅–) β†’ SimplicialObject.Splitting.IndexSet Ξ” β†’ C
Nimber.lt_one_iff_zero
Mathlib.SetTheory.Nimber.Basic
βˆ€ {a : Nimber}, a < 1 ↔ a = 0
MonoidAlgebra.liftNCRingHom._proof_3
Mathlib.Algebra.MonoidAlgebra.Lift
βˆ€ {k : Type u_1} {G : Type u_2} {R : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R] (f : k β†’+* R) (g : G β†’* R), (βˆ€ (x : k) (y : G), Commute (f x) (g y)) β†’ βˆ€ (_a _b : MonoidAlgebra k G), (MonoidAlgebra.liftNC ↑f ⇑g) (_a * _b) = (MonoidAlgebra.liftNC ↑f ⇑g) _a * (MonoidAlgebra.liftNC ↑f ⇑g) _b
FintypeCat.of.sizeOf_spec
Mathlib.CategoryTheory.FintypeCat
βˆ€ (carrier : Type u_1) [str : Fintype carrier], sizeOf { carrier := carrier, str := str } = 1 + sizeOf carrier + sizeOf str
Std.TreeSet.min?_le_of_contains
Std.Data.TreeSet.Lemmas
βˆ€ {Ξ± : Type u} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.TreeSet Ξ± cmp} [inst : Std.TransCmp cmp] {k km : Ξ±} (hc : t.contains k = true), t.min?.get β‹― = km β†’ (cmp km k).isLE = true
OreLocalization.add_assoc
Mathlib.RingTheory.OreLocalization.Basic
βˆ€ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2} [inst_2 : AddMonoid X] [inst_3 : DistribMulAction R X] (x y z : OreLocalization S X), x + y + z = x + (y + z)
Complex.exp_int_mul_two_pi_mul_I
Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
βˆ€ (n : β„€), Complex.exp (↑n * (2 * ↑Real.pi * Complex.I)) = 1
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceR.match_1.eq_4
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) (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) (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_2 : β„•) β†’ (k : Ξ±) β†’ (v : Ξ² k) β†’ (l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ rr = Std.DTreeMap.Internal.Impl.inner size_2 k v l r β†’ (hrb : (Std.DTreeMap.Internal.Impl.inner size rk rv Std.DTreeMap.Internal.Impl.leaf (Std.DTreeMap.Internal.Impl.inner size_2 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_2 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_2 k v l r)) hrb hlr) (h_4 : (size : β„•) β†’ (rk : Ξ±) β†’ (rv : Ξ² rk) β†’ (size_2 : β„•) β†’ (rlk : Ξ±) β†’ (rlv : Ξ² rlk) β†’ (l r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β†’ (hrb : (Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_2 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_2 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_2 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), (match 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 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_2 k v l r), hrb, hlr => h_3 size rk rv rr size_2 k v l r h hrb hlr | Std.DTreeMap.Internal.Impl.inner size rk rv (Std.DTreeMap.Internal.Impl.inner size_2 rlk rlv l r) Std.DTreeMap.Internal.Impl.leaf, hrb, hlr => h_4 size rk rv size_2 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_4 size rk rv size_1 rlk rlv l r hrb hlr
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_3
Mathlib.Data.Int.CardIntervalMod
βˆ€ {Ξ± : Type u_1} [inst : Preorder Ξ±] [inst_1 : LocallyFiniteOrder Ξ±] {a b x : Ξ±}, (x ∈ Finset.Ico a b) = (a ≀ x ∧ x < b)
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMkβ‚„_app_three._proof_1
Mathlib.CategoryTheory.ComposableArrows.Basic
Β¬3 < 4 + 1 β†’ False
_private.Lean.Elab.Extra.0.Lean.Elab.Term.elabForIn.match_1
Lean.Elab.Extra
(motive : Lean.LOption Lean.Expr β†’ Sort u_1) β†’ (__do_lift : Lean.LOption Lean.Expr) β†’ ((inst : Lean.Expr) β†’ motive (Lean.LOption.some inst)) β†’ (Unit β†’ motive Lean.LOption.undef) β†’ (Unit β†’ motive Lean.LOption.none) β†’ motive __do_lift
_private.Lean.PrettyPrinter.Formatter.0.Lean.PrettyPrinter.Formatter.withMaybeTag.match_4
Lean.PrettyPrinter.Formatter
(motive : Option String.Pos.Raw β†’ Sort u_1) β†’ (pos? : Option String.Pos.Raw) β†’ ((p : String.Pos.Raw) β†’ motive (some p)) β†’ ((x : Option String.Pos.Raw) β†’ motive x) β†’ motive pos?
_private.Mathlib.Geometry.Manifold.VectorField.Pullback.0.VectorField.mpullback_zero._simp_1_1
Mathlib.Geometry.Manifold.VectorField.Pullback
βˆ€ {π•œ : 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} {M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSpace H'] {E' : Type u_6} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace π•œ E'] {I' : ModelWithCorners π•œ E' H'} {M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M β†’ M'} {V : (x : M') β†’ TangentSpace I' x}, VectorField.mpullback I I' f V = VectorField.mpullbackWithin I I' f V Set.univ
CategoryTheory.Functor.mapSquare._proof_6
Mathlib.CategoryTheory.Square
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) (X : CategoryTheory.Square C), { τ₁ := F.map (CategoryTheory.CategoryStruct.id X).τ₁, Ο„β‚‚ := F.map (CategoryTheory.CategoryStruct.id X).Ο„β‚‚, τ₃ := F.map (CategoryTheory.CategoryStruct.id X).τ₃, Ο„β‚„ := F.map (CategoryTheory.CategoryStruct.id X).Ο„β‚„, comm₁₂ := β‹―, comm₁₃ := β‹―, commβ‚‚β‚„ := β‹―, comm₃₄ := β‹― } = CategoryTheory.CategoryStruct.id (X.map F)
PartOrdEmb.hasForgetToPartOrd._proof_4
Mathlib.Order.Category.PartOrdEmb
{ obj := fun X => { carrier := ↑X, str := X.str }, map := fun {X Y} f => PartOrd.ofHom ↑(PartOrdEmb.Hom.hom f), map_id := PartOrdEmb.hasForgetToPartOrd._proof_1, map_comp := @PartOrdEmb.hasForgetToPartOrd._proof_2 }.comp (CategoryTheory.forget PartOrd) = { obj := fun X => { carrier := ↑X, str := X.str }, map := fun {X Y} f => PartOrd.ofHom ↑(PartOrdEmb.Hom.hom f), map_id := PartOrdEmb.hasForgetToPartOrd._proof_1, map_comp := @PartOrdEmb.hasForgetToPartOrd._proof_2 }.comp (CategoryTheory.forget PartOrd)
Filter.ker_surjective
Mathlib.Order.Filter.Ker
βˆ€ {Ξ± : Type u_2}, Function.Surjective Filter.ker
MeasureTheory.Lp.smul_neg
Mathlib.MeasureTheory.Function.Holder
βˆ€ {Ξ± : Type u_1} {π•œ : Type u_3} {E : Type u_4} {m : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {p q r : ENNReal} [hpqr : p.HolderTriple q r] [inst : NormedRing π•œ] [inst_1 : NormedAddCommGroup E] [inst_2 : Module π•œ E] [inst_3 : IsBoundedSMul π•œ E] (f : β†₯(MeasureTheory.Lp π•œ p ΞΌ)) (g : β†₯(MeasureTheory.Lp E q ΞΌ)), f β€’ -g = -(f β€’ g)
Lean.Lsp.SymbolTag.deprecated
Lean.Data.Lsp.LanguageFeatures
Lean.Lsp.SymbolTag
Con.subgroup_quotientGroupCon
Mathlib.GroupTheory.QuotientGroup.Defs
βˆ€ {G : Type u_1} [inst : Group G] (H : Subgroup G) [inst_1 : H.Normal], (QuotientGroup.con H).subgroup = H
WeierstrassCurve.map_preΨ₄
Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic
βˆ€ {R : Type r} {S : Type s} [inst : CommRing R] [inst_1 : CommRing S] (W : WeierstrassCurve R) (f : R β†’+* S), (W.map f).preΞ¨β‚„ = Polynomial.map f W.preΞ¨β‚„
nsmulBinRec.go_spec
Mathlib.Algebra.Group.Defs
βˆ€ {M : Type u_2} [inst : AddSemigroup M] [inst_1 : Zero M] (k : β„•) (m n : M), nsmulBinRec.go (k + 1) m n = m + nsmulRec' (k + 1) n
Plausible.Configuration.quiet
Plausible.Testable
Plausible.Configuration β†’ Bool
FixedPoints.instAlgebraSubtypeMemSubfieldSubfield
Mathlib.FieldTheory.Fixed
(M : Type u) β†’ [inst : Monoid M] β†’ (F : Type v) β†’ [inst_1 : Field F] β†’ [inst_2 : MulSemiringAction M F] β†’ Algebra (β†₯(FixedPoints.subfield M F)) F
Std.Internal.List.getValueD_filter_not_contains_of_contains_right
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u} {Ξ² : Type v} [inst : BEq Ξ±] [EquivBEq Ξ±] {l₁ : List ((_ : Ξ±) Γ— Ξ²)} {lβ‚‚ : List Ξ±} {k : Ξ±} {fallback : Ξ²}, Std.Internal.List.DistinctKeys l₁ β†’ lβ‚‚.contains k = true β†’ Std.Internal.List.getValueD k (List.filter (fun p => !lβ‚‚.contains p.fst) l₁) fallback = fallback
Units.map._proof_4
Mathlib.Algebra.Group.Units.Hom
βˆ€ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M β†’* N) (x y : MΛ£), f (x * y).inv * f ↑(x * y) = 1
CategoryTheory.Equivalence.unitIso_hom_app_comp_inverse_map_Ξ·_functor_assoc
Mathlib.CategoryTheory.Monoidal.Functor
βˆ€ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type uβ‚‚} [inst_2 : CategoryTheory.Category.{vβ‚‚, uβ‚‚} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C β‰Œ D) [inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] {Z : C} (h : e.inverse.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit D) ⟢ Z), CategoryTheory.CategoryStruct.comp (e.unitIso.hom.app (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) (CategoryTheory.CategoryStruct.comp (e.inverse.map (CategoryTheory.Functor.OplaxMonoidal.Ξ· e.functor)) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.Ξ΅ e.inverse) h
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.ctorElimType
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
{motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof β†’ Sort u} β†’ β„• β†’ Sort (max 1 u)
Std.DHashMap.getD_eq_fallback
Std.Data.DHashMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.DHashMap Ξ± Ξ²} [inst : LawfulBEq Ξ±] {a : Ξ±} {fallback : Ξ² a}, a βˆ‰ m β†’ m.getD a fallback = fallback
AlgebraicGeometry.PresheafedSpace.isIso_of_components
Mathlib.Geometry.RingedSpace.PresheafedSpace
βˆ€ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟢ Y) [CategoryTheory.IsIso f.base] [CategoryTheory.IsIso f.c], CategoryTheory.IsIso f
Lean.Meta.Grind.SavedState
Lean.Meta.Tactic.Grind.Types
Type
WithLp.toLp_zero
Mathlib.Analysis.Normed.Lp.WithLp
βˆ€ (p : ENNReal) {V : Type u_4} [inst : AddCommGroup V], WithLp.toLp p 0 = 0
HasCompactMulSupport.sup
Mathlib.Topology.Algebra.Order.Support
βˆ€ {X : Type u_1} {M : Type u_2} [inst : TopologicalSpace X] [inst_1 : One M] [inst_2 : SemilatticeSup M] {f g : X β†’ M}, HasCompactMulSupport f β†’ HasCompactMulSupport g β†’ HasCompactMulSupport (f βŠ” g)
IsLUB.exists_between_sub_self'
Mathlib.Algebra.Order.Group.Bounds
βˆ€ {Ξ± : Type u_1} [inst : AddCommGroup Ξ±] [inst_1 : LinearOrder Ξ±] [IsOrderedAddMonoid Ξ±] {s : Set Ξ±} {a Ξ΅ : Ξ±}, IsLUB s a β†’ a βˆ‰ s β†’ 0 < Ξ΅ β†’ βˆƒ b ∈ s, a - Ξ΅ < b ∧ b < a
Mathlib.Tactic.Ring.neg_one_mul
Mathlib.Tactic.Ring.Basic
βˆ€ {R : Type u_2} [inst : CommRing R] {a b : R}, (Int.negOfNat 1).rawCast * a = b β†’ -a = b
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.2101956971._hygCtx._hyg.2
Lean.Elab.DocString
IO Unit
Std.Iterators.IterM.DefaultConsumers.forIn'_eq_forIn'
Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop
βˆ€ {m : Type w β†’ Type w'} {Ξ± Ξ² : Type w} [inst : Std.Iterators.Iterator Ξ± m Ξ²] {n : Type x β†’ Type x'} [inst_1 : Monad n] [LawfulMonad n] {lift : (Ξ³ : Type w) β†’ (Ξ΄ : Type x) β†’ (Ξ³ β†’ n Ξ΄) β†’ m Ξ³ β†’ n Ξ΄} {Ξ³ : Type x} {it : Std.IterM m Ξ²} {init : Ξ³} {P : Ξ² β†’ Prop} {hP : βˆ€ (b : Ξ²), it.IsPlausibleIndirectOutput b β†’ P b} {Q : Ξ² β†’ Prop} {hQ : βˆ€ (b : Ξ²), it.IsPlausibleIndirectOutput b β†’ Q b} (Pl : Ξ² β†’ Ξ³ β†’ ForInStep Ξ³ β†’ Prop) {f : (b : Ξ²) β†’ P b β†’ (c : Ξ³) β†’ n (Subtype (Pl b c))} {g : (b : Ξ²) β†’ Q b β†’ (c : Ξ³) β†’ n (Subtype (Pl b c))}, Std.Iterators.IteratorLoop.WellFounded Ξ± m Pl β†’ (βˆ€ (b : Ξ²) (c : Ξ³) (hPb : P b) (hQb : Q b), f b hPb c = g b hQb c) β†’ Std.Iterators.IterM.DefaultConsumers.forIn' lift Ξ³ Pl it init P hP f = Std.Iterators.IterM.DefaultConsumers.forIn' lift Ξ³ Pl it init Q hQ g
fderiv_tsum_apply
Mathlib.Analysis.Calculus.SmoothSeries
βˆ€ {Ξ± : Type u_1} {π•œ : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField π•œ] [IsRCLikeNormedField π•œ] [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace π•œ E] [inst_4 : NormedAddCommGroup F] [CompleteSpace F] {u : Ξ± β†’ ℝ} [inst_6 : NormedSpace π•œ F] {f : Ξ± β†’ E β†’ F} {xβ‚€ : E}, Summable u β†’ (βˆ€ (n : Ξ±), Differentiable π•œ (f n)) β†’ (βˆ€ (n : Ξ±) (x : E), β€–fderiv π•œ (f n) xβ€– ≀ u n) β†’ (Summable fun n => f n xβ‚€) β†’ βˆ€ (x : E), fderiv π•œ (fun y => βˆ‘' (n : Ξ±), f n y) x = βˆ‘' (n : Ξ±), fderiv π•œ (f n) x
_private.Init.Data.Array.Find.0.Array.idxOf?.eq_1
Init.Data.Array.Find
βˆ€ {Ξ± : Type u} [inst : BEq Ξ±] (xs : Array Ξ±) (v : Ξ±), xs.idxOf? v = Option.map (fun x => ↑x) (xs.finIdxOf? v)
DirectSum.decompose_of_mem_same
Mathlib.Algebra.DirectSum.Decomposition
βˆ€ {ΞΉ : Type u_1} {M : Type u_3} {Οƒ : Type u_4} [inst : DecidableEq ΞΉ] [inst_1 : AddCommMonoid M] [inst_2 : SetLike Οƒ M] [inst_3 : AddSubmonoidClass Οƒ M] (β„³ : ΞΉ β†’ Οƒ) [inst_4 : DirectSum.Decomposition β„³] {x : M} {i : ΞΉ}, x ∈ β„³ i β†’ ↑(((DirectSum.decompose β„³) x) i) = x
CategoryTheory.Functor.Faithful.of_comp_eq
Mathlib.CategoryTheory.Functor.FullyFaithful
βˆ€ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [β„‹ : H.Faithful], F.comp G = H β†’ F.Faithful
Lean.indentExpr
Lean.Message
Lean.Expr β†’ Lean.MessageData
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence._proof_1
Mathlib.CategoryTheory.Comma.Over.Basic
βˆ€ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T) (a a_1 : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X) (a_2 : a ⟢ a_1), CategoryTheory.CategoryStruct.comp a_2 (CategoryTheory.CategoryStruct.id a_1) = CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse F Y X).map ((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).map a_2))
CompHausLike.instHasPropSigma
Mathlib.Topology.Category.CompHausLike.SigmaComparison
βˆ€ {P : TopCat β†’ Prop} [CompHausLike.HasExplicitFiniteCoproducts P] {Ξ± : Type u} [Finite Ξ±] (Οƒ : Ξ± β†’ Type u) [inst : (a : Ξ±) β†’ TopologicalSpace (Οƒ a)] [βˆ€ (a : Ξ±), CompactSpace (Οƒ a)] [βˆ€ (a : Ξ±), T2Space (Οƒ a)] [βˆ€ (a : Ξ±), CompHausLike.HasProp P (Οƒ a)], CompHausLike.HasProp P ((a : Ξ±) Γ— Οƒ a)
CategoryTheory.Limits.IsColimit.mono_ΞΉ_app_of_isFiltered
Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Colim
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} J] {X : CategoryTheory.Functor J C} [βˆ€ (j j' : J) (Ο† : j ⟢ j'), CategoryTheory.Mono (X.map Ο†)] {c : CategoryTheory.Limits.Cocone X} (hc : CategoryTheory.Limits.IsColimit c) [CategoryTheory.IsFiltered J] (jβ‚€ : J) [inst_4 : CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Under jβ‚€) C] [CategoryTheory.Limits.colim.PreservesMonomorphisms], CategoryTheory.Mono (c.ΞΉ.app jβ‚€)
GaloisInsertion.recOn
Mathlib.Order.GaloisConnection.Defs
{Ξ± : Type u_2} β†’ {Ξ² : Type u_3} β†’ [inst : Preorder Ξ±] β†’ [inst_1 : Preorder Ξ²] β†’ {l : Ξ± β†’ Ξ²} β†’ {u : Ξ² β†’ Ξ±} β†’ {motive : GaloisInsertion l u β†’ Sort u} β†’ (t : GaloisInsertion l u) β†’ ((choice : (x : Ξ±) β†’ u (l x) ≀ x β†’ Ξ²) β†’ (gc : GaloisConnection l u) β†’ (le_l_u : βˆ€ (x : Ξ²), x ≀ l (u x)) β†’ (choice_eq : βˆ€ (a : Ξ±) (h : u (l a) ≀ a), choice a h = l a) β†’ motive { choice := choice, gc := gc, le_l_u := le_l_u, choice_eq := choice_eq }) β†’ motive t
_private.Lean.ErrorExplanation.0.Lean.ErrorExplanation.parseExplanation.match_5
Lean.ErrorExplanation
(motive : β„• Γ— String.Slice β†’ Sort u_1) β†’ (__discr : β„• Γ— String.Slice) β†’ ((fst : β„•) β†’ (closing : String.Slice) β†’ motive (fst, closing)) β†’ motive __discr
CochainComplex.mkAux._proof_2
Mathlib.Algebra.Homology.HomologicalComplex
βˆ€ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (Xβ‚€ X₁ Xβ‚‚ : V) (dβ‚€ : Xβ‚€ ⟢ X₁) (d₁ : X₁ ⟢ Xβ‚‚) (s : CategoryTheory.CategoryStruct.comp dβ‚€ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) β†’ (Xβ‚„ : V) Γ—' (dβ‚‚ : S.X₃ ⟢ Xβ‚„) Γ—' CategoryTheory.CategoryStruct.comp S.g dβ‚‚ = 0) (n : β„•), CategoryTheory.CategoryStruct.comp (CochainComplex.mkAux Xβ‚€ X₁ Xβ‚‚ dβ‚€ d₁ s succ n).g (succ (CochainComplex.mkAux Xβ‚€ X₁ Xβ‚‚ dβ‚€ d₁ s succ n)).snd.fst = 0
_private.Mathlib.MeasureTheory.Function.AEMeasurableSequence.0.aeSeq.measure_compl_aeSeqSet_eq_zero._simp_1_3
Mathlib.MeasureTheory.Function.AEMeasurableSequence
βˆ€ {Ξ± : Type u_1} {F : Type u_3} [inst : FunLike F (Set Ξ±) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F Ξ±] {ΞΌ : F} {ΞΉ : Sort u_4} [Countable ΞΉ] {p : Ξ± β†’ ΞΉ β†’ Prop}, (βˆ€ (i : ΞΉ), βˆ€α΅ (a : Ξ±) βˆ‚ΞΌ, p a i) = βˆ€α΅ (a : Ξ±) βˆ‚ΞΌ, βˆ€ (i : ΞΉ), p a i
PseudoEmetricSpace.ofRiemannianMetric._proof_3
Mathlib.Geometry.Manifold.Riemannian.Basic
βˆ€ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_3} [inst_2 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) (M : Type u_1) [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] [inst_5 : IsManifold I 1 M], VectorBundle ℝ E (TangentSpace I)
MeasureTheory.NullMeasurableSet.diff._simp_1
Mathlib.MeasureTheory.Measure.NullMeasurable
βˆ€ {Ξ± : Type u_2} {m0 : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {s t : Set Ξ±}, MeasureTheory.NullMeasurableSet s ΞΌ β†’ MeasureTheory.NullMeasurableSet t ΞΌ β†’ MeasureTheory.NullMeasurableSet (s \ t) ΞΌ = True
ProbabilityTheory.condIndepFun_self_right
Mathlib.Probability.Independence.Conditional
βˆ€ {Ξ© : Type u_1} {Ξ² : Type u_3} {Ξ²' : Type u_4} {mΞ© : MeasurableSpace Ξ©} [inst : StandardBorelSpace Ξ©] {ΞΌ : MeasureTheory.Measure Ξ©} [inst_1 : MeasureTheory.IsFiniteMeasure ΞΌ] {mΞ² : MeasurableSpace Ξ²} {mΞ²' : MeasurableSpace Ξ²'} {X : Ξ© β†’ Ξ²} {Z : Ξ© β†’ Ξ²'}, Measurable X β†’ βˆ€ (hZ : Measurable Z), ProbabilityTheory.CondIndepFun (MeasurableSpace.comap Z inferInstance) β‹― X Z ΞΌ
Int.add_one_tdiv_of_pos
Init.Data.Int.DivMod.Lemmas
βˆ€ {a b : β„€}, 0 < b β†’ (a + 1).tdiv b = a.tdiv b + if 0 < a + 1 ∧ b ∣ a + 1 ∨ a < 0 ∧ b ∣ a then 1 else 0
Qq.Impl.stripDollars
Qq.Macro
Lean.Name β†’ Lean.Name
AlgEquiv.aut._proof_10
Mathlib.Algebra.Algebra.Equiv
βˆ€ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁] (Ο• : A₁ ≃ₐ[R] A₁), Ο•.symm * Ο• = 1
_private.Init.Data.List.Find.0.List.findIdx_lt_length_of_exists._simp_1_2
Init.Data.List.Find
βˆ€ {a b c : Prop}, (a ∧ b β†’ c) = (a β†’ b β†’ c)
CategoryTheory.Enriched.FunctorCategory.homEquiv._proof_7
Mathlib.CategoryTheory.Enriched.FunctorCategory
βˆ€ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_3 : CategoryTheory.Category.{u_4, u_1} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {F₁ Fβ‚‚ : CategoryTheory.Functor J C} [inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ Fβ‚‚] (Ο„ : F₁ ⟢ Fβ‚‚), { app := fun j => (CategoryTheory.eHomEquiv V).symm (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.end_.lift (fun j => (CategoryTheory.eHomEquiv V) (Ο„.app j)) β‹―) (CategoryTheory.Limits.end_.Ο€ (CategoryTheory.Enriched.FunctorCategory.diagram V F₁ Fβ‚‚) j)), naturality := β‹― } = Ο„
SummationFilter.tprod_symmetricIcc_eq_tprod_symmetricIco
Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt
βˆ€ {Ξ± : Type u_1} {f : β„€ β†’ Ξ±} [inst : CommGroup Ξ±] [inst_1 : TopologicalSpace Ξ±] [ContinuousMul Ξ±] [T2Space Ξ±], Multipliable f (SummationFilter.symmetricIcc β„€) β†’ Filter.Tendsto (fun N => (f ↑N)⁻¹) Filter.atTop (nhds 1) β†’ ∏'[SummationFilter.symmetricIco β„€] (b : β„€), f b = ∏'[SummationFilter.symmetricIcc β„€] (b : β„€), f b
Std.DTreeMap.Internal.Impl.minKeyD_insert_le_self
Std.Data.DTreeMap.Internal.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [Std.TransOrd Ξ±] (h : t.WF) {k : Ξ±} {v : Ξ² k} {fallback : Ξ±}, (compare ((Std.DTreeMap.Internal.Impl.insert k v t β‹―).impl.minKeyD fallback) k).isLE = true
eventually_le_nhds
Mathlib.Topology.Order.OrderClosed
βˆ€ {Ξ± : Type u} [inst : TopologicalSpace Ξ±] [inst_1 : LinearOrder Ξ±] [ClosedIciTopology Ξ±] {a b : Ξ±}, a < b β†’ βˆ€αΆ  (x : Ξ±) in nhds a, x ≀ b
IsArtinianRing.quotNilradicalEquivPi._proof_1
Mathlib.RingTheory.Artinian.Module
βˆ€ (R : Type u_1) [inst : CommRing R] [IsArtinianRing R] (x : R), x ∈ nilradical R ↔ x ∈ β¨… i, i.asIdeal
BoundedGENhdsClass.mk
Mathlib.Topology.Order.LiminfLimsup
βˆ€ {Ξ± : Type u_7} [inst : Preorder Ξ±] [inst_1 : TopologicalSpace Ξ±], (βˆ€ (a : Ξ±), Filter.IsBounded (fun x1 x2 => x1 β‰₯ x2) (nhds a)) β†’ BoundedGENhdsClass Ξ±
AlgebraicGeometry.Scheme.instOverXPullbackCoverOverProp'
Mathlib.AlgebraicGeometry.Cover.Over
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} β†’ (S : AlgebraicGeometry.Scheme) β†’ [inst : P.IsStableUnderBaseChange] β†’ [inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] β†’ {X W : AlgebraicGeometry.Scheme} β†’ (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) β†’ (f : W ⟢ X) β†’ [inst_2 : W.Over S] β†’ [inst_3 : X.Over S] β†’ [inst_4 : AlgebraicGeometry.Scheme.Cover.Over S 𝒰] β†’ [inst_5 : AlgebraicGeometry.Scheme.Hom.IsOver f S] β†’ {Q : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} β†’ [inst_6 : Q.HasOfPostcompProperty Q] β†’ [inst_7 : Q.IsStableUnderBaseChange] β†’ [inst_8 : Q.IsStableUnderComposition] β†’ (hX : Q (X β†˜ S)) β†’ (hW : Q (W β†˜ S)) β†’ (hQ : βˆ€ (j : 𝒰.Iβ‚€), Q (𝒰.X j β†˜ S)) β†’ (j : 𝒰.Iβ‚€) β†’ ((AlgebraicGeometry.Scheme.Cover.pullbackCoverOverProp' S 𝒰 f hX hW hQ).X j).Over S
_private.Mathlib.Order.WithBot.0.WithBot.le_of_forall_lt_iff_le._simp_1_1
Mathlib.Order.WithBot
βˆ€ {Ξ± : Type u_3} {inst : LT Ξ±} [self : NoMinOrder Ξ±] (a : Ξ±), (βˆƒ b, b < a) = True
sdiff_sdiff_sdiff_cancel_right
Mathlib.Order.BooleanAlgebra.Basic
βˆ€ {Ξ± : Type u} {x y z : Ξ±} [inst : GeneralizedBooleanAlgebra Ξ±], z ≀ y β†’ (x \ z) \ (y \ z) = x \ y
Lean.Meta.Grind.Arith.Linear.ProofM.State.mk._flat_ctor
Lean.Meta.Tactic.Grind.Arith.Linear.Proof
Std.HashMap UInt64 Lean.Expr β†’ Std.HashMap Lean.Grind.Linarith.Var Lean.Expr β†’ Std.HashMap Lean.Grind.Linarith.Poly Lean.Expr β†’ Std.HashMap Lean.Meta.Grind.Arith.Linear.LinExpr Lean.Expr β†’ Std.HashMap Lean.Grind.CommRing.Poly Lean.Expr β†’ Std.HashMap Lean.Meta.Grind.Arith.CommRing.RingExpr Lean.Expr β†’ Std.HashMap Lean.Grind.Linarith.Var Lean.Expr β†’ Lean.Meta.Grind.Arith.Linear.ProofM.State
trdeg_add_eq
Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis
βˆ€ (R : Type u_1) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Nontrivial R] {A : Type v} [inst_4 : CommRing A] [NoZeroDivisors A] [inst_6 : Algebra R A] [inst_7 : Algebra S A] [FaithfulSMul R S] [FaithfulSMul S A] [IsScalarTower R S A], Algebra.trdeg R S + Algebra.trdeg S A = Algebra.trdeg R A
Std.Internal.List.containsKey_filter_not_contains_iff
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} [inst : BEq Ξ±] [EquivBEq Ξ±] {l₁ : List ((a : Ξ±) Γ— Ξ² a)} {lβ‚‚ : List Ξ±} {hl₁ : Std.Internal.List.DistinctKeys l₁} {k : Ξ±}, Std.Internal.List.containsKey k (List.filter (fun p => !lβ‚‚.contains p.fst) l₁) = true ↔ Std.Internal.List.containsKey k l₁ = true ∧ Β¬lβ‚‚.contains k = true
Lean.Core.CoreM.asTask'
Lean.Elab.Task
{Ξ± : Type} β†’ Lean.CoreM Ξ± β†’ Lean.CoreM (Task (Lean.CoreM Ξ±))
Std.Time.Format.parse
Std.Time.Format.Basic
{f : Type} β†’ {typ : Type β†’ f β†’ Type} β†’ [self : Std.Time.Format f typ] β†’ {Ξ± : Type} β†’ (fmt : f) β†’ typ (Option Ξ±) fmt β†’ String β†’ Except String Ξ±
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.sigma_eq_iff_eq_comp_cast.match_1_1
Mathlib.Data.Fin.Tuple.Basic
βˆ€ {Ξ± : Type u_1} {a b : (ii : β„•) Γ— (Fin ii β†’ Ξ±)} (motive : (βˆƒ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h) β†’ Prop) (x : βˆƒ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h), (βˆ€ (w : a.fst = b.fst) (h' : a.snd = b.snd ∘ Fin.cast w), motive β‹―) β†’ motive x
Lean.Meta.mkImpCongr
Lean.Meta.AppBuilder
Lean.Expr β†’ Lean.Expr β†’ Lean.MetaM Lean.Expr
Polynomial.instNatCast
Mathlib.Algebra.Polynomial.Basic
{R : Type u} β†’ [inst : Semiring R] β†’ NatCast (Polynomial R)
Equiv.symm_bijective
Mathlib.Logic.Equiv.Defs
βˆ€ {Ξ± : Sort u} {Ξ² : Sort v}, Function.Bijective Equiv.symm
CategoryTheory.Limits.MonoCoprod.isColimitBinaryCofanSum._proof_2
Mathlib.CategoryTheory.Limits.MonoCoprod
βˆ€ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I₁ : Type u_3} {Iβ‚‚ : Type u_4} {X : I₁ βŠ• Iβ‚‚ β†’ C} (c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl)) (cβ‚‚ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c) (hc₁ : CategoryTheory.Limits.IsColimit c₁) (hcβ‚‚ : CategoryTheory.Limits.IsColimit cβ‚‚) {T : C} (f₁ : c₁.pt ⟢ T) (fβ‚‚ : cβ‚‚.pt ⟢ T), CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.MonoCoprod.binaryCofanSum c c₁ cβ‚‚ hc₁ hcβ‚‚).inr (CategoryTheory.Limits.Cofan.IsColimit.desc hc fun i => match i with | Sum.inl i₁ => CategoryTheory.CategoryStruct.comp (c₁.inj i₁) f₁ | Sum.inr iβ‚‚ => CategoryTheory.CategoryStruct.comp (cβ‚‚.inj iβ‚‚) fβ‚‚) = fβ‚‚
Nat.toList_roc_eq_if
Init.Data.Range.Polymorphic.NatLemmas
βˆ€ {m n : β„•}, (m<...=n).toList = if m + 1 ≀ n then (m + 1) :: ((m + 1)<...=n).toList else []
AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.mk._flat_ctor
Mathlib.AlgebraicGeometry.Morphisms.Basic
βˆ€ {P : AlgebraicGeometry.AffineTargetMorphismProperty}, P.toProperty.RespectsIso β†’ (βˆ€ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine Y] (f : X ⟢ Y) (r : ↑(Y.presheaf.obj (Opposite.op ⊀))), P f β†’ P (f ∣_ Y.basicOpen r)) β†’ (βˆ€ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine Y] (f : X ⟢ Y) (s : Finset ↑(Y.presheaf.obj (Opposite.op ⊀))), Ideal.span ↑s = ⊀ β†’ (βˆ€ (r : β†₯s), P (f ∣_ Y.basicOpen ↑r)) β†’ P f) β†’ P.IsLocal
FirstOrder.Language.LHom.casesOn
Mathlib.ModelTheory.LanguageMap
{L : FirstOrder.Language} β†’ {L' : FirstOrder.Language} β†’ {motive : (L β†’α΄Έ L') β†’ Sort u_1} β†’ (t : L β†’α΄Έ L') β†’ ((onFunction : ⦃n : ℕ⦄ β†’ L.Functions n β†’ L'.Functions n) β†’ (onRelation : ⦃n : ℕ⦄ β†’ L.Relations n β†’ L'.Relations n) β†’ motive { onFunction := onFunction, onRelation := onRelation }) β†’ motive t
hasFPowerSeriesOnBall_pi_iff
Mathlib.Analysis.Analytic.Constructions
βˆ€ {π•œ : Type u_2} [inst : NontriviallyNormedField π•œ] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] {ΞΉ : Type u_9} [inst_3 : Fintype ΞΉ] {e : E} {Fm : ΞΉ β†’ Type u_10} [inst_4 : (i : ΞΉ) β†’ NormedAddCommGroup (Fm i)] [inst_5 : (i : ΞΉ) β†’ NormedSpace π•œ (Fm i)] {f : (i : ΞΉ) β†’ E β†’ Fm i} {r : ENNReal} {p : (i : ΞΉ) β†’ FormalMultilinearSeries π•œ E (Fm i)}, 0 < r β†’ (HasFPowerSeriesOnBall (fun x x_1 => f x_1 x) (FormalMultilinearSeries.pi p) e r ↔ βˆ€ (i : ΞΉ), HasFPowerSeriesOnBall (f i) (p i) e r)
Module.comap_annihilator
Mathlib.RingTheory.Ideal.Maps
βˆ€ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {Rβ‚€ : Type u_4} [inst_3 : CommSemiring Rβ‚€] [inst_4 : Module Rβ‚€ M] [inst_5 : Algebra Rβ‚€ R] [IsScalarTower Rβ‚€ R M], Ideal.comap (algebraMap Rβ‚€ R) (Module.annihilator R M) = Module.annihilator Rβ‚€ M
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Visibility.mk
Lean.Compiler.IR.LLVMBindings
UInt64 β†’ LLVM.Visibility
Lean.Elab.Tactic.Doc.TacticDoc.docString
Lean.Elab.Tactic.Doc
Lean.Elab.Tactic.Doc.TacticDoc β†’ Option String
Set.mul_sInter_subset
Mathlib.Algebra.Group.Pointwise.Set.Lattice
βˆ€ {Ξ± : Type u_2} [inst : Mul Ξ±] (s : Set Ξ±) (T : Set (Set Ξ±)), s * β‹‚β‚€ T βŠ† β‹‚ t ∈ T, s * t
Lean.ConstantKind.ctor.elim
Lean.Environment
{motive : Lean.ConstantKind β†’ Sort u} β†’ (t : Lean.ConstantKind) β†’ t.ctorIdx = 6 β†’ motive Lean.ConstantKind.ctor β†’ motive t
IsDedekindDomain.HeightOneSpectrum.intValuation_le_pow_iff_dvd
Mathlib.RingTheory.DedekindDomain.AdicValuation
βˆ€ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R) (n : β„•), v.intValuation r ≀ WithZero.exp (-↑n) ↔ v.asIdeal ^ n ∣ Ideal.span {r}