name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Irrational.ne_one
|
Mathlib.NumberTheory.Real.Irrational
|
β {x : β}, Irrational x β x β 1
|
forall_imp_iff_exists_imp
|
Mathlib.Logic.Basic
|
β {Ξ± : Sort u_3} {p : Ξ± β Prop} {b : Prop} [ha : Nonempty Ξ±], (β (x : Ξ±), p x) β b β β x, p x β b
|
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_1.eq_1
|
Std.Data.DTreeMap.Internal.Model
|
β {Ξ± : Type u_1} {Ξ² : Ξ± β Type u_2} (l' r' : Std.DTreeMap.Internal.Impl Ξ± Ξ²)
(motive : Std.DTreeMap.Internal.Impl.View Ξ± Ξ² (l'.size + r'.size) β Sort u_3) (dk : Ξ±) (dv : Ξ² dk)
(dt : Std.DTreeMap.Internal.Impl Ξ± Ξ²) (hdt : dt.Balanced) (hdt' : dt.size = l'.size + r'.size)
(h_1 :
(dk : Ξ±) β
(dv : Ξ² dk) β
(dt : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(hdt : dt.Balanced) β
(hdt' : dt.size = l'.size + r'.size) β
motive { k := dk, v := dv, tree := { impl := dt, balanced_impl := hdt, size_impl := hdt' } }),
(match { k := dk, v := dv, tree := { impl := dt, balanced_impl := hdt, size_impl := hdt' } } with
| { k := dk, v := dv, tree := { impl := dt, balanced_impl := hdt, size_impl := hdt' } } => h_1 dk dv dt hdt hdt') =
h_1 dk dv dt hdt hdt'
|
PMF.support_uniformOfFintype
|
Mathlib.Probability.Distributions.Uniform
|
β (Ξ± : Type u_2) [inst : Fintype Ξ±] [inst_1 : Nonempty Ξ±], (PMF.uniformOfFintype Ξ±).support = β€
|
Mathlib.Tactic.BicategoryLike.MorβIso._sizeOf_inst
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
SizeOf Mathlib.Tactic.BicategoryLike.MorβIso
|
CommGrpCat.Forgetβ.createsLimit.eq_1
|
Mathlib.Algebra.Category.Grp.Limits
|
β {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommGrpCat),
CommGrpCat.Forgetβ.createsLimit F =
CategoryTheory.createsLimitOfReflectsIso fun c hc =>
have this := β―;
have this := β―;
have this_1 := this;
have this_2 := this_1;
{
liftedCone :=
{
pt :=
CommGrpCat.of
(CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommGrpCat))).pt,
Ο :=
{
app := fun j =>
CommGrpCat.ofHom
(MonCat.limitΟMonoidHom
(F.comp ((CategoryTheory.forgetβ CommGrpCat GrpCat).comp (CategoryTheory.forgetβ GrpCat MonCat)))
j),
naturality := β― } },
validLift := (GrpCat.limitConeIsLimit (F.comp (CategoryTheory.forgetβ CommGrpCat GrpCat))).uniqueUpToIso hc,
makesLimit :=
CategoryTheory.Limits.IsLimit.ofFaithful
((CategoryTheory.forgetβ CommGrpCat GrpCat).comp (CategoryTheory.forgetβ GrpCat MonCat))
(MonCat.HasLimits.limitConeIsLimit
(F.comp ((CategoryTheory.forgetβ CommGrpCat GrpCat).comp (CategoryTheory.forgetβ GrpCat MonCat))))
(fun s =>
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
β((F.comp
((CategoryTheory.forgetβ CommGrpCat GrpCat).comp
(CategoryTheory.forgetβ GrpCat MonCat))).comp
(CategoryTheory.forget MonCat)).sections)
β¨fun j =>
((CategoryTheory.forget MonCat).mapCone
(((CategoryTheory.forgetβ CommGrpCat GrpCat).comp
(CategoryTheory.forgetβ GrpCat MonCat)).mapCone
s)).Ο.app
j v,
β―β©,
map_one' := β―, map_mul' := β― } })
β― }
|
CategoryTheory.NatTrans.PullbackShift.natIsoId.eq_1
|
Mathlib.CategoryTheory.Shift.Pullback
|
β (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (Ο : A β+ B) [inst_3 : CategoryTheory.HasShift C B],
CategoryTheory.NatTrans.PullbackShift.natIsoId C Ο =
CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.PullbackShift C Ο))
|
NormedAddGroupHom.norm_id_le
|
Mathlib.Analysis.Normed.Group.Hom
|
β (V : Type u_1) [inst : SeminormedAddCommGroup V], βNormedAddGroupHom.id Vβ β€ 1
|
SimpleGraph.not_isDiag_of_mem_edgeSet
|
Mathlib.Combinatorics.SimpleGraph.Basic
|
β {V : Type u} (G : SimpleGraph V) {e : Sym2 V}, e β G.edgeSet β Β¬e.IsDiag
|
Array.append_inj_left
|
Init.Data.Array.Lemmas
|
β {Ξ± : Type u_1} {xsβ xsβ ysβ ysβ : Array Ξ±}, xsβ ++ ysβ = xsβ ++ ysβ β xsβ.size = xsβ.size β xsβ = xsβ
|
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_limsup._simp_1_6
|
Mathlib.Order.Filter.ENNReal
|
β {q : NNReal}, (0 β€ βq) = True
|
List.take_modify
|
Init.Data.List.Nat.Modify
|
β {Ξ± : Type u_1} (f : Ξ± β Ξ±) (i j : β) (l : List Ξ±), List.take j (l.modify i f) = (List.take j l).modify i f
|
MeasureTheory.exists_isSigmaFiniteSet_measure_ge
|
Mathlib.MeasureTheory.Measure.Decomposition.Exhaustion
|
β {Ξ± : Type u_1} {mΞ± : MeasurableSpace Ξ±} (ΞΌ Ξ½ : MeasureTheory.Measure Ξ±) [MeasureTheory.IsFiniteMeasure Ξ½] (n : β),
β t,
MeasurableSet t β§
MeasureTheory.SigmaFinite (ΞΌ.restrict t) β§
(β¨ s, β¨ (_ : MeasurableSet s), β¨ (_ : MeasureTheory.SigmaFinite (ΞΌ.restrict s)), Ξ½ s) - 1 / βn β€ Ξ½ t
|
Subring.prod_top
|
Mathlib.Algebra.Ring.Subring.Basic
|
β {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (s : Subring R),
s.prod β€ = Subring.comap (RingHom.fst R S) s
|
RestrictedProduct.instRingCoeOfSubringClass._proof_10
|
Mathlib.Topology.Algebra.RestrictedProduct.Basic
|
β {ΞΉ : Type u_1} (R : ΞΉ β Type u_2) {π : Filter ΞΉ} {S : ΞΉ β Type u_3} [inst : (i : ΞΉ) β SetLike (S i) (R i)]
{B : (i : ΞΉ) β S i} [inst_1 : (i : ΞΉ) β Ring (R i)] [inst_2 : β (i : ΞΉ), SubringClass (S i) (R i)], β0 = β0
|
CategoryTheory.Arrow.homMk._auto_1
|
Mathlib.CategoryTheory.Comma.Arrow
|
Lean.Syntax
|
addOrderOf.eq_1
|
Mathlib.GroupTheory.OrderOfElement
|
β {G : Type u_1} [inst : AddMonoid G] (x : G), addOrderOf x = Function.minimalPeriod (fun x_1 => x + x_1) 0
|
AffineSubspace.setOf_sSameSide_eq_image2
|
Mathlib.Analysis.Convex.Side
|
β {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x p : P},
x β s β p β s β {y | s.SSameSide x y} = Set.image2 (fun t q => t β’ (x -α΅₯ p) +α΅₯ q) (Set.Ioi 0) βs
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_minKey!._simp_1_2
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {instOrd : Ord Ξ±} {a b : Ξ±}, (compare a b β Ordering.eq) = ((a == b) = false)
|
Lean.Server.instRpcEncodableOption
|
Lean.Server.Rpc.Basic
|
{Ξ± : Type} β [Lean.Server.RpcEncodable Ξ±] β Lean.Server.RpcEncodable (Option Ξ±)
|
QuotientAddGroup.quotientKerEquivOfRightInverse._proof_2
|
Mathlib.GroupTheory.QuotientGroup.Basic
|
β {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (Ο : G β+ H) (x y : G β§Έ Ο.ker),
(β(QuotientAddGroup.kerLift Ο)).toFun (x + y) =
(β(QuotientAddGroup.kerLift Ο)).toFun x + (β(QuotientAddGroup.kerLift Ο)).toFun y
|
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.instToMessageDataNewDecl.match_1
|
Lean.Meta.IndPredBelow
|
(motive : Lean.Meta.IndPredBelow.NewDeclβ β Sort u_1) β
(x : Lean.Meta.IndPredBelow.NewDeclβΒΉ) β
((decl : Lean.LocalDecl) β
(indName : Lean.Name) β
(vars : Array Lean.FVarId) β motive (Lean.Meta.IndPredBelow.NewDecl.belowβ decl indName vars)) β
((decl : Lean.LocalDecl) β
(idx : β) β (vars : Array Lean.FVarId) β motive (Lean.Meta.IndPredBelow.NewDecl.motiveβ decl idx vars)) β
motive x
|
Simps.Config.rhsMd._default
|
Mathlib.Tactic.Simps.Basic
|
Lean.Meta.TransparencyMode
|
MulOpposite.instIsCancelMulZero
|
Mathlib.Algebra.GroupWithZero.Opposite
|
β {Ξ± : Type u_1} [inst : Mul Ξ±] [inst_1 : Zero Ξ±] [IsCancelMulZero Ξ±], IsCancelMulZero Ξ±α΅α΅α΅
|
instInhabitedInt32
|
Init.Data.SInt.Basic
|
Inhabited Int32
|
ENat.LEInfty.casesOn
|
Mathlib.Geometry.Manifold.IsManifold.Basic
|
{m : WithTop ββ} β {motive : ENat.LEInfty m β Sort u} β (t : ENat.LEInfty m) β ((out : m β€ ββ€) β motive β―) β motive t
|
ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_one
|
Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity
|
β {p q : β} [inst : Fact (Nat.Prime p)] [inst_1 : Fact (Nat.Prime q)], p % 4 = 1 β q β 2 β (IsSquare βq β IsSquare βp)
|
CategoryTheory.Under.homMk_eta
|
Mathlib.CategoryTheory.Comma.Over.Basic
|
β {T : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} T] {X : T} {U V : CategoryTheory.Under X} (f : U βΆ V)
(h : CategoryTheory.CategoryStruct.comp U.hom f.right = V.hom), CategoryTheory.Under.homMk f.right h = f
|
CategoryTheory.sheafHom'Iso
|
Mathlib.CategoryTheory.Sites.SheafHom
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{J : CategoryTheory.GrothendieckTopology C} β
{A : Type u'} β
[inst_1 : CategoryTheory.Category.{v', u'} A] β
(F G : CategoryTheory.Sheaf J A) β CategoryTheory.sheafHom' F G β
CategoryTheory.presheafHom F.val G.val
|
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.instIteratorIdSearchStep.match_1.eq_1
|
Init.Data.String.Pattern.String
|
β (s : String.Slice) (motive : String.Slice.Pattern.ForwardSliceSearcher s β Sort u_1) (pos : s.Pos)
(h_1 : (pos : s.Pos) β motive (String.Slice.Pattern.ForwardSliceSearcher.emptyBefore pos))
(h_2 : (pos : s.Pos) β (h : pos β s.endPos) β motive (String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos h))
(h_3 :
(needle : String.Slice) β
(table : Vector β needle.utf8ByteSize) β
(ht : table = String.Slice.Pattern.ForwardSliceSearcher.buildTable needle) β
(stackPos needlePos : String.Pos.Raw) β
(hn : needlePos < needle.rawEndPos) β
motive (String.Slice.Pattern.ForwardSliceSearcher.proper needle table ht stackPos needlePos hn))
(h_4 : Unit β motive String.Slice.Pattern.ForwardSliceSearcher.atEnd),
(match String.Slice.Pattern.ForwardSliceSearcher.emptyBefore pos with
| String.Slice.Pattern.ForwardSliceSearcher.emptyBefore pos => h_1 pos
| String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos h => h_2 pos h
| String.Slice.Pattern.ForwardSliceSearcher.proper needle table ht stackPos needlePos hn =>
h_3 needle table ht stackPos needlePos hn
| String.Slice.Pattern.ForwardSliceSearcher.atEnd => h_4 ()) =
h_1 pos
|
Lean.Grind.AC.Expr.denote_toSeq
|
Init.Grind.AC
|
β {Ξ± : Sort u_1} (ctx : Lean.Grind.AC.Context Ξ±) {x : Std.Associative ctx.op} (e : Lean.Grind.AC.Expr),
Lean.Grind.AC.Seq.denote ctx e.toSeq = Lean.Grind.AC.Expr.denote ctx e
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go.eq_def
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const
|
β {Ξ± : Type} [inst : Hashable Ξ±] [inst_1 : DecidableEq Ξ±] {w : β} (aig : Std.Sat.AIG Ξ±) (val : BitVec w) (curr : β)
(s : aig.RefVec curr) (hcurr : curr β€ w),
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go aig val curr s hcurr =
if hcurr : curr < w then
have bitRef := aig.mkConstCached (val.getLsbD curr);
have s := s.push bitRef;
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go aig val (curr + 1) s β―
else
have hcurr := β―;
hcurr βΈ s
|
AffineSubspace.affineSpan_pair_parallel_iff_vectorSpan_eq
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic
|
β {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {pβ pβ pβ pβ : P},
(affineSpan k {pβ, pβ}).Parallel (affineSpan k {pβ, pβ}) β vectorSpan k {pβ, pβ} = vectorSpan k {pβ, pβ}
|
IsLprojection.instLatticeSubtypeOfFaithfulSMul._proof_2
|
Mathlib.Analysis.Normed.Module.MStructure
|
β {X : Type u_2} [inst : NormedAddCommGroup X] {M : Type u_1} [inst_1 : Ring M] [inst_2 : Module M X]
[inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), Q β€ P β Q
|
Additive.ofMul_lt._simp_1
|
Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {a b : Ξ±}, (Additive.ofMul a < Additive.ofMul b) = (a < b)
|
Std.Tactic.BVDecide.BVExpr.extract.noConfusion
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
|
{P : Sort u} β
{w start len : β} β
{expr : Std.Tactic.BVDecide.BVExpr w} β
{w' start' len' : β} β
{expr' : Std.Tactic.BVDecide.BVExpr w'} β
len = len' β
Std.Tactic.BVDecide.BVExpr.extract start len expr β Std.Tactic.BVDecide.BVExpr.extract start' len' expr' β
(w = w' β start = start' β len = len' β expr β expr' β P) β P
|
_private.Mathlib.LinearAlgebra.Matrix.DotProduct.0.Matrix.vecMul_conjTranspose_mul_self_eq_zero._simp_1_2
|
Mathlib.LinearAlgebra.Matrix.DotProduct
|
β {n : Type u_3} {Ξ± : Type v} {ΞΉ : Type u_6} [inst : Zero Ξ±] [Nonempty ΞΉ] (v : n β Ξ±),
(Matrix.replicateRow ΞΉ v = 0) = (v = 0)
|
CategoryTheory.Functor.CoreMonoidal.toOplaxMonoidal_Ξ·
|
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]
{F : CategoryTheory.Functor C D} (h : F.CoreMonoidal), CategoryTheory.Functor.OplaxMonoidal.Ξ· F = h.Ξ΅Iso.inv
|
Mathlib.Tactic.DepRewrite.zetaDelta
|
Mathlib.Tactic.DepRewrite
|
Lean.Expr β Std.HashSet Lean.FVarId β Lean.MetaM Lean.Expr
|
Lean.Meta.Grind.SymbolPriorityEntry.mk.injEq
|
Lean.Meta.Tactic.Grind.EMatchTheorem
|
β (declName : Lean.Name) (prio : β) (declName_1 : Lean.Name) (prio_1 : β),
({ declName := declName, prio := prio } = { declName := declName_1, prio := prio_1 }) =
(declName = declName_1 β§ prio = prio_1)
|
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.Inv2.property._simp_1_5
|
Std.Sat.AIG.RelabelNat
|
β {Ξ± : Type u_1} [inst : BEq Ξ±] [LawfulBEq Ξ±] {a b : Ξ±}, ((a == b) = false) = (a β b)
|
Std.DTreeMap.Internal.Impl.size_insert_le
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [Std.TransOrd Ξ±] (h : t.WF)
{k : Ξ±} {v : Ξ² k}, (Std.DTreeMap.Internal.Impl.insert k v t β―).impl.size β€ t.size + 1
|
WeierstrassCurve.Ξ¨_neg
|
Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic
|
β {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R) (n : β€), W.Ξ¨ (-n) = -W.Ξ¨ n
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.knowsType
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context β Bool
|
CategoryTheory.Functor.isMittagLeffler_of_surjective
|
Mathlib.CategoryTheory.CofilteredSystem
|
β {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v)),
(β β¦i j : Jβ¦ (f : i βΆ j), Function.Surjective (F.map f)) β F.IsMittagLeffler
|
_private.Mathlib.RingTheory.Polynomial.ContentIdeal.0.Polynomial.mul_contentIdeal_le_radical_contentIdeal_mul._simp_1_3
|
Mathlib.RingTheory.Polynomial.ContentIdeal
|
β {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] {I : Ideal R} (f : F), (I β€ RingHom.ker f) = (Ideal.map f I = β₯)
|
CategoryTheory.Bicategory.HasLeftKanExtension.rec
|
Mathlib.CategoryTheory.Bicategory.Kan.HasKan
|
{B : Type u} β
[inst : CategoryTheory.Bicategory B] β
{a b c : B} β
{f : a βΆ b} β
{g : a βΆ c} β
{motive : CategoryTheory.Bicategory.HasLeftKanExtension f g β Sort u_1} β
((hasInitial : CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftExtension f g)) β motive β―) β
(t : CategoryTheory.Bicategory.HasLeftKanExtension f g) β motive t
|
Pi.addSemigroup._proof_1
|
Mathlib.Algebra.Group.Pi.Basic
|
β {I : Type u_1} {f : I β Type u_2} [inst : (i : I) β AddSemigroup (f i)] (a b c : (i : I) β f i),
a + b + c = a + (b + c)
|
List.flatMap.eq_1
|
Init.Data.List.Basic
|
β {Ξ± : Type u} {Ξ² : Type v} (b : Ξ± β List Ξ²) (as : List Ξ±), List.flatMap b as = (List.map b as).flatten
|
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop._sunfold
|
Init.Data.Nat.Fold
|
{Ξ± : Type u} β (n : β) β ((i : β) β i < n β Ξ± β Ξ±) β (j : β) β j β€ n β Ξ± β Ξ±
|
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.ne_zero._simp_1_2
|
Mathlib.Analysis.Meromorphic.FactorizedRational
|
β {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b β 0) = (a β b)
|
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.caching._sparseCasesOn_4
|
Lean.Meta.Tactic.Grind.Arith.Linear.Proof
|
{Ξ± : Type u} β
{motive : Option Ξ± β Sort u_1} β
(t : Option Ξ±) β ((val : Ξ±) β motive (some val)) β (Nat.hasNotBit 2 t.ctorIdx β motive t) β motive t
|
_private.Mathlib.Computability.DFA.0.Language.IsRegular.add.match_1_1
|
Mathlib.Computability.DFA
|
β {T : Type u_1} {L2 : Language T} (motive : L2.IsRegular β Prop) (h2 : L2.IsRegular),
(β (Ο2 : Type) (w : Fintype Ο2) (M2 : DFA T Ο2) (hM2 : M2.accepts = L2), motive β―) β motive h2
|
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min.sizeOf_spec
|
Mathlib.CategoryTheory.Filtered.Small
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {n : β} {X : (k : β) β k < n β (t : Type (max v w)) Γ (t β C)}
[inst_1 : SizeOf C] {k k' : β} (hk : k < n) (hk' : k' < n) (a : (X k hk).fst) (a_1 : (X k' hk').fst),
sizeOf (CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.minβ hk hk' a a_1) =
1 + sizeOf k + sizeOf k' + sizeOf hk + sizeOf hk' + sizeOf a + sizeOf a_1
|
NNReal.inner_le_Lp_mul_Lq_tsum'
|
Mathlib.Analysis.MeanInequalities
|
β {ΞΉ : Type u} {f g : ΞΉ β NNReal} {p q : β},
p.HolderConjugate q β
(Summable fun i => f i ^ p) β
(Summable fun i => g i ^ q) β
β' (i : ΞΉ), f i * g i β€ (β' (i : ΞΉ), f i ^ p) ^ (1 / p) * (β' (i : ΞΉ), g i ^ q) ^ (1 / q)
|
_private.Batteries.Data.Fin.Fold.0.Fin.dfoldrM_loop_succ._proof_3
|
Batteries.Data.Fin.Fold
|
β {n i : β} {h : i + 1 < n + 1}, Β¬i < n + 1 β False
|
Batteries.RBNode.Path.zoom_del._unary
|
Batteries.Data.RBMap.Lemmas
|
β {Ξ± : Type u_1}
(_x :
(_ : Ξ± β Ordering) Γ'
(_ : Batteries.RBNode.Path Ξ±) Γ' (_ : Batteries.RBNode Ξ±) Γ' (_ : Batteries.RBNode.Path Ξ±) Γ' Batteries.RBNode Ξ±),
Batteries.RBNode.zoom _x.1 _x.2.2.2.2 _x.2.1 = (_x.2.2.1, _x.2.2.2.1) β
_x.2.1.del (Batteries.RBNode.del _x.1 _x.2.2.2.2)
(match _x.2.2.2.2 with
| Batteries.RBNode.node c l v r => c
| x => Batteries.RBColor.red) =
_x.2.2.2.1.del _x.2.2.1.delRoot
(match _x.2.2.1 with
| Batteries.RBNode.node c l v r => c
| x => Batteries.RBColor.red)
|
Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letOptZeta.formatter_21
|
Lean.Parser.Term
|
IO Unit
|
_private.Mathlib.Order.Monotone.Basic.0.StrictAnti.isMax_of_apply.match_1_1
|
Mathlib.Order.Monotone.Basic
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {a : Ξ±} (motive : (β b, a < b) β Prop) (x : β b, a < b),
(β (w : Ξ±) (hb : a < w), motive β―) β motive x
|
_private.Lean.ExtraModUses.0.Lean.instHashableExtraModUse.hash.match_1
|
Lean.ExtraModUses
|
(motive : Lean.ExtraModUse β Sort u_1) β
(x : Lean.ExtraModUse) β
((a : Lean.Name) β (a_1 a_2 : Bool) β motive { module := a, isExported := a_1, isMeta := a_2 }) β motive x
|
CategoryTheory.Quotient.lift._proof_2
|
Mathlib.CategoryTheory.Quotient
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D)
(H : β (x y : C) (fβ fβ : x βΆ y), r fβ fβ β F.map fβ = F.map fβ) {a b c : CategoryTheory.Quotient r} (f : a βΆ b)
(g : b βΆ c),
Quot.liftOn (CategoryTheory.CategoryStruct.comp f g) (fun f => F.map f) β― =
CategoryTheory.CategoryStruct.comp (Quot.liftOn f (fun f => F.map f) β―) (Quot.liftOn g (fun f => F.map f) β―)
|
IntermediateField.map_id
|
Mathlib.FieldTheory.IntermediateField.Basic
|
β {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L),
IntermediateField.map (AlgHom.id K L) S = S
|
_private.Mathlib.LinearAlgebra.Dimension.Constructions.0.rank_quotient_add_rank_le.match_1_1
|
Mathlib.LinearAlgebra.Dimension.Constructions
|
β {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (M' : Submodule R M)
(motive : { s // LinearIndepOn R id s } β Prop) (x : { s // LinearIndepOn R id s }),
(β (t : Set β₯M') (ht : LinearIndepOn R id t), motive β¨t, htβ©) β motive x
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.structuresPass
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Pass
|
CategoryTheory.Functor.whiskeringLeft._proof_2
|
Mathlib.CategoryTheory.Whiskering
|
β (C : Type u_5) [inst : CategoryTheory.Category.{u_6, u_5} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
(F : CategoryTheory.Functor C D) {X Y Z : CategoryTheory.Functor D E} (f : X βΆ Y) (g : Y βΆ Z),
F.whiskerLeft (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (F.whiskerLeft f) (F.whiskerLeft g)
|
Module.End.isIntegral
|
Mathlib.RingTheory.IntegralClosure.Algebra.Basic
|
β {R : Type u_1} [inst : CommRing R] {M : Type u_5} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M],
Algebra.IsIntegral R (Module.End R M)
|
Std.HashMap.getKeyD_union_of_not_mem_left
|
Std.Data.HashMap.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Type v} {mβ mβ : Std.HashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±]
{k fallback : Ξ±}, k β mβ β (mβ βͺ mβ).getKeyD k fallback = mβ.getKeyD k fallback
|
Module.Basis.norm_nonneg
|
Mathlib.Analysis.Normed.Unbundled.FiniteExtension
|
β {K : Type u_1} {L : Type u_2} [inst : NormedField K] [inst_1 : Ring L] [inst_2 : Algebra K L] {ΞΉ : Type u_3}
[inst_3 : Fintype ΞΉ] [inst_4 : Nonempty ΞΉ] (B : Module.Basis ΞΉ K L) (x : L), 0 β€ B.norm x
|
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenexImp.match_1.splitter._sparseCasesOn_6
|
Mathlib.ModelTheory.Complexity
|
{L : FirstOrder.Language} β
{Ξ± : Type u'} β
{motive : (a : β) β L.BoundedFormula Ξ± a β Sort u_1} β
{a : β} β
(t : L.BoundedFormula Ξ± a) β
({n : β} β (fβ fβ : L.BoundedFormula Ξ± n) β motive n (fβ.imp fβ)) β
(Nat.hasNotBit 8 t.ctorIdx β motive a t) β motive a t
|
AnalyticAt.smul
|
Mathlib.Analysis.Analytic.Constructions
|
β {π : Type u_2} [inst : NontriviallyNormedField π] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {π : Type u_7}
[inst_5 : NontriviallyNormedField π] [inst_6 : NormedAlgebra π π] [inst_7 : NormedSpace π F] [IsScalarTower π π F]
{f : E β π} {g : E β F} {z : E}, AnalyticAt π f z β AnalyticAt π g z β AnalyticAt π (f β’ g) z
|
_private.Batteries.Data.BinaryHeap.0.Batteries.BinaryHeap.mkHeap.loop
|
Batteries.Data.BinaryHeap
|
{Ξ± : Type u_1} β {sz : β} β (Ξ± β Ξ± β Bool) β (i : β) β Vector Ξ± sz β i β€ sz β Vector Ξ± sz
|
Std.DHashMap.Raw.Const.getD
|
Std.Data.DHashMap.Raw
|
{Ξ± : Type u} β {Ξ² : Type v} β [BEq Ξ±] β [Hashable Ξ±] β (Std.DHashMap.Raw Ξ± fun x => Ξ²) β Ξ± β Ξ² β Ξ²
|
Plausible.Fin.Arbitrary._proof_1
|
Plausible.Arbitrary
|
β {n : β} (__do_lift : β), 0 β€ min __do_lift n
|
ContinuousMap.instSeminormedRing
|
Mathlib.Topology.ContinuousMap.Compact
|
{Ξ± : Type u_1} β
[inst : TopologicalSpace Ξ±] β [CompactSpace Ξ±] β {R : Type u_4} β [inst_2 : SeminormedRing R] β SeminormedRing C(Ξ±, R)
|
Int.negOnePow_one
|
Mathlib.Algebra.Ring.NegOnePow
|
Int.negOnePow 1 = -1
|
BoundedContinuousMapClass.recOn
|
Mathlib.Topology.ContinuousMap.Bounded.Basic
|
{F : Type u_2} β
{Ξ± : Type u_3} β
{Ξ² : Type u_4} β
[inst : TopologicalSpace Ξ±] β
[inst_1 : PseudoMetricSpace Ξ²] β
[inst_2 : FunLike F Ξ± Ξ²] β
{motive : BoundedContinuousMapClass F Ξ± Ξ² β Sort u} β
(t : BoundedContinuousMapClass F Ξ± Ξ²) β
([toContinuousMapClass : ContinuousMapClass F Ξ± Ξ²] β
(map_bounded : β (f : F), β C, β (x y : Ξ±), dist (f x) (f y) β€ C) β motive β―) β
motive t
|
AddCon.liftOnAddUnits._proof_4
|
Mathlib.GroupTheory.Congruence.Defs
|
β {M : Type u_1} [inst : AddMonoid M] {c : AddCon M} (u : AddUnits c.Quotient), βu + u.neg = 0
|
Nat.descFactorial_pos._simp_1
|
Mathlib.Data.Nat.Factorial.Basic
|
β {n k : β}, (0 < n.descFactorial k) = (k β€ n)
|
Encodable.encodeSubtype.eq_1
|
Mathlib.Logic.Encodable.Basic
|
β {Ξ± : Type u_1} {P : Ξ± β Prop} [encA : Encodable Ξ±] (v : Ξ±) (property : P v),
Encodable.encodeSubtype β¨v, propertyβ© = Encodable.encode v
|
Lean.Meta.AuxLemmas.recOn
|
Lean.Meta.Tactic.AuxLemma
|
{motive : Lean.Meta.AuxLemmas β Sort u} β
(t : Lean.Meta.AuxLemmas) β
((lemmas : Lean.PHashMap Lean.Meta.AuxLemmaKey (Lean.Name Γ List Lean.Name)) β motive { lemmas := lemmas }) β
motive t
|
_private.Mathlib.MeasureTheory.Group.Action.0.MeasureTheory.smul_mem_ae._simp_1_1
|
Mathlib.MeasureTheory.Group.Action
|
β {Ξ± : Type u_1} {F : Type u_3} [inst : FunLike F (Set Ξ±) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F Ξ±]
{ΞΌ : F} {s : Set Ξ±}, (s β MeasureTheory.ae ΞΌ) = (ΞΌ sαΆ = 0)
|
_private.Init.Data.Nat.Basic.0.Nat.add_one_ne_zero.match_1_1
|
Init.Data.Nat.Basic
|
β (n : β) (motive : n + 1 = 0 β Prop) (a : n + 1 = 0), motive a
|
_private.Batteries.Data.List.Lemmas.0.List.replaceF.match_1.splitter
|
Batteries.Data.List.Lemmas
|
{Ξ± : Type u_1} β
(motive : Option Ξ± β Sort u_2) β (x : Option Ξ±) β (Unit β motive none) β ((a : Ξ±) β motive (some a)) β motive x
|
Std.DTreeMap.size_diff_le_size_left
|
Std.Data.DTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.DTreeMap Ξ± Ξ² cmp} [Std.TransCmp cmp],
(tβ \ tβ).size β€ tβ.size
|
UniformSpace.Completion.ring._proof_28
|
Mathlib.Topology.Algebra.UniformRing
|
β {Ξ± : Type u_1} [inst : Ring Ξ±] [inst_1 : UniformSpace Ξ±] [inst_2 : IsUniformAddGroup Ξ±]
(a : UniformSpace.Completion Ξ±), -a + a = 0
|
Finpartition.ofSetSetoid_parts
|
Mathlib.Order.Partition.Finpartition
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] (s : Setoid Ξ±) (x : Finset Ξ±) [inst_1 : DecidableRel βs],
(Finpartition.ofSetSetoid s x).parts = Finset.image (fun a => {b β x | s a b}) x
|
IsGreatest.maximal
|
Mathlib.Order.Minimal
|
β {Ξ± : Type u_2} {x : Ξ±} {s : Set Ξ±} [inst : Preorder Ξ±], IsGreatest s x β Maximal (fun x => x β s) x
|
Commute.function_commute_mul_left
|
Mathlib.Algebra.Group.Commute.Basic
|
β {G : Type u_1} [inst : Semigroup G] {a b : G}, Commute a b β Function.Commute (fun x => a * x) fun x => b * x
|
Valuation.HasExtension.val_map_lt_iff
|
Mathlib.RingTheory.Valuation.Extension
|
β {R : Type u_1} {A : Type u_2} {ΞR : Type u_3} {ΞA : Type u_4} [inst : CommRing R] [inst_1 : Ring A]
[inst_2 : LinearOrderedCommMonoidWithZero ΞR] [inst_3 : LinearOrderedCommMonoidWithZero ΞA] [inst_4 : Algebra R A]
(vR : Valuation R ΞR) (vA : Valuation A ΞA) [vR.HasExtension vA] (x y : R),
vA ((algebraMap R A) x) < vA ((algebraMap R A) y) β vR x < vR y
|
CategoryTheory.ObjectProperty.IsSeparating.mono_iff
|
Mathlib.CategoryTheory.Generator.Basic
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {P : CategoryTheory.ObjectProperty C},
P.IsSeparating β
β {X Y : C} (f : X βΆ Y),
CategoryTheory.Mono f β
β (G : C),
P G β
β (gβ gβ : G βΆ X),
CategoryTheory.CategoryStruct.comp gβ f = CategoryTheory.CategoryStruct.comp gβ f β gβ = gβ
|
_private.Mathlib.CategoryTheory.Localization.Triangulated.0.CategoryTheory.Triangulated.Localization.distinguished_cocone_triangle._simp_1_1
|
Mathlib.CategoryTheory.Localization.Triangulated
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X βΆ Y) (g : Y βΆ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g)
|
Std.TreeMap.Raw.minEntry!
|
Std.Data.TreeMap.Raw.Basic
|
{Ξ± : Type u} β {Ξ² : Type v} β {cmp : Ξ± β Ξ± β Ordering} β [Inhabited (Ξ± Γ Ξ²)] β Std.TreeMap.Raw Ξ± Ξ² cmp β Ξ± Γ Ξ²
|
_private.Mathlib.NumberTheory.Zsqrtd.Basic.0.Zsqrtd.Nonnegg.match_1.eq_4
|
Mathlib.NumberTheory.Zsqrtd.Basic
|
β (motive : β€ β β€ β Sort u_1) (a a_1 : β) (h_1 : (a b : β) β motive (Int.ofNat a) (Int.ofNat b))
(h_2 : (a b : β) β motive (Int.ofNat a) (Int.negSucc b)) (h_3 : (a b : β) β motive (Int.negSucc a) (Int.ofNat b))
(h_4 : (a a_2 : β) β motive (Int.negSucc a) (Int.negSucc a_2)),
(match Int.negSucc a, Int.negSucc a_1 with
| Int.ofNat a, Int.ofNat b => h_1 a b
| Int.ofNat a, Int.negSucc b => h_2 a b
| Int.negSucc a, Int.ofNat b => h_3 a b
| Int.negSucc a, Int.negSucc a_2 => h_4 a a_2) =
h_4 a a_1
|
ArithmeticFunction.natCoe_apply
|
Mathlib.NumberTheory.ArithmeticFunction.Defs
|
β {R : Type u_1} [inst : AddMonoidWithOne R] {f : ArithmeticFunction β} {x : β}, βf x = β(f x)
|
Equiv.prodEmbeddingDisjointEquivSigmaEmbeddingRestricted
|
Mathlib.Logic.Equiv.Embedding
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
{Ξ³ : Type u_3} β { f // Disjoint (Set.range βf.1) (Set.range βf.2) } β (f : Ξ± βͺ Ξ³) Γ (Ξ² βͺ β(Set.range βf)αΆ)
|
Module.Basis.SmithNormalForm
|
Mathlib.LinearAlgebra.FreeModule.PID
|
{R : Type u_2} β
[inst : CommRing R] β
{M : Type u_3} β
[inst_1 : AddCommGroup M] β [inst_2 : Module R M] β Submodule R M β Type u_4 β β β Type (max (max u_2 u_3) u_4)
|
Rep.coinvariantsFunctor_hom_ext
|
Mathlib.RepresentationTheory.Coinvariants
|
β {k G : Type u} [inst : CommRing k] [inst_1 : Monoid G] {A : Rep k G} {M : ModuleCat k}
{f g : (Rep.coinvariantsFunctor k G).obj A βΆ M},
CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk k G).app A) f =
CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk k G).app A) g β
f = g
|
MeasureTheory.eLpNormEssSup_eq_iSup
|
Mathlib.MeasureTheory.Function.LpSeminorm.Basic
|
β {Ξ± : Type u_1} {m0 : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {Ξ΅ : Type u_8} [inst : ENorm Ξ΅],
(β (a : Ξ±), ΞΌ {a} β 0) β β (f : Ξ± β Ξ΅), MeasureTheory.eLpNormEssSup f ΞΌ = β¨ a, βf aββ
|
Topology.WithUpper.ofUpper_le_ofUpper._simp_1
|
Mathlib.Topology.Order.LowerUpperTopology
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {x y : Topology.WithUpper Ξ±},
(Topology.WithUpper.ofUpper x β€ Topology.WithUpper.ofUpper y) = (x β€ y)
|
ProbabilityTheory.aemeasurable_of_integrable_exp_mul
|
Mathlib.Probability.Moments.IntegrableExpMul
|
β {Ξ© : Type u_1} {m : MeasurableSpace Ξ©} {X : Ξ© β β} {ΞΌ : MeasureTheory.Measure Ξ©} {u v : β},
u β v β
MeasureTheory.Integrable (fun Ο => Real.exp (u * X Ο)) ΞΌ β
MeasureTheory.Integrable (fun Ο => Real.exp (v * X Ο)) ΞΌ β AEMeasurable X ΞΌ
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.