name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Filter.instDistribNeg._proof_2
|
Mathlib.Order.Filter.Pointwise
|
β {Ξ± : Type u_1} [inst : Mul Ξ±] [inst_1 : HasDistribNeg Ξ±] (x x_1 : Filter Ξ±),
Filter.mapβ (fun x1 x2 => x1 * x2) x (Filter.map Neg.neg x_1) =
Filter.map Neg.neg (Filter.mapβ (fun x1 x2 => x1 * x2) x x_1)
|
CategoryTheory.LaxBraidedFunctor.hom_ext_iff
|
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 G : CategoryTheory.LaxBraidedFunctor C D} {Ξ± Ξ² : F βΆ G}, Ξ± = Ξ² β Ξ±.hom = Ξ².hom
|
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_1
|
Mathlib.Algebra.Homology.ShortComplex.RightHomology
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.RightHomologyData.ofZeros S hf hg).p
(CategoryTheory.Limits.Cofork.Ο c) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id S).Οβ
(CategoryTheory.ShortComplex.RightHomologyData.ofIsColimitCokernelCofork S hg c hc).p
|
Std.Internal.IsStrictCut.toIsCut
|
Std.Data.Internal.Cut
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {cut : Ξ± β Ordering} [self : Std.Internal.IsStrictCut cmp cut],
Std.Internal.IsCut cmp cut
|
WellFoundedGT.toIsSuccArchimedean
|
Mathlib.Order.SuccPred.Archimedean
|
β {Ξ± : Type u_1} [inst : PartialOrder Ξ±] [h : WellFoundedGT Ξ±] [inst_1 : SuccOrder Ξ±], IsSuccArchimedean Ξ±
|
AlgebraicGeometry.Scheme.IdealSheafData.support_bot
|
Mathlib.AlgebraicGeometry.IdealSheaf.Basic
|
β {X : AlgebraicGeometry.Scheme}, β₯.support = β€
|
ContDiffMapSupportedIn.iteratedFDerivLM_eq_of_scalars
|
Mathlib.Analysis.Distribution.ContDiffMapSupportedIn
|
β (π : Type u_1) {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField π] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace β E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace β F] [inst_5 : NormedSpace π F]
[inst_6 : SMulCommClass β π F] {K : TopologicalSpace.Compacts E} {i : β} (π' : Type u_5)
[inst_7 : NontriviallyNormedField π'] [inst_8 : NormedSpace π' F] [inst_9 : SMulCommClass β π' F],
β(ContDiffMapSupportedIn.iteratedFDerivLM π i) = β(ContDiffMapSupportedIn.iteratedFDerivLM π' i)
|
AddMonoidHom.le_map_tsub
|
Mathlib.Algebra.Order.Sub.Unbundled.Hom
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Preorder Ξ±] [inst_1 : AddCommMonoid Ξ±] [inst_2 : Sub Ξ±] [OrderedSub Ξ±]
[inst_4 : Preorder Ξ²] [inst_5 : AddZeroClass Ξ²] [inst_6 : Sub Ξ²] [OrderedSub Ξ²] (f : Ξ± β+ Ξ²),
Monotone βf β β (a b : Ξ±), f a - f b β€ f (a - b)
|
AddSubgroup.finiteIndex_iInf'
|
Mathlib.GroupTheory.Index
|
β {G : Type u_1} [inst : AddGroup G] {ΞΉ : Type u_3} {s : Finset ΞΉ} (f : ΞΉ β AddSubgroup G),
(β i β s, (f i).FiniteIndex) β (β¨
i β s, f i).FiniteIndex
|
Finset.card_mul_singleton
|
Mathlib.Algebra.Group.Pointwise.Finset.Basic
|
β {Ξ± : Type u_2} [inst : Mul Ξ±] [IsRightCancelMul Ξ±] [inst_2 : DecidableEq Ξ±] (s : Finset Ξ±) (a : Ξ±),
(s * {a}).card = s.card
|
Affine.Triangle.sbtw_touchpoint_empty
|
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] (t : Affine.Triangle β P) {iβ iβ iβ : Fin 3},
iβ β iβ β iβ β iβ β iβ β iβ β Sbtw β (t.points iβ) (Affine.Simplex.touchpoint t β
iβ) (t.points iβ)
|
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.tendsto_euler_sin_prod'._simp_1_6
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent
|
β {Gβ : Type u_3} [inst : GroupWithZero Gβ] {a : Gβ} (n : β€), a β 0 β (a ^ n = 0) = False
|
_private.Mathlib.Algebra.Order.Star.Pi.0.Pi.instStarOrderedRing.match_6
|
Mathlib.Algebra.Order.Star.Pi
|
β {ΞΉ : Type u_1} {A : ΞΉ β Type u_2} [inst : (i : ΞΉ) β NonUnitalSemiring (A i)] [inst_1 : (i : ΞΉ) β StarRing (A i)]
(x : (i : ΞΉ) β A i) (motive : (β y, β (x_1 : ΞΉ), star (y x_1) * y x_1 = x x_1) β Prop)
(x_1 : β y, β (x_1 : ΞΉ), star (y x_1) * y x_1 = x x_1),
(β (y : (i : ΞΉ) β A i) (hy : β (x_2 : ΞΉ), star (y x_2) * y x_2 = x x_2), motive β―) β motive x_1
|
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.zero_le_pairingIn_of_root_sub_mem._simp_1_1
|
Mathlib.LinearAlgebra.RootSystem.Finite.G2
|
β {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b
|
TendstoUniformlyOn.div
|
Mathlib.Topology.Algebra.IsUniformGroup.Basic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : UniformSpace Ξ±] [inst_1 : Group Ξ±] [IsUniformGroup Ξ±] {ΞΉ : Type u_3}
{l : Filter ΞΉ} {f f' : ΞΉ β Ξ² β Ξ±} {g g' : Ξ² β Ξ±} {s : Set Ξ²},
TendstoUniformlyOn f g l s β TendstoUniformlyOn f' g' l s β TendstoUniformlyOn (f / f') (g / g') l s
|
AddGroupSeminorm.smul_sup
|
Mathlib.Analysis.Normed.Group.Seminorm
|
β {R : Type u_1} {E : Type u_3} [inst : AddGroup E] [inst_1 : SMul R β] [inst_2 : SMul R NNReal]
[inst_3 : IsScalarTower R NNReal β] (r : R) (p q : AddGroupSeminorm E), r β’ (p β q) = r β’ p β r β’ q
|
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._simp_1_2
|
Mathlib.Data.List.Triplewise
|
β {Ξ± : Type u_1} {R : Ξ± β Ξ± β Prop} {l : List Ξ±},
List.Pairwise R l = β (i j : β) (_hi : i < l.length) (_hj : j < l.length), i < j β R l[i] l[j]
|
_private.Mathlib.Algebra.Algebra.Subalgebra.Basic.0.AlgHom.rangeRestrict_surjective.match_1_1
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
β {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A ββ[R] B) (_y : B) (motive : _y β f.range β Prop)
(hy : _y β f.range), (β (x : A) (hx : f.toRingHom x = _y), motive β―) β motive hy
|
_private.Mathlib.Algebra.Order.Interval.Set.Instances.0.Set.Ioo.one_sub_mem._simp_1_2
|
Mathlib.Algebra.Order.Interval.Set.Instances
|
β {Ξ± : Type u} [inst : AddGroup Ξ±] [inst_1 : LT Ξ±] [AddRightStrictMono Ξ±] {a b : Ξ±}, (0 < a - b) = (b < a)
|
Units.inv_eq_val_inv
|
Mathlib.Algebra.Group.Units.Defs
|
β {Ξ± : Type u} [inst : Monoid Ξ±] (a : Ξ±Λ£), a.inv = βaβ»ΒΉ
|
MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal
|
Mathlib.MeasureTheory.Function.L2Space
|
{Ξ± : Type u_1} β
{E : Type u_2} β
{π : Type u_4} β
[inst : RCLike π] β
[inst_1 : MeasurableSpace Ξ±] β
{ΞΌ : MeasureTheory.Measure Ξ±} β
[inst_2 : NormedAddCommGroup E] β [InnerProductSpace π E] β Inner π β₯(MeasureTheory.Lp E 2 ΞΌ)
|
Nat.eq_two_pow_or_exists_odd_prime_and_dvd
|
Mathlib.Data.Nat.Factors
|
β (n : β), (β k, n = 2 ^ k) β¨ β p, Nat.Prime p β§ p β£ n β§ Odd p
|
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.measurable_div_const'._simp_1_1
|
Mathlib.MeasureTheory.Group.Arithmetic
|
β {M : Type u_2} {inst : MeasurableSpace M} {inst_1 : Mul M} [self : MeasurableMul M] (c : M),
(Measurable fun x => x * c) = True
|
Continuous.enorm
|
Mathlib.Analysis.Normed.Group.Basic
|
β {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {X : Type u_9} [inst_2 : TopologicalSpace X]
{f : X β E}, Continuous f β Continuous fun x => βf xββ
|
List.getElem_getElem_findIdxs_sub._proof_2
|
Batteries.Data.List.Lemmas
|
β {i : β} {Ξ± : Type u_1} {xs : List Ξ±} {p : Ξ± β Bool} (s : β) (h : i < (List.findIdxs p xs s).length),
(List.findIdxs p xs s)[i] - s < xs.length
|
CompleteLat.Iso.mk
|
Mathlib.Order.Category.CompleteLat
|
{Ξ± Ξ² : CompleteLat} β βΞ± βo βΞ² β (Ξ± β
Ξ²)
|
CategoryTheory.EnrichedFunctor.comp_map
|
Mathlib.CategoryTheory.Enriched.Basic
|
β (V : Type v) [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type uβ}
{D : Type uβ} {E : Type uβ} [inst_2 : CategoryTheory.EnrichedCategory V C]
[inst_3 : CategoryTheory.EnrichedCategory V D] [inst_4 : CategoryTheory.EnrichedCategory V E]
(F : CategoryTheory.EnrichedFunctor V C D) (G : CategoryTheory.EnrichedFunctor V D E) (x x_1 : C),
(CategoryTheory.EnrichedFunctor.comp V F G).map x x_1 =
CategoryTheory.CategoryStruct.comp (F.map x x_1) (G.map (F.obj x) (F.obj x_1))
|
tendsto_atTop_iSup
|
Mathlib.Topology.Order.MonotoneConvergence
|
β {Ξ± : Type u_1} {ΞΉ : Type u_3} [inst : Preorder ΞΉ] [inst_1 : TopologicalSpace Ξ±] [inst_2 : CompleteLattice Ξ±]
[SupConvergenceClass Ξ±] {f : ΞΉ β Ξ±}, Monotone f β Filter.Tendsto f Filter.atTop (nhds (β¨ i, f i))
|
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_sq_not_dvd_a_add_eta_sq_mul_b._simp_1_3
|
Mathlib.NumberTheory.FLT.Three
|
β {Mβ : Type u_1} [inst : CancelMonoidWithZero Mβ] {a b c : Mβ}, (a * b = a * c) = (b = c β¨ a = 0)
|
Nucleus.coe_toInfHom
|
Mathlib.Order.Nucleus
|
β {X : Type u_1} [inst : SemilatticeInf X] (n : Nucleus X), βn.toInfHom = βn
|
ImplicitFunctionData.hasStrictFDerivAt
|
Mathlib.Analysis.Calculus.Implicit
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace π F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 : NormedSpace π G] [inst_9 : CompleteSpace G] (Ο : ImplicitFunctionData π E F G),
HasStrictFDerivAt Ο.prodFun (β(Ο.leftDeriv.equivProdOfSurjectiveOfIsCompl Ο.rightDeriv β― β― β―)) Ο.pt
|
SchwartzMap.toLp.eq_1
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace β F] [inst_4 : MeasurableSpace E] [inst_5 : OpensMeasurableSpace E]
[inst_6 : SecondCountableTopologyEither E F] (f : SchwartzMap E F) (p : ENNReal) (ΞΌ : MeasureTheory.Measure E)
[hΞΌ : ΞΌ.HasTemperateGrowth], f.toLp p ΞΌ = MeasureTheory.MemLp.toLp βf β―
|
List.IsChain.induction
|
Mathlib.Data.List.Chain
|
β {Ξ± : Type u} {r : Ξ± β Ξ± β Prop} (p : Ξ± β Prop) (l : List Ξ±),
List.IsChain r l β (β β¦x y : Ξ±β¦, r x y β p x β p y) β (β (lne : l β []), p (l.head lne)) β β i β l, p i
|
Std.Iterators.IteratorLoop.rel
|
Init.Data.Iterators.Consumers.Monadic.Loop
|
(Ξ± : Type w) β
(m : Type w β Type w') β
{Ξ² : Type w} β
[Std.Iterators.Iterator Ξ± m Ξ²] β
{Ξ³ : Type x} β (Ξ² β Ξ³ β ForInStep Ξ³ β Prop) β Std.IterM m Ξ² Γ Ξ³ β Std.IterM m Ξ² Γ Ξ³ β Prop
|
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._proof_1_6
|
Mathlib.Topology.Algebra.InfiniteSum.SummationFilter
|
β (a b : β), b β₯ a + 1 β b + 1 β₯ a
|
SchwartzMap.instAddCommGroup._proof_3
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace β F] (x x_1 : SchwartzMap E F), β(x + x_1) = β(x + x_1)
|
Set.Iic_disjoint_Ioi._simp_1
|
Mathlib.Order.Interval.Set.Disjoint
|
β {Ξ± : Type v} [inst : Preorder Ξ±] {a b : Ξ±}, a β€ b β Disjoint (Set.Iic a) (Set.Ioi b) = True
|
CategoryTheory.Functor.relativelyRepresentable.symmetryIso_inv
|
Mathlib.CategoryTheory.MorphismProperty.Representable
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
{F : CategoryTheory.Functor C D} {Y : D} {b : C} {f' : F.obj b βΆ Y} (hf' : F.relativelyRepresentable f') {a : C}
{g : F.obj a βΆ Y} (hg : F.relativelyRepresentable g) [inst_2 : F.Full] [inst_3 : F.Faithful],
(hf'.symmetryIso hg).inv = hg.symmetry hf'
|
AddGroupExtension._sizeOf_inst
|
Mathlib.GroupTheory.GroupExtension.Defs
|
(N : Type u_1) β
(E : Type u_2) β
(G : Type u_3) β
{inst : AddGroup N} β
{inst_1 : AddGroup E} β
{inst_2 : AddGroup G} β [SizeOf N] β [SizeOf E] β [SizeOf G] β SizeOf (AddGroupExtension N E G)
|
LinearMap.quotKerEquivOfSurjective_symm_apply
|
Mathlib.LinearAlgebra.Isomorphisms
|
β {R : Type u_1} {M : Type u_2} {Mβ : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup Mβ]
[inst_3 : Module R M] [inst_4 : Module R Mβ] (f : M ββ[R] Mβ) (hf : Function.Surjective βf) (x : M),
(f.quotKerEquivOfSurjective hf).symm (f x) = Submodule.Quotient.mk x
|
Quiver.IsSStronglyConnected
|
Mathlib.Combinatorics.Quiver.ConnectedComponent
|
(V : Type u_2) β [Quiver V] β Prop
|
_private.Mathlib.FieldTheory.SeparablyGenerated.0.exists_isTranscendenceBasis_and_isSeparable_of_linearIndepOn_pow_of_adjoin_eq_top.match_1_1
|
Mathlib.FieldTheory.SeparablyGenerated
|
β {k : Type u_2} {K : Type u_3} {ΞΉ : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {a : ΞΉ β K}
(motive :
(β i, (IsTranscendenceBasis k fun j => a βj) β§ IsSeparable (β₯(IntermediateField.adjoin k (a '' {i}αΆ))) (a i)) β
Prop)
(x : β i, (IsTranscendenceBasis k fun j => a βj) β§ IsSeparable (β₯(IntermediateField.adjoin k (a '' {i}αΆ))) (a i)),
(β (i : ΞΉ)
(hi : (IsTranscendenceBasis k fun j => a βj) β§ IsSeparable (β₯(IntermediateField.adjoin k (a '' {i}αΆ))) (a i)),
motive β―) β
motive x
|
StieltjesFunction.zero_apply
|
Mathlib.MeasureTheory.Measure.Stieltjes
|
β (x : β), β0 x = 0
|
subsetInfSet._proof_1
|
Mathlib.Order.CompleteLatticeIntervals
|
β {Ξ± : Type u_1} (s : Set Ξ±) [inst : Preorder Ξ±] [inst_1 : InfSet Ξ±] (t : Set βs),
t.Nonempty β§ BddBelow t β§ sInf (Subtype.val '' t) β s β sInf (Subtype.val '' t) β s
|
CategoryTheory.Grothendieck.comp.eq_1
|
Mathlib.CategoryTheory.Grothendieck
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y Z : CategoryTheory.Grothendieck F} (f : X.Hom Y) (g : Y.Hom Z),
CategoryTheory.Grothendieck.comp f g =
{ base := CategoryTheory.CategoryStruct.comp f.base g.base,
fiber :=
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom β―)
(CategoryTheory.CategoryStruct.comp ((F.map g.base).map f.fiber) g.fiber) }
|
derivationQuotKerSq._proof_4
|
Mathlib.RingTheory.Smooth.Kaehler
|
β (R : Type u_3) (P : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
LinearMap.CompatibleSMul Ξ©[PβR] (TensorProduct P S Ξ©[PβR]) R P
|
_private.Init.Data.List.Erase.0.List.eraseP_filterMap.match_1.eq_2
|
Init.Data.List.Erase
|
β {Ξ² : Type u_1} (motive : Option Ξ² β Sort u_2) (h_1 : (y : Ξ²) β motive (some y)) (h_2 : Unit β motive none),
(match none with
| some y => h_1 y
| none => h_2 ()) =
h_2 ()
|
Lean.Meta.Grind.Arith.Linear.instMonadGetStructLinearM
|
Lean.Meta.Tactic.Grind.Arith.Linear.LinearM
|
Lean.Meta.Grind.Arith.Linear.MonadGetStruct Lean.Meta.Grind.Arith.Linear.LinearM
|
MulOpposite.instAdd
|
Mathlib.Algebra.Opposites
|
{Ξ± : Type u_1} β [Add Ξ±] β Add Ξ±α΅α΅α΅
|
ContinuousOn.prodMk
|
Mathlib.Topology.ContinuousOn
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} [inst : TopologicalSpace Ξ±] [inst_1 : TopologicalSpace Ξ²]
[inst_2 : TopologicalSpace Ξ³] {f : Ξ± β Ξ²} {g : Ξ± β Ξ³} {s : Set Ξ±},
ContinuousOn f s β ContinuousOn g s β ContinuousOn (fun x => (f x, g x)) s
|
PrincipalSeg.ofElement
|
Mathlib.Order.InitialSeg
|
{Ξ± : Type u_4} β (r : Ξ± β Ξ± β Prop) β (a : Ξ±) β PrincipalSeg (Subrel r fun x => r x a) r
|
AlgebraicGeometry.Scheme.Pullback.gluedLift._proof_2
|
Mathlib.AlgebraicGeometry.Pullbacks
|
β {X Y Z : AlgebraicGeometry.Scheme} (π° : X.OpenCover) (f : X βΆ Z) (g : Y βΆ Z)
(s : CategoryTheory.Limits.PullbackCone f g) (i : (CategoryTheory.Precoverage.ZeroHypercover.pullbackβ s.fst π°).Iβ),
CategoryTheory.Limits.HasPullback s.fst (π°.f i)
|
PresheafOfModules.pushforwardβ._proof_3
|
Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward
|
β {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dα΅α΅ RingCat) (X : PresheafOfModules R),
{ app := fun X_1 => (CategoryTheory.CategoryStruct.id X).app (F.op.obj X_1), naturality := β― } =
CategoryTheory.CategoryStruct.id (PresheafOfModules.pushforwardβ_obj F R X)
|
CategoryTheory.Presieve.yonedaFamilyOfElements_fromCocone
|
Mathlib.CategoryTheory.Sites.SheafOfTypes
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{X : C} β
(R : CategoryTheory.Presieve X) β
(s : CategoryTheory.Limits.Cocone R.diagram) β
CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.yoneda.obj s.pt) R
|
AffineSubspace.smul_vsub_vadd_mem
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs
|
β {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] (self : AffineSubspace k P) (c : k) {pβ pβ pβ : P},
pβ β self.carrier β pβ β self.carrier β pβ β self.carrier β c β’ (pβ -α΅₯ pβ) +α΅₯ pβ β self.carrier
|
RelSeries.ctorIdx
|
Mathlib.Order.RelSeries
|
{Ξ± : Type u_1} β {r : SetRel Ξ± Ξ±} β RelSeries r β β
|
CategoryTheory.IsMonHom.one_hom._autoParam
|
Mathlib.CategoryTheory.Monoidal.Mon_
|
Lean.Syntax
|
_private.Qq.ForLean.ToExpr.0.toExprLevel.match_1
|
Qq.ForLean.ToExpr
|
(motive : Lean.Level β Sort u_1) β
(x : Lean.Level) β
(Unit β motive Lean.Level.zero) β
((l : Lean.Level) β motive l.succ) β
((lβ lβ : Lean.Level) β motive (lβ.max lβ)) β
((lβ lβ : Lean.Level) β motive (lβ.imax lβ)) β
((n : Lean.Name) β motive (Lean.Level.param n)) β
((n : Lean.LMVarId) β motive (Lean.Level.mvar n)) β motive x
|
SimpleGraph.instMax
|
Mathlib.Combinatorics.SimpleGraph.Basic
|
{V : Type u} β Max (SimpleGraph V)
|
DirectSum.liftRingHom._proof_3
|
Mathlib.Algebra.DirectSum.Ring
|
β {ΞΉ : Type u_1} [inst : DecidableEq ΞΉ] {A : ΞΉ β Type u_2} {R : Type u_3} [inst_1 : (i : ΞΉ) β AddCommMonoid (A i)]
[inst_2 : AddMonoid ΞΉ] [inst_3 : DirectSum.GSemiring A] [inst_4 : Semiring R],
AddMonoidHomClass ((DirectSum ΞΉ fun i => A i) β+* R) (DirectSum ΞΉ fun i => A i) R
|
_private.Mathlib.MeasureTheory.Measure.Haar.NormedSpace.0.MeasureTheory.Measure.setIntegral_comp_smul._simp_1_1
|
Mathlib.MeasureTheory.Measure.Haar.NormedSpace
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {f : Ξ± β Ξ²} {g : Ξ² β Ξ³} {s : Set Ξ³}, f β»ΒΉ' (g β»ΒΉ' s) = g β f β»ΒΉ' s
|
_private.Mathlib.RingTheory.PowerSeries.NoZeroDivisors.0.PowerSeries.instNoZeroDivisors._simp_1
|
Mathlib.RingTheory.PowerSeries.NoZeroDivisors
|
β {R : Type u_1} [inst : Semiring R] {Ο : PowerSeries R}, (Ο = 0) = (Ο.order = β€)
|
TopologicalSpace.IsTopologicalBasis.of_isOpen_of_subset
|
Mathlib.Topology.Bases
|
β {Ξ± : Type u} [t : TopologicalSpace Ξ±] {s s' : Set (Set Ξ±)},
(β u β s', IsOpen u) β TopologicalSpace.IsTopologicalBasis s β s β s' β TopologicalSpace.IsTopologicalBasis s'
|
Lean.Parser.Tactic.Grind.grindAdmit
|
Init.Grind.Interactive
|
Lean.ParserDescr
|
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_2
|
Std.Time.Date.ValidDate
|
β {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : β€),
Β¬acc + β(Std.Time.Month.Ordinal.days leap idx) - acc = β(Std.Time.Month.Ordinal.days leap idx) β False
|
CategoryTheory.Limits.HasCountableCoproducts.casesOn
|
Mathlib.CategoryTheory.Limits.Shapes.Countable
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{u_3, u_1} C] β
{motive : CategoryTheory.Limits.HasCountableCoproducts C β Sort u} β
(t : CategoryTheory.Limits.HasCountableCoproducts C) β
((out : β (J : Type) [Countable J], CategoryTheory.Limits.HasCoproductsOfShape J C) β motive β―) β motive t
|
_private.Lean.Server.Completion.ImportCompletion.0.ImportCompletion.computePartialImportCompletions.match_6
|
Lean.Server.Completion.ImportCompletion
|
(motive : Option (Lean.Name Γ String) β Sort u_1) β
(x : Option (Lean.Name Γ String)) β
((completePrefix : Lean.Name) β (incompleteSuffix : String) β motive (some (completePrefix, incompleteSuffix))) β
((x : Option (Lean.Name Γ String)) β motive x) β motive x
|
Lean.Widget.instToJsonRpcEncodablePacket._@.Lean.Server.FileWorker.WidgetRequests.433270988._hygCtx._hyg.43
|
Lean.Server.FileWorker.WidgetRequests
|
Lean.ToJson Lean.Widget.RpcEncodablePacketβ
|
TrivSqZeroExt.invertibleFstOfInvertible._proof_2
|
Mathlib.Algebra.TrivSqZeroExt
|
β {R : Type u_1} {M : Type u_2} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rα΅α΅α΅ M]
[inst_3 : Module R M] (x : TrivSqZeroExt R M) [inst_4 : Invertible x], x.fst * (β
x).fst = 1
|
PNat.natPred_eq_pred
|
Mathlib.Data.PNat.Defs
|
β {n : β} (h : 0 < n), PNat.natPred β¨n, hβ© = n.pred
|
List.modify_succ_cons
|
Init.Data.List.Nat.Modify
|
β {Ξ± : Type u_1} (f : Ξ± β Ξ±) (a : Ξ±) (l : List Ξ±) (i : β), (a :: l).modify (i + 1) f = a :: l.modify i f
|
MultilinearMap.alternatization._proof_8
|
Mathlib.LinearAlgebra.Alternating.Basic
|
β {R : Type u_3} [inst : Semiring R] {M : Type u_4} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N' : Type u_2}
[inst_3 : AddCommGroup N'] [inst_4 : Module R N'] {ΞΉ : Type u_1} [inst_5 : Fintype ΞΉ] [inst_6 : DecidableEq ΞΉ]
(a b : MultilinearMap R (fun x => M) N') [inst_7 : DecidableEq ΞΉ] (m : ΞΉ β M) (i : ΞΉ) (c : R) (x : M),
(β Ο, Equiv.Perm.sign Ο β’ MultilinearMap.domDomCongr Ο (a + b)).toFun (Function.update m i (c β’ x)) =
c β’ (β Ο, Equiv.Perm.sign Ο β’ MultilinearMap.domDomCongr Ο (a + b)).toFun (Function.update m i x)
|
Finset.card_le_of_interleaved
|
Mathlib.Data.Finset.Max
|
β {Ξ± : Type u_2} [inst : LinearOrder Ξ±] {s t : Finset Ξ±},
(β x β s, β y β s, x < y β (β z β s, z β Set.Ioo x y) β β z β t, x < z β§ z < y) β s.card β€ t.card + 1
|
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.IntervalIntegrable.intervalIntegrable_slope._proof_1_3
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope
|
β {a b c : β}, a β€ b β 0 β€ c β Set.uIcc a b β Set.uIcc a (b + c)
|
AddEquiv.ext
|
Mathlib.Algebra.Group.Equiv.Defs
|
β {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f g : M β+ N}, (β (x : M), f x = g x) β f = g
|
SetTheory.PGame.Relabelling.subCongr
|
Mathlib.SetTheory.PGame.Algebra
|
{w x y z : SetTheory.PGame} β w.Relabelling x β y.Relabelling z β (w - y).Relabelling (x - z)
|
IsLocalMax.norm_add_self
|
Mathlib.Analysis.Normed.Module.Extr
|
β {X : Type u_2} {E : Type u_3} [inst : SeminormedAddCommGroup E] [NormedSpace β E] [inst_2 : TopologicalSpace X]
{f : X β E} {c : X}, IsLocalMax (norm β f) c β IsLocalMax (fun x => βf x + f cβ) c
|
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk._flat_ctor
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
|
Int.Linear.Poly β Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof β Lean.Meta.Grind.Arith.Cutsat.LeCnstr
|
Batteries.RBNode.append._unary.eq_def
|
Batteries.Data.RBMap.Basic
|
β {Ξ± : Type u_1} (_x : (_ : Batteries.RBNode Ξ±) Γ' Batteries.RBNode Ξ±),
Batteries.RBNode.append._unary _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| Batteries.RBNode.nil, x => x
| x, Batteries.RBNode.nil => x
| Batteries.RBNode.node Batteries.RBColor.red a x b, Batteries.RBNode.node Batteries.RBColor.red c y d =>
match Batteries.RBNode.append._unary β¨b, cβ© with
| Batteries.RBNode.node Batteries.RBColor.red b' z c' =>
Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red a x b') z
(Batteries.RBNode.node Batteries.RBColor.red c' y d)
| bc => Batteries.RBNode.node Batteries.RBColor.red a x (Batteries.RBNode.node Batteries.RBColor.red bc y d)
| Batteries.RBNode.node Batteries.RBColor.black a x b, Batteries.RBNode.node Batteries.RBColor.black c y d =>
match Batteries.RBNode.append._unary β¨b, cβ© with
| Batteries.RBNode.node Batteries.RBColor.red b' z c' =>
Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.black a x b') z
(Batteries.RBNode.node Batteries.RBColor.black c' y d)
| bc => a.balLeft x (Batteries.RBNode.node Batteries.RBColor.black bc y d)
| a@h:(Batteries.RBNode.node Batteries.RBColor.black l v r), Batteries.RBNode.node Batteries.RBColor.red b x c =>
Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.append._unary β¨a, bβ©) x c
| Batteries.RBNode.node Batteries.RBColor.red a x b, c@h:(Batteries.RBNode.node Batteries.RBColor.black l v r) =>
Batteries.RBNode.node Batteries.RBColor.red a x (Batteries.RBNode.append._unary β¨b, cβ©)
|
Aesop.UnsafeQueue.instEmptyCollection
|
Aesop.Tree.UnsafeQueue
|
EmptyCollection Aesop.UnsafeQueue
|
_private.Init.Data.List.MapIdx.0.Option.getD.match_1.splitter
|
Init.Data.List.MapIdx
|
{Ξ± : Type u_1} β
(motive : Option Ξ± β Sort u_2) β (opt : Option Ξ±) β ((x : Ξ±) β motive (some x)) β motive none β motive opt
|
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.filter._proof_1
|
Std.Data.ExtDHashMap.Basic
|
β {Ξ± : Type u_1} {Ξ² : Ξ± β Type u_2} {x : BEq Ξ±} {x_1 : Hashable Ξ±} (f : (a : Ξ±) β Ξ² a β Bool) (m m' : Std.DHashMap Ξ± Ξ²),
m.Equiv m' β Std.ExtDHashMap.mk (Std.DHashMap.filter f m) = Std.ExtDHashMap.mk (Std.DHashMap.filter f m')
|
MeasureTheory.SimpleFunc.bind._proof_2
|
Mathlib.MeasureTheory.Function.SimpleFunc
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {Ξ³ : Type u_1} [inst : MeasurableSpace Ξ±] (f : MeasureTheory.SimpleFunc Ξ± Ξ²)
(g : Ξ² β MeasureTheory.SimpleFunc Ξ± Ξ³), (Set.range fun a => (g (f a)) a).Finite
|
Tropical.instLinearOrderTropical._proof_1
|
Mathlib.Algebra.Tropical.Basic
|
β {R : Type u_1} [inst : LinearOrder R] (a b : Tropical R),
Tropical.untrop a β€ Tropical.untrop b β¨ Tropical.untrop b β€ Tropical.untrop a
|
CategoryTheory.CommGrp.forgetβCommMon_map_hom
|
Mathlib.CategoryTheory.Monoidal.CommGrp_
|
β (C : Type uβ) [inst : CategoryTheory.Category.{vβ, uβ} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {A B : CategoryTheory.CommGrp C} (f : A βΆ B),
((CategoryTheory.CommGrp.forgetβCommMon C).map f).hom = f.hom
|
UInt64.toUInt8_or
|
Init.Data.UInt.Bitwise
|
β (a b : UInt64), (a ||| b).toUInt8 = a.toUInt8 ||| b.toUInt8
|
_private.Lean.Meta.Tactic.Grind.Anchor.0.Lean.Meta.Grind.getAnchor.match_4
|
Lean.Meta.Tactic.Grind.Anchor
|
(motive : Lean.Expr β Sort u_1) β
(e : Lean.Expr) β
((declName : Lean.Name) β (us : List Lean.Level) β motive (Lean.Expr.const declName us)) β
((fvarId : Lean.FVarId) β motive (Lean.Expr.fvar fvarId)) β
((data : Lean.MData) β (b : Lean.Expr) β motive (Lean.Expr.mdata data b)) β
((n : Lean.Name) β (v t b : Lean.Expr) β (nondep : Bool) β motive (Lean.Expr.letE n v t b nondep)) β
((n : Lean.Name) β
(d b : Lean.Expr) β (binderInfo : Lean.BinderInfo) β motive (Lean.Expr.lam n d b binderInfo)) β
((n : Lean.Name) β
(d b : Lean.Expr) β (binderInfo : Lean.BinderInfo) β motive (Lean.Expr.forallE n d b binderInfo)) β
((typeName : Lean.Name) β (i : β) β (s : Lean.Expr) β motive (Lean.Expr.proj typeName i s)) β
((idx : β) β motive (Lean.Expr.bvar idx)) β
((v : Lean.Literal) β motive (Lean.Expr.lit v)) β
((fn arg : Lean.Expr) β motive (fn.app arg)) β
((u : Lean.Level) β motive (Lean.Expr.sort u)) β
((mvarId : Lean.MVarId) β motive (Lean.Expr.mvar mvarId)) β motive e
|
Lean.SCC.State.recOn
|
Lean.Util.SCC
|
{Ξ± : Type} β
[inst : BEq Ξ±] β
[inst_1 : Hashable Ξ±] β
{motive : Lean.SCC.State Ξ± β Sort u} β
(t : Lean.SCC.State Ξ±) β
((stack : List Ξ±) β
(nextIndex : β) β
(data : Std.HashMap Ξ± Lean.SCC.Data) β
(sccs : List (List Ξ±)) β
motive { stack := stack, nextIndex := nextIndex, data := data, sccs := sccs }) β
motive t
|
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_6
|
Mathlib.RingTheory.Unramified.Finite
|
β {Ξ± : Type u_1} {M : Type u_4} [inst : Zero M] {f : Ξ± ββ M} {a : Ξ±}, (a β f.support) = (f a β 0)
|
FirstOrder.Language.LEquiv.symm_invLHom
|
Mathlib.ModelTheory.LanguageMap
|
β {L : FirstOrder.Language} {L' : FirstOrder.Language} (e : L βα΄Έ L'), e.symm.invLHom = e.toLHom
|
_private.Mathlib.Computability.PostTuringMachine.0.Turing.TM1.stmts_supportsStmt._simp_1_4
|
Mathlib.Computability.PostTuringMachine
|
β {Ξ± : Type u_1} {a : Ξ±} {b : Option Ξ±}, (a β b) = (b = some a)
|
CommGroup.toDistribLattice.eq_1
|
Mathlib.Algebra.Order.Group.Lattice
|
β (Ξ± : Type u_2) [inst : Lattice Ξ±] [inst_1 : CommGroup Ξ±] [inst_2 : MulLeftMono Ξ±],
CommGroup.toDistribLattice Ξ± = { toLattice := inst, le_sup_inf := β― }
|
Ctop.Realizer.id._proof_1
|
Mathlib.Data.Analysis.Topology
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] (x x_1 : { x // IsOpen x }) (_a : Ξ±) (h : _a β βx β© βx_1),
_a β
β(match x, h with
| β¨_x, hββ©, _hβ =>
match x_1, _hβ with
| β¨_y, hββ©, _hβ => β¨_x β© _y, β―β©)
|
Lean.Lsp.CompletionClientCapabilities.casesOn
|
Lean.Data.Lsp.Capabilities
|
{motive : Lean.Lsp.CompletionClientCapabilities β Sort u} β
(t : Lean.Lsp.CompletionClientCapabilities) β
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) β motive { completionItem? := completionItem? }) β
motive t
|
not_or._simp_3
|
Mathlib.Tactic.Push
|
β {p q : Prop}, (Β¬p β§ Β¬q) = Β¬(p β¨ q)
|
Vector.finRev?_push
|
Init.Data.Vector.Find
|
β {Ξ± : Type} {n : β} {p : Ξ± β Bool} {a : Ξ±} {xs : Vector Ξ± n},
Vector.findRev? p (xs.push a) = (Option.guard p a).or (Vector.findRev? p xs)
|
Finset.sup_inf_sup
|
Mathlib.Data.Finset.Lattice.Prod
|
β {Ξ± : Type u_2} {ΞΉ : Type u_5} {ΞΊ : Type u_6} [inst : DistribLattice Ξ±] [inst_1 : OrderBot Ξ±] (s : Finset ΞΉ)
(t : Finset ΞΊ) (f : ΞΉ β Ξ±) (g : ΞΊ β Ξ±), s.sup f β t.sup g = (s ΓΛ’ t).sup fun i => f i.1 β g i.2
|
List.cons_sublist_iff
|
Init.Data.List.Sublist
|
β {Ξ± : Type u_1} {a : Ξ±} {l l' : List Ξ±}, (a :: l).Sublist l' β β rβ rβ, l' = rβ ++ rβ β§ a β rβ β§ l.Sublist rβ
|
Subring.toRing
|
Mathlib.Algebra.Ring.Subring.Defs
|
{R : Type u} β [inst : Ring R] β (s : Subring R) β Ring β₯s
|
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.refineCore._sparseCasesOn_1
|
Lean.Elab.Tactic.ElabTerm
|
{Ξ± : Type u} β
{motive : Option Ξ± β Sort u_1} β
(t : Option Ξ±) β ((val : Ξ±) β motive (some val)) β (t.ctorIdx β 1 β motive t) β motive t
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.