name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
CategoryTheory.Limits.Cones.extendComp_inv_hom
|
Mathlib.CategoryTheory.Limits.Cones
|
β {J : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} J] {C : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} C]
{F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cone F) {X Y : C} (f : X βΆ Y) (g : Y βΆ s.pt),
(CategoryTheory.Limits.Cones.extendComp s f g).inv.hom = CategoryTheory.CategoryStruct.id X
|
_private.Mathlib.Probability.Martingale.Upcrossing.0.MeasureTheory.upcrossingStrat_le_one._simp_1_2
|
Mathlib.Probability.Martingale.Upcrossing
|
β {Ξ± : Type v} [inst : LinearOrder Ξ±] {aβ aβ bβ bβ : Ξ±},
Disjoint (Set.Ico aβ aβ) (Set.Ico bβ bβ) = (min aβ bβ β€ max aβ bβ)
|
AlgHom.toEnd._proof_1
|
Mathlib.Algebra.Algebra.Hom
|
β {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
AlgHom.toLinearMap 1 = AlgHom.toLinearMap 1
|
Lean.NameHashSet.insert
|
Lean.Data.NameMap.Basic
|
Lean.NameHashSet β Lean.Name β Std.HashSet Lean.Name
|
BooleanSubalgebra
|
Mathlib.Order.BooleanSubalgebra
|
(Ξ± : Type u_2) β [BooleanAlgebra Ξ±] β Type u_2
|
LocallyConstant.instNonUnitalCommSemiring
|
Mathlib.Topology.LocallyConstant.Algebra
|
{X : Type u_1} β
{Y : Type u_2} β [inst : TopologicalSpace X] β [NonUnitalCommSemiring Y] β NonUnitalCommSemiring (LocallyConstant X Y)
|
Lean.Meta.Monotonicity.defaultFailK
|
Lean.Elab.Tactic.Monotonicity
|
{Ξ± : Type} β Lean.Expr β Array Lean.Name β Lean.MetaM Ξ±
|
MeasurableSpace.sUnion_countablePartition
|
Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated
|
β (Ξ± : Type u_3) [inst : MeasurableSpace Ξ±] [inst_1 : MeasurableSpace.CountablyGenerated Ξ±] (n : β),
ββ MeasurableSpace.countablePartition Ξ± n = Set.univ
|
ChartedSpaceCore.noConfusionType
|
Mathlib.Geometry.Manifold.ChartedSpace
|
Sort u β
{H : Type u_5} β
[inst : TopologicalSpace H] β
{M : Type u_6} β
ChartedSpaceCore H M β
{H' : Type u_5} β [inst' : TopologicalSpace H'] β {M' : Type u_6} β ChartedSpaceCore H' M' β Sort u
|
Submodule.lTensorOne'.eq_1
|
Mathlib.LinearAlgebra.TensorProduct.Submodule
|
β {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (N : Submodule R S),
N.lTensorOne' =
β(LinearEquiv.ofEq (LinearMap.range ((Subalgebra.toSubmodule β₯).mulMap N)) N β―) ββ
((Subalgebra.toSubmodule β₯).mulMap N).rangeRestrict
|
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_nontrivial_inv._simp_1_11
|
Mathlib.NumberTheory.JacobiSum.Basic
|
β {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : β), (βn + 1 = 0) = False
|
Lean.StructureFieldInfo.noConfusionType
|
Lean.Structure
|
Sort u β Lean.StructureFieldInfo β Lean.StructureFieldInfo β Sort u
|
UInt64.mul_assoc
|
Init.Data.UInt.Lemmas
|
β (a b c : UInt64), a * b * c = a * (b * c)
|
Batteries.Tactic.TransRelation._sizeOf_1
|
Batteries.Tactic.Trans
|
Batteries.Tactic.TransRelation β β
|
EuclideanGeometry.Sphere.secondInter_mem._simp_1
|
Mathlib.Geometry.Euclidean.Sphere.SecondInter
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p : P} (v : V), (s.secondInter p v β s) = (p β s)
|
Std.DHashMap.Raw.Const.get!_filter_of_getKey?_eq_some
|
Std.Data.DHashMap.RawLemmas
|
β {Ξ± : Type u} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {Ξ² : Type v} {m : Std.DHashMap.Raw Ξ± fun x => Ξ²} [EquivBEq Ξ±]
[LawfulHashable Ξ±] [inst_4 : Inhabited Ξ²] {f : Ξ± β Ξ² β Bool} {k k' : Ξ±},
m.WF β
m.getKey? k = some k' β
Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.filter f m) k =
(Option.filter (fun x => f k' x) (Std.DHashMap.Raw.Const.get? m k)).get!
|
_private.Lean.Meta.InferType.0.Lean.Meta.isArrowProposition'.match_1
|
Lean.Meta.InferType
|
(motive : Lean.Expr β β β Sort u_1) β
(x : Lean.Expr) β
(x_1 : β) β
((binderName : Lean.Name) β
(t b : Lean.Expr) β
(binderInfo : Lean.BinderInfo) β (n : β) β motive (Lean.Expr.forallE binderName t b binderInfo) n.succ) β
((declName : Lean.Name) β
(t value b : Lean.Expr) β (nondep : Bool) β (n : β) β motive (Lean.Expr.letE declName t value b nondep) n) β
((data : Lean.MData) β (e : Lean.Expr) β (n : β) β motive (Lean.Expr.mdata data e) n) β
((idx : β) β motive (Lean.Expr.bvar idx) 0) β
((type : Lean.Expr) β motive type 0) β ((x : Lean.Expr) β (x_2 : β) β motive x x_2) β motive x x_1
|
PowerBasis.mk.injEq
|
Mathlib.RingTheory.PowerBasis
|
β {R : Type u_7} {S : Type u_8} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (gen : S) (dim : β)
(basis : Module.Basis (Fin dim) R S) (basis_eq_pow : β (i : Fin dim), basis i = gen ^ βi) (gen_1 : S) (dim_1 : β)
(basis_1 : Module.Basis (Fin dim_1) R S) (basis_eq_pow_1 : β (i : Fin dim_1), basis_1 i = gen_1 ^ βi),
({ gen := gen, dim := dim, basis := basis, basis_eq_pow := basis_eq_pow } =
{ gen := gen_1, dim := dim_1, basis := basis_1, basis_eq_pow := basis_eq_pow_1 }) =
(gen = gen_1 β§ dim = dim_1 β§ basis β basis_1)
|
_private.Mathlib.ModelTheory.Basic.0.FirstOrder.Language.isEmpty_empty._simp_1
|
Mathlib.ModelTheory.Basic
|
β {Ξ± : Type u_4} {Ξ² : Type u_5}, IsEmpty (Ξ± β Ξ²) = (IsEmpty Ξ± β§ IsEmpty Ξ²)
|
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.realize_toPrenexImp._simp_1_2
|
Mathlib.ModelTheory.Complexity
|
β {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {Ξ± : Type u'} {l : β} {Ο Ο : L.BoundedFormula Ξ± l}
{v : Ξ± β M} {xs : Fin l β M}, (Ο.imp Ο).Realize v xs = (Ο.Realize v xs β Ο.Realize v xs)
|
sdiff_sdiff_le
|
Mathlib.Order.Heyting.Basic
|
β {Ξ± : Type u_2} [inst : GeneralizedCoheytingAlgebra Ξ±] {a b : Ξ±}, a \ (a \ b) β€ b
|
Lean.PrettyPrinter.Formatter.categoryFormatter
|
Lean.PrettyPrinter.Formatter
|
Lean.Name β Lean.PrettyPrinter.Formatter
|
_private.Init.Data.Array.Basic.0.Array.takeWhile.go._unary._proof_1
|
Init.Data.Array.Basic
|
β {Ξ± : Type u_1} (as : Array Ξ±) (i : β) (acc : Array Ξ±) (h : i < as.size),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i acc => as.size - i) β¨i + 1, acc.push as[i]β© β¨i, accβ©
|
Std.Time.Modifier.F
|
Std.Time.Format.Basic
|
Std.Time.Number β Std.Time.Modifier
|
StateRefT'.run
|
Init.Control.StateRef
|
{Ο Ο : Type} β {m : Type β Type} β [Monad m] β [MonadLiftT (ST Ο) m] β {Ξ± : Type} β StateRefT' Ο Ο m Ξ± β Ο β m (Ξ± Γ Ο)
|
IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers
|
Mathlib.RingTheory.DedekindDomain.AdicValuation
|
{R : Type u_1} β
[inst : CommRing R] β
[inst_1 : IsDedekindDomain R] β
(K : Type u_2) β
[inst_2 : Field K] β
[inst_3 : Algebra R K] β
[inst_4 : IsFractionRing R K] β
(v : IsDedekindDomain.HeightOneSpectrum R) β
ValuationSubring (IsDedekindDomain.HeightOneSpectrum.adicCompletion K v)
|
LinearOrderedAddCommGroup.negGen_eq_of_top
|
Mathlib.Algebra.Order.Group.Cyclic
|
β (G : Type u_1) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
[inst_3 : Nontrivial G] [inst_4 : IsAddCyclic G],
LinearOrderedAddCommGroup.negGen G = LinearOrderedAddCommGroup.Subgroup.negGen β€
|
IsCompl.sup_eq_top
|
Mathlib.Order.Disjoint
|
β {Ξ± : Type u_1} [inst : Lattice Ξ±] [inst_1 : BoundedOrder Ξ±] {x y : Ξ±}, IsCompl x y β x β y = β€
|
ENNReal.one_le_coe_iff._simp_1
|
Mathlib.Data.ENNReal.Basic
|
β {r : NNReal}, (1 β€ βr) = (1 β€ r)
|
MeasureTheory.crossing_eq_crossing_of_lowerCrossingTime_lt
|
Mathlib.Probability.Martingale.Upcrossing
|
β {Ξ© : Type u_1} {a b : β} {f : β β Ξ© β β} {N n : β} {Ο : Ξ©} {M : β},
N β€ M β
MeasureTheory.lowerCrossingTime a b f N n Ο < N β
MeasureTheory.upperCrossingTime a b f M n Ο = MeasureTheory.upperCrossingTime a b f N n Ο β§
MeasureTheory.lowerCrossingTime a b f M n Ο = MeasureTheory.lowerCrossingTime a b f N n Ο
|
AlgCat.instBraidedModuleCatForgetβ
|
Mathlib.Algebra.Category.AlgCat.Symmetric
|
{R : Type u} β [inst : CommRing R] β (CategoryTheory.forgetβ (AlgCat R) (ModuleCat R)).Braided
|
Std.Time.instHSubOffsetOffset_41
|
Std.Time.Date.Basic
|
HSub Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset
|
CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse._proof_6
|
Mathlib.CategoryTheory.Localization.Construction
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C) (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (G : W.FunctorsInverting D),
CategoryTheory.Localization.Construction.natTransExtension
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id G) (CategoryTheory.eqToHom β―))) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Localization.Construction.lift G.obj β―)
|
Filter.HasBasis.forall_iff
|
Mathlib.Order.Filter.Bases.Basic
|
β {Ξ± : Type u_1} {ΞΉ : Sort u_4} {l : Filter Ξ±} {p : ΞΉ β Prop} {s : ΞΉ β Set Ξ±},
l.HasBasis p s β
β {P : Set Ξ± β Prop}, (β β¦s t : Set Ξ±β¦, s β t β P s β P t) β ((β s β l, P s) β β (i : ΞΉ), p i β P (s i))
|
String.Pos.noConfusionType
|
Init.Data.String.Defs
|
Sort u β {s : String} β s.Pos β {s' : String} β s'.Pos β Sort u
|
AddGroup.ofLeftAxioms._proof_3
|
Mathlib.Algebra.Group.MinimalAxioms
|
β {G : Type u_1} [inst : Add G] [inst_1 : Zero G] (assoc : β (a b c : G), a + b + c = a + (b + c)) (n : β) (x : G),
nsmulRecAuto (n + 1) x = nsmulRecAuto (n + 1) x
|
UniformSpaceCat.instReflectiveCpltSepUniformSpaceForgetβ._proof_1
|
Mathlib.Topology.Category.UniformSpace
|
(CategoryTheory.forgetβ CpltSepUniformSpace UniformSpaceCat).Full
|
covariant_le_of_covariant_lt
|
Mathlib.Algebra.Order.Monoid.Unbundled.Defs
|
β (M : Type u_1) (N : Type u_2) (ΞΌ : M β N β N) [inst : PartialOrder N],
(Covariant M N ΞΌ fun x1 x2 => x1 < x2) β Covariant M N ΞΌ fun x1 x2 => x1 β€ x2
|
CategoryTheory.Functor.LaxBraided.mk
|
Mathlib.CategoryTheory.Monoidal.Braided.Basic
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
[inst_1 : CategoryTheory.MonoidalCategory C] β
[inst_2 : CategoryTheory.BraidedCategory C] β
{D : Type uβ} β
[inst_3 : CategoryTheory.Category.{vβ, uβ} D] β
[inst_4 : CategoryTheory.MonoidalCategory D] β
[inst_5 : CategoryTheory.BraidedCategory D] β
{F : CategoryTheory.Functor C D} β
[toLaxMonoidal : F.LaxMonoidal] β
autoParam
(β (X Y : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ΞΌ F X Y)
(F.map (Ξ²_ X Y).hom) =
CategoryTheory.CategoryStruct.comp (Ξ²_ (F.obj X) (F.obj Y)).hom
(CategoryTheory.Functor.LaxMonoidal.ΞΌ F Y X))
CategoryTheory.Functor.LaxBraided.braided._autoParam β
F.LaxBraided
|
Finite.of_addSubgroup_quotient
|
Mathlib.GroupTheory.QuotientGroup.Finite
|
β {G : Type u_2} [inst : AddGroup G] (H : AddSubgroup G) [Finite β₯H] [Finite (G β§Έ H)], Finite G
|
Lean.Elab.Term.Context.declName?
|
Lean.Elab.Term.TermElabM
|
Lean.Elab.Term.Context β Option Lean.Name
|
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.summable_residueClass_non_primes_div._simp_1_2
|
Mathlib.NumberTheory.LSeries.PrimesInAP
|
β {Gβ : Type u_3} [inst : GroupWithZero Gβ] {a b : Gβ}, (a / b = 0) = (a = 0 β¨ b = 0)
|
AddSubsemigroup.centerCongr_apply_coe
|
Mathlib.GroupTheory.Submonoid.Center
|
β {M : Type u_2} {N : Type u_1} [inst : Add M] [inst_1 : Add N] (e : M β+ N) (r : β₯(AddSubsemigroup.center M)),
β((AddSubsemigroup.centerCongr e) r) = e βr
|
Matrix.ofNat_mulVec
|
Mathlib.Data.Matrix.Mul
|
β {m : Type u_2} {Ξ± : Type v} [inst : NonAssocSemiring Ξ±] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (x : β)
[inst_3 : x.AtLeastTwo] (v : m β Ξ±), (OfNat.ofNat x).mulVec v = OfNat.ofNat x β’ v
|
SchwartzMap.fderivCLM._proof_5
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β (π : Type u_1) {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : RCLike π] [inst_2 : NormedSpace π F],
ContinuousConstSMul π F
|
Std.Iterators.IterM.toList_empty
|
Std.Data.Iterators.Lemmas.Producers.Monadic.Empty
|
β {m : Type u_1 β Type u_2} {Ξ² : Type u_1} [inst : Monad m] [LawfulMonad m],
(Std.Iterators.IterM.empty m Ξ²).toList = pure []
|
CategoryTheory.Bicategory.eqToHomTransIso._proof_1
|
Mathlib.CategoryTheory.Bicategory.EqToHom
|
β {B : Type u_1} {x y : B}, x = y β x = y
|
Semiring.toOppositeModule._proof_3
|
Mathlib.Algebra.Module.Opposite
|
β {R : Type u_1} [inst : Semiring R] (x x_1 : Rα΅α΅α΅) (x_2 : R),
x_2 * (MulOpposite.unop x + MulOpposite.unop x_1) = x_2 * MulOpposite.unop x + x_2 * MulOpposite.unop x_1
|
StarSubalgebra.one_mem_toNonUnitalStarSubalgebra
|
Mathlib.Algebra.Star.Subalgebra
|
β {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A),
1 β S.toNonUnitalStarSubalgebra
|
Primrec.ite
|
Mathlib.Computability.Primrec
|
β {Ξ± : Type u_1} {Ο : Type u_3} [inst : Primcodable Ξ±] [inst_1 : Primcodable Ο] {c : Ξ± β Prop}
[inst_2 : DecidablePred c] {f g : Ξ± β Ο},
PrimrecPred c β Primrec f β Primrec g β Primrec fun a => if c a then f a else g a
|
GroupTopology.instCompleteLattice._proof_1
|
Mathlib.Topology.Algebra.Group.GroupTopology
|
β {Ξ± : Type u_1} [inst : Group Ξ±] (a b : GroupTopology Ξ±), a β€ SemilatticeSup.sup a b
|
LieSubmodule.subsingleton_iff
|
Mathlib.Algebra.Lie.Submodule
|
β (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M], Subsingleton (LieSubmodule R L M) β Subsingleton M
|
Odd.exists_bit1
|
Mathlib.Algebra.Ring.Parity
|
β {Ξ± : Type u_2} [inst : Semiring Ξ±] {a : Ξ±}, Odd a β β b, a = 2 * b + 1
|
Int32.toUInt32_le
|
Init.Data.SInt.Lemmas
|
β {a b : Int32}, 0 β€ a β a β€ b β a.toUInt32 β€ b.toUInt32
|
Int16.or_neg_one
|
Init.Data.SInt.Bitwise
|
β {a : Int16}, a ||| -1 = -1
|
HomologicalComplexβ.shape_f
|
Mathlib.Algebra.Homology.HomologicalBicomplex
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{Iβ : Type u_2} {Iβ : Type u_3} {cβ : ComplexShape Iβ} {cβ : ComplexShape Iβ} (K : HomologicalComplexβ C cβ cβ)
(iβ iβ' : Iβ), Β¬cβ.Rel iβ iβ' β β (iβ : Iβ), (K.d iβ iβ').f iβ = 0
|
Cardinal.mul_eq_max_of_aleph0_le_right
|
Mathlib.SetTheory.Cardinal.Arithmetic
|
β {a b : Cardinal.{u_1}}, a β 0 β Cardinal.aleph0 β€ b β a * b = max a b
|
Prod.addAction._proof_2
|
Mathlib.Algebra.Group.Action.Prod
|
β {M : Type u_3} {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M Ξ±] [inst_2 : AddAction M Ξ²]
(x : Ξ± Γ Ξ²), 0 +α΅₯ x = x
|
HasSubset.casesOn
|
Init.Core
|
{Ξ± : Type u} β
{motive : HasSubset Ξ± β Sort u_1} β
(t : HasSubset Ξ±) β ((Subset : Ξ± β Ξ± β Prop) β motive { Subset := Subset }) β motive t
|
Std.DTreeMap.Β«term_~m_Β»
|
Std.Data.DTreeMap.Basic
|
Lean.TrailingParserDescr
|
Lean.Compiler.LCNF.CSE.instMonadFVarSubstStateM
|
Lean.Compiler.LCNF.CSE
|
Lean.Compiler.LCNF.MonadFVarSubstState Lean.Compiler.LCNF.CSE.M
|
SmoothBumpCovering.noConfusionType
|
Mathlib.Geometry.Manifold.PartitionOfUnity
|
Sort u β
{ΞΉ : Type uΞΉ} β
{E : Type uE} β
[inst : NormedAddCommGroup E] β
[inst_1 : NormedSpace β E] β
{H : Type uH} β
[inst_2 : TopologicalSpace H] β
{I : ModelWithCorners β E H} β
{M : Type uM} β
[inst_3 : TopologicalSpace M] β
[inst_4 : ChartedSpace H M] β
[inst_5 : FiniteDimensional β E] β
{s : Set M} β
SmoothBumpCovering ΞΉ I M s β
{ΞΉ' : Type uΞΉ} β
{E' : Type uE} β
[inst' : NormedAddCommGroup E'] β
[inst'_1 : NormedSpace β E'] β
{H' : Type uH} β
[inst'_2 : TopologicalSpace H'] β
{I' : ModelWithCorners β E' H'} β
{M' : Type uM} β
[inst'_3 : TopologicalSpace M'] β
[inst'_4 : ChartedSpace H' M'] β
[inst'_5 : FiniteDimensional β E'] β
{s' : Set M'} β SmoothBumpCovering ΞΉ' I' M' s' β Sort u
|
Filter.lift_iInf_of_directed
|
Mathlib.Order.Filter.Lift
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {ΞΉ : Sort u_4} [Nonempty ΞΉ] {f : ΞΉ β Filter Ξ±} {g : Set Ξ± β Filter Ξ²},
Directed (fun x1 x2 => x1 β₯ x2) f β Monotone g β (iInf f).lift g = β¨
i, (f i).lift g
|
ZFSet.choice_mem
|
Mathlib.SetTheory.ZFC.Class
|
β (x : ZFSet.{u}), β
β x β β y β x, βx.choice β² βy β βy
|
IsSquare.exists_sq
|
Mathlib.Algebra.Group.Even
|
β {Ξ± : Type u_2} [inst : Monoid Ξ±] (a : Ξ±), IsSquare a β β r, a = r ^ 2
|
Aesop.Frontend.BuilderOption.index.noConfusion
|
Aesop.Frontend.RuleExpr
|
{P : Sort u} β
{imode imode' : Aesop.IndexingMode} β
Aesop.Frontend.BuilderOption.index imode = Aesop.Frontend.BuilderOption.index imode' β (imode = imode' β P) β P
|
CategoryTheory.Equivalence.cancel_counitInv_right._simp_1
|
Mathlib.CategoryTheory.Equivalence
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
(e : C β D) {X Y : D} (f f' : X βΆ Y),
(CategoryTheory.CategoryStruct.comp f (e.counitInv.app Y) =
CategoryTheory.CategoryStruct.comp f' (e.counitInv.app Y)) =
(f = f')
|
MvPolynomial.mem_supported_vars
|
Mathlib.Algebra.MvPolynomial.Supported
|
β {Ο : Type u_1} {R : Type u} [inst : CommSemiring R] (p : MvPolynomial Ο R), p β MvPolynomial.supported R βp.vars
|
self_mem_nhdsWithin
|
Mathlib.Topology.NhdsWithin
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] {a : Ξ±} {s : Set Ξ±}, s β nhdsWithin a s
|
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabRunElab.unsafe_impl_5
|
Lean.Elab.BuiltinNotation
|
Lean.TSyntax `term β Lean.Elab.TermElabM (Option Lean.Expr β Lean.Elab.TermElabM Lean.Expr)
|
Nonneg.unitsHomeomorphPos._proof_1
|
Mathlib.Topology.Algebra.Field
|
β (R : Type u_1) [inst : DivisionSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : PosMulReflectLT R] [inst_4 : TopologicalSpace R], Continuous (Nonneg.unitsEquivPos R).toFun
|
IsSl2Triple.HasPrimitiveVectorWith.casesOn
|
Mathlib.Algebra.Lie.Sl2
|
{R : Type u_1} β
{L : Type u_2} β
{M : Type u_3} β
[inst : CommRing R] β
[inst_1 : LieRing L] β
[inst_2 : AddCommGroup M] β
[inst_3 : Module R M] β
[inst_4 : LieRingModule L M] β
{h e f : L} β
{t : IsSl2Triple h e f} β
{m : M} β
{ΞΌ : R} β
{motive : t.HasPrimitiveVectorWith m ΞΌ β Sort u} β
(t_1 : t.HasPrimitiveVectorWith m ΞΌ) β
((ne_zero : m β 0) β (lie_h : β
h, mβ = ΞΌ β’ m) β (lie_e : β
e, mβ = 0) β motive β―) β
motive t_1
|
SimpleGraph.Copy.isoSubgraphMap._simp_1
|
Mathlib.Combinatorics.SimpleGraph.Copy
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {Ξ΄ : Type u_4} {r : Ξ± β Ξ² β Prop} {f : Ξ± β Ξ³} {g : Ξ² β Ξ΄} {c : Ξ³}
{d : Ξ΄}, Relation.Map r f g c d = β a b, r a b β§ f a = c β§ g b = d
|
Aesop.Rapp.setState
|
Aesop.Tree.Data
|
Aesop.NodeState β Aesop.Rapp β Aesop.Rapp
|
Subrepresentation.instMax
|
Mathlib.RepresentationTheory.Subrepresentation
|
{A : Type u_1} β
[inst : CommRing A] β
{G : Type u_2} β
[inst_1 : Group G] β
{W : Type u_3} β
[inst_2 : AddCommMonoid W] β [inst_3 : Module A W] β {Ο : Representation A G W} β Max (Subrepresentation Ο)
|
List.find?_pmap.match_1
|
Init.Data.List.Find
|
{Ξ± : Type u_1} β
{xs : List Ξ±} β
(motive : { x // x β xs } β Sort u_2) β (x : { x // x β xs }) β ((a : Ξ±) β (m : a β xs) β motive β¨a, mβ©) β motive x
|
TwoSidedIdeal.jacobson
|
Mathlib.RingTheory.Jacobson.Ideal
|
{R : Type u} β [inst : Ring R] β TwoSidedIdeal R β TwoSidedIdeal R
|
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitCore.match_3
|
Lean.Compiler.LCNF.ToLCNF
|
(motive : Lean.Expr β Sort u_1) β
(e : Lean.Expr) β
((fn arg : Lean.Expr) β motive (fn.app arg)) β
((declName : Lean.Name) β (us : List Lean.Level) β motive (Lean.Expr.const declName us)) β
((s : Lean.Name) β (i : β) β (e : Lean.Expr) β motive (Lean.Expr.proj s i e)) β
((d : Lean.MData) β (e : Lean.Expr) β motive (Lean.Expr.mdata d e)) β
((binderName : Lean.Name) β
(binderType body : Lean.Expr) β
(binderInfo : Lean.BinderInfo) β motive (Lean.Expr.lam binderName binderType body binderInfo)) β
((declName : Lean.Name) β
(type value body : Lean.Expr) β
(nondep : Bool) β motive (Lean.Expr.letE declName type value body nondep)) β
((lit : Lean.Literal) β motive (Lean.Expr.lit lit)) β
((fvarId : Lean.FVarId) β motive (Lean.Expr.fvar fvarId)) β
((binderName : Lean.Name) β
(binderType body : Lean.Expr) β
(binderInfo : Lean.BinderInfo) β
motive (Lean.Expr.forallE binderName binderType body binderInfo)) β
((mvarId : Lean.MVarId) β motive (Lean.Expr.mvar mvarId)) β
((deBruijnIndex : β) β motive (Lean.Expr.bvar deBruijnIndex)) β
((u : Lean.Level) β motive (Lean.Expr.sort u)) β motive e
|
_private.Mathlib.RingTheory.WittVector.MulCoeff.0.WittVector._aux_Mathlib_RingTheory_WittVector_MulCoeff___unexpand_WittVector_1
|
Mathlib.RingTheory.WittVector.MulCoeff
|
Lean.PrettyPrinter.Unexpander
|
SchwartzMap.instLineDeriv._proof_1
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β (π : Type u_1) [inst : RCLike π], RingHomCompTriple (RingHom.id π) (RingHom.id π) (RingHom.id π)
|
Lean.Meta.repeat1'
|
Lean.Meta.Tactic.Repeat
|
{m : Type β Type} β
{Ξ΅ : Type u_1} β
{s : Type} β
[Monad m] β
[Lean.MonadError m] β
[MonadExcept Ξ΅ m] β
[Lean.MonadBacktrack s m] β
[Lean.MonadMCtx m] β
(Lean.MVarId β m (List Lean.MVarId)) β List Lean.MVarId β optParam β 100000 β m (List Lean.MVarId)
|
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Collector.Context.mk.injEq
|
Lean.Meta.Tactic.Grind.EMatchTheorem
|
β (proof : Lean.Expr) (xs : Array Lean.Expr) (proof_1 : Lean.Expr) (xs_1 : Array Lean.Expr),
({ proof := proof, xs := xs } = { proof := proof_1, xs := xs_1 }) = (proof = proof_1 β§ xs = xs_1)
|
Aesop.Script.SScript.empty
|
Aesop.Script.SScript
|
Aesop.Script.SScript
|
add_sub_assoc'
|
Mathlib.Algebra.Group.Basic
|
β {G : Type u_3} [inst : SubNegMonoid G] (a b c : G), a + (b - c) = a + b - c
|
RatFunc.toFractionRingAlgEquiv
|
Mathlib.FieldTheory.RatFunc.Basic
|
(K : Type u) β
[inst : CommRing K] β
[inst_1 : IsDomain K] β
(R : Type u_1) β
[inst_2 : CommSemiring R] β [inst_3 : Algebra R (Polynomial K)] β RatFunc K ββ[R] FractionRing (Polynomial K)
|
Algebra.Extension.algebraMap_Ο
|
Mathlib.RingTheory.Extension.Basic
|
β {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(self : Algebra.Extension R S) (x : S), (algebraMap self.Ring S) (self.Ο x) = x
|
List.not_lt_minimum_of_mem
|
Mathlib.Data.List.MinMax
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] [inst_1 : DecidableLT Ξ±] {l : List Ξ±} {a m : Ξ±}, a β l β l.minimum = βm β Β¬a < m
|
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalNestedTactic
|
Lean.Elab.Tactic.Grind.BuiltinTactic
|
Lean.Elab.Tactic.Grind.GrindTactic
|
_private.Init.Data.List.Nat.Basic.0.List.length_filterMap_lt_length_iff_exists._proof_1_5
|
Init.Data.List.Nat.Basic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Option Ξ²} (xs : List Ξ±),
(List.filterMap f xs).length β€ xs.length β Β¬(List.filterMap f xs).length < xs.length + 1 β False
|
Lean.Parser.Tactic.Conv.convLeft
|
Init.Conv
|
Lean.ParserDescr
|
Ideal.map_sup
|
Mathlib.RingTheory.Ideal.Maps
|
β {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
(I J : Ideal R) [RingHomClass F R S], Ideal.map f (I β J) = Ideal.map f I β Ideal.map f J
|
FirstOrder.Language.LHom.substructureReduct._proof_2
|
Mathlib.ModelTheory.Substructures
|
β {L : FirstOrder.Language} {M : Type u_3} [inst : L.Structure M] {L' : FirstOrder.Language} [inst_1 : L'.Structure M]
(Ο : L βα΄Έ L') [inst_2 : Ο.IsExpansionOn M] {x x_1 : L'.Substructure M},
{ toFun := fun S => { carrier := βS, fun_mem := β― }, inj' := β― } x β€
{ toFun := fun S => { carrier := βS, fun_mem := β― }, inj' := β― } x_1 β
{ toFun := fun S => { carrier := βS, fun_mem := β― }, inj' := β― } x β€
{ toFun := fun S => { carrier := βS, fun_mem := β― }, inj' := β― } x_1
|
AlgebraicGeometry.LocallyRingedSpace.HasCoequalizer.imageBasicOpen
|
Mathlib.Geometry.RingedSpace.LocallyRingedSpace.HasColimits
|
{X Y : AlgebraicGeometry.LocallyRingedSpace} β
(f g : X βΆ Y) β
(U :
TopologicalSpace.Opens
ββ(CategoryTheory.Limits.coequalizer (AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom f)
(AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom g)).toPresheafedSpace) β
β((CategoryTheory.Limits.coequalizer (AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom f)
(AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom g)).presheaf.obj
(Opposite.op U)) β
TopologicalSpace.Opens βY.toTopCat
|
unitarySubgroupUnitsEquiv._proof_7
|
Mathlib.Algebra.Star.Unitary
|
β {M : Type u_1} [inst : Monoid M] [inst_1 : StarMul M] (x : β₯(unitarySubgroup MΛ£)),
star { val := ββ¨ββx, β―β©, inv := star ββ¨ββx, β―β©, val_inv := β―, inv_val := β― } *
{ val := ββ¨ββx, β―β©, inv := star ββ¨ββx, β―β©, val_inv := β―, inv_val := β― } =
1 β§
{ val := ββ¨ββx, β―β©, inv := star ββ¨ββx, β―β©, val_inv := β―, inv_val := β― } *
star { val := ββ¨ββx, β―β©, inv := star ββ¨ββx, β―β©, val_inv := β―, inv_val := β― } =
1
|
NumberField.mixedEmbedding.instIsZLatticeRealMixedSpaceIntegerLattice
|
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic
|
β (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], IsZLattice β (NumberField.mixedEmbedding.integerLattice K)
|
Std.TreeMap.min?_keys
|
Std.Data.TreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeMap Ξ± Ξ² cmp} [Std.TransCmp cmp] [inst : Min Ξ±]
[inst_1 : LE Ξ±] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin Ξ±] [Std.LawfulOrderLeftLeaningMin Ξ±]
[Std.LawfulEqCmp cmp], t.keys.min? = t.minKey?
|
LocalizedModule.instRing._proof_2
|
Mathlib.Algebra.Module.LocalizedModule.Basic
|
β {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Submonoid R}
(n : β), (Int.negSucc n).castDef = (Int.negSucc n).castDef
|
BialgCat.Hom.mk.sizeOf_spec
|
Mathlib.Algebra.Category.BialgCat.Basic
|
β {R : Type u} [inst : CommRing R] {V W : BialgCat R} [inst_1 : SizeOf R] (toBialgHom' : V.carrier ββc[R] W.carrier),
sizeOf { toBialgHom' := toBialgHom' } = 1 + sizeOf toBialgHom'
|
Mathlib.Meta.NormNum.Result'.isNat.injEq
|
Mathlib.Tactic.NormNum.Result
|
β (inst lit proof inst_1 lit_1 proof_1 : Lean.Expr),
(Mathlib.Meta.NormNum.Result'.isNat inst lit proof = Mathlib.Meta.NormNum.Result'.isNat inst_1 lit_1 proof_1) =
(inst = inst_1 β§ lit = lit_1 β§ proof = proof_1)
|
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.IsBigO.fiberwise_right._simp_1_2
|
Mathlib.Analysis.Asymptotics.Defs
|
β {Ξ± : Type u} {f : Filter Ξ±} {P : Ξ± β Prop}, (βαΆ (x : Ξ±) in f, P x) = ({x | P x} β f)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.