name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Set.iInterβ_add_subset
|
Mathlib.Algebra.Group.Pointwise.Set.Lattice
|
β {Ξ± : Type u_2} {ΞΉ : Sort u_5} {ΞΊ : ΞΉ β Sort u_6} [inst : Add Ξ±] (s : (i : ΞΉ) β ΞΊ i β Set Ξ±) (t : Set Ξ±),
(β i, β j, s i j) + t β β i, β j, s i j + t
|
ciSup_or'
|
Mathlib.Order.ConditionallyCompleteLattice.Indexed
|
β {Ξ± : Type u_1} [inst : ConditionallyCompleteLinearOrderBot Ξ±] (p q : Prop) (f : p β¨ q β Ξ±),
β¨ (h : p β¨ q), f h = max (β¨ (h : p), f β―) (β¨ (h : q), f β―)
|
_private.Lean.Meta.Tactic.Grind.AlphaShareCommon.0.Lean.Meta.Grind.alphaEq.match_16
|
Lean.Meta.Tactic.Grind.AlphaShareCommon
|
(motive : Lean.Expr β Sort u_1) β
(eβ : Lean.Expr) β
((nβ : Lean.Name) β (iβ : β) β (bβ : Lean.Expr) β motive (Lean.Expr.proj nβ iβ bβ)) β
((x : Lean.Expr) β motive x) β motive eβ
|
Fin2.cases'.match_1
|
Mathlib.Data.Fin.Fin2
|
{n : β} β
(motive : Fin2 n.succ β Sort u_1) β
(x : Fin2 n.succ) β (Unit β motive Fin2.fz) β ((n_1 : Fin2 n) β motive n_1.fs) β motive x
|
_private.Lean.Elab.GuardMsgs.0.Lean.Elab.Tactic.GuardMsgs.messageToString._sparseCasesOn_3
|
Lean.Elab.GuardMsgs
|
{Ξ± : Type u} β
{motive : Option Ξ± β Sort u_1} β
(t : Option Ξ±) β ((val : Ξ±) β motive (some val)) β (Nat.hasNotBit 2 t.ctorIdx β motive t) β motive t
|
FreeAddMonoid.ofList_nil
|
Mathlib.Algebra.FreeMonoid.Basic
|
β {Ξ± : Type u_1}, FreeAddMonoid.ofList [] = 0
|
UInt8.ofInt_add
|
Init.Data.UInt.Lemmas
|
β (x y : β€), UInt8.ofInt (x + y) = UInt8.ofInt x + UInt8.ofInt y
|
Lean.Parser.Command.declModifiersF.formatter
|
Lean.Parser.Command
|
Lean.PrettyPrinter.Formatter
|
ComplexShape.instTotalComplexShapeSymmetryIntUp._proof_2
|
Mathlib.Algebra.Homology.ComplexShapeSigns
|
β (p : β€) {q iβ' : β€},
(ComplexShape.up β€).Rel q iβ' β
(p * q).negOnePow * (ComplexShape.up β€).Ξ΅β (ComplexShape.up β€) (ComplexShape.up β€) (p, q) =
(ComplexShape.up β€).Ξ΅β (ComplexShape.up β€) (ComplexShape.up β€) (q, p) * (p * iβ').negOnePow
|
_private.Mathlib.Algebra.Lie.Subalgebra.0.LieSubalgebra.toSubmodule_eq_top._simp_1_1
|
Mathlib.Algebra.Lie.Subalgebra
|
β {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(Lβ' Lβ' : LieSubalgebra R L), (Lβ' = Lβ') = (Lβ'.toSubmodule = Lβ'.toSubmodule)
|
Algebra.TensorProduct.productLeftAlgHom
|
Mathlib.RingTheory.TensorProduct.Maps
|
{R : Type uR} β
{S : Type uS} β
{A : Type uA} β
{B : Type uB} β
{C : Type uC} β
[inst : CommSemiring R] β
[inst_1 : CommSemiring S] β
[inst_2 : Algebra R S] β
[inst_3 : Semiring A] β
[inst_4 : Algebra R A] β
[inst_5 : Algebra S A] β
[inst_6 : IsScalarTower R S A] β
[inst_7 : Semiring B] β
[inst_8 : Algebra R B] β
[inst_9 : CommSemiring C] β
[inst_10 : Algebra R C] β
[inst_11 : Algebra S C] β
[IsScalarTower R S C] β (A ββ[S] C) β (B ββ[R] C) β TensorProduct R A B ββ[S] C
|
Nat.add_div_eq_of_le_mod_add_mod
|
Mathlib.Data.Nat.ModEq
|
β {a b c : β}, c β€ a % c + b % c β 0 < c β (a + b) / c = a / c + b / c + 1
|
CommRingCat.Colimits.instCommRingColimitType._proof_16
|
Mathlib.Algebra.Category.Ring.Colimits
|
β {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x : CommRingCat.Colimits.ColimitType F), npowRecAuto 0 x = 1
|
SimpleGraph.map_adj
|
Mathlib.Combinatorics.SimpleGraph.Maps
|
β {V : Type u_1} {W : Type u_2} (f : V βͺ W) (G : SimpleGraph V) (u v : W),
(SimpleGraph.map f G).Adj u v β β u' v', G.Adj u' v' β§ f u' = u β§ f v' = v
|
CategoryTheory.Triangulated.TStructure.IsGE.mk._flat_ctor
|
Mathlib.CategoryTheory.Triangulated.TStructure.Basic
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C β€]
[inst_4 : β (n : β€), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{t : CategoryTheory.Triangulated.TStructure C} {X : C} {n : β€}, t.ge n X β t.IsGE X n
|
ProbabilityTheory.Kernel.iIndepFun.indepFun_sum_range_succ
|
Mathlib.Probability.Independence.Kernel.IndepFun
|
β {Ξ± : Type u_1} {Ξ© : Type u_2} {mΞ± : MeasurableSpace Ξ±} {mΞ© : MeasurableSpace Ξ©} {ΞΊ : ProbabilityTheory.Kernel Ξ± Ξ©}
{ΞΌ : MeasureTheory.Measure Ξ±} {Ξ² : Type u_8} {m : MeasurableSpace Ξ²} [inst : AddCommMonoid Ξ²] [MeasurableAddβ Ξ²]
{f : β β Ξ© β Ξ²},
ProbabilityTheory.Kernel.iIndepFun f ΞΊ ΞΌ β
(β (i : β), Measurable (f i)) β β (n : β), ProbabilityTheory.Kernel.IndepFun (β j β Finset.range n, f j) (f n) ΞΊ ΞΌ
|
List.toFinsupp
|
Mathlib.Data.List.ToFinsupp
|
{M : Type u_1} β [inst : Zero M] β (l : List M) β [DecidablePred fun x => l.getD x 0 β 0] β β ββ M
|
smul_nonpos_iff_pos_imp_nonpos
|
Mathlib.Algebra.Order.Module.Defs
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Ring Ξ±] [inst_1 : LinearOrder Ξ±] [IsStrictOrderedRing Ξ±]
[inst_3 : AddCommGroup Ξ²] [inst_4 : LinearOrder Ξ²] [IsOrderedAddMonoid Ξ²] [inst_6 : Module Ξ± Ξ²]
[PosSMulStrictMono Ξ± Ξ²] {a : Ξ±} {b : Ξ²}, a β’ b β€ 0 β (0 < a β b β€ 0) β§ (b < 0 β 0 β€ a)
|
CategoryTheory.Pseudofunctor.mapComp'βββ_hom_assoc
|
Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor
|
β {B : Type uβ} {C : Type uβ} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {bβ bβ bβ bβ : B} (fββ : bβ βΆ bβ)
(fββ : bβ βΆ bβ) (fββ : bβ βΆ bβ) (fββ : bβ βΆ bβ) (fββ : bβ βΆ bβ) (f : bβ βΆ bβ)
(hββ : CategoryTheory.CategoryStruct.comp fββ fββ = fββ) (hββ : CategoryTheory.CategoryStruct.comp fββ fββ = fββ)
(hf : CategoryTheory.CategoryStruct.comp fββ fββ = f) {Z : F.obj bβ βΆ F.obj bβ}
(h : CategoryTheory.CategoryStruct.comp (F.map fββ) (F.map fββ) βΆ Z),
CategoryTheory.CategoryStruct.comp (F.mapComp' fββ fββ f β―).hom h =
CategoryTheory.CategoryStruct.comp (F.mapComp' fββ fββ f β―).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (F.mapComp' fββ fββ fββ hββ).hom (F.map fββ))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map fββ) (F.map fββ) (F.map fββ)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map fββ) (F.mapComp' fββ fββ fββ hββ).inv) h)))
|
Std.Time.PlainDate.format
|
Std.Time.Format
|
Std.Time.PlainDate β String β String
|
CategoryTheory.exactPairingCongrLeft._proof_6
|
Mathlib.CategoryTheory.Monoidal.Rigid.Basic
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X X' : C}
(i : X β
X'),
CategoryTheory.monoidalComp
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X))
(CategoryTheory.monoidalComp (CategoryTheory.CategoryStruct.comp i.hom i.inv)
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv
|
Int.cast_multiset_sum
|
Mathlib.Algebra.BigOperators.Ring.Finset
|
β {R : Type u_4} [inst : AddCommGroupWithOne R] (s : Multiset β€), βs.sum = (Multiset.map Int.cast s).sum
|
FirstOrder.Language.BoundedFormula.equal.sizeOf_spec
|
Mathlib.ModelTheory.Syntax
|
β {L : FirstOrder.Language} {Ξ± : Type u'} [inst : SizeOf Ξ±] {n : β} (tβ tβ : L.Term (Ξ± β Fin n)),
sizeOf (FirstOrder.Language.BoundedFormula.equal tβ tβ) = 1 + sizeOf n + sizeOf tβ + sizeOf tβ
|
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.noConfusionType
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.Types
|
Sort u β Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr β Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr β Sort u
|
Subsemiring.instCompleteLattice._proof_7
|
Mathlib.Algebra.Ring.Subsemiring.Basic
|
β {R : Type u_1} [inst : NonAssocSemiring R] (s : Set (Subsemiring R)), β a β s, sInf s β€ a
|
_private.Mathlib.Algebra.Order.Floor.Ring.0.Mathlib.Meta.Positivity.evalIntFloor.match_4
|
Mathlib.Algebra.Order.Floor.Ring
|
(u_1 : Lean.Level) β
(Ξ±' : Q(Type u_1)) β
(ir : Q(Ring Β«$Ξ±'Β»)) β
(io : Q(LinearOrder Β«$Ξ±'Β»)) β
(a : Q(Β«$Ξ±'Β»)) β
(motive : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) a β Sort u_1) β
(__do_lift : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) a) β
((pa : Q(0 < Β«$aΒ»)) β motive (Mathlib.Meta.Positivity.Strictness.positive pa)) β
((pa : Q(0 β€ Β«$aΒ»)) β motive (Mathlib.Meta.Positivity.Strictness.nonnegative pa)) β
((x : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) a) β motive x) β
motive __do_lift
|
CategoryTheory.Adjunction.leftAdjointCompIso
|
Mathlib.CategoryTheory.Adjunction.CompositionIso
|
{Cβ : Type u_1} β
{Cβ : Type u_2} β
{Cβ : 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} Cβ] β
{Fββ : CategoryTheory.Functor Cβ Cβ} β
{Fββ : CategoryTheory.Functor Cβ Cβ} β
{Fββ : CategoryTheory.Functor Cβ Cβ} β
{Gββ : CategoryTheory.Functor Cβ Cβ} β
{Gββ : CategoryTheory.Functor Cβ Cβ} β
{Gββ : CategoryTheory.Functor Cβ Cβ} β
(Fββ β£ Gββ) β (Fββ β£ Gββ) β (Fββ β£ Gββ) β (Gββ.comp Gββ β
Gββ) β (Fββ.comp Fββ β
Fββ)
|
Dynamics.coverEntropyInfEntourage_antitone
|
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy
|
β {X : Type u_1} (T : X β X) (F : Set X), Antitone fun U => Dynamics.coverEntropyInfEntourage T F U
|
Nat.succ_le_of_lt
|
Init.Data.Nat.Basic
|
β {n m : β}, n < m β n.succ β€ m
|
_private.Mathlib.LinearAlgebra.TensorAlgebra.Basis.0.TensorAlgebra.rank_eq.match_1_1
|
Mathlib.LinearAlgebra.TensorAlgebra.Basis
|
β {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : Nonempty ((I : Type u_1) Γ Module.Basis I R M) β Prop) (x : Nonempty ((I : Type u_1) Γ Module.Basis I R M)),
(β (ΞΊ : Type u_1) (b : Module.Basis ΞΊ R M), motive β―) β motive x
|
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?._sparseCasesOn_1
|
Lean.Meta.Tactic.Grind.EMatchTheorem
|
{motive : Lean.Meta.Grind.EMatchTheoremKind β Sort u} β
(t : Lean.Meta.Grind.EMatchTheoremKind) β
((gen : Bool) β motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) β
((gen : Bool) β motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) β
motive Lean.Meta.Grind.EMatchTheoremKind.eqBwd β (Nat.hasNotBit 11 t.ctorIdx β motive t) β motive t
|
Array.getElem?_attach
|
Init.Data.Array.Attach
|
β {Ξ± : Type u_1} {xs : Array Ξ±} {i : β}, xs.attach[i]? = Option.pmap Subtype.mk xs[i]? β―
|
Rat.interior_compact_eq_empty
|
Mathlib.Topology.Instances.RatLemmas
|
β {s : Set β}, IsCompact s β interior s = β
|
Lean.Parser.OrElseOnAntiquotBehavior.merge.sizeOf_spec
|
Lean.Parser.Basic
|
sizeOf Lean.Parser.OrElseOnAntiquotBehavior.merge = 1
|
String.reduceLE._regBuiltin.String.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.974433241._hygCtx._hyg.22
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.String
|
IO Unit
|
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.HasSubgaussianMGF_iff_kernel.match_1_3
|
Mathlib.Probability.Moments.SubGaussian
|
β {Ξ© : Type u_1} {mΞ© : MeasurableSpace Ξ©} {ΞΌ : MeasureTheory.Measure Ξ©} {X : Ξ© β β} {c : NNReal}
(motive :
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (ProbabilityTheory.Kernel.const Unit ΞΌ)
(MeasureTheory.Measure.dirac ()) β
Prop)
(x :
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (ProbabilityTheory.Kernel.const Unit ΞΌ)
(MeasureTheory.Measure.dirac ())),
(β
(h1 :
β (t : β),
MeasureTheory.Integrable (fun Ο => Real.exp (t * X Ο))
((MeasureTheory.Measure.dirac ()).bind β(ProbabilityTheory.Kernel.const Unit ΞΌ)))
(h2 :
βα΅ (Ο' : Unit) βMeasureTheory.Measure.dirac (),
β (t : β),
ProbabilityTheory.mgf X ((ProbabilityTheory.Kernel.const Unit ΞΌ) Ο') t β€ Real.exp (βc * t ^ 2 / 2)),
motive β―) β
motive x
|
NormedAddGroupHom._sizeOf_1
|
Mathlib.Analysis.Normed.Group.Hom
|
{V : Type u_1} β
{W : Type u_2} β
{inst : SeminormedAddCommGroup V} β
{inst_1 : SeminormedAddCommGroup W} β [SizeOf V] β [SizeOf W] β NormedAddGroupHom V W β β
|
MulArchimedeanOrder.val.eq_1
|
Mathlib.Algebra.Order.Archimedean.Class
|
β {M : Type u_1}, MulArchimedeanOrder.val = Equiv.refl (MulArchimedeanOrder M)
|
MeasurableSMul.rec
|
Mathlib.MeasureTheory.Group.Arithmetic
|
{M : Type u_2} β
{Ξ± : Type u_3} β
[inst : SMul M Ξ±] β
[inst_1 : MeasurableSpace M] β
[inst_2 : MeasurableSpace Ξ±] β
{motive : MeasurableSMul M Ξ± β Sort u} β
([toMeasurableConstSMul : MeasurableConstSMul M Ξ±] β
(measurable_smul_const : β (x : Ξ±), Measurable fun x_1 => x_1 β’ x) β motive β―) β
(t : MeasurableSMul M Ξ±) β motive t
|
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_middle
|
Lean.Meta.Tactic.Grind.AC.Types
|
Bool β
Lean.Grind.AC.Seq β
Lean.Grind.AC.Seq β Lean.Meta.Grind.AC.EqCnstr β Lean.Meta.Grind.AC.DiseqCnstr β Lean.Meta.Grind.AC.DiseqCnstrProof
|
Std.ExtHashMap.contains_of_contains_filterMap
|
Std.Data.ExtHashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.ExtHashMap Ξ± Ξ²} [inst : EquivBEq Ξ±]
[inst_1 : LawfulHashable Ξ±] {f : Ξ± β Ξ² β Option Ξ³} {k : Ξ±},
(Std.ExtHashMap.filterMap f m).contains k = true β m.contains k = true
|
Complex.UnitDisc.mk_neg
|
Mathlib.Analysis.Complex.UnitDisc.Basic
|
β (z : β) (hz : β-zβ < 1), Complex.UnitDisc.mk (-z) hz = -Complex.UnitDisc.mk z β―
|
ValuativeRel.trivialRel._proof_5
|
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial
|
β {R : Type} [inst : CommRing R] [inst_1 : DecidableEq R] [IsDomain R] {x y z : R},
(Β¬if 0 = 0 then z = 0 else True) β (if y * z = 0 then x * z = 0 else True) β if y = 0 then x = 0 else True
|
PowerBasis.liftEquiv._proof_6
|
Mathlib.RingTheory.PowerBasis
|
β {S : Type u_3} [inst : Ring S] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_1}
[inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S)
(y : { y // (Polynomial.aeval y) (minpoly A pb.gen) = 0 }), β¨(pb.lift βy β―) pb.gen, β―β© = y
|
Mathlib.Tactic.superscriptTerm
|
Mathlib.Util.Superscript
|
Lean.Parser.Parser
|
CategoryTheory.effectiveEpiFamilyStructOfComp._proof_4
|
Mathlib.CategoryTheory.EffectiveEpi.Comp
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {Z Y : I β C} {X : C}
(g : (i : I) β Z i βΆ Y i) (f : (i : I) β Y i βΆ X) {W : C} (Ο : (a : I) β Y a βΆ W),
(β {Z : C} (aβ aβ : I) (gβ : Z βΆ Y aβ) (gβ : Z βΆ Y aβ),
CategoryTheory.CategoryStruct.comp gβ (f aβ) = CategoryTheory.CategoryStruct.comp gβ (f aβ) β
CategoryTheory.CategoryStruct.comp gβ (Ο aβ) = CategoryTheory.CategoryStruct.comp gβ (Ο aβ)) β
β {Z_1 : C} (iβ iβ : I) (gβ : Z_1 βΆ Z iβ) (gβ : Z_1 βΆ Z iβ),
CategoryTheory.CategoryStruct.comp gβ (CategoryTheory.CategoryStruct.comp (g iβ) (f iβ)) =
CategoryTheory.CategoryStruct.comp gβ (CategoryTheory.CategoryStruct.comp (g iβ) (f iβ)) β
CategoryTheory.CategoryStruct.comp gβ (CategoryTheory.CategoryStruct.comp (g iβ) (Ο iβ)) =
CategoryTheory.CategoryStruct.comp gβ (CategoryTheory.CategoryStruct.comp (g iβ) (Ο iβ))
|
_private.Mathlib.SetTheory.Nimber.Field.0.Nimber.mul_nonempty
|
Mathlib.SetTheory.Nimber.Field
|
β (a b : Nimber), {x | β a' < a, β b' < b, a' * b + a * b' + a' * b' = x}αΆ.Nonempty
|
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.existsUnique_div_zpow_mem_Ico._simp_1_1
|
Mathlib.Algebra.Order.Archimedean.Basic
|
β {Ξ± : Type u_1} [inst : Preorder Ξ±] {a b x : Ξ±}, (x β Set.Ico a b) = (a β€ x β§ x < b)
|
AlternatingMap.instFunLike._proof_1
|
Mathlib.LinearAlgebra.Alternating.Basic
|
β {R : Type u_4} [inst : Semiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ΞΉ : Type u_3} (f g : M [β^ΞΉ]ββ[R] N),
(fun f => (βf).toFun) f = (fun f => (βf).toFun) g β f = g
|
AlgebraicGeometry.Scheme.Cover.map_prop
|
Mathlib.AlgebraicGeometry.Cover.MorphismProperty
|
β {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
(π° : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (i : π°.Iβ), P (π°.f i)
|
Condensed.StoneanCompHaus.equivalence._proof_5
|
Mathlib.Condensed.Equivalence
|
CategoryTheory.FinitaryPreExtensive Stonean
|
_private.Mathlib.Tactic.FunProp.Mor.0.Mathlib.Meta.FunProp.Mor.whnfPred.match_3
|
Mathlib.Tactic.FunProp.Mor
|
(motive : Option Lean.Expr β Sort u_1) β
(__do_lift : Option Lean.Expr) β ((e : Lean.Expr) β motive (some e)) β (Unit β motive none) β motive __do_lift
|
_private.Mathlib.Analysis.Normed.Operator.BoundedLinearMaps.0.IsBoundedLinearMap.isBigO_id.match_1_1
|
Mathlib.Analysis.Normed.Operator.BoundedLinearMaps
|
β {E : Type u_2} [inst : SeminormedAddCommGroup E] {F : Type u_1} [inst_1 : SeminormedAddCommGroup F] {f : E β F}
(motive : (β M, 0 < M β§ β (x : E), βf xβ β€ M * βxβ) β Prop) (x : β M, 0 < M β§ β (x : E), βf xβ β€ M * βxβ),
(β (w : β) (left : 0 < w) (hM : β (x : E), βf xβ β€ w * βxβ), motive β―) β motive x
|
CategoryTheory.TransfiniteCompositionOfShape.incl
|
Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{J : Type w} β
[inst_1 : LinearOrder J] β
[inst_2 : OrderBot J] β
{X Y : C} β
{f : X βΆ Y} β
[inst_3 : SuccOrder J] β
[inst_4 : WellFoundedLT J] β
(self : CategoryTheory.TransfiniteCompositionOfShape J f) β
self.F βΆ (CategoryTheory.Functor.const J).obj Y
|
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.HasProd.hasProd_symmetricIco_of_hasProd_symmetricIcc._proof_1_3
|
Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt
|
β (N : β), -βN β€ βN
|
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply._simp_1_1
|
Mathlib.GroupTheory.Perm.Cycle.Basic
|
β {Ξ± : Sort u_1} {Ξ² : Sort u_2} (e : Ξ± β Ξ²) {x : Ξ²} {y : Ξ±}, (y = e.symm x) = (e y = x)
|
Lean.Order.coind_monotone_forall
|
Init.Internal.Order.Basic
|
β {Ξ± : Sort u_1} [inst : Lean.Order.PartialOrder Ξ±] {Ξ² : Sort u_2} (f : Ξ± β Ξ² β Lean.Order.ReverseImplicationOrder),
Lean.Order.monotone f β Lean.Order.monotone fun x => β (y : Ξ²), f x y
|
CategoryTheory.GlueData'.t''._proof_7
|
Mathlib.CategoryTheory.GlueData
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData' C) (i j k : D.J)
(hij : Β¬i = j) (hjk : Β¬j = k), CategoryTheory.Limits.HasPullback (D.f j k hjk) (D.f j i β―)
|
_private.Init.Grind.ToInt.0.Lean.Grind.instBEqIntInterval.beq.eq_def
|
Init.Grind.ToInt
|
β (x x_1 : Lean.Grind.IntInterval),
Lean.Grind.instBEqIntInterval.beq x x_1 =
match x, x_1 with
| Lean.Grind.IntInterval.co a a_1, Lean.Grind.IntInterval.co b b_1 => a == b && a_1 == b_1
| Lean.Grind.IntInterval.ci a, Lean.Grind.IntInterval.ci b => a == b
| Lean.Grind.IntInterval.io a, Lean.Grind.IntInterval.io b => a == b
| Lean.Grind.IntInterval.ii, Lean.Grind.IntInterval.ii => true
| x, x_2 => false
|
Lean.ParserDescr.unicodeSymbol
|
Init.Prelude
|
String β String β Bool β Lean.ParserDescr
|
_private.Lean.Meta.Tactic.Grind.Order.Assert.0.Lean.Meta.Grind.Order.propagatePending.match_1
|
Lean.Meta.Tactic.Grind.Order.Assert
|
(motive : Lean.Meta.Grind.Order.ToPropagate β Sort u_1) β
(p : Lean.Meta.Grind.Order.ToPropagate) β
((c : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId) β
(e : Lean.Expr) β
(u v : Lean.Meta.Grind.Order.NodeId) β
(k k' : Lean.Meta.Grind.Order.Weight) β motive (Lean.Meta.Grind.Order.ToPropagate.eqTrue c e u v k k')) β
((c : Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId) β
(e : Lean.Expr) β
(u v : Lean.Meta.Grind.Order.NodeId) β
(k k' : Lean.Meta.Grind.Order.Weight) β motive (Lean.Meta.Grind.Order.ToPropagate.eqFalse c e u v k k')) β
((u v : Lean.Meta.Grind.Order.NodeId) β motive (Lean.Meta.Grind.Order.ToPropagate.eq u v)) β motive p
|
Module.Dual.baseChange._proof_2
|
Mathlib.LinearAlgebra.Dual.BaseChange
|
β {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
SMulCommClass R A A
|
Cardinal.partialOrder._proof_2
|
Mathlib.SetTheory.Cardinal.Order
|
β (a b c : Cardinal.{u_1}), a β€ b β b β€ c β a β€ c
|
UpperHalfPlane.petersson_slash_SL
|
Mathlib.NumberTheory.ModularForms.Petersson
|
β (k : β€) (f f' : UpperHalfPlane β β) (g : Matrix.SpecialLinearGroup (Fin 2) β€) (Ο : UpperHalfPlane),
UpperHalfPlane.petersson k (SlashAction.map k g f) (SlashAction.map k g f') Ο =
UpperHalfPlane.petersson k f f' (g β’ Ο)
|
ContinuousMapZero.instNonUnitalCommSemiring._proof_10
|
Mathlib.Topology.ContinuousMap.ContinuousMapZero
|
β {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : IsTopologicalSemiring R] (a : ContinuousMapZero X R), 0 * a = 0
|
CategoryTheory.CostructuredArrow.map_mk
|
Mathlib.CategoryTheory.Comma.StructuredArrow.Basic
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
{T T' : D} {Y : C} {S : CategoryTheory.Functor C D} {f : S.obj Y βΆ T} (g : T βΆ T'),
(CategoryTheory.CostructuredArrow.map g).obj (CategoryTheory.CostructuredArrow.mk f) =
CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp f g)
|
_private.Lean.Compiler.LCNF.Simp.FunDeclInfo.0.Lean.Compiler.LCNF.Simp.FunDeclInfoMap.update.addLetValueOccs
|
Lean.Compiler.LCNF.Simp.FunDeclInfo
|
Lean.Compiler.LCNF.LetValue β
StateRefT' IO.RealWorld Lean.Compiler.LCNF.Simp.FunDeclInfoMap Lean.Compiler.LCNF.CompilerM Unit
|
DilationEquiv.recOn
|
Mathlib.Topology.MetricSpace.DilationEquiv
|
{X : Type u_1} β
{Y : Type u_2} β
[inst : PseudoEMetricSpace X] β
[inst_1 : PseudoEMetricSpace Y] β
{motive : X βα΅ Y β Sort u} β
(t : X βα΅ Y) β
((toEquiv : X β Y) β
(edist_eq' : β r, r β 0 β§ β (x y : X), edist (toEquiv.toFun x) (toEquiv.toFun y) = βr * edist x y) β
motive { toEquiv := toEquiv, edist_eq' := edist_eq' }) β
motive t
|
CondensedSet.topCatAdjunctionUnit
|
Mathlib.Condensed.TopCatAdjunction
|
(X : CondensedSet) β X βΆ X.toTopCat.toCondensedSet
|
AlgebraicTopology.DoldKan.QInfty_comp_PInfty_assoc
|
Mathlib.AlgebraicTopology.DoldKan.PInfty
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {Z : ChainComplex C β}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X βΆ Z),
CategoryTheory.CategoryStruct.comp AlgebraicTopology.DoldKan.QInfty
(CategoryTheory.CategoryStruct.comp AlgebraicTopology.DoldKan.PInfty h) =
CategoryTheory.CategoryStruct.comp 0 h
|
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.isSubstCandidate
|
Lean.Elab.BuiltinNotation
|
Lean.Expr β Lean.Expr β Lean.MetaM Bool
|
Order.isSuccPrelimit_toDual_iff
|
Mathlib.Order.SuccPred.Limit
|
β {Ξ± : Type u_1} {a : Ξ±} [inst : LT Ξ±], Order.IsSuccPrelimit (OrderDual.toDual a) β Order.IsPredPrelimit a
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.assertCore
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr
|
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr β Lean.Meta.Grind.GoalM Unit
|
FirstOrder.Field.FieldAxiom.toProp.eq_7
|
Mathlib.ModelTheory.Algebra.Field.Basic
|
β (K : Type u_2) [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Zero K] [inst_4 : One K],
FirstOrder.Field.FieldAxiom.toProp K FirstOrder.Field.FieldAxiom.existsInv = β (x : K), x β 0 β β y, x * y = 1
|
CategoryTheory.Limits.PreservesFiniteProducts.casesOn
|
Mathlib.CategoryTheory.Limits.Preserves.Finite
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{D : Type uβ} β
[inst_1 : CategoryTheory.Category.{vβ, uβ} D] β
{F : CategoryTheory.Functor C D} β
{motive : CategoryTheory.Limits.PreservesFiniteProducts F β Sort u} β
(t : CategoryTheory.Limits.PreservesFiniteProducts F) β
((preserves :
β (n : β), CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete (Fin n)) F) β
motive β―) β
motive t
|
CommRingCat.Colimits.ColimitType.AddGroupWithOne._proof_3
|
Mathlib.Algebra.Category.Ring.Colimits
|
β {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat) (n : β),
(βn).castDef = (βn).castDef
|
ContinuousMap.instNormedAlgebra._proof_2
|
Mathlib.Topology.ContinuousMap.Compact
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] {π : Type u_3} {Ξ³ : Type u_2} [inst_1 : NormedField π]
[inst_2 : SeminormedRing Ξ³] [inst_3 : NormedAlgebra π Ξ³] (r : π) (x : C(Ξ±, Ξ³)),
Algebra.algebraMap r * x = x * Algebra.algebraMap r
|
smoothPresheafRing
|
Mathlib.Geometry.Manifold.Sheaf.Smooth
|
{π : Type u_1} β
[inst : NontriviallyNormedField π] β
{EM : Type u_2} β
[inst_1 : NormedAddCommGroup EM] β
[inst_2 : NormedSpace π EM] β
{HM : Type u_3} β
[inst_3 : TopologicalSpace HM] β
ModelWithCorners π EM HM β
{E : Type u_4} β
[inst_4 : NormedAddCommGroup E] β
[inst_5 : NormedSpace π E] β
{H : Type u_5} β
[inst_6 : TopologicalSpace H] β
(I : ModelWithCorners π E H) β
(M : Type u) β
[inst_7 : TopologicalSpace M] β
[ChartedSpace HM M] β
(R : Type u) β
[inst_9 : TopologicalSpace R] β
[inst_10 : ChartedSpace H R] β
[inst_11 : Ring R] β
[ContMDiffRing I (ββ€) R] β
TopCat.Presheaf RingCat { carrier := M, str := inst_7 }
|
_private.Mathlib.Order.WithBot.0.WithTop.noBotOrder.match_3
|
Mathlib.Order.WithBot
|
β {Ξ± : Type u_1} (motive : WithTop Ξ± β Prop) (x : WithTop Ξ±),
(β (a : Unit), motive none) β (β (a : Ξ±), motive (some a)) β motive x
|
ContinuousMap.instNonUnitalSemiringOfIsTopologicalSemiring._proof_1
|
Mathlib.Topology.ContinuousMap.Algebra
|
β {Ξ² : Type u_1} [inst : TopologicalSpace Ξ²] [inst_1 : NonUnitalSemiring Ξ²] [IsTopologicalSemiring Ξ²], ContinuousAdd Ξ²
|
Matrix.l2_opNNNorm_conjTranspose
|
Mathlib.Analysis.CStarAlgebra.Matrix
|
β {π : Type u_1} {m : Type u_2} {n : Type u_3} [inst : RCLike π] [inst_1 : Fintype m] [inst_2 : Fintype n]
[inst_3 : DecidableEq n] [inst_4 : DecidableEq m] (A : Matrix m n π), βA.conjTransposeββ = βAββ
|
LT.lt.pos
|
Mathlib.Algebra.Order.Monoid.Canonical.Defs
|
β {Ξ± : Type u} [inst : AddZeroClass Ξ±] [inst_1 : Preorder Ξ±] [CanonicallyOrderedAdd Ξ±] {a b : Ξ±}, a < b β 0 < b
|
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.delab.go.match_1.splitter
|
Lean.Elab.PreDefinition.TerminationMeasure
|
(motive : β β Lean.TSyntaxArray `ident β Sort u_1) β
(x : β) β
(x_1 : Lean.TSyntaxArray `ident) β
((vars : Lean.TSyntaxArray `ident) β motive 0 vars) β
((i : β) β (vars : Lean.TSyntaxArray `ident) β motive i.succ vars) β motive x x_1
|
LieAlgebra.exists_isRegular
|
Mathlib.Algebra.Lie.Rank
|
β (R : Type u_1) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [IsDomain R] [Infinite R], β x, LieAlgebra.IsRegular R x
|
CategoryTheory.MorphismProperty.LeftFraction.f
|
Mathlib.CategoryTheory.Localization.CalculusOfFractions
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{v_1, u_1} C] β
{W : CategoryTheory.MorphismProperty C} β {X Y : C} β (self : W.LeftFraction X Y) β X βΆ self.Y'
|
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.isMatching_iff_forall_degree._simp_1_1
|
Mathlib.Combinatorics.SimpleGraph.Matching
|
β {V : Type u} {G : SimpleGraph V} {G' : G.Subgraph} {v : V} [inst : Fintype β(G'.neighborSet v)],
(G'.degree v = 1) = β! w, G'.Adj v w
|
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.enumsPass.postprocess
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums
|
Lean.MVarId β
StateRefT' IO.RealWorld Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessStateβ Lean.MetaM Lean.MVarId
|
NFA.accepts_iff_exists_path
|
Mathlib.Computability.NFA
|
β {Ξ± : Type u} {Ο : Type v} {M : NFA Ξ± Ο} {x : List Ξ±},
x β M.accepts β β s β M.start, β t β M.accept, Nonempty (M.Path s t x)
|
Multiset.mem_sym2_iff
|
Mathlib.Data.Multiset.Sym
|
β {Ξ± : Type u_1} {m : Multiset Ξ±} {z : Sym2 Ξ±}, z β m.sym2 β β y β z, y β m
|
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits.termGβ
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc
|
Lean.ParserDescr
|
MeasureTheory.probReal_add_probReal_compl
|
Mathlib.MeasureTheory.Measure.Typeclasses.Probability
|
β {Ξ± : Type u_1} {m0 : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {s : Set Ξ±}
[MeasureTheory.IsProbabilityMeasure ΞΌ], MeasurableSet s β ΞΌ.real s + ΞΌ.real sαΆ = 1
|
Function.mem_support
|
Mathlib.Algebra.Notation.Support
|
β {ΞΉ : Type u_1} {M : Type u_3} [inst : Zero M] {f : ΞΉ β M} {x : ΞΉ}, x β Function.support f β f x β 0
|
_private.Init.Meta.Defs.0.Lean.Syntax.decodeNameLit.match_1
|
Init.Meta.Defs
|
(motive : Lean.Name β Sort u_1) β
(x : Lean.Name) β (Unit β motive Lean.Name.anonymous) β ((name : Lean.Name) β motive name) β motive x
|
_private.Lean.Meta.ExprLens.0.Lean.Meta.foldAncestorsAux._unsafe_rec
|
Lean.Meta.ExprLens
|
{M : Type β Type} β
[Monad M] β
[MonadLiftT Lean.MetaM M] β
[MonadControlT Lean.MetaM M] β
[Lean.MonadError M] β
{Ξ± : Type} β (Array Lean.Expr β Lean.Expr β β β Ξ± β M Ξ±) β Ξ± β List β β Array Lean.Expr β Lean.Expr β M Ξ±
|
CategoryTheory.Limits.ConeMorphism.ext
|
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} {c c' : CategoryTheory.Limits.Cone F} (f g : c βΆ c'), f.hom = g.hom β f = g
|
LinearMap.compAlternatingMap_smul
|
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} {S : Type u_10} {Nβ : Type u_11}
[inst_5 : AddCommMonoid Nβ] [inst_6 : Module R Nβ] [inst_7 : Monoid S] [inst_8 : DistribMulAction S N]
[inst_9 : DistribMulAction S Nβ] [inst_10 : SMulCommClass R S N] [inst_11 : SMulCommClass R S Nβ]
[LinearMap.CompatibleSMul N Nβ S R] (g : N ββ[R] Nβ) (s : S) (f : M [β^ΞΉ]ββ[R] N),
g.compAlternatingMap (s β’ f) = s β’ g.compAlternatingMap f
|
Nat.getElem?_toArray_roc
|
Init.Data.Range.Polymorphic.NatLemmas
|
β {m n i : β}, (m<...=n).toArray[i]? = if i < n - m then some (m + 1 + i) else none
|
Module.Basis.isUnitSMul
|
Mathlib.LinearAlgebra.Basis.SMul
|
{ΞΉ : Type u_1} β
{R : Type u_2} β
{M : Type u_4} β
[inst : Semiring R] β
[inst_1 : AddCommMonoid M] β
[inst_2 : Module R M] β Module.Basis ΞΉ R M β {w : ΞΉ β R} β (β (i : ΞΉ), IsUnit (w i)) β Module.Basis ΞΉ R M
|
squarefree_iff_irreducible_sq_not_dvd_of_ne_zero
|
Mathlib.Algebra.Squarefree.Basic
|
β {R : Type u_1} [inst : CommMonoidWithZero R] [WfDvdMonoid R] {r : R},
r β 0 β (Squarefree r β β (x : R), Irreducible x β Β¬x * x β£ r)
|
Int.negSucc_shiftRight
|
Init.Data.Int.Bitwise.Lemmas
|
β (m n : β), Int.negSucc m >>> n = Int.negSucc (m >>> n)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.