name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
List.head_takeWhile
|
Init.Data.List.TakeDrop
|
β {Ξ± : Type u_1} {p : Ξ± β Bool} {l : List Ξ±} (w : List.takeWhile p l β []), (List.takeWhile p l).head w = l.head β―
|
StructureGroupoid.LocalInvariantProp.liftPropWithinAt_of_liftPropAt
|
Mathlib.Geometry.Manifold.LocalInvariantProperties
|
β {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H β H') β Set H β H β Prop} {g : M β M'}
{s : Set M} {x : M},
(β β¦s : Set Hβ¦ β¦x : Hβ¦ β¦t : Set Hβ¦ β¦f : H β H'β¦, t β s β P f s x β P f t x) β
ChartedSpace.LiftPropAt P g x β ChartedSpace.LiftPropWithinAt P g s x
|
Scott.IsOpen.inter
|
Mathlib.Topology.OmegaCompletePartialOrder
|
β (Ξ± : Type u) [inst : OmegaCompletePartialOrder Ξ±] (s t : Set Ξ±),
Scott.IsOpen Ξ± s β Scott.IsOpen Ξ± t β Scott.IsOpen Ξ± (s β© t)
|
OrderIso.toGaloisInsertion._proof_1
|
Mathlib.Order.GaloisConnection.Basic
|
β {Ξ± : Type u_2} {Ξ² : Type u_1} [inst : Preorder Ξ±] [inst_1 : Preorder Ξ²] (e : Ξ± βo Ξ²) (g : Ξ²), g β€ e (e.symm g)
|
Fin2.fs.injEq
|
Mathlib.Data.Fin.Fin2
|
β {n : β} (a a_1 : Fin2 n), (a.fs = a_1.fs) = (a = a_1)
|
Array.getElem_zero_filterMap._proof_1
|
Init.Data.Array.Find
|
β {Ξ± : Type u_2} {Ξ² : Type u_1} {f : Ξ± β Option Ξ²} {xs : Array Ξ±},
0 < (Array.filterMap f xs).size β (Array.findSome? f xs).isSome = true
|
_private.Mathlib.LinearAlgebra.Eigenspace.Pi.0.Module.End.independent_iInf_maxGenEigenspace_of_forall_mapsTo._simp_1_3
|
Mathlib.LinearAlgebra.Eigenspace.Pi
|
β {Ξ± : Type u_1} {ΞΉ : Type u_3} [inst : Lattice Ξ±] [inst_1 : OrderBot Ξ±] {s : Finset ΞΉ} {f : ΞΉ β Ξ±}
[inst_2 : DecidableEq ΞΉ], s.SupIndep f = β i β s, Disjoint (f i) ((s.erase i).sup f)
|
Finset.right_eq_union
|
Mathlib.Data.Finset.Lattice.Basic
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {s t : Finset Ξ±}, s = t βͺ s β t β s
|
IsPrimitiveRoot.norm_pow_sub_one_of_prime_pow_ne_two
|
Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots
|
β {p : β} {K : Type u} {L : Type v} [inst : Field L] {ΞΆ : L} [inst_1 : Field K] [inst_2 : Algebra K L] {k s : β},
IsPrimitiveRoot ΞΆ (p ^ (k + 1)) β
β [hpri : Fact (Nat.Prime p)] [IsCyclotomicExtension {p ^ (k + 1)} K L],
Irreducible (Polynomial.cyclotomic (p ^ (k + 1)) K) β
s β€ k β p ^ (k - s + 1) β 2 β (Algebra.norm K) (ΞΆ ^ p ^ s - 1) = βp ^ p ^ s
|
_private.Lean.Elab.AutoBound.0.Lean.Elab.checkValidAutoBoundImplicitName._sparseCasesOn_1
|
Lean.Elab.AutoBound
|
{motive : Lean.Name β Sort u} β
(t : Lean.Name) β
((pre : Lean.Name) β (str : String) β motive (pre.str str)) β (Nat.hasNotBit 2 t.ctorIdx β motive t) β motive t
|
Matrix.subsingleton_of_empty_left
|
Mathlib.LinearAlgebra.Matrix.Defs
|
β {m : Type u_2} {n : Type u_3} {Ξ± : Type v} [IsEmpty m], Subsingleton (Matrix m n Ξ±)
|
OrthonormalBasis.det_to_matrix_orthonormalBasis_of_same_orientation
|
Mathlib.Analysis.InnerProductSpace.Orientation
|
β {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace β E] {ΞΉ : Type u_2} [inst_2 : Fintype ΞΉ]
[inst_3 : DecidableEq ΞΉ] (e f : OrthonormalBasis ΞΉ β E),
e.toBasis.orientation = f.toBasis.orientation β e.toBasis.det βf = 1
|
Vector.insertIdx._proof_2
|
Init.Data.Vector.Basic
|
β {Ξ± : Type u_1} {n : β} (xs : Vector Ξ± n), β i β€ n, i β€ xs.toArray.size
|
MonomialOrder.degLex_single_le_iff
|
Mathlib.Data.Finsupp.MonomialOrder.DegLex
|
β {Ο : Type u_2} [inst : LinearOrder Ο] [inst_1 : WellFoundedGT Ο] {a b : Ο},
((MonomialOrder.degLex.toSyn funβ | a => 1) β€ MonomialOrder.degLex.toSyn funβ | b => 1) β b β€ a
|
CategoryTheory.Limits.WidePushout.hom_eq_desc._proof_1
|
Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks
|
β {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {objs : J β C}
(arrows : (j : J) β B βΆ objs j) [inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C}
(g : CategoryTheory.Limits.widePushout B objs arrows βΆ X) (j : J),
CategoryTheory.CategoryStruct.comp (arrows j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePushout.ΞΉ arrows j) g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePushout.head arrows) g
|
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?.go.match_1
|
Lean.Meta.Tactic.Grind.EMatchTheorem
|
(motive : Option (List Lean.Expr Γ List Lean.HeadIndex) β Sort u_1) β
(__discr : Option (List Lean.Expr Γ List Lean.HeadIndex)) β
((patterns : List Lean.Expr) β (symbols : List Lean.HeadIndex) β motive (some (patterns, symbols))) β
((x : Option (List Lean.Expr Γ List Lean.HeadIndex)) β motive x) β motive __discr
|
BddDistLat.hom_ext
|
Mathlib.Order.Category.BddDistLat
|
β {X Y : BddDistLat} {f g : X βΆ Y}, BddDistLat.Hom.hom f = BddDistLat.Hom.hom g β f = g
|
AlgebraicGeometry.ProjIsoSpecTopComponent.toSpec
|
Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme
|
{A : Type u_1} β
{Ο : Type u_2} β
[inst : CommRing A] β
[inst_1 : SetLike Ο A] β
[inst_2 : AddSubgroupClass Ο A] β
(π : β β Ο) β
[inst_3 : GradedRing π] β
(f : A) β
β((AlgebraicGeometry.Proj.toLocallyRingedSpace π).restrict β―).toPresheafedSpace βΆ
β(AlgebraicGeometry.Spec.locallyRingedSpaceObj
{ carrier := HomogeneousLocalization.Away π f,
commRing := HomogeneousLocalization.homogeneousLocalizationCommRing }).toPresheafedSpace
|
Mathlib.Meta.FunProp.MaybeFunctionData.recOn
|
Mathlib.Tactic.FunProp.FunctionData
|
{motive : Mathlib.Meta.FunProp.MaybeFunctionData β Sort u} β
(t : Mathlib.Meta.FunProp.MaybeFunctionData) β
((f : Lean.Expr) β motive (Mathlib.Meta.FunProp.MaybeFunctionData.letE f)) β
((f : Lean.Expr) β motive (Mathlib.Meta.FunProp.MaybeFunctionData.lam f)) β
((fData : Mathlib.Meta.FunProp.FunctionData) β motive (Mathlib.Meta.FunProp.MaybeFunctionData.data fData)) β
motive t
|
Lean.Elab.Tactic.EvalTacticFailure.rec
|
Lean.Elab.Tactic.Basic
|
{motive : Lean.Elab.Tactic.EvalTacticFailure β Sort u} β
((exception : Lean.Exception) β
(state : Lean.Elab.Tactic.SavedState) β motive { exception := exception, state := state }) β
(t : Lean.Elab.Tactic.EvalTacticFailure) β motive t
|
Lean.Doc.Syntax.linebreak
|
Lean.DocString.Syntax
|
Lean.ParserDescr
|
CliffordAlgebra.instStarRing._proof_3
|
Mathlib.LinearAlgebra.CliffordAlgebra.Star
|
β {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x y : CliffordAlgebra Q),
CliffordAlgebra.reverse (CliffordAlgebra.involute (x + y)) =
CliffordAlgebra.reverse (CliffordAlgebra.involute x) + CliffordAlgebra.reverse (CliffordAlgebra.involute y)
|
Lean.Meta.Grind.propagateMatchCondDown._regBuiltin.Lean.Meta.Grind.propagateMatchCondDown.declare_1._@.Lean.Meta.Tactic.Grind.MatchCond.2992396906._hygCtx._hyg.8
|
Lean.Meta.Tactic.Grind.MatchCond
|
IO Unit
|
Representation.single_smul
|
Mathlib.RepresentationTheory.Basic
|
β {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (Ο : Representation k G V) (t : k) (g : G) (v : Ο.asModule),
MonoidAlgebra.single g t β’ v = t β’ (Ο g) (Ο.asModuleEquiv v)
|
CategoryTheory.LocalizerMorphism.homMap_apply_assoc
|
Mathlib.CategoryTheory.Localization.HomEquiv
|
β {Cβ : Type u_2} {Cβ : Type u_3} {Dβ : Type u_5} {Dβ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} Cβ]
[inst_1 : CategoryTheory.Category.{v_3, u_3} Cβ] [inst_2 : CategoryTheory.Category.{v_5, u_5} Dβ]
[inst_3 : CategoryTheory.Category.{v_6, u_6} Dβ] {Wβ : CategoryTheory.MorphismProperty Cβ}
{Wβ : CategoryTheory.MorphismProperty Cβ} (Ξ¦ : CategoryTheory.LocalizerMorphism Wβ Wβ)
(Lβ : CategoryTheory.Functor Cβ Dβ) [inst_4 : Lβ.IsLocalization Wβ] (Lβ : CategoryTheory.Functor Cβ Dβ)
[inst_5 : Lβ.IsLocalization Wβ] {X Y : Cβ} (G : CategoryTheory.Functor Dβ Dβ) (e : Ξ¦.functor.comp Lβ β
Lβ.comp G)
(f : Lβ.obj X βΆ Lβ.obj Y) {Z : Dβ} (h : Lβ.obj (Ξ¦.functor.obj Y) βΆ Z),
CategoryTheory.CategoryStruct.comp (Ξ¦.homMap Lβ Lβ f) h =
CategoryTheory.CategoryStruct.comp (e.hom.app X)
(CategoryTheory.CategoryStruct.comp (G.map f) (CategoryTheory.CategoryStruct.comp (e.inv.app Y) h))
|
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTRβ.eq_1
|
Init.Data.List.Sort.Impl
|
β {Ξ± : Type u_1} (l : List Ξ±) (le : Ξ± β Ξ± β Bool),
List.MergeSort.Internal.mergeSortTRβ l le = List.MergeSort.Internal.mergeSortTRβ.runβ le β¨l, β―β©
|
Bool.atLeastTwo_false_left
|
Init.Data.BitVec.Bitblast
|
β {b c : Bool}, false.atLeastTwo b c = (b && c)
|
List.pairwise_lt_finRange
|
Batteries.Data.List.Lemmas
|
β (n : β), List.Pairwise (fun x1 x2 => x1 < x2) (List.finRange n)
|
CommGrpCat.Forgetβ.createsLimit._proof_12
|
Mathlib.Algebra.Category.Grp.Limits
|
β {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommGrpCat)
(this : Small.{u_2, max u_2 u_3} β(F.comp (CategoryTheory.forget CommGrpCat)).sections)
(this_1 :
Small.{u_2, max u_2 u_3}
β((F.comp ((CategoryTheory.forgetβ CommGrpCat GrpCat).comp (CategoryTheory.forgetβ GrpCat MonCat))).comp
(CategoryTheory.forget MonCat)).sections)
(s : CategoryTheory.Limits.Cone F),
((CategoryTheory.forgetβ CommGrpCat GrpCat).comp (CategoryTheory.forgetβ GrpCat MonCat)).map
{
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.forgetβ CommGrpCat GrpCat).comp (CategoryTheory.forgetβ GrpCat MonCat)).map
{
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' := β― } }
|
meromorphicOrderAt_const_intCast
|
Mathlib.Analysis.Meromorphic.Order
|
β {π : Type u_1} [inst : NontriviallyNormedField π] (zβ : π) (n : β€) [inst_1 : Decidable (βn = 0)],
meromorphicOrderAt (βn) zβ = if βn = 0 then β€ else 0
|
Fintype.sum_neg_iff_of_nonpos
|
Mathlib.Algebra.Order.BigOperators.Group.Finset
|
β {ΞΉ : Type u_1} {M : Type u_4} [inst : Fintype ΞΉ] [inst_1 : AddCommMonoid M] [inst_2 : PartialOrder M]
[IsOrderedCancelAddMonoid M] {f : ΞΉ β M}, f β€ 0 β (β i, f i < 0 β f < 0)
|
Std.Tactic.BVDecide.Gate.eval.eq_4
|
Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic
|
Std.Tactic.BVDecide.Gate.or.eval = fun x1 x2 => x1 || x2
|
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.instFintypeElemProdNatSetOfLtSndCountFst._simp_10
|
Mathlib.Data.Multiset.Fintype
|
β {a b : Prop}, (a β§ b β b) = (b β a)
|
Lean.Meta.Grind.AC.addTermOpId
|
Lean.Meta.Tactic.Grind.AC.Util
|
Lean.Expr β Lean.Meta.Grind.AC.ACM Unit
|
SimpleGraph.isSubgraph_eq_le
|
Mathlib.Combinatorics.SimpleGraph.Basic
|
β {V : Type u}, SimpleGraph.IsSubgraph = fun x1 x2 => x1 β€ x2
|
Std.Internal.List.getValueCast?_modifyKey_self
|
Std.Data.Internal.List.Associative
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : BEq Ξ±] [inst_1 : LawfulBEq Ξ±] {k : Ξ±} {f : Ξ² k β Ξ² k}
(l : List ((a : Ξ±) Γ Ξ² a)),
Std.Internal.List.DistinctKeys l β
Std.Internal.List.getValueCast? k (Std.Internal.List.modifyKey k f l) =
Option.map f (Std.Internal.List.getValueCast? k l)
|
Submodule.adjoint_orthogonalProjection
|
Mathlib.Analysis.InnerProductSpace.Adjoint
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
[inst_3 : CompleteSpace E] (U : Submodule π E) [inst_4 : CompleteSpace β₯U],
ContinuousLinearMap.adjoint U.orthogonalProjection = U.subtypeL
|
MonoidHom.coe_of_map_div
|
Mathlib.Algebra.Group.Hom.Basic
|
β {G : Type u_5} [inst : Group G] {H : Type u_8} [inst_1 : Group H] (f : G β H)
(hf : β (x y : G), f (x / y) = f x / f y), β(MonoidHom.ofMapDiv f hf) = f
|
Std.Tactic.BVDecide.BVExpr.Return.recOn
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr
|
{aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} β
{w : β} β
{motive : Std.Tactic.BVDecide.BVExpr.Return aig w β Sort u} β
(t : Std.Tactic.BVDecide.BVExpr.Return aig w) β
((result : aig.ExtendingRefVecEntry w) β
(cache : Std.Tactic.BVDecide.BVExpr.Cache (βresult).aig) β motive { result := result, cache := cache }) β
motive t
|
_private.Mathlib.Data.Finset.Range.0.notMemRangeEquiv._proof_2
|
Mathlib.Data.Finset.Range
|
β (k j : β), k + j β Finset.range k
|
MulZeroMemClass.isCancelMulZero
|
Mathlib.Algebra.GroupWithZero.Submonoid.CancelMulZero
|
β {Mβ : Type u_1} [inst : Mul Mβ] [inst_1 : Zero Mβ] {S : Type u_2} [inst_2 : SetLike S Mβ] [inst_3 : MulMemClass S Mβ]
[inst_4 : ZeroMemClass S Mβ] (s : S) [IsCancelMulZero Mβ], IsCancelMulZero β₯s
|
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.AffineSpace.nhds_bind_asymptoticNhds._simp_1_1
|
Mathlib.Topology.Algebra.AsymptoticCone
|
β {Ξ± : Type u_1} {f g : Filter Ξ±}, (f β€ g) = β x β g, x β f
|
Filter.pureAddMonoidHom
|
Mathlib.Order.Filter.Pointwise
|
{Ξ± : Type u_2} β [inst : AddZeroClass Ξ±] β Ξ± β+ Filter Ξ±
|
CategoryTheory.Enriched.FunctorCategory.enrichedHom_condition_assoc
|
Mathlib.CategoryTheory.Enriched.FunctorCategory
|
β (V : Type uβ) [inst : CategoryTheory.Category.{vβ, uβ} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type uβ}
[inst_2 : CategoryTheory.Category.{vβ, uβ} C] {J : Type uβ} [inst_3 : CategoryTheory.Category.{vβ, uβ} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] (Fβ Fβ : CategoryTheory.Functor J C)
[inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V Fβ Fβ] {i j : J} (f : i βΆ j) {Z : V}
(h : (Fβ.obj i βΆ[V] Fβ.obj j) βΆ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomΟ V Fβ Fβ i)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eHomWhiskerLeft V (Fβ.obj i) (Fβ.map f)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomΟ V Fβ Fβ j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eHomWhiskerRight V (Fβ.map f) (Fβ.obj j)) h)
|
MeasureTheory.sdiff_addFundamentalFrontier
|
Mathlib.MeasureTheory.Group.FundamentalDomain
|
β (G : Type u_1) {Ξ± : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G Ξ±] (s : Set Ξ±),
s \ MeasureTheory.addFundamentalFrontier G s = MeasureTheory.addFundamentalInterior G s
|
Stream'.homomorphism
|
Mathlib.Data.Stream.Init
|
β {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Ξ²) (a : Ξ±), Stream'.pure f β Stream'.pure a = Stream'.pure (f a)
|
_private.Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField.0.AlgebraicGeometry.LocallyRingedSpace.basicOpen_eq_bot_iff_forall_evaluation_eq_zero._simp_1_1
|
Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField
|
β {Ξ± : Sort u} {p : Ξ± β Prop} {q : { a // p a } β Prop}, (β (x : { a // p a }), q x) = β (a : Ξ±) (b : p a), q β¨a, bβ©
|
DFinsupp.nonempty_neLocus_iff
|
Mathlib.Data.DFinsupp.NeLocus
|
β {Ξ± : Type u_1} {N : Ξ± β Type u_2} [inst : DecidableEq Ξ±] [inst_1 : (a : Ξ±) β DecidableEq (N a)]
[inst_2 : (a : Ξ±) β Zero (N a)] {f g : Ξ β (a : Ξ±), N a}, (f.neLocus g).Nonempty β f β g
|
Module.mapEvalEquiv._proof_1
|
Mathlib.LinearAlgebra.Dual.Defs
|
β (R : Type u_1) [inst : CommSemiring R], RingHomSurjective (RingHom.id R)
|
Num.instOrOp
|
Mathlib.Data.Num.Bitwise
|
OrOp Num
|
AlgebraicGeometry.StructureSheaf.const_apply
|
Mathlib.AlgebraicGeometry.StructureSheaf
|
β (R : Type u) [inst : CommRing R] (f g : R) (U : TopologicalSpace.Opens β(AlgebraicGeometry.PrimeSpectrum.Top R))
(hu : β x β U, g β x.asIdeal.primeCompl) (x : β₯U),
β(AlgebraicGeometry.StructureSheaf.const R f g U hu) x =
IsLocalization.mk' (Localization.AtPrime (βx).asIdeal) f β¨g, β―β©
|
Submodule.mem_toAffineSubspace._simp_1
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs
|
β {k : Type u_1} {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] {p : Submodule k V}
{x : V}, (x β p.toAffineSubspace) = (x β p)
|
Lean.Meta.SolveByElim.SolveByElimConfig.testSolutions
|
Lean.Meta.Tactic.SolveByElim
|
optParam Lean.Meta.SolveByElim.SolveByElimConfig { } β
(List Lean.Expr β Lean.MetaM Bool) β Lean.Meta.SolveByElim.SolveByElimConfig
|
CategoryTheory.MorphismProperty.pushout_inl
|
Mathlib.CategoryTheory.MorphismProperty.Limits
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderCobaseChange] {A B A' : C} (f : A βΆ A') (g : A βΆ B) [inst_2 : CategoryTheory.Limits.HasPushout f g],
P g β P (CategoryTheory.Limits.pushout.inl f g)
|
ContinuousSemilinearEquivClass.map_continuous
|
Mathlib.Topology.Algebra.Module.Equiv
|
β {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Semiring R} {inst_1 : Semiring S}
{Ο : outParam (R β+* S)} {Ο' : outParam (S β+* R)} {inst_2 : RingHomInvPair Ο Ο'} {inst_3 : RingHomInvPair Ο' Ο}
{M : outParam (Type u_4)} {inst_4 : TopologicalSpace M} {inst_5 : AddCommMonoid M} {Mβ : outParam (Type u_5)}
{inst_6 : TopologicalSpace Mβ} {inst_7 : AddCommMonoid Mβ} {inst_8 : Module R M} {inst_9 : Module S Mβ}
{inst_10 : EquivLike F M Mβ} [self : ContinuousSemilinearEquivClass F Ο M Mβ] (f : F), Continuous βf
|
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_map_Οβ
|
Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence
|
β (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (Ο : X βΆ Y),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).map Ο).Οβ =
CategoryTheory.Functor.whiskerRight Ο CategoryTheory.ShortComplex.Οβ
|
Polynomial.cyclotomic_irreducible_pow_of_irreducible_pow
|
Mathlib.RingTheory.Polynomial.Cyclotomic.Expand
|
β {p : β},
Nat.Prime p β
β {R : Type u_1} [inst : CommRing R] [IsDomain R] {n m : β},
m β€ n β Irreducible (Polynomial.cyclotomic (p ^ n) R) β Irreducible (Polynomial.cyclotomic (p ^ m) R)
|
_private.Mathlib.Data.Seq.Computation.0.Stream'.cons.match_1.eq_2
|
Mathlib.Data.Seq.Computation
|
β (motive : β β Sort u_1) (n : β) (h_1 : Unit β motive 0) (h_2 : (n : β) β motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n
|
Lean.Name.componentsRev._sunfold
|
Lean.Data.Name
|
Lean.Name β List Lean.Name
|
PartialEquiv.image_symm_image_of_subset_target
|
Mathlib.Logic.Equiv.PartialEquiv
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} (e : PartialEquiv Ξ± Ξ²) {s : Set Ξ²}, s β e.target β βe '' (βe.symm '' s) = s
|
DistLat.Iso.mk._proof_2
|
Mathlib.Order.Category.DistLat
|
β {Ξ± Ξ² : DistLat} (e : βΞ± βo βΞ²),
CategoryTheory.CategoryStruct.comp (DistLat.ofHom { toFun := βe, map_sup' := β―, map_inf' := β― })
(DistLat.ofHom { toFun := βe.symm, map_sup' := β―, map_inf' := β― }) =
CategoryTheory.CategoryStruct.id Ξ±
|
instCoeTCAddEquivOfAddEquivClass
|
Mathlib.Algebra.Group.Equiv.Defs
|
{F : Type u_1} β
{Ξ± : Type u_2} β
{Ξ² : Type u_3} β
[inst : EquivLike F Ξ± Ξ²] β [inst_1 : Add Ξ±] β [inst_2 : Add Ξ²] β [AddEquivClass F Ξ± Ξ²] β CoeTC F (Ξ± β+ Ξ²)
|
DistribLattice.ofInfSupLe._proof_2
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u_1} [inst : Lattice Ξ±] (inf_sup_le : β (a b c : Ξ±), a β (b β c) β€ a β b β a β c) (a b : Ξ±α΅α΅α΅α΅),
Lattice.inf a b β€ b
|
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.maxView.match_1.splitter
|
Std.Data.DTreeMap.Internal.Model
|
{Ξ± : Type u_1} β
{Ξ² : Ξ± β Type u_2} β
(l : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(motive :
(r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
r.Balanced β Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size β Sort u_3) β
(r : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(hr : r.Balanced) β
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size) β
((hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) β
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size Std.DTreeMap.Internal.Impl.leaf.size) β
motive Std.DTreeMap.Internal.Impl.leaf hr hlr) β
((size : β) β
(k' : Ξ±) β
(v' : Ξ² k') β
(l' r' : Std.DTreeMap.Internal.Impl Ξ± Ξ²) β
(hr : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) β
(hlr :
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size) β
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') hr hlr) β
motive r hr hlr
|
Aesop.UnorderedArraySet.partition
|
Aesop.Util.UnorderedArraySet
|
{Ξ± : Type u_1} β
[inst : BEq Ξ±] β (Ξ± β Bool) β Aesop.UnorderedArraySet Ξ± β Aesop.UnorderedArraySet Ξ± Γ Aesop.UnorderedArraySet Ξ±
|
CategoryTheory.Limits.Trident.ofΞΉ._proof_1
|
Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers
|
β {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J β (X βΆ Y)}
[inst_1 : Nonempty J] {P : C} (ΞΉ : P βΆ X),
(β (jβ jβ : J), CategoryTheory.CategoryStruct.comp ΞΉ (f jβ) = CategoryTheory.CategoryStruct.comp ΞΉ (f jβ)) β
β (i j : CategoryTheory.Limits.WalkingParallelFamily J) (f_1 : i βΆ j),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj P).map f_1)
(CategoryTheory.Limits.WalkingParallelFamily.casesOn j ΞΉ
(CategoryTheory.CategoryStruct.comp ΞΉ (f (Classical.arbitrary J)))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.WalkingParallelFamily.casesOn i ΞΉ
(CategoryTheory.CategoryStruct.comp ΞΉ (f (Classical.arbitrary J))))
((CategoryTheory.Limits.parallelFamily f).map f_1)
|
analyticOrderAt_mul_eq_top_of_right
|
Mathlib.Analysis.Analytic.Order
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {f g : π β π} {zβ : π},
analyticOrderAt g zβ = β€ β analyticOrderAt (f * g) zβ = β€
|
_private.Mathlib.Algebra.TrivSqZeroExt.0._aux_Mathlib_Algebra_TrivSqZeroExt___unexpand_TrivSqZeroExt_1
|
Mathlib.Algebra.TrivSqZeroExt
|
Lean.PrettyPrinter.Unexpander
|
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getSepFromSplice._sparseCasesOn_1
|
Lean.Elab.Quotation
|
{motive_1 : Lean.Syntax β Sort u} β
(t : Lean.Syntax) β
((info : Lean.SourceInfo) β (val : String) β motive_1 (Lean.Syntax.atom info val)) β
(Nat.hasNotBit 4 t.ctorIdx β motive_1 t) β motive_1 t
|
Lean.Lsp.CompletionParams._sizeOf_inst
|
Lean.Data.Lsp.LanguageFeatures
|
SizeOf Lean.Lsp.CompletionParams
|
_private.Mathlib.MeasureTheory.PiSystem.0.piiUnionInter_singleton._simp_1_6
|
Mathlib.MeasureTheory.PiSystem
|
β {Ξ± : Type u_1} {a b : Ξ±}, (b β {a}) = (b = a)
|
CliffordAlgebra.ofBaseChange_tmul_one
|
Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange
|
β {R : Type u_1} (A : Type u_2) {V : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : AddCommGroup V]
[inst_3 : Algebra R A] [inst_4 : Module R V] [inst_5 : Invertible 2] (Q : QuadraticForm R V) (z : A),
(CliffordAlgebra.ofBaseChange A Q) (z ββ[R] 1) = (algebraMap A (CliffordAlgebra (QuadraticForm.baseChange A Q))) z
|
WithVal
|
Mathlib.Topology.Algebra.Valued.WithVal
|
{R : Type u_1} β
{Ξβ : Type u_2} β [inst : LinearOrderedCommGroupWithZero Ξβ] β [inst_1 : Ring R] β Valuation R Ξβ β Type u_1
|
Int.add_shiftLeft
|
Init.Data.Int.Bitwise.Lemmas
|
β (a b : β€) (n : β), (a + b) <<< n = a <<< n + b <<< n
|
_private.Mathlib.Order.InitialSeg.0.collapseF
|
Mathlib.Order.InitialSeg
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
{r : Ξ± β Ξ± β Prop} β {s : Ξ² β Ξ² β Prop} β [IsWellOrder Ξ² s] β (f : r βͺr s) β (a : Ξ±) β { b // Β¬s (f a) b }
|
TrivSqZeroExt.commRing._proof_8
|
Mathlib.Algebra.TrivSqZeroExt
|
β {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rα΅α΅α΅ M] (a : TrivSqZeroExt R M), a * 1 = a
|
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Grind.AC.Seq.findSimpAC?.match_4
|
Lean.Meta.Tactic.Grind.AC.Eq
|
(motive : Option (Option (Lean.Meta.Grind.AC.EqCnstr Γ Lean.Grind.AC.SubsetResult)) β Sort u_1) β
(x : Option (Option (Lean.Meta.Grind.AC.EqCnstr Γ Lean.Grind.AC.SubsetResult))) β
(Unit β motive none) β
((a : Option (Lean.Meta.Grind.AC.EqCnstr Γ Lean.Grind.AC.SubsetResult)) β motive (some a)) β motive x
|
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.MeromorphicOn.extract_zeros_poles_log._simp_1_3
|
Mathlib.Analysis.Meromorphic.FactorizedRational
|
β {Mβ : Type u_1} [inst : MulZeroClass Mβ] [NoZeroDivisors Mβ] {a b : Mβ}, (a * b = 0) = (a = 0 β¨ b = 0)
|
Quiver.FreeGroupoid.quotInv
|
Mathlib.CategoryTheory.Groupoid.FreeGroupoid
|
{V : Type u} β [inst : Quiver V] β {X Y : Quiver.FreeGroupoid V} β (X βΆ Y) β (Y βΆ X)
|
AlgebraicGeometry.IsSmoothOfRelativeDimension.exists_isStandardSmoothOfRelativeDimension
|
Mathlib.AlgebraicGeometry.Morphisms.Smooth
|
β {n : β} {X Y : AlgebraicGeometry.Scheme} {f : X βΆ Y} [self : AlgebraicGeometry.IsSmoothOfRelativeDimension n f]
(x : β₯X),
β U V,
β (_ : x β βV) (e : βV β€ (TopologicalSpace.Opens.map f.base).obj βU),
RingHom.IsStandardSmoothOfRelativeDimension n
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f (βU) (βV) e))
|
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_subsingleton._simp_1_1
|
Mathlib.RingTheory.Spectrum.Prime.FreeLocus
|
β {Ξ± : Type u} {s : Set Ξ±}, (s = β
) = β (x : Ξ±), x β s
|
List.getElem_pmap
|
Init.Data.List.Attach
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {p : Ξ± β Prop} (f : (a : Ξ±) β p a β Ξ²) {l : List Ξ±} (h : β a β l, p a) {i : β}
(hn : i < (List.pmap f l h).length), (List.pmap f l h)[i] = f l[i] β―
|
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_1.eq_1
|
Std.Data.DTreeMap.Internal.Zipper
|
β (motive : Ordering β Sort u_1) (h_1 : Unit β motive Ordering.lt) (h_2 : Unit β motive Ordering.eq)
(h_3 : Unit β motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 ()
|
CategoryTheory.Limits.Fork.IsLimit.homIso._proof_4
|
Mathlib.CategoryTheory.Limits.Shapes.Equalizers
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X βΆ Y}
{t : CategoryTheory.Limits.Fork f g} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (x : Z βΆ t.pt),
β(CategoryTheory.Limits.Fork.IsLimit.lift' ht ββ¨CategoryTheory.CategoryStruct.comp x t.ΞΉ, β―β© β―) = x
|
CategoryTheory.Limits.cospanCompIso_inv_app_left
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
(F : CategoryTheory.Functor C D) {X Y Z : C} (f : X βΆ Z) (g : Y βΆ Z),
(CategoryTheory.Limits.cospanCompIso F f g).inv.app CategoryTheory.Limits.WalkingCospan.left =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.cospan (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingCospan.left)
|
EuclideanGeometry.Sphere.ext_iff
|
Mathlib.Geometry.Euclidean.Sphere.Basic
|
β {P : Type u_2} {inst : MetricSpace P} {x y : EuclideanGeometry.Sphere P},
x = y β x.center = y.center β§ x.radius = y.radius
|
Fin.image_castSucc_Ioi
|
Mathlib.Order.Interval.Set.Fin
|
β {n : β} (i : Fin n), Fin.castSucc '' Set.Ioi i = Set.Ioo i.castSucc (Fin.last n)
|
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0.wrapped._proof_1._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.1784184353._hygCtx._hyg.8
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital
|
@definitionβ = @definitionβ
|
Lean.PrettyPrinter.OneLine.State.mk._flat_ctor
|
Lean.PrettyPrinter.Formatter
|
Std.Format β β β List (β Γ Std.Format) β Lean.PrettyPrinter.OneLine.State
|
lt_sSup_iff
|
Mathlib.Order.CompleteLattice.Defs
|
β {Ξ± : Type u_1} [inst : CompleteLinearOrder Ξ±] {s : Set Ξ±} {b : Ξ±}, b < sSup s β β a β s, b < a
|
Lean.Compiler.LCNF.Simp.CtorInfo.ctor.inj
|
Lean.Compiler.LCNF.Simp.DiscrM
|
β {val : Lean.ConstructorVal} {args : Array Lean.Compiler.LCNF.Arg} {val_1 : Lean.ConstructorVal}
{args_1 : Array Lean.Compiler.LCNF.Arg},
Lean.Compiler.LCNF.Simp.CtorInfo.ctor val args = Lean.Compiler.LCNF.Simp.CtorInfo.ctor val_1 args_1 β
val = val_1 β§ args = args_1
|
Std.ExtDTreeMap.getKey_insert_self
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp] {k : Ξ±}
{v : Ξ² k}, (t.insert k v).getKey k β― = k
|
CategoryTheory.Functor.LaxMonoidal.tensorHom_Ξ΅_comp_ΞΌ_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]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] {X : C} {Y : D} (f : Y βΆ F.obj X) {Z : D}
(h :
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) βΆ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom f (CategoryTheory.Functor.LaxMonoidal.Ξ΅ F))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ΞΌ F X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f (CategoryTheory.MonoidalCategoryStruct.tensorUnit D))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv) h))
|
CategoryTheory.Lax.OplaxTrans.vCompNaturality
|
Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax
|
{B : Type uβ} β
[inst : CategoryTheory.Bicategory B] β
{C : Type uβ} β
[inst_1 : CategoryTheory.Bicategory C] β
{F G H : CategoryTheory.LaxFunctor B C} β
(Ξ· : CategoryTheory.Lax.OplaxTrans F G) β
(ΞΈ : CategoryTheory.Lax.OplaxTrans G H) β
{a b : B} β
(f : a βΆ b) β
CategoryTheory.CategoryStruct.comp (F.map f)
(CategoryTheory.CategoryStruct.comp (Ξ·.app b) (ΞΈ.app b)) βΆ
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (Ξ·.app a) (ΞΈ.app a))
(H.map f)
|
Ordering.isEq
|
Init.Data.Ord.Basic
|
Ordering β Bool
|
List.Vector.set._proof_1
|
Mathlib.Data.Vector.Basic
|
β {Ξ± : Type u_1} {n : β} (v : List.Vector Ξ± n) (i : Fin n) (a : Ξ±), ((βv).set (βi) a).length = n
|
CategoryTheory.Subpresheaf.lift.congr_simp
|
Mathlib.CategoryTheory.Subpresheaf.Image
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor Cα΅α΅ (Type w)} (f f_1 : F' βΆ F)
(e_f : f = f_1) {G : CategoryTheory.Subpresheaf F} (hf : CategoryTheory.Subpresheaf.range f β€ G),
CategoryTheory.Subpresheaf.lift f hf = CategoryTheory.Subpresheaf.lift f_1 β―
|
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.map_mono._simp_1_1
|
Mathlib.Combinatorics.SimpleGraph.Subgraph
|
β {Ξ± : Type u} {Ξ² : Type v} (f : Ξ± β Ξ²) (s : Set Ξ±) (y : Ξ²), (y β f '' s) = β x β s, f x = y
|
List.ofFn_congr
|
Mathlib.Data.List.OfFn
|
β {Ξ± : Type u} {m n : β} (h : m = n) (f : Fin m β Ξ±), List.ofFn f = List.ofFn fun i => f (Fin.cast β― i)
|
Std.DTreeMap.Raw.self_le_maxKey?_insert
|
Std.Data.DTreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.DTreeMap.Raw Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
(h : t.WF) {k : Ξ±} {v : Ξ² k} {kmi : Ξ±}, (t.insert k v).maxKey?.get β― = kmi β (cmp k kmi).isLE = true
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.