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
AddSubmonoid.matrix._proof_1
Mathlib.Data.Matrix.Basic
βˆ€ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : AddMonoid A] (S : AddSubmonoid A) {a b : Matrix m n A}, a ∈ (↑S).matrix β†’ b ∈ (↑S).matrix β†’ βˆ€ (i : m) (j : n), a i j + b i j ∈ S
CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero_hom_app_hom₃
Mathlib.CategoryTheory.Triangulated.TriangleShift
βˆ€ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] [inst_2 : CategoryTheory.HasShift C β„€] (X : CategoryTheory.Pretriangulated.Triangle C), ((CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero C).hom.app X).hom₃ = (CategoryTheory.shiftFunctorZero C β„€).hom.app X.obj₃
IsCyclotomicExtension.Rat.ramificationIdxIn_eq
Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal
βˆ€ (n : β„•) {m p k : β„•} [hp : Fact (Nat.Prime p)] (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] [IsCyclotomicExtension {n} β„š K], n = p ^ (k + 1) * m β†’ Β¬p ∣ m β†’ (Ideal.span {↑p}).ramificationIdxIn (NumberField.RingOfIntegers K) = p ^ k * (p - 1)
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Option.map_dmap
Std.Data.Internal.List.Associative
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} (x : Option Ξ±) (f : (a : Ξ±) β†’ x = some a β†’ Ξ²) (g : Ξ² β†’ Ξ³), Option.map g (Std.Internal.List.Option.dmap✝ x f) = Std.Internal.List.Option.dmap✝¹ x fun a h => g (f a h)
Lean.Grind.CommRing.Mon.beq'
Init.Grind.Ring.CommSolver
Lean.Grind.CommRing.Mon β†’ Lean.Grind.CommRing.Mon β†’ Bool
Polynomial.natDegree_multiset_prod_of_monic
Mathlib.Algebra.Polynomial.BigOperators
βˆ€ {R : Type u} [inst : CommSemiring R] (t : Multiset (Polynomial R)), (βˆ€ f ∈ t, f.Monic) β†’ t.prod.natDegree = (Multiset.map Polynomial.natDegree t).sum
CategoryTheory.Bicategory.rightUnitor_comp_inv
Mathlib.CategoryTheory.Bicategory.Basic
βˆ€ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟢ b) (g : b ⟢ c), (CategoryTheory.Bicategory.rightUnitor (CategoryTheory.CategoryStruct.comp f g)).inv = CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.rightUnitor g).inv) (CategoryTheory.Bicategory.associator f g (CategoryTheory.CategoryStruct.id c)).inv
ISize.toBitVec_or
Init.Data.SInt.Bitwise
βˆ€ (a b : ISize), (a ||| b).toBitVec = a.toBitVec ||| b.toBitVec
Mathlib.Tactic.BicategoryLike.HorizontalComp.cons.sizeOf_spec
Mathlib.Tactic.CategoryTheory.Coherence.Normalize
βˆ€ (e : Mathlib.Tactic.BicategoryLike.Morβ‚‚) (Ξ· : Mathlib.Tactic.BicategoryLike.WhiskerRight) (Ξ·s : Mathlib.Tactic.BicategoryLike.HorizontalComp), sizeOf (Mathlib.Tactic.BicategoryLike.HorizontalComp.cons e Ξ· Ξ·s) = 1 + sizeOf e + sizeOf Ξ· + sizeOf Ξ·s
Std.DTreeMap.Raw.instInhabited
Std.Data.DTreeMap.Raw.Basic
{Ξ± : Type u} β†’ {Ξ² : Ξ± β†’ Type v} β†’ {cmp : Ξ± β†’ Ξ± β†’ Ordering} β†’ Inhabited (Std.DTreeMap.Raw Ξ± Ξ² cmp)
AlgCat.instCategory._proof_1
Mathlib.Algebra.Category.AlgCat.Basic
βˆ€ (R : Type u_2) [inst : CommRing R] {X Y : AlgCat R} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := AlgHom.id R ↑X }.hom' } = f
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor._proof_14
Mathlib.CategoryTheory.Monoidal.Action.End
βˆ€ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] (c : C) {c' c'' : C} (f : c' ⟢ c'') (d : D), (F.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f)).app d = CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.OplaxMonoidal.Ξ΄ F c c').app d) (CategoryTheory.CategoryStruct.comp ((F.map f).app ((F.obj c).obj d)) ((CategoryTheory.Functor.LaxMonoidal.ΞΌ F c c'').app d))
ContinuousMonoidHom.compLeft._proof_1
Mathlib.Topology.Algebra.Group.CompactOpen
βˆ€ {A : Type u_1} {B : Type u_3} (E : Type u_2) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : CommGroup E] [inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace E] [inst_6 : IsTopologicalGroup E] (f : A β†’β‚œ* B), ContinuousMonoidHom.comp 1 f = ContinuousMonoidHom.comp 1 f
Finsupp.Lex.wellFounded
Mathlib.Data.Finsupp.WellFounded
βˆ€ {Ξ± : Type u_1} {N : Type u_2} [inst : Zero N] {r : Ξ± β†’ Ξ± β†’ Prop} {s : N β†’ N β†’ Prop}, (βˆ€ ⦃n : N⦄, Β¬s n 0) β†’ WellFounded s β†’ WellFounded (rᢜ βŠ“ fun x1 x2 => x1 β‰  x2) β†’ WellFounded (Finsupp.Lex r s)
Lean.Elab.Tactic.Conv.evalUnfold
Lean.Elab.Tactic.Conv.Unfold
Lean.Elab.Tactic.Tactic
ENNReal.add_lt_add_iff_right
Mathlib.Data.ENNReal.Operations
βˆ€ {a b c : ENNReal}, a β‰  ⊀ β†’ (b + a < c + a ↔ b < c)
PSigma.Lex.orderTop._proof_1
Mathlib.Data.PSigma.Order
βˆ€ {ΞΉ : Type u_1} {Ξ± : ΞΉ β†’ Type u_2} [inst : PartialOrder ΞΉ] [inst_1 : OrderTop ΞΉ] [inst_2 : (i : ΞΉ) β†’ Preorder (Ξ± i)] [inst_3 : OrderTop (Ξ± ⊀)] (a : ΞΉ) (b : Ξ± a), ⟨a, b⟩ ≀ ⟨⊀, ⊀⟩
Std.DTreeMap.Internal.Unit.RioSliceData._sizeOf_inst
Std.Data.DTreeMap.Internal.Zipper
(Ξ± : Type u) β†’ {inst : Ord Ξ±} β†’ [SizeOf Ξ±] β†’ SizeOf (Std.DTreeMap.Internal.Unit.RioSliceData Ξ±)
Std.ExtDTreeMap.maxKeyD_le
Std.Data.ExtDTreeMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {cmp : Ξ± β†’ Ξ± β†’ Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp], t β‰  βˆ… β†’ βˆ€ {k fallback : Ξ±}, (cmp (t.maxKeyD fallback) k).isLE = true ↔ βˆ€ k' ∈ t, (cmp k' k).isLE = true
Set.subset_symmDiff_union_symmDiff_left
Mathlib.Data.Set.SymmDiff
βˆ€ {Ξ± : Type u} {s t u : Set Ξ±}, Disjoint s t β†’ u βŠ† symmDiff s u βˆͺ symmDiff t u
HomologicalComplex.extend.d_eq
Mathlib.Algebra.Homology.Embedding.Extend
βˆ€ {ΞΉ : Type u_1} {c : ComplexShape ΞΉ} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) {i j : Option ΞΉ} {a b : ΞΉ} (hi : i = some a) (hj : j = some b), HomologicalComplex.extend.d K i j = CategoryTheory.CategoryStruct.comp (HomologicalComplex.extend.XIso K hi).hom (CategoryTheory.CategoryStruct.comp (K.d a b) (HomologicalComplex.extend.XIso K hj).inv)
ContinuousMap.tendsto_iff_tendstoLocallyUniformly
Mathlib.Topology.UniformSpace.CompactConvergence
βˆ€ {Ξ± : Type u₁} {Ξ² : Type uβ‚‚} [inst : TopologicalSpace Ξ±] [inst_1 : UniformSpace Ξ²] {f : C(Ξ±, Ξ²)} {ΞΉ : Type u₃} {p : Filter ΞΉ} {F : ΞΉ β†’ C(Ξ±, Ξ²)} [WeaklyLocallyCompactSpace Ξ±], Filter.Tendsto F p (nhds f) ↔ TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p
CompletelyRegularSpace.mk
Mathlib.Topology.Separation.CompletelyRegular
βˆ€ {X : Type u} [inst : TopologicalSpace X], (βˆ€ (x : X) (K : Set X), IsClosed K β†’ x βˆ‰ K β†’ βˆƒ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K) β†’ CompletelyRegularSpace X
BitVec.carry_extractLsb'_eq_carry
Init.Data.BitVec.Bitblast
βˆ€ {w i len : β„•}, i < len β†’ βˆ€ {x y : BitVec w} {b : Bool}, BitVec.carry i (BitVec.extractLsb' 0 len x) (BitVec.extractLsb' 0 len y) b = BitVec.carry i x y b
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_2
Mathlib.CategoryTheory.Bicategory.InducedBicategory
βˆ€ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B β†’ C} {a b c : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟢ b) (g : b ⟢ c), CategoryTheory.Bicategory.InducedBicategory.mkHomβ‚‚ (CategoryTheory.Bicategory.whiskerLeft f.hom (CategoryTheory.CategoryStruct.id g).hom) = CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g)
Flag.ofIsMaxChain._proof_2
Mathlib.Order.Preorder.Chain
βˆ€ {Ξ± : Type u_1} [inst : LE Ξ±] (c : Set Ξ±), IsMaxChain (fun x1 x2 => x1 ≀ x2) c β†’ βˆ€ ⦃t : Set α⦄, IsChain (fun x1 x2 => x1 ≀ x2) t β†’ c βŠ† t β†’ c = t
Mathlib.Tactic.IntervalCases.Bound._sizeOf_1
Mathlib.Tactic.IntervalCases
Mathlib.Tactic.IntervalCases.Bound β†’ β„•
TopCommRingCat.isCommRing
Mathlib.Topology.Category.TopCommRingCat
(self : TopCommRingCat) β†’ CommRing self.Ξ±
mulActionSphereClosedBall._proof_2
Mathlib.Analysis.Normed.Module.Ball.Action
βˆ€ {π•œ : Type u_2} {E : Type u_1} [inst : NormedField π•œ] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace π•œ E] {r : ℝ} (x : ↑(Metric.closedBall 0 r)), 1 β€’ x = x
Submonoid.map.congr_simp
Mathlib.Algebra.Group.Submonoid.Operations
βˆ€ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N] [mc : MonoidHomClass F M N] (f f_1 : F), f = f_1 β†’ βˆ€ (S S_1 : Submonoid M), S = S_1 β†’ Submonoid.map f S = Submonoid.map f_1 S_1
Std.Iterators.Iter.allM
Init.Data.Iterators.Consumers.Loop
{Ξ± Ξ² : Type w} β†’ {m : Type β†’ Type w'} β†’ [Monad m] β†’ [inst : Std.Iterators.Iterator Ξ± Id Ξ²] β†’ [Std.Iterators.IteratorLoop Ξ± Id m] β†’ (Ξ² β†’ m Bool) β†’ Std.Iter Ξ² β†’ m Bool
CategoryTheory.Limits.idZeroEquivIsoZero_apply_hom
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
βˆ€ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C) (h : CategoryTheory.CategoryStruct.id X = 0), ((CategoryTheory.Limits.idZeroEquivIsoZero X) h).hom = 0
divisionRingOfFiniteDimensional._proof_15
Mathlib.LinearAlgebra.FiniteDimensional.Basic
βˆ€ (F : Type u_2) (K : Type u_1) [inst : Field F] [inst_1 : Ring K] [inst_2 : IsDomain K] [inst_3 : Algebra F K] [inst_4 : FiniteDimensional F K], (if H : 0 = 0 then 0 else Classical.choose β‹―) = 0
CentroidHom.instFunLike._proof_1
Mathlib.Algebra.Ring.CentroidHom
βˆ€ {Ξ± : Type u_1} [inst : NonUnitalNonAssocSemiring Ξ±] (f g : CentroidHom Ξ±), (fun f => (↑f.toAddMonoidHom).toFun) f = (fun f => (↑f.toAddMonoidHom).toFun) g β†’ f = g
CommGroupWithZero.ctorIdx
Mathlib.Algebra.GroupWithZero.Defs
{Gβ‚€ : Type u_2} β†’ CommGroupWithZero Gβ‚€ β†’ β„•
HomologicalComplex.units_smul_f_apply
Mathlib.Algebra.Homology.Linear
βˆ€ {R : Type u_1} [inst : Semiring R] {C : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} C] [inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {ΞΉ : Type u_4} {c : ComplexShape ΞΉ} {X Y : HomologicalComplex C c} (r : RΛ£) (f : X ⟢ Y) (n : ΞΉ), (r β€’ f).f n = r β€’ f.f n
CategoryTheory.Limits.IsImage.lift
Mathlib.CategoryTheory.Limits.Shapes.Images
{C : Type u} β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ {X Y : C} β†’ {f : X ⟢ Y} β†’ {F : CategoryTheory.Limits.MonoFactorisation f} β†’ CategoryTheory.Limits.IsImage F β†’ (F' : CategoryTheory.Limits.MonoFactorisation f) β†’ F.I ⟢ F'.I
Std.Sat.AIG.Entrypoint.ctorIdx
Std.Sat.AIG.Basic
{Ξ± : Type} β†’ {inst : DecidableEq Ξ±} β†’ {inst_1 : Hashable Ξ±} β†’ Std.Sat.AIG.Entrypoint Ξ± β†’ β„•
Lean.Unhygienic.Context.mk.inj
Lean.Hygiene
βˆ€ {ref : Lean.Syntax} {scope : Lean.MacroScope} {ref_1 : Lean.Syntax} {scope_1 : Lean.MacroScope}, { ref := ref, scope := scope } = { ref := ref_1, scope := scope_1 } β†’ ref = ref_1 ∧ scope = scope_1
Std.DHashMap.insert_eq_insert
Std.Data.DHashMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.DHashMap Ξ± Ξ²} {p : (a : Ξ±) Γ— Ξ² a}, insert p m = m.insert p.fst p.snd
Std.DHashMap.Equiv.symm
Std.Data.DHashMap.Lemmas
βˆ€ {Ξ± : Type u} {Ξ² : Ξ± β†’ Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m₁ mβ‚‚ : Std.DHashMap Ξ± Ξ²}, m₁.Equiv mβ‚‚ β†’ mβ‚‚.Equiv m₁
UInt8.toFin_inj
Init.Data.UInt.Lemmas
βˆ€ {a b : UInt8}, a.toFin = b.toFin ↔ a = b
Set.encard_exchange'
Mathlib.Data.Set.Card
βˆ€ {Ξ± : Type u_1} {s : Set Ξ±} {a b : Ξ±}, a βˆ‰ s β†’ b ∈ s β†’ (insert a s \ {b}).encard = s.encard
_private.Init.Data.FloatArray.Basic.0.FloatArray.forIn.loop._proof_3
Init.Data.FloatArray.Basic
βˆ€ (as : FloatArray) (i : β„•), as.size - 1 < as.size β†’ as.size - 1 - i < as.size
Matrix.self_mul_conjTranspose_mulVec_eq_zero
Mathlib.LinearAlgebra.Matrix.DotProduct
βˆ€ {m : Type u_1} {n : Type u_2} {R : Type u_4} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : PartialOrder R] [inst_3 : NonUnitalRing R] [inst_4 : StarRing R] [StarOrderedRing R] [NoZeroDivisors R] (A : Matrix m n R) (v : m β†’ R), (A * A.conjTranspose).mulVec v = 0 ↔ A.conjTranspose.mulVec v = 0
Rat.le_coe_toNNRat
Mathlib.Data.NNRat.Defs
βˆ€ (q : β„š), q ≀ ↑q.toNNRat
_private.Init.Grind.Ordered.Rat.0.Lean.Grind.instOrderedAddRat._simp_1
Init.Grind.Ordered.Rat
βˆ€ {a b c : β„š}, (c + a ≀ c + b) = (a ≀ b)
Aesop.RulePattern.mk
Aesop.RulePattern
Lean.Meta.AbstractMVarsResult β†’ Array (Option β„•) β†’ Array (Option β„•) β†’ Array Lean.Meta.DiscrTree.Key β†’ Aesop.RulePattern
_private.Std.Time.Format.Basic.0.Std.Time.formatMarkerShort.match_1
Std.Time.Format.Basic
(motive : Std.Time.HourMarker β†’ Sort u_1) β†’ (marker : Std.Time.HourMarker) β†’ (Unit β†’ motive Std.Time.HourMarker.am) β†’ (Unit β†’ motive Std.Time.HourMarker.pm) β†’ motive marker
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.surjective_Ο€_app_zero_of_surjective_map_aux.match_1_1
Mathlib.CategoryTheory.Limits.Types.Images
(motive : β„•α΅’α΅– β†’ Sort u_1) β†’ (x : β„•α΅’α΅–) β†’ ((n : β„•) β†’ motive (Opposite.op n)) β†’ motive x
WeierstrassCurve.toCharTwoJNeZeroNF
Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms
{F : Type u_2} β†’ [inst : Field F] β†’ (W : WeierstrassCurve F) β†’ W.a₁ β‰  0 β†’ WeierstrassCurve.VariableChange F
Lean.Server.FileWorker.FileSetupResultKind._sizeOf_1
Lean.Server.FileWorker.SetupFile
Lean.Server.FileWorker.FileSetupResultKind β†’ β„•
Nat.psub
Mathlib.Data.Nat.PSub
β„• β†’ β„• β†’ Option β„•
Quiver.Path.addWeightOfEPs_cons
Mathlib.Combinatorics.Quiver.Path.Weight
βˆ€ {V : Type u_1} [inst : Quiver V] {R : Type u_2} [inst_1 : AddMonoid R] (w : V β†’ V β†’ R) {a b c : V} (p : Quiver.Path a b) (e : b ⟢ c), Quiver.Path.addWeightOfEPs w (p.cons e) = Quiver.Path.addWeightOfEPs w p + w b c
AffineEquiv.equivLike
Mathlib.LinearAlgebra.AffineSpace.AffineEquiv
{k : Type u_1} β†’ {P₁ : Type u_2} β†’ {Pβ‚‚ : Type u_3} β†’ {V₁ : Type u_6} β†’ {Vβ‚‚ : Type u_7} β†’ [inst : Ring k] β†’ [inst_1 : AddCommGroup V₁] β†’ [inst_2 : AddCommGroup Vβ‚‚] β†’ [inst_3 : Module k V₁] β†’ [inst_4 : Module k Vβ‚‚] β†’ [inst_5 : AddTorsor V₁ P₁] β†’ [inst_6 : AddTorsor Vβ‚‚ Pβ‚‚] β†’ EquivLike (P₁ ≃ᡃ[k] Pβ‚‚) P₁ Pβ‚‚
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.findGoalsAt?.getPositions
Lean.Server.FileWorker.RequestHandling
Lean.Syntax β†’ Option (String.Pos.Raw Γ— String.Pos.Raw Γ— String.Pos.Raw)
UpperSet.mem_iInf_iff
Mathlib.Order.UpperLower.CompleteLattice
βˆ€ {Ξ± : Type u_1} {ΞΉ : Sort u_4} [inst : LE Ξ±] {a : Ξ±} {f : ΞΉ β†’ UpperSet Ξ±}, a ∈ β¨… i, f i ↔ βˆƒ i, a ∈ f i
ModularGroup.denom_apply
Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction
βˆ€ (g : Matrix.SpecialLinearGroup (Fin 2) β„€) (z : UpperHalfPlane), UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) g)) ↑z = ↑(↑g 1 0) * ↑z + ↑(↑g 1 1)
Nat.lt.base
Init.Data.Nat.Basic
βˆ€ (n : β„•), n < n.succ
finprod_apply
Mathlib.Algebra.BigOperators.Finprod
βˆ€ {N : Type u_6} [inst : CommMonoid N] {Ξ± : Type u_7} {ΞΉ : Type u_8} {f : ΞΉ β†’ Ξ± β†’ N}, (Function.mulSupport f).Finite β†’ βˆ€ (a : Ξ±), (∏ᢠ (i : ΞΉ), f i) a = ∏ᢠ (i : ΞΉ), f i a
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.ins.match_1_1
Batteries.Data.RBMap.WF
βˆ€ {Ξ± : Type u_1} {cmp : Ξ± β†’ Ξ± β†’ Ordering} (motive : (x : Batteries.RBNode Ξ±) β†’ Batteries.RBNode.Ordered cmp x β†’ Prop) (x : Batteries.RBNode Ξ±) (x_1 : Batteries.RBNode.Ordered cmp x), (βˆ€ (x : Batteries.RBNode.Ordered cmp Batteries.RBNode.nil), motive Batteries.RBNode.nil x) β†’ (βˆ€ (a : Batteries.RBNode Ξ±) (y : Ξ±) (b : Batteries.RBNode Ξ±) (ay : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y) a) (yb : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp y x) b) (ha : Batteries.RBNode.Ordered cmp a) (hb : Batteries.RBNode.Ordered cmp b), motive (Batteries.RBNode.node Batteries.RBColor.red a y b) β‹―) β†’ (βˆ€ (a : Batteries.RBNode Ξ±) (y : Ξ±) (b : Batteries.RBNode Ξ±) (ay : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y) a) (yb : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp y x) b) (ha : Batteries.RBNode.Ordered cmp a) (hb : Batteries.RBNode.Ordered cmp b), motive (Batteries.RBNode.node Batteries.RBColor.black a y b) β‹―) β†’ motive x x_1
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_endpoint._simp_1_5
Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph
βˆ€ {Ξ± : Type u_1} {p p' : Ξ± Γ— Ξ±}, (Sym2.mk p = Sym2.mk p') = Sym2.Rel Ξ± p p'
AddUnits.neg_mul_left
Mathlib.Algebra.Ring.Invertible
βˆ€ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {x : AddUnits R} {y : R}, -x.mulLeft y = (-x).mulLeft y
_private.Lean.Data.RBMap.0.Lean.RBMap.erase.match_1
Lean.Data.RBMap
{Ξ± : Type u_1} β†’ {Ξ² : Type u_2} β†’ {cmp : Ξ± β†’ Ξ± β†’ Ordering} β†’ (motive : Lean.RBMap Ξ± Ξ² cmp β†’ Ξ± β†’ Sort u_3) β†’ (x : Lean.RBMap Ξ± Ξ² cmp) β†’ (x_1 : Ξ±) β†’ ((t : Lean.RBNode Ξ± fun x => Ξ²) β†’ (w : Lean.RBNode.WellFormed cmp t) β†’ (k : Ξ±) β†’ motive ⟨t, w⟩ k) β†’ motive x x_1
MeasureTheory.weightedSMul_union'
Mathlib.MeasureTheory.Integral.Bochner.L1
βˆ€ {Ξ± : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} (s t : Set Ξ±), MeasurableSet t β†’ ΞΌ s β‰  ⊀ β†’ ΞΌ t β‰  ⊀ β†’ Disjoint s t β†’ MeasureTheory.weightedSMul ΞΌ (s βˆͺ t) = MeasureTheory.weightedSMul ΞΌ s + MeasureTheory.weightedSMul ΞΌ t
AlgebraicGeometry.IsAffine.casesOn
Mathlib.AlgebraicGeometry.AffineScheme
{X : AlgebraicGeometry.Scheme} β†’ {motive : AlgebraicGeometry.IsAffine X β†’ Sort u} β†’ (t : AlgebraicGeometry.IsAffine X) β†’ ((affine : CategoryTheory.IsIso X.toSpecΞ“) β†’ motive β‹―) β†’ motive t
_private.Mathlib.Data.Finset.Card.0.Finset.exists_subset_or_subset_of_two_mul_lt_card._proof_1_3
Mathlib.Data.Finset.Card
βˆ€ {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {X Y : Finset Ξ±} {n : β„•}, 2 * n < (X βˆͺ Y).card β†’ (X βˆͺ Y).card = X.card + (Y \ X).card β†’ n < X.card ∨ n < (Y \ X).card
Std.ExtDHashMap.Const.getD_union
Std.Data.ExtDHashMap.Lemmas
βˆ€ {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Type v} {m₁ mβ‚‚ : Std.ExtDHashMap Ξ± fun x => Ξ²} [inst : EquivBEq Ξ±] [inst_1 : LawfulHashable Ξ±] {k : Ξ±} {fallback : Ξ²}, Std.ExtDHashMap.Const.getD (m₁.union mβ‚‚) k fallback = Std.ExtDHashMap.Const.getD mβ‚‚ k (Std.ExtDHashMap.Const.getD m₁ k fallback)
Filter.prod_mono_right
Mathlib.Order.Filter.Prod
βˆ€ {Ξ± : Type u_1} {Ξ² : Type u_2} (f : Filter Ξ±) {g₁ gβ‚‚ : Filter Ξ²}, g₁ ≀ gβ‚‚ β†’ f Γ—Λ’ g₁ ≀ f Γ—Λ’ gβ‚‚
Lean.Meta.Grind.Order.Weight.casesOn
Lean.Meta.Tactic.Grind.Order.Types
{motive : Lean.Meta.Grind.Order.Weight β†’ Sort u} β†’ (t : Lean.Meta.Grind.Order.Weight) β†’ ((k : β„€) β†’ (strict : Bool) β†’ motive { k := k, strict := strict }) β†’ motive t
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_sum._simp_1_1
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne
βˆ€ {Ξ± : Type u_1} (s : Finset Ξ±) (f : Ξ± β†’ ℝ), ∏ x ∈ s, Real.exp (f x) = Real.exp (βˆ‘ x ∈ s, f x)
ONote.split._sunfold
Mathlib.SetTheory.Ordinal.Notation
ONote β†’ ONote Γ— β„•
Lean.Doc.DocScope.local.sizeOf_spec
Lean.Elab.DocString.Builtin.Scopes
sizeOf Lean.Doc.DocScope.local = 1
Std.Time.PlainDateTime.instHSubDuration
Std.Time.DateTime
HSub Std.Time.PlainDateTime Std.Time.PlainDateTime Std.Time.Duration
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.entryAtIdx?_eq_getElem?._simp_1_3
Std.Data.DTreeMap.Internal.WF.Lemmas
βˆ€ {a b : β„•}, (compare a b = Ordering.eq) = (a = b)
ArchimedeanOrder.of
Mathlib.Algebra.Order.Archimedean.Class
{M : Type u_1} β†’ M ≃ ArchimedeanOrder M
WriterT.uliftable'
Mathlib.Control.ULiftable
{w : Type u_3} β†’ {w' : Type u_4} β†’ {m : Type u_3 β†’ Type u_5} β†’ {m' : Type u_4 β†’ Type u_6} β†’ [ULiftable m m'] β†’ w ≃ w' β†’ ULiftable (WriterT w m) (WriterT w' m')
USize.ofBitVec.sizeOf_spec
Init.SizeOf
βˆ€ (toBitVec : BitVec System.Platform.numBits), sizeOf { toBitVec := toBitVec } = 1 + sizeOf toBitVec
CommRingCat.instCategory._proof_1
Mathlib.Algebra.Category.Ring.Basic
βˆ€ {X Y : CommRingCat} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f
mul_eq_zero_iff_right
Mathlib.Algebra.GroupWithZero.Defs
βˆ€ {Mβ‚€ : Type u_1} [inst : MulZeroClass Mβ‚€] [NoZeroDivisors Mβ‚€] {a b : Mβ‚€}, b β‰  0 β†’ (a * b = 0 ↔ a = 0)
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.size.eq_1
Init.Data.Slice.Array.Lemmas
βˆ€ {Ξ± : Type u_1} (s : Subarray Ξ±), s.size = s.stop - s.start
WithLp.instProdPseudoMetricSpace
Mathlib.Analysis.Normed.Lp.ProdLp
(p : ENNReal) β†’ (Ξ± : Type u_2) β†’ (Ξ² : Type u_3) β†’ [hp : Fact (1 ≀ p)] β†’ [PseudoMetricSpace Ξ±] β†’ [PseudoMetricSpace Ξ²] β†’ PseudoMetricSpace (WithLp p (Ξ± Γ— Ξ²))
CategoryTheory.Limits.LimitPresentation.changeDiag
Mathlib.CategoryTheory.Limits.Presentation
{C : Type u} β†’ [inst : CategoryTheory.Category.{v, u} C] β†’ {J : Type w} β†’ [inst_1 : CategoryTheory.Category.{t, w} J] β†’ {X : C} β†’ (P : CategoryTheory.Limits.LimitPresentation J X) β†’ {F : CategoryTheory.Functor J C} β†’ (F β‰… P.diag) β†’ CategoryTheory.Limits.LimitPresentation J X
Stream'.Seq.cons_not_terminatedAt_zero._simp_1
Mathlib.Data.Seq.Defs
βˆ€ {Ξ± : Type u} {x : Ξ±} {s : Stream'.Seq Ξ±}, (Stream'.Seq.cons x s).TerminatedAt 0 = False
Denumerable
Mathlib.Logic.Denumerable
Type u_3 β†’ Type u_3
BitVec.toInt_sshiftRight'
Init.Data.BitVec.Lemmas
βˆ€ {w : β„•} {x y : BitVec w}, (x.sshiftRight' y).toInt = x.toInt >>> y.toNat
TopologicalSpace.Opens.map_id_obj
Mathlib.Topology.Category.TopCat.Opens
βˆ€ {X : TopCat} (U : TopologicalSpace.Opens ↑X), (TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)).obj U = U
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm
Mathlib.Tactic.NormNum.Ineq
{u : Lean.Level} β†’ {Ξ± : Q(Type u)} β†’ (lΞ± : Q(LT Β«$Ξ±Β»)) β†’ {a b : Q(Β«$Ξ±Β»)} β†’ Mathlib.Meta.NormNum.Result a β†’ Mathlib.Meta.NormNum.Result b β†’ have e := q(Β«$aΒ» < Β«$bΒ»); Lean.MetaM (Mathlib.Meta.NormNum.Result e)
Std.Internal.IO.Async.Signal.sigttou.elim
Std.Internal.Async.Signal
{motive : Std.Internal.IO.Async.Signal β†’ Sort u} β†’ (t : Std.Internal.IO.Async.Signal) β†’ t.ctorIdx = 14 β†’ motive Std.Internal.IO.Async.Signal.sigttou β†’ motive t
normSeminorm
Mathlib.Analysis.Seminorm
(π•œ : Type u_3) β†’ (E : Type u_7) β†’ [inst : NormedField π•œ] β†’ [inst_1 : SeminormedAddCommGroup E] β†’ [inst_2 : NormedSpace π•œ E] β†’ Seminorm π•œ E
_private.Mathlib.Algebra.GroupWithZero.Basic.0.zero_pow.match_1_1
Mathlib.Algebra.GroupWithZero.Basic
βˆ€ (motive : (x : β„•) β†’ x β‰  0 β†’ Prop) (x : β„•) (x_1 : x β‰  0), (βˆ€ (n : β„•) (x : n + 1 β‰  0), motive n.succ x) β†’ motive x x_1
CategoryTheory.ShortComplex.Splitting.map
Mathlib.Algebra.Homology.ShortComplex.Exact
{C : Type u_1} β†’ {D : Type u_2} β†’ [inst : CategoryTheory.Category.{v_1, u_1} C] β†’ [inst_1 : CategoryTheory.Category.{v_2, u_2} D] β†’ [inst_2 : CategoryTheory.Preadditive C] β†’ [inst_3 : CategoryTheory.Preadditive D] β†’ {S : CategoryTheory.ShortComplex C} β†’ S.Splitting β†’ (F : CategoryTheory.Functor C D) β†’ [inst_4 : F.Additive] β†’ (S.map F).Splitting
Lean.PersistentHashMap.Node.brecOn_3
Lean.Data.PersistentHashMap
{Ξ± : Type u} β†’ {Ξ² : Type v} β†’ {motive_1 : Lean.PersistentHashMap.Node Ξ± Ξ² β†’ Sort u_1} β†’ {motive_2 : Array (Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²)) β†’ Sort u_1} β†’ {motive_3 : List (Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²)) β†’ Sort u_1} β†’ {motive_4 : Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²) β†’ Sort u_1} β†’ (t : Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²)) β†’ ((t : Lean.PersistentHashMap.Node Ξ± Ξ²) β†’ t.below β†’ motive_1 t) β†’ ((t : Array (Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²))) β†’ Lean.PersistentHashMap.Node.below_1 t β†’ motive_2 t) β†’ ((t : List (Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²))) β†’ Lean.PersistentHashMap.Node.below_2 t β†’ motive_3 t) β†’ ((t : Lean.PersistentHashMap.Entry Ξ± Ξ² (Lean.PersistentHashMap.Node Ξ± Ξ²)) β†’ Lean.PersistentHashMap.Node.below_3 t β†’ motive_4 t) β†’ motive_4 t
MeasureTheory.L1.SimpleFunc.setToL1SCLM.congr_simp
Mathlib.MeasureTheory.Integral.SetToL1
βˆ€ (Ξ± : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace Ξ±} (ΞΌ : MeasureTheory.Measure Ξ±) {T T_1 : Set Ξ± β†’ E β†’L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1) (hT : MeasureTheory.DominatedFinMeasAdditive ΞΌ T C), MeasureTheory.L1.SimpleFunc.setToL1SCLM Ξ± E ΞΌ hT = MeasureTheory.L1.SimpleFunc.setToL1SCLM Ξ± E ΞΌ β‹―
specializingMap_iff_isClosed_image_closure_singleton
Mathlib.Topology.Inseparable
βˆ€ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X β†’ Y}, Continuous f β†’ (SpecializingMap f ↔ βˆ€ (x : X), IsClosed (f '' closure {x}))
Module.Basis.traceDual_traceDual
Mathlib.RingTheory.Trace.Basic
βˆ€ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {ΞΉ : Type w} [inst_3 : FiniteDimensional K L] [inst_4 : Algebra.IsSeparable K L] [inst_5 : Finite ΞΉ] [inst_6 : DecidableEq ΞΉ] (b : Module.Basis ΞΉ K L), b.traceDual.traceDual = b
Lean.Meta.Match.Pattern.val.sizeOf_spec
Lean.Meta.Match.Basic
βˆ€ (e : Lean.Expr), sizeOf (Lean.Meta.Match.Pattern.val e) = 1 + sizeOf e
_private.Mathlib.SetTheory.PGame.Basic.0.SetTheory.PGame.ofLists._proof_1
Mathlib.SetTheory.PGame.Basic
βˆ€ (L : List SetTheory.PGame), Β¬L.length ≀ L.length β†’ False
MeasureTheory.MemLp.of_fst_of_snd_prodLp
Mathlib.MeasureTheory.SpecificCodomains.WithLp
βˆ€ {X : Type u_1} {mX : MeasurableSpace X} {ΞΌ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≀ q)] {E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F] {f : X β†’ WithLp q (E Γ— F)}, MeasureTheory.MemLp (fun x => (f x).fst) p ΞΌ ∧ MeasureTheory.MemLp (fun x => (f x).snd) p ΞΌ β†’ MeasureTheory.MemLp f p ΞΌ
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.TaggedTextHighlightState.mk.inj
Lean.Server.FileWorker.WidgetRequests
βˆ€ {query : String} {ms : Array String.Pos.Raw} {p : String.Pos.Raw} {anyHighlight : Bool} {query_1 : String} {ms_1 : Array String.Pos.Raw} {p_1 : String.Pos.Raw} {anyHighlight_1 : Bool}, { query := query, ms := ms, p := p, anyHighlight := anyHighlight } = { query := query_1, ms := ms_1, p := p_1, anyHighlight := anyHighlight_1 } β†’ query = query_1 ∧ ms = ms_1 ∧ p = p_1 ∧ anyHighlight = anyHighlight_1