name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Real.Wallis.W._proof_1
|
Mathlib.Analysis.Real.Pi.Wallis
|
(1 + 1).AtLeastTwo
|
CategoryTheory.GradedObject.mapBifunctorMapMapIso._proof_1
|
Mathlib.CategoryTheory.GradedObject.Bifunctor
|
β {Cβ : Type u_5} {Cβ : Type u_7} {Cβ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} Cβ]
[inst_1 : CategoryTheory.Category.{u_6, u_7} Cβ] [inst_2 : CategoryTheory.Category.{u_2, u_3} Cβ]
(F : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ Cβ)) {I : Type u_8} {J : Type u_9} {K : Type u_1}
(p : I Γ J β K) {Xβ Xβ : CategoryTheory.GradedObject I Cβ} {Yβ Yβ : CategoryTheory.GradedObject J Cβ}
[inst_3 : (((CategoryTheory.GradedObject.mapBifunctor F I J).obj Xβ).obj Yβ).HasMap p]
[inst_4 : (((CategoryTheory.GradedObject.mapBifunctor F I J).obj Xβ).obj Yβ).HasMap p] (e : Xβ β
Xβ) (e' : Yβ β
Yβ),
CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapBifunctorMapMap F p e.hom e'.hom)
(CategoryTheory.GradedObject.mapBifunctorMapMap F p e.inv e'.inv) =
CategoryTheory.CategoryStruct.id (CategoryTheory.GradedObject.mapBifunctorMapObj F p Xβ Yβ)
|
Set.one_subset
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
β {Ξ± : Type u_2} [inst : One Ξ±] {s : Set Ξ±}, 1 β s β 1 β s
|
Std.ExtDTreeMap.Const.ordered_keys_toList
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {Ξ² : Type v} {t : Std.ExtDTreeMap Ξ± (fun x => Ξ²) cmp} [inst : Std.TransCmp cmp],
List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) (Std.ExtDTreeMap.Const.toList t)
|
Batteries.Tactic.Instances._aux_Batteries_Tactic_Instances___elabRules_Batteries_Tactic_Instances_instancesCmd_1
|
Batteries.Tactic.Instances
|
Lean.Elab.Command.CommandElab
|
Lean.Elab.Tactic.Omega.Justification.combine.sizeOf_spec
|
Lean.Elab.Tactic.Omega.Core
|
β {s t : Lean.Omega.Constraint} {c : Lean.Omega.Coeffs} (j : Lean.Elab.Tactic.Omega.Justification s c)
(k : Lean.Elab.Tactic.Omega.Justification t c),
sizeOf (j.combine k) = 1 + sizeOf s + sizeOf t + sizeOf c + sizeOf j + sizeOf k
|
Fin.cast_rev
|
Mathlib.Data.Fin.Rev
|
β {n m : β} (i : Fin n) (h : n = m), Fin.cast h i.rev = (Fin.cast h i).rev
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.instReprSupportedTermKind.repr.match_1
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr
|
(motive : Lean.Meta.Grind.Arith.Cutsat.SupportedTermKindβ β Sort u_1) β
(x : Lean.Meta.Grind.Arith.Cutsat.SupportedTermKindβΒΉ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.addβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mulβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.numβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.divβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.modβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.subβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.powβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbsβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.toNatβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natCastβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.negβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.toIntβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.finValβ) β
(Unit β motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.finMkβ) β motive x
|
FP.RMode.NE.sizeOf_spec
|
Mathlib.Data.FP.Basic
|
sizeOf FP.RMode.NE = 1
|
Std.DTreeMap.Raw.Const.getD_inter_of_not_mem_left
|
Std.Data.DTreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {Ξ² : Type v} {mβ mβ : Std.DTreeMap.Raw Ξ± (fun x => Ξ²) cmp} [Std.TransCmp cmp],
mβ.WF β mβ.WF β β {k : Ξ±} {fallback : Ξ²}, k β mβ β Std.DTreeMap.Raw.Const.getD (mβ β© mβ) k fallback = fallback
|
CategoryTheory.Bicategory.instIsIsoHomLeftZigzagHom
|
Mathlib.CategoryTheory.Bicategory.Adjunction.Basic
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a βΆ b} {g : b βΆ a}
(Ξ· : CategoryTheory.CategoryStruct.id a β
CategoryTheory.CategoryStruct.comp f g)
(Ξ΅ : CategoryTheory.CategoryStruct.comp g f β
CategoryTheory.CategoryStruct.id b),
CategoryTheory.IsIso (CategoryTheory.Bicategory.leftZigzag Ξ·.hom Ξ΅.hom)
|
Lean.LocalContext.findDecl?
|
Lean.LocalContext
|
{Ξ² : Type u_1} β Lean.LocalContext β (Lean.LocalDecl β Option Ξ²) β Option Ξ²
|
_private.Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite.0.CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.generator
|
Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{D : Type v} β
[inst_1 : CategoryTheory.SmallCategory D] β
CategoryTheory.Functor D Cα΅α΅ β
[inst_2 : CategoryTheory.Abelian C] β [CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] β Cα΅α΅
|
Lists'.mem_of_subset'
|
Mathlib.SetTheory.Lists
|
β {Ξ± : Type u_1} {a : Lists Ξ±} {lβ lβ : Lists' Ξ± true}, lβ β lβ β a β lβ.toList β a β lβ
|
_private.Mathlib.Data.Finset.NatDivisors.0.Nat.divisors_mul._simp_1_2
|
Mathlib.Data.Finset.NatDivisors
|
β {n m : β}, (n β m.divisors) = (n β£ m β§ m β 0)
|
ModP.preVal_eq_zero
|
Mathlib.RingTheory.Perfection
|
β {K : Type uβ} [inst : Field K] {v : Valuation K NNReal} {O : Type uβ} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O β β {p : β} {x : ModP O p}, ModP.preVal K v O p x = 0 β x = 0
|
Finset.mem_coe
|
Mathlib.Data.Finset.Defs
|
β {Ξ± : Type u_1} {a : Ξ±} {s : Finset Ξ±}, a β βs β a β s
|
Lean.SubExpr.Pos.pushAppFn
|
Lean.SubExpr
|
Lean.SubExpr.Pos β Lean.SubExpr.Pos
|
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_of_linearIndepOn_of_finite_span._simp_1_13
|
Mathlib.LinearAlgebra.LinearIndependent.Lemmas
|
β {Ξ± : Type u} {a b : Set Ξ±}, (a = b) = β (x : Ξ±), x β a β x β b
|
MonoidAlgebra.liftNCAlgHom._proof_1
|
Mathlib.Algebra.MonoidAlgebra.Basic
|
β {k : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring k] [inst_1 : Semiring A] [inst_2 : Algebra k A]
[inst_3 : Semiring B] [inst_4 : Algebra k B], RingHomClass (A ββ[k] B) A B
|
ContDiffWithinAt.congr_of_mem
|
Mathlib.Analysis.Calculus.ContDiff.Defs
|
β {π : Type u} [inst : NontriviallyNormedField π] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {s : Set E}
{f fβ : E β F} {x : E} {n : WithTop ββ},
ContDiffWithinAt π n f s x β (β y β s, fβ y = f y) β x β s β ContDiffWithinAt π n fβ s x
|
isIntegral_algebraMap_iff
|
Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic
|
β {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] {x : A},
Function.Injective β(algebraMap A B) β (IsIntegral R ((algebraMap A B) x) β IsIntegral R x)
|
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.SatelliteConfig.exists_normalized_aux3._simp_1_4
|
Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace
|
β {Ξ± : Type u_2} [inst : Zero Ξ±] [inst_1 : OfNat Ξ± 3] [NeZero 3], (3 = 0) = False
|
dimH_orthogonalProjection_le
|
Mathlib.Topology.MetricSpace.HausdorffDimension
|
β {π : Type u_6} {E : Type u_7} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
(K : Submodule π E) [inst_3 : K.HasOrthogonalProjection] (s : Set E), dimH (βK.orthogonalProjection '' s) β€ dimH s
|
Nat.zero_shiftRight
|
Init.Data.Nat.Lemmas
|
β (n : β), 0 >>> n = 0
|
Mathlib.Meta.Positivity.evalAddNorm
|
Mathlib.Analysis.Normed.Group.Basic
|
Mathlib.Meta.Positivity.PositivityExt
|
CategoryTheory.Limits.coconeEquivalenceOpConeOp._proof_1
|
Mathlib.CategoryTheory.Limits.Cones
|
β {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J C)
{X Y : CategoryTheory.Limits.Cocone F} (f : X βΆ Y) (j : Jα΅α΅),
CategoryTheory.CategoryStruct.comp f.hom.op (X.op.Ο.app j) = Y.op.Ο.app j
|
CategoryTheory.Limits.IsZero.isoZero
|
Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : CategoryTheory.Limits.HasZeroObject C] β {X : C} β CategoryTheory.Limits.IsZero X β (X β
0)
|
FreeMonoid.length_eq_four
|
Mathlib.Algebra.FreeMonoid.Basic
|
β {Ξ± : Type u_1} {v : FreeMonoid Ξ±},
v.length = 4 β β a b c d, v = FreeMonoid.of a * FreeMonoid.of b * FreeMonoid.of c * FreeMonoid.of d
|
Lean.instBEqReducibilityStatus.beq
|
Lean.ReducibilityAttrs
|
Lean.ReducibilityStatus β Lean.ReducibilityStatus β Bool
|
Std.TreeMap.Raw.getElem!_ofList_of_contains_eq_false
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} [Std.TransCmp cmp] [inst : BEq Ξ±] [Std.LawfulBEqCmp cmp]
{l : List (Ξ± Γ Ξ²)} {k : Ξ±} [inst_2 : Inhabited Ξ²],
(List.map Prod.fst l).contains k = false β (Std.TreeMap.Raw.ofList l cmp)[k]! = default
|
SemidirectProduct.congr'_apply_left
|
Mathlib.GroupTheory.SemidirectProduct
|
β {Nβ : Type u_4} {Gβ : Type u_5} {Nβ : Type u_6} {Gβ : Type u_7} [inst : Group Nβ] [inst_1 : Group Gβ]
[inst_2 : Group Nβ] [inst_3 : Group Gβ] {Οβ : Gβ β* MulAut Nβ} (fn : Nβ β* Nβ) (fg : Gβ β* Gβ) (x : Nβ β[Οβ] Gβ),
((SemidirectProduct.congr' fn fg) x).left = fn x.left
|
Booleanisation.instPartialOrder
|
Mathlib.Order.Booleanisation
|
{Ξ± : Type u_1} β [GeneralizedBooleanAlgebra Ξ±] β PartialOrder (Booleanisation Ξ±)
|
Subsemigroup.op_eq_top._simp_4
|
Mathlib.Algebra.Group.Subsemigroup.MulOpposite
|
β {M : Type u_2} [inst : Add M] {S : AddSubsemigroup M}, (S.op = β€) = (S = β€)
|
Module.Relations.Solution.ofΟ.congr_simp
|
Mathlib.Algebra.Module.Presentation.Basic
|
β {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (Ο Ο_1 : (relations.G ββ A) ββ[A] M) (e_Ο : Ο = Ο_1)
(hΟ : β (r : relations.R), Ο (relations.relation r) = 0),
Module.Relations.Solution.ofΟ Ο hΟ = Module.Relations.Solution.ofΟ Ο_1 β―
|
right_le_midpoint
|
Mathlib.LinearAlgebra.AffineSpace.Ordered
|
β {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, b β€ midpoint k a b β b β€ a
|
CochainComplex.ΞΉMapBifunctor.congr_simp
|
Mathlib.Algebra.Homology.BifunctorShift
|
β {Cβ : Type u_1} {Cβ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} Cβ]
[inst_1 : CategoryTheory.Category.{v_2, u_2} Cβ] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms Cβ] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms Cβ]
(Kβ : CochainComplex Cβ β€) (Kβ : CochainComplex Cβ β€) [inst_5 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ D)) [inst_6 : F.PreservesZeroMorphisms]
[inst_7 : β (Xβ : Cβ), (F.obj Xβ).PreservesZeroMorphisms] [inst_8 : Kβ.HasMapBifunctor Kβ F] (nβ nβ n : β€)
(h : nβ + nβ = n), Kβ.ΞΉMapBifunctor Kβ F nβ nβ n h = Kβ.ΞΉMapBifunctor Kβ F nβ nβ n h
|
OneHomClass.toOneHom.eq_1
|
Mathlib.Algebra.Group.Hom.Defs
|
β {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
[inst_3 : OneHomClass F M N] (f : F), βf = { toFun := βf, map_one' := β― }
|
Lean.Meta.pp.showLetValues.threshold
|
Lean.Meta.PPGoal
|
Lean.Option β
|
BooleanAlgebra.lt._inherited_default
|
Mathlib.Order.BooleanAlgebra.Defs
|
{Ξ± : Type u} β (Ξ± β Ξ± β Prop) β Ξ± β Ξ± β Prop
|
Finset.map_comp_coe_apply
|
Mathlib.Data.Finset.Functor
|
β {Ξ± Ξ² : Type u} (h : Ξ± β Ξ²) (s : Multiset Ξ±), Finset.image h s.toFinset = (h <$> s).toFinset
|
Algebra.SubmersivePresentation.jacobian_isUnit
|
Mathlib.RingTheory.Extension.Presentation.Submersive
|
β {R : Type u} {S : Type v} {ΞΉ : Type w} {Ο : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Finite Ο] (self : Algebra.SubmersivePresentation R S ΞΉ Ο), IsUnit self.jacobian
|
Pi.mulActionWithZero._proof_1
|
Mathlib.Algebra.GroupWithZero.Action.Pi
|
β {I : Type u_1} {f : I β Type u_2} (Ξ± : Type u_3) [inst : MonoidWithZero Ξ±] [inst_1 : (i : I) β Zero (f i)]
[inst_2 : (i : I) β MulActionWithZero Ξ± (f i)] (a : Ξ±), a β’ 0 = 0
|
ENNReal.holderTriple_coe_iff._simp_1
|
Mathlib.Data.Real.ConjExponents
|
β {p q r : NNReal}, r β 0 β (βp).HolderTriple βq βr = p.HolderTriple q r
|
Pretrivialization.toPartialEquiv_injective
|
Mathlib.Topology.FiberBundle.Trivialization
|
β {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z β B}
[Nonempty F], Function.Injective Pretrivialization.toPartialEquiv
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.append_assoc'._proof_1
|
Init.Data.BitVec.Lemmas
|
β {wβ wβ wβ : β}, Β¬wβ + wβ + wβ = wβ + (wβ + wβ) β False
|
MulActionHom.congr_fun
|
Mathlib.GroupTheory.GroupAction.Hom
|
β {M : Type u_2} {N : Type u_3} {Ο : M β N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{f g : X ββ[Ο] Y}, f = g β β (x : X), f x = g x
|
Partition.mk.inj
|
Mathlib.Order.Partition.Basic
|
β {Ξ± : Type u_1} {inst : CompleteLattice Ξ±} {s : Ξ±} {parts : Set Ξ±} {sSupIndep' : sSupIndep parts}
{bot_notMem' : β₯ β parts} {sSup_eq' : sSup parts = s} {parts_1 : Set Ξ±} {sSupIndep'_1 : sSupIndep parts_1}
{bot_notMem'_1 : β₯ β parts_1} {sSup_eq'_1 : sSup parts_1 = s},
{ parts := parts, sSupIndep' := sSupIndep', bot_notMem' := bot_notMem', sSup_eq' := sSup_eq' } =
{ parts := parts_1, sSupIndep' := sSupIndep'_1, bot_notMem' := bot_notMem'_1, sSup_eq' := sSup_eq'_1 } β
parts = parts_1
|
ENNReal.eventuallyEq_of_toReal_eventuallyEq
|
Mathlib.Topology.Instances.ENNReal.Lemmas
|
β {Ξ± : Type u_1} {l : Filter Ξ±} {f g : Ξ± β ENNReal},
(βαΆ (x : Ξ±) in l, f x β β€) β
(βαΆ (x : Ξ±) in l, g x β β€) β ((fun x => (f x).toReal) =αΆ [l] fun x => (g x).toReal) β f =αΆ [l] g
|
PartialEquiv.symm
|
Mathlib.Logic.Equiv.PartialEquiv
|
{Ξ± : Type u_1} β {Ξ² : Type u_2} β PartialEquiv Ξ± Ξ² β PartialEquiv Ξ² Ξ±
|
Std.ExtDHashMap.Const.contains_modify
|
Std.Data.ExtDHashMap.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Type v} {m : Std.ExtDHashMap Ξ± fun x => Ξ²} [inst : EquivBEq Ξ±]
[inst_1 : LawfulHashable Ξ±] {k k' : Ξ±} {f : Ξ² β Ξ²}, (Std.ExtDHashMap.Const.modify m k f).contains k' = m.contains k'
|
deriv_fun_finset_prod
|
Mathlib.Analysis.Calculus.Deriv.Mul
|
β {π : Type u} [inst : NontriviallyNormedField π] {x : π} {ΞΉ : Type u_2} [inst_1 : DecidableEq ΞΉ] {πΈ' : Type u_3}
[inst_2 : NormedCommRing πΈ'] [inst_3 : NormedAlgebra π πΈ'] {u : Finset ΞΉ} {f : ΞΉ β π β πΈ'},
(β i β u, DifferentiableAt π (f i) x) β
deriv (fun x => β i β u, f i x) x = β i β u, (β j β u.erase i, f j x) β’ deriv (f i) x
|
Wbtw.neg
|
Mathlib.Analysis.Convex.Between
|
β {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] {x y z : V}, Wbtw R x y z β Wbtw R (-x) (-y) (-z)
|
Polynomial.map_modByMonic
|
Mathlib.Algebra.Polynomial.Div
|
β {R : Type u} {S : Type v} [inst : Ring R] {p q : Polynomial R} [inst_1 : Ring S] (f : R β+* S),
q.Monic β Polynomial.map f (p %β q) = Polynomial.map f p %β Polynomial.map f q
|
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.getDeprecatedInfo.match_1
|
Mathlib.Tactic.Linter.FindDeprecations
|
(motive : Option Lean.Name β Sort u_1) β
(__do_lift : Option Lean.Name) β
((mod : Lean.Name) β motive (some mod)) β ((x : Option Lean.Name) β motive x) β motive __do_lift
|
Lean.Elab.Tactic.Do.Context.simpCtx
|
Lean.Elab.Tactic.Do.VCGen.Basic
|
Lean.Elab.Tactic.Do.Context β Lean.Meta.Simp.Context
|
RingCon.quotientKerEquivOfSurjective
|
Mathlib.RingTheory.Congruence.Hom
|
{M : Type u_1} β
{P : Type u_3} β
[inst : NonAssocSemiring M] β
[inst_1 : NonAssocSemiring P] β (f : M β+* P) β Function.Surjective βf β (RingCon.ker f).Quotient β+* P
|
InvariantBasisNumber.casesOn
|
Mathlib.LinearAlgebra.InvariantBasisNumber
|
{R : Type u} β
[inst : Semiring R] β
{motive : InvariantBasisNumber R β Sort u_1} β
(t : InvariantBasisNumber R) β
((eq_of_fin_equiv : β {n m : β} (a : (Fin n β R) ββ[R] Fin m β R), n = m) β motive β―) β motive t
|
Pi.single_opβ
|
Mathlib.Algebra.Notation.Pi.Basic
|
β {ΞΉ : Type u_1} {M : ΞΉ β Type u_6} {N : ΞΉ β Type u_7} {O : ΞΉ β Type u_8} [inst : (i : ΞΉ) β Zero (M i)]
[inst_1 : (i : ΞΉ) β Zero (N i)] [inst_2 : (i : ΞΉ) β Zero (O i)] [inst_3 : DecidableEq ΞΉ]
(op : (i : ΞΉ) β M i β N i β O i),
(β (i : ΞΉ), op i 0 0 = 0) β
β (i : ΞΉ) (x : M i) (y : N i), Pi.single i (op i x y) = fun j => op j (Pi.single i x j) (Pi.single i y j)
|
Std.DTreeMap.Internal.Impl.isEmpty_alter!
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [Std.TransOrd Ξ±]
[inst : Std.LawfulEqOrd Ξ±],
t.WF β
β {k : Ξ±} {f : Option (Ξ² k) β Option (Ξ² k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).isEmpty =
((t.isEmpty || t.size == 1 && Std.DTreeMap.Internal.Impl.contains k t) && (f (t.get? k)).isNone)
|
_private.Mathlib.Data.Multiset.Sym.0.Multiset.setOf_mem_sym2._simp_1_1
|
Mathlib.Data.Multiset.Sym
|
β {Ξ± : Type u_1} {m : Multiset Ξ±} {a b : Ξ±}, (s(a, b) β m.sym2) = (a β m β§ b β m)
|
ENNReal.inv_three_add_inv_three
|
Mathlib.Data.ENNReal.Inv
|
3β»ΒΉ + 3β»ΒΉ + 3β»ΒΉ = 1
|
ULift.nonAssocSemiring._proof_2
|
Mathlib.Algebra.Ring.ULift
|
β {R : Type u_2} [inst : NonAssocSemiring R] (a : ULift.{u_1, u_2} R), a * 1 = a
|
Aesop.Options'.generateScript
|
Aesop.Options.Internal
|
Aesop.Options' β Bool
|
CategoryTheory.Preadditive.comp_sub_assoc
|
Mathlib.CategoryTheory.Preadditive.Basic
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C} (f : P βΆ Q)
(g g' : Q βΆ R) {Z : C} (h : R βΆ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (g - g') h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp f g - CategoryTheory.CategoryStruct.comp f g') h
|
RingQuot.instSub
|
Mathlib.Algebra.RingQuot
|
{R : Type uR} β [inst : Ring R] β (r : R β R β Prop) β Sub (RingQuot r)
|
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augment.match_3.eq_3
|
Mathlib.Algebra.Homology.Augment
|
β (motive : β β β β Sort u_1) (x x_1 : β) (h_1 : Unit β motive 1 0) (h_2 : (i j : β) β motive i.succ j.succ)
(h_3 : (x x_2 : β) β motive x x_2),
(x = 1 β x_1 = 0 β False) β
(β (i j : β), x = i.succ β x_1 = j.succ β False) β
(match x, x_1 with
| 1, 0 => h_1 ()
| i.succ, j.succ => h_2 i j
| x, x_4 => h_3 x x_4) =
h_3 x x_1
|
Lean.Order.instPartialOrderStateRefT'
|
Init.Internal.Order.Basic
|
{m : Type β Type} β
{Ο Ο Ξ± : Type} β [inst : Lean.Order.PartialOrder (m Ξ±)] β Lean.Order.PartialOrder (StateRefT' Ο Ο m Ξ±)
|
getElem_congr_coll
|
Init.GetElem
|
β {coll : Type u_1} {idx : Type u_2} {elem : Type u_3} {valid : coll β idx β Prop} [inst : GetElem coll idx elem valid]
{c d : coll} {i : idx} {w : valid c i} (h : c = d), c[i] = d[i]
|
AlgebraicGeometry.RingedSpace.mem_top_basicOpen._simp_1
|
Mathlib.Geometry.RingedSpace.Basic
|
β (X : AlgebraicGeometry.RingedSpace) (f : β(X.presheaf.obj (Opposite.op β€))) (x : ββX.toPresheafedSpace),
(x β X.basicOpen f) = IsUnit ((CategoryTheory.ConcreteCategory.hom (X.presheaf.Ξgerm x)) f)
|
QuadraticMap.IsOrtho.symm
|
Mathlib.LinearAlgebra.QuadraticForm.Basic
|
β {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M}, Q.IsOrtho x y β Q.IsOrtho y x
|
Lean.Elab.Term.Quotation.HeadCheck._sizeOf_1
|
Lean.Elab.Quotation
|
Lean.Elab.Term.Quotation.HeadCheck β β
|
Mathlib.Meta.FunProp.LambdaTheorems.mk.noConfusion
|
Mathlib.Tactic.FunProp.Theorems
|
{P : Sort u} β
{theorems theorems' :
Std.HashMap (Lean.Name Γ Mathlib.Meta.FunProp.LambdaTheoremType) (Array Mathlib.Meta.FunProp.LambdaTheorem)} β
{ theorems := theorems } = { theorems := theorems' } β (theorems = theorems' β P) β P
|
Ideal.map_includeRight_eq
|
Mathlib.LinearAlgebra.TensorProduct.RightExactness
|
β {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} {B : Type u_3} [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B),
Submodule.restrictScalars R (Ideal.map Algebra.TensorProduct.includeRight I) =
LinearMap.range (LinearMap.lTensor A (Submodule.restrictScalars R I).subtype)
|
Hyperreal.termΞ΅
|
Mathlib.Analysis.Real.Hyperreal
|
Lean.ParserDescr
|
Filter.map_mul
|
Mathlib.Order.Filter.Pointwise
|
β {F : Type u_1} {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : Mul Ξ±] [inst_1 : Mul Ξ²] {fβ fβ : Filter Ξ±}
[inst_2 : FunLike F Ξ± Ξ²] [MulHomClass F Ξ± Ξ²] (m : F),
Filter.map (βm) (fβ * fβ) = Filter.map (βm) fβ * Filter.map (βm) fβ
|
Pi.smulZeroClass._proof_1
|
Mathlib.Algebra.GroupWithZero.Action.Pi
|
β {I : Type u_1} {f : I β Type u_2} (Ξ± : Type u_3) {n : (i : I) β Zero (f i)} [inst : (i : I) β SMulZeroClass Ξ± (f i)]
(x : Ξ±), x β’ 0 = 0
|
Int.fdiv_nonneg
|
Init.Data.Int.DivMod.Lemmas
|
β {a b : β€}, 0 β€ a β 0 β€ b β 0 β€ a.fdiv b
|
Affine.Simplex.incenter_mem_interior
|
Mathlib.Geometry.Euclidean.Incenter
|
β {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : β} [inst_4 : NeZero n] (s : Affine.Simplex β P n), s.incenter β s.interior
|
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame
|
Lean.DocString.Extension
|
Type
|
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.TendstoLocallyUniformlyOn.deriv._simp_1_2
|
Mathlib.Analysis.Complex.LocallyUniformLimit
|
β (Ξ± : Sort u), (β (a : Ξ±), True) = True
|
tprod_apply
|
Mathlib.Topology.Algebra.InfiniteSum.Constructions
|
β {Ξ± : Type u_1} {ΞΉ : Type u_4} {X : Ξ± β Type u_5} [inst : (x : Ξ±) β CommMonoid (X x)]
[inst_1 : (x : Ξ±) β TopologicalSpace (X x)] {L : SummationFilter ΞΉ} [L.NeBot] [β (x : Ξ±), T2Space (X x)]
{f : ΞΉ β (x : Ξ±) β X x} {x : Ξ±}, Multipliable f L β (β'[L] (i : ΞΉ), f i) x = β'[L] (i : ΞΉ), f i x
|
CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCoconeIsColimit._proof_1
|
Mathlib.CategoryTheory.Monad.Limits
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {T : CategoryTheory.Comonad C}
(D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget))
(t : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cocone D) (j : J),
CategoryTheory.CategoryStruct.comp (c.ΞΉ.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone D c t).pt.a
(T.map (t.desc (T.forget.mapCocone s)))) =
CategoryTheory.CategoryStruct.comp (c.ΞΉ.app j)
(CategoryTheory.CategoryStruct.comp (t.desc (T.forget.mapCocone s)) s.pt.a)
|
HahnSeries.coeff_zero
|
Mathlib.RingTheory.HahnSeries.Basic
|
β {Ξ : Type u_1} {R : Type u_3} [inst : PartialOrder Ξ] [inst_1 : Zero R] {a : Ξ}, HahnSeries.coeff 0 a = 0
|
Combinatorics.Line.casesOn
|
Mathlib.Combinatorics.HalesJewett
|
{Ξ± : Type u_5} β
{ΞΉ : Type u_6} β
{motive : Combinatorics.Line Ξ± ΞΉ β Sort u} β
(t : Combinatorics.Line Ξ± ΞΉ) β
((idxFun : ΞΉ β Option Ξ±) β (proper : β i, idxFun i = none) β motive { idxFun := idxFun, proper := proper }) β
motive t
|
Descriptive.Tree.mem_pullSub_append._simp_1
|
Mathlib.SetTheory.Descriptive.Tree
|
β {A : Type u_1} {T : β₯(Descriptive.tree A)} {x y : List A}, (x ++ y β Descriptive.Tree.pullSub T x) = (y β T)
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_filter_key_eq_false_iff._simp_1_1
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Sort u_1} {p : Ξ± β Prop}, (Β¬β (x : Ξ±), p x) = β x, Β¬p x
|
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan_functor_obj
|
Mathlib.CategoryTheory.Limits.Constructions.Over.Products
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X βΆ Y} {g : X βΆ Z}
(c : CategoryTheory.Limits.PushoutCocone f g),
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan.functor.obj c =
CategoryTheory.Limits.BinaryCofan.mk (CategoryTheory.Under.homMk c.inl β―) (CategoryTheory.Under.homMk c.inr β―)
|
Turing.ToPartrec.Cfg.ret.elim
|
Mathlib.Computability.TMConfig
|
{motive : Turing.ToPartrec.Cfg β Sort u} β
(t : Turing.ToPartrec.Cfg) β
t.ctorIdx = 1 β ((a : Turing.ToPartrec.Cont) β (a_1 : List β) β motive (Turing.ToPartrec.Cfg.ret a a_1)) β motive t
|
R0Space.casesOn
|
Mathlib.Topology.Separation.Basic
|
{X : Type u} β
[inst : TopologicalSpace X] β
{motive : R0Space X β Sort u_1} β
(t : R0Space X) β ((specializes_symmetric : Symmetric Specializes) β motive β―) β motive t
|
SimpleGraph.dist_eq_one_iff_adj._simp_1
|
Mathlib.Combinatorics.SimpleGraph.Metric
|
β {V : Type u_1} {G : SimpleGraph V} {u v : V}, (G.dist u v = 1) = G.Adj u v
|
Lean.Compiler.LCNF.FloatLetIn.dontFloat
|
Lean.Compiler.LCNF.FloatLetIn
|
Lean.Compiler.LCNF.CodeDecl β Lean.Compiler.LCNF.FloatLetIn.FloatM Unit
|
WithTop.instUniqueOfIsEmpty.eq_1
|
Mathlib.Order.WithBot
|
β {Ξ± : Type u_1} [inst : IsEmpty Ξ±], WithTop.instUniqueOfIsEmpty = Option.instUniqueOfIsEmpty
|
LinearMap.coe_compAlternatingMap
|
Mathlib.LinearAlgebra.Alternating.Basic
|
β {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ΞΉ : Type u_7} {Nβ : Type u_11} [inst_5 : AddCommMonoid Nβ]
[inst_6 : Module R Nβ] (g : N ββ[R] Nβ) (f : M [β^ΞΉ]ββ[R] N), β(g.compAlternatingMap f) = βg β βf
|
Lean.MonadLog.logMessage
|
Lean.Log
|
{m : Type β Type} β [self : Lean.MonadLog m] β Lean.Message β m Unit
|
Topology.RelCWComplex.isClosed_inter_cellFrontier_succ_of_le_isClosed_inter_closedCell
|
Mathlib.Topology.CWComplex.Classical.Basic
|
β {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] [T2Space X] {A : Set X}
{n : β},
(β m β€ n, β (j : Topology.RelCWComplex.cell C m), IsClosed (A β© Topology.RelCWComplex.closedCell m j)) β
β (j : Topology.RelCWComplex.cell C (n + 1)),
IsClosed (A β© D) β IsClosed (A β© Topology.RelCWComplex.cellFrontier (n + 1) j)
|
CategoryTheory.Functor.CommShiftβ.commShiftFlipObj
|
Mathlib.CategoryTheory.Shift.CommShiftTwo
|
{Cβ : Type u_1} β
{Cβ : Type u_3} β
{D : Type u_5} β
{inst : CategoryTheory.Category.{v_1, u_1} Cβ} β
{inst_1 : CategoryTheory.Category.{v_3, u_3} Cβ} β
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} β
{M : Type u_6} β
{inst_3 : AddCommMonoid M} β
{inst_4 : CategoryTheory.HasShift Cβ M} β
{inst_5 : CategoryTheory.HasShift Cβ M} β
{inst_6 : CategoryTheory.HasShift D M} β
{G : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ D)} β
(h : CategoryTheory.CommShiftβSetup D M) β
[self : G.CommShiftβ h] β (Xβ : Cβ) β (G.flip.obj Xβ).CommShift M
|
Std.Internal.IO.Async.Signal.Waiter._sizeOf_1
|
Std.Internal.Async.Signal
|
Std.Internal.IO.Async.Signal.Waiter β β
|
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_pos_iff._simp_1_1
|
Mathlib.Order.KrullDimension
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {a : Ξ±}, (β (b : Ξ±), Β¬a < b) = IsMax a
|
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.cond.match_1.eq_2
|
Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable
|
β (motive : Bool β Sort u_1) (h_1 : Unit β motive true) (h_2 : Unit β motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 ()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.