name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Set.image_neg_of_apply_neg_eq
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : InvolutiveNeg Ξ±] {s : Set Ξ±} {f g : Ξ± β Ξ²},
(β x β s, f (-x) = g x) β f '' (-s) = g '' s
|
BddAbove.of_closure
|
Mathlib.Topology.Order.OrderClosed
|
β {Ξ± : Type u} [inst : TopologicalSpace Ξ±] [inst_1 : Preorder Ξ±] {s : Set Ξ±}, BddAbove (closure s) β BddAbove s
|
Qq._aux_Qq_Commands___elabRules_Qq_termBy_elabq__1
|
Qq.Commands
|
Lean.Elab.Term.TermElab
|
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.map_dual._simp_1_6
|
Mathlib.Combinatorics.Matroid.Map
|
β {a b : Prop}, (a β§ b β a) = (a β b)
|
Filter.limsInf_le_of_le
|
Mathlib.Order.LiminfLimsup
|
β {Ξ± : Type u_1} [inst : ConditionallyCompleteLattice Ξ±] {f : Filter Ξ±} {a : Ξ±},
autoParam (Filter.IsBounded (fun x1 x2 => x1 β₯ x2) f) Filter.limsInf_le_of_le._auto_1 β
(β (b : Ξ±), (βαΆ (n : Ξ±) in f, b β€ n) β b β€ a) β f.limsInf β€ a
|
Batteries.CodeAction.getExplicitArgs._unsafe_rec
|
Batteries.CodeAction.Misc
|
Lean.Expr β Array Lean.Name β Array Lean.Name
|
PosNum.ldiff._sparseCasesOn_1
|
Mathlib.Data.Num.Bitwise
|
{motive : PosNum β Sort u} β
(t : PosNum) β ((a : PosNum) β motive a.bit0) β (Nat.hasNotBit 4 t.ctorIdx β motive t) β motive t
|
_private.Init.Data.SInt.Lemmas.0.Int16.le_total._simp_1_1
|
Init.Data.SInt.Lemmas
|
β {x y : Int16}, (x β€ y) = (x.toInt β€ y.toInt)
|
RestrictScalars.addEquiv
|
Mathlib.Algebra.Algebra.RestrictScalars
|
(R : Type u_1) β (S : Type u_2) β (M : Type u_3) β [inst : AddCommMonoid M] β RestrictScalars R S M β+ M
|
MeasureTheory.Measure.count_ne_zero
|
Mathlib.MeasureTheory.Measure.Count
|
β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {s : Set Ξ±}, s.Nonempty β MeasureTheory.Measure.count s β 0
|
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.getElem_succ_leftInvSeq_alternatingWord._simp_1_2
|
Mathlib.GroupTheory.Coxeter.Inversion
|
β {G : Type u_1} [inst : Mul G] [IsLeftCancelMul G] (a : G) {b c : G}, (a * b = a * c) = (b = c)
|
Prod.isRightRegular_mk._simp_4
|
Mathlib.Algebra.Regular.Prod
|
β {R : Type u_2} {S : Type u_3} [inst : Add R] [inst_1 : Add S] {a : R} {b : S},
IsAddRightRegular (a, b) = (IsAddRightRegular a β§ IsAddRightRegular b)
|
ENNReal.eq_top_of_forall_nnreal_le
|
Mathlib.Data.ENNReal.Inv
|
β {x : ENNReal}, (β (r : NNReal), βr β€ x) β x = β€
|
Cycle.formPerm_eq_self_of_notMem
|
Mathlib.GroupTheory.Perm.Cycle.Concrete
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] (s : Cycle Ξ±) (h : s.Nodup), β x β s, (s.formPerm h) x = x
|
Lean.Elab.Tactic.Do.ProofMode.addLocalVarInfo
|
Lean.Elab.Tactic.Do.ProofMode.MGoal
|
Lean.Syntax β Lean.LocalContext β Lean.Expr β Option Lean.Expr β optParam Bool false β Lean.MetaM Unit
|
InnerProductSpace.Core.norm_eq_sqrt_re_inner
|
Mathlib.Analysis.InnerProductSpace.Defs
|
β {π : Type u_1} {F : Type u_3} [inst : RCLike π] [inst_1 : AddCommGroup F] [inst_2 : Module π F]
[c : PreInnerProductSpace.Core π F] (x : F), βxβ = β(RCLike.re (inner π x x))
|
CategoryTheory.Sheaf.over
|
Mathlib.CategoryTheory.Sites.Over
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{J : CategoryTheory.GrothendieckTopology C} β
{A : Type u'} β
[inst_1 : CategoryTheory.Category.{v', u'} A] β
CategoryTheory.Sheaf J A β (X : C) β CategoryTheory.Sheaf (J.over X) A
|
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.d_comp_d._proof_1_6
|
Mathlib.Algebra.Homology.Embedding.Connect
|
β (m p : β€), m + 1 = p β β (n : β), Int.negSucc (n + 1 + 1) + 1 = m β m = Int.negSucc (n + 1)
|
IsCoprime.neg_neg
|
Mathlib.RingTheory.Coprime.Basic
|
β {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y β IsCoprime (-x) (-y)
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_of_not_smulOverflow._proof_1_7
|
Init.Data.BitVec.Lemmas
|
β (w : β) {x y : BitVec (w + 1)},
x.toInt * y.toInt < 2 ^ w β§ -2 ^ w β€ x.toInt * y.toInt β Β¬x.toInt * y.toInt < (2 ^ (w + 1) + 1) / 2 β False
|
VectorFourier.fourierIntegral.eq_1
|
Mathlib.Analysis.Fourier.FourierTransform
|
β {π : Type u_1} [inst : CommRing π] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module π V]
[inst_3 : MeasurableSpace V] {W : Type u_3} [inst_4 : AddCommGroup W] [inst_5 : Module π W] {E : Type u_4}
[inst_6 : NormedAddCommGroup E] [inst_7 : NormedSpace β E] (e : AddChar π Circle) (ΞΌ : MeasureTheory.Measure V)
(L : V ββ[π] W ββ[π] π) (f : V β E) (w : W),
VectorFourier.fourierIntegral e ΞΌ L f w = β« (v : V), e (-(L v) w) β’ f v βΞΌ
|
CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv
|
Mathlib.CategoryTheory.Localization.CalculusOfFractions
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{v_1, u_1} C] β
{W : CategoryTheory.MorphismProperty C} β
[inst_1 : W.HasLeftCalculusOfFractions] β
{X Y : C} β
(s : X βΆ Y) β
W s β
((CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj Y βΆ
(CategoryTheory.MorphismProperty.LeftFraction.Localization.Q W).obj X)
|
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.MutualClosure.mkLetRecClosureFor.match_3
|
Lean.Elab.MutualDef
|
(motive : Option (Lean.Name Γ Lean.BinderInfo) β Sort u_1) β
(x : Option (Lean.Name Γ Lean.BinderInfo)) β
((userName : Lean.Name) β (bi : Lean.BinderInfo) β motive (some (userName, bi))) β
((x : Option (Lean.Name Γ Lean.BinderInfo)) β motive x) β motive x
|
String.Slice.SplitIterator.instIteratorLoopIdOfMonad
|
Init.Data.String.Slice
|
{Ο : Type} β
{Ο : String.Slice β Type} β
[inst : (s : String.Slice) β Std.Iterators.Iterator (Ο s) Id (String.Slice.Pattern.SearchStep s)] β
{pat : Ο} β
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat Ο] β
{n : Type u_1 β Type u_2} β
{s : String.Slice} β [Monad n] β Std.Iterators.IteratorLoop (String.Slice.SplitIterator pat s) Id n
|
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.isTactic._sparseCasesOn_1
|
Lean.Parser.Tactic.Doc
|
{Ξ± : Type u} β
{motive : Option Ξ± β Sort u_1} β
(t : Option Ξ±) β ((val : Ξ±) β motive (some val)) β (Nat.hasNotBit 2 t.ctorIdx β motive t) β motive t
|
PredSubOrder.mk._flat_ctor
|
Mathlib.Algebra.Order.SuccPred
|
{Ξ± : Type u_1} β
[inst : Preorder Ξ±] β
[inst_1 : Sub Ξ±] β
[inst_2 : One Ξ±] β
(pred : Ξ± β Ξ±) β
(β (a : Ξ±), pred a β€ a) β
(β {a : Ξ±}, a β€ pred a β IsMin a) β
(β {a b : Ξ±}, a < b β a β€ pred b) β (β (x : Ξ±), pred x = x - 1) β PredSubOrder Ξ±
|
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.merge'.match_1_5
|
Batteries.Data.BinomialHeap.Basic
|
β {Ξ± : Type u_1} {le : Ξ± β Ξ± β Bool} {n : β} (rβ : β) (tβ tβ : Batteries.BinomialHeap.Imp.Heap Ξ±) (a : Ξ±)
(n_1 : Batteries.BinomialHeap.Imp.HeapNode Ξ±)
(motive :
Batteries.BinomialHeap.Imp.Heap.WF le n
(Batteries.BinomialHeap.Imp.Heap.merge le tβ (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ)) β§
((tβ.rankGT n β (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ).rankGT n) β
(Batteries.BinomialHeap.Imp.Heap.merge le tβ (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ)).rankGT
n) β
Prop)
(x :
Batteries.BinomialHeap.Imp.Heap.WF le n
(Batteries.BinomialHeap.Imp.Heap.merge le tβ (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ)) β§
((tβ.rankGT n β (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ).rankGT n) β
(Batteries.BinomialHeap.Imp.Heap.merge le tβ (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ)).rankGT
n)),
(β
(ihβ :
Batteries.BinomialHeap.Imp.Heap.WF le n
(Batteries.BinomialHeap.Imp.Heap.merge le tβ (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ)))
(ihβ :
(tβ.rankGT n β (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ).rankGT n) β
(Batteries.BinomialHeap.Imp.Heap.merge le tβ (Batteries.BinomialHeap.Imp.Heap.cons rβ.succ a n_1 tβ)).rankGT
n),
motive β―) β
motive x
|
Std.LawfulOrderMax.rec
|
Init.Data.Order.Classes
|
{Ξ± : Type u} β
[inst : Max Ξ±] β
[inst_1 : LE Ξ±] β
{motive : Std.LawfulOrderMax Ξ± β Sort u_1} β
([toMaxEqOr : Std.MaxEqOr Ξ±] β [toLawfulOrderSup : Std.LawfulOrderSup Ξ±] β motive β―) β
(t : Std.LawfulOrderMax Ξ±) β motive t
|
Ideal.prod_span_singleton
|
Mathlib.RingTheory.Ideal.Operations
|
β {R : Type u} [inst : CommSemiring R] {ΞΉ : Type u_2} (s : Finset ΞΉ) (I : ΞΉ β R),
β i β s, Ideal.span {I i} = Ideal.span {β i β s, I i}
|
_private.Mathlib.Data.List.OfFn.0.List.find?_ofFn_eq_some._proof_1_5
|
Mathlib.Data.List.OfFn
|
β {n : β} (i : Fin n), β j < βi, j < n
|
Lean.ModuleDoc.casesOn
|
Lean.DocString.Extension
|
{motive : Lean.ModuleDoc β Sort u} β
(t : Lean.ModuleDoc) β
((doc : String) β
(declarationRange : Lean.DeclarationRange) β motive { doc := doc, declarationRange := declarationRange }) β
motive t
|
Polynomial.toFinsuppIsoLinear
|
Mathlib.Algebra.Polynomial.Basic
|
(R : Type u) β [inst : Semiring R] β Polynomial R ββ[R] AddMonoidAlgebra R β
|
Nat.sqrt.iter._unsafe_rec
|
Batteries.Data.Nat.Basic
|
β β β β β
|
Real.sin_sq_pi_over_two_pow
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
|
β (n : β), Real.sin (Real.pi / 2 ^ (n + 1)) ^ 2 = 1 - (Real.sqrtTwoAddSeries 0 n / 2) ^ 2
|
_private.Mathlib.Topology.Homotopy.HSpaces.0.HSpace.prod._simp_2
|
Mathlib.Topology.Homotopy.HSpaces
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {aβ aβ : Ξ±} {bβ bβ : Ξ²}, ((aβ, bβ) = (aβ, bβ)) = (aβ = aβ β§ bβ = bβ)
|
Topology.isEmbedding_sigmoid
|
Mathlib.Analysis.SpecialFunctions.Sigmoid
|
Topology.IsEmbedding unitInterval.sigmoid
|
ContinuousOrderHom.instContinuousOrderHomClass
|
Mathlib.Topology.Order.Hom.Basic
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : TopologicalSpace Ξ±] [inst_1 : Preorder Ξ±] [inst_2 : TopologicalSpace Ξ²]
[inst_3 : Preorder Ξ²], ContinuousOrderHomClass (Ξ± βCo Ξ²) Ξ± Ξ²
|
differentiableAt_natCast
|
Mathlib.Analysis.Calculus.FDeriv.Const
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F]
[inst_5 : NatCast F] (n : β) (x : E), DifferentiableAt π (βn) x
|
Std.DTreeMap.Internal.Impl.Const.maxEntry.match_1
|
Std.Data.DTreeMap.Internal.Queries
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
(motive : (x : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β x.isEmpty = false β Sort u_3) β
(x : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β
(x_1 : x.isEmpty = false) β
((size : β) β
(k : Ξ±) β
(v : Ξ²) β
(l : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β
(x :
(Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).isEmpty = false) β
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf) x) β
((size : β) β
(k : Ξ±) β
(v : Ξ²) β
(l l_1 : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β
(size_1 : β) β
(k_1 : Ξ±) β
(v_1 : Ξ²) β
(l_2 r : Std.DTreeMap.Internal.Impl Ξ± fun x => Ξ²) β
(h : l_1 = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_2 r) β
(h_2 :
(Std.DTreeMap.Internal.Impl.inner size k v l
(namedPattern l_1 (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_2 r)
h)).isEmpty =
false) β
motive
(Std.DTreeMap.Internal.Impl.inner size k v l
(namedPattern l_1 (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_2 r) h))
h_2) β
motive x x_1
|
intervalIntegral.integral_finset_sum
|
Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic
|
β {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] {a b : β} {ΞΌ : MeasureTheory.Measure β}
{ΞΉ : Type u_8} {s : Finset ΞΉ} {f : ΞΉ β β β E},
(β i β s, IntervalIntegrable (f i) ΞΌ a b) β
β« (x : β) in a..b, β i β s, f i x βΞΌ = β i β s, β« (x : β) in a..b, f i x βΞΌ
|
ContinuousAffineEquiv.prodAssoc_toAffineEquiv
|
Mathlib.Topology.Algebra.ContinuousAffineEquiv
|
β (k : Type u_1) (Pβ : Type u_2) (Pβ : Type u_3) (Pβ : Type u_4) {Vβ : Type u_6} {Vβ : Type u_7} {Vβ : Type u_8}
[inst : Ring k] [inst_1 : AddCommGroup Vβ] [inst_2 : Module k Vβ] [inst_3 : AddTorsor Vβ Pβ]
[inst_4 : TopologicalSpace Pβ] [inst_5 : AddCommGroup Vβ] [inst_6 : Module k Vβ] [inst_7 : AddTorsor Vβ Pβ]
[inst_8 : TopologicalSpace Pβ] [inst_9 : AddCommGroup Vβ] [inst_10 : Module k Vβ] [inst_11 : AddTorsor Vβ Pβ]
[inst_12 : TopologicalSpace Pβ], β(ContinuousAffineEquiv.prodAssoc k Pβ Pβ Pβ) = AffineEquiv.prodAssoc k Pβ Pβ Pβ
|
CommGrpCat.coyoneda.eq_1
|
Mathlib.Algebra.Category.Grp.Yoneda
|
CommGrpCat.coyoneda =
{
obj := fun M =>
{ obj := fun N => CommGrpCat.of (β(Opposite.unop M) β* βN),
map := fun {X Y} f => CommGrpCat.ofHom (MonoidHom.compHom (CommGrpCat.Hom.hom f)), map_id := β―, map_comp := β― },
map := fun {X Y} f => { app := fun N => CommGrpCat.ofHom (CommGrpCat.Hom.hom f.unop).compHom', naturality := β― },
map_id := CommGrpCat.coyoneda._proof_4, map_comp := @CommGrpCat.coyoneda._proof_5 }
|
StrictAnti.wellFoundedLT
|
Mathlib.Order.Monotone.Basic
|
β {Ξ± : Type u} {Ξ² : Type v} [inst : Preorder Ξ±] [inst_1 : Preorder Ξ²] {f : Ξ± β Ξ²} [WellFoundedGT Ξ²],
StrictAnti f β WellFoundedLT Ξ±
|
Filter.tendsto_atTop_mono'
|
Mathlib.Order.Filter.AtTopBot.Tendsto
|
β {Ξ± : Type u_3} {Ξ² : Type u_4} [inst : Preorder Ξ²] (l : Filter Ξ±) β¦fβ fβ : Ξ± β Ξ²β¦,
fβ β€αΆ [l] fβ β Filter.Tendsto fβ l Filter.atTop β Filter.Tendsto fβ l Filter.atTop
|
segment_eq_image'
|
Mathlib.Analysis.Convex.Segment
|
β (π : Type u_1) {E : Type u_2} [inst : Ring π] [inst_1 : PartialOrder π] [AddRightMono π] [inst_3 : AddCommGroup E]
[inst_4 : Module π E] (x y : E), segment π x y = (fun ΞΈ => x + ΞΈ β’ (y - x)) '' Set.Icc 0 1
|
Bool.le_true._simp_1
|
Init.Data.Bool
|
β (x : Bool), (x β€ true) = True
|
Finset.prod_filter
|
Mathlib.Algebra.BigOperators.Group.Finset.Basic
|
β {ΞΉ : Type u_1} {M : Type u_4} {s : Finset ΞΉ} [inst : CommMonoid M] (p : ΞΉ β Prop) [inst_1 : DecidablePred p]
(f : ΞΉ β M), β a β s with p a, f a = β a β s, if p a then f a else 1
|
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable.match_1
|
Lean.Elab.DeclModifiers
|
(motive : Lean.Elab.ComputeKind β Sort u_1) β
(x : Lean.Elab.ComputeKind) β
(Unit β motive Lean.Elab.ComputeKind.noncomputable) β ((x : Lean.Elab.ComputeKind) β motive x) β motive x
|
Multiset.zero_disjoint
|
Mathlib.Data.Multiset.UnionInter
|
β {Ξ± : Type u_1} (l : Multiset Ξ±), Disjoint 0 l
|
CategoryTheory.CommGrpObj
|
Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] β [CategoryTheory.BraidedCategory C] β C β Type v
|
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFail._regBuiltin._private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFail_1
|
Lean.Elab.Tactic.Grind.BuiltinTactic
|
IO Unit
|
Fin.univ_image_get
|
Mathlib.Data.Fintype.Basic
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] (l : List Ξ±), Finset.image l.get Finset.univ = l.toFinset
|
Std.DTreeMap.instUnion
|
Std.Data.DTreeMap.Basic
|
{Ξ± : Type u} β {Ξ² : Ξ± β Type v} β {cmp : Ξ± β Ξ± β Ordering} β Union (Std.DTreeMap Ξ± Ξ² cmp)
|
Polynomial.UniversalCoprimeFactorizationRing.isCoprime_factorβ_factorβ
|
Mathlib.RingTheory.Polynomial.UniversalFactorizationRing
|
β {R : Type u_1} [inst : CommRing R] {n : β} (m k : β) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
IsCoprime β(Polynomial.UniversalCoprimeFactorizationRing.factorβ m k hn p)
β(Polynomial.UniversalCoprimeFactorizationRing.factorβ m k hn p)
|
ComplexShape.notMem_range_embeddingUpIntLE_iff
|
Mathlib.Algebra.Homology.Embedding.Basic
|
β (p n : β€), (β (i : β), (ComplexShape.embeddingUpIntLE p).f i β n) β p < n
|
PMF.filter_apply_eq_zero_iff
|
Mathlib.Probability.ProbabilityMassFunction.Constructions
|
β {Ξ± : Type u_1} {p : PMF Ξ±} {s : Set Ξ±} (h : β a β s, a β p.support) (a : Ξ±),
(p.filter s h) a = 0 β a β s β¨ a β p.support
|
CliffordAlgebra.EvenHom._sizeOf_1
|
Mathlib.LinearAlgebra.CliffordAlgebra.Even
|
{R : Type u_1} β
{M : Type u_2} β
{inst : CommRing R} β
{inst_1 : AddCommGroup M} β
{inst_2 : Module R M} β
{Q : QuadraticForm R M} β
{A : Type u_3} β
{inst_3 : Ring A} β
{inst_4 : Algebra R A} β [SizeOf R] β [SizeOf M] β [SizeOf A] β CliffordAlgebra.EvenHom Q A β β
|
Finsupp.lcoeFun._proof_1
|
Mathlib.LinearAlgebra.Finsupp.Pi
|
β {Ξ± : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (x y : Ξ± ββ M), β(x + y) = βx + βy
|
_private.Mathlib.Order.Heyting.Hom.0.OrderIsoClass.toHeytingHomClass._simp_1
|
Mathlib.Order.Heyting.Hom
|
β {F : Type u_1} {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : LE Ξ±] [inst_1 : LE Ξ²] [inst_2 : EquivLike F Ξ± Ξ²]
[OrderIsoClass F Ξ± Ξ²] (f : F) {a : Ξ±} {b : Ξ²}, (b β€ f a) = (EquivLike.inv f b β€ a)
|
CategoryTheory.PreGaloisCategory.instPreservesColimitsOfShapeActionFintypeCatAutFunctorSingleObjFunctorToActionOfFinite
|
Mathlib.CategoryTheory.Galois.Action
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.GaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F] (G : Type u_2)
[inst_3 : Group G] [Finite G],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.SingleObj G)
(CategoryTheory.PreGaloisCategory.functorToAction F)
|
CStarMatrix.toCLM_apply_single_apply
|
Mathlib.Analysis.CStarAlgebra.CStarMatrix
|
β {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Fintype m] [inst_1 : NonUnitalCStarAlgebra A]
[inst_2 : PartialOrder A] [inst_3 : StarOrderedRing A] [inst_4 : DecidableEq m] {M : CStarMatrix m n A} {i : m}
{j : n} (a : A), (CStarMatrix.toCLM M) ((WithCStarModule.equiv A (m β A)).symm (Pi.single i a)) j = a * M i j
|
_private.Lean.MetavarContext.0.Lean.DependsOn.dep.visit
|
Lean.MetavarContext
|
(Lean.FVarId β Bool) β (Lean.MVarId β Bool) β Lean.Expr β Lean.DependsOn.Mβ Bool
|
ULift.instLinearOrder._proof_2
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u_2} [inst : LinearOrder Ξ±] {x y : ULift.{u_1, u_2} Ξ±}, x.down < y.down β x < y
|
Metric.closedBall_subset_closedBall
|
Mathlib.Topology.MetricSpace.Pseudo.Defs
|
β {Ξ± : Type u} [inst : PseudoMetricSpace Ξ±] {x : Ξ±} {Ξ΅β Ξ΅β : β},
Ξ΅β β€ Ξ΅β β Metric.closedBall x Ξ΅β β Metric.closedBall x Ξ΅β
|
Array.extract_size_left
|
Init.Data.Array.Extract
|
β {Ξ± : Type u_1} {j : β} {as : Array Ξ±}, as.extract as.size j = #[]
|
LinearEquiv.curry._proof_2
|
Mathlib.Algebra.Module.Equiv.Basic
|
β (R : Type u_4) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (V : Type u_1)
(Vβ : Type u_2) (x : R) (x_1 : V Γ Vβ β M),
(Equiv.curry V Vβ M).toFun (x β’ x_1) = (Equiv.curry V Vβ M).toFun (x β’ x_1)
|
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.mem_iff._simp_1_2
|
Mathlib.Topology.Algebra.Valued.LocallyCompact
|
β {rβ rβ : NNReal}, (rβ β€ rβ) = (βrβ β€ βrβ)
|
DirichletCharacter.LFunction_ne_zero_of_one_le_re
|
Mathlib.NumberTheory.LSeries.Nonvanishing
|
β {N : β} (Ο : DirichletCharacter β N) [inst : NeZero N] β¦s : ββ¦,
Ο β 1 β¨ s β 1 β 1 β€ s.re β DirichletCharacter.LFunction Ο s β 0
|
_private.Lean.Environment.0.Lean.ImportedModule.mk.injEq
|
Lean.Environment
|
β (toEffectiveImport : Lean.EffectiveImport) (parts : Array (Lean.ModuleData Γ Lean.CompactedRegion))
(irData? : Option (Lean.ModuleData Γ Lean.CompactedRegion)) (needsData needsIRTrans : Bool)
(toEffectiveImport_1 : Lean.EffectiveImport) (parts_1 : Array (Lean.ModuleData Γ Lean.CompactedRegion))
(irData?_1 : Option (Lean.ModuleData Γ Lean.CompactedRegion)) (needsData_1 needsIRTrans_1 : Bool),
({ toEffectiveImport := toEffectiveImport, parts := parts, irData? := irData?, needsData := needsData,
needsIRTrans := needsIRTrans } =
{ toEffectiveImport := toEffectiveImport_1, parts := parts_1, irData? := irData?_1, needsData := needsData_1,
needsIRTrans := needsIRTrans_1 }) =
(toEffectiveImport = toEffectiveImport_1 β§
parts = parts_1 β§ irData? = irData?_1 β§ needsData = needsData_1 β§ needsIRTrans = needsIRTrans_1)
|
Std.Rxo.Iterator.mk.sizeOf_spec
|
Init.Data.Range.Polymorphic.RangeIterator
|
β {Ξ± : Type u} [inst : SizeOf Ξ±] (next : Option Ξ±) (upperBound : Ξ±),
sizeOf { next := next, upperBound := upperBound } = 1 + sizeOf next + sizeOf upperBound
|
normalClosure_of_stabilizer_eq_top
|
Mathlib.GroupTheory.GroupAction.Jordan
|
β {G : Type u_1} {Ξ± : Type u_2} [inst : Group G] [inst_1 : MulAction G Ξ±],
2 < ENat.card Ξ± β
MulAction.IsMultiplyPretransitive G Ξ± 2 β β {a : Ξ±}, Subgroup.normalClosure β(MulAction.stabilizer G a) = β€
|
_private.Aesop.Util.Tactic.Ext.0.Aesop.straightLineExt.go._sparseCasesOn_5
|
Aesop.Util.Tactic.Ext
|
{Ξ± : Type u} β
{motive : Option Ξ± β Sort u_1} β
(t : Option Ξ±) β ((val : Ξ±) β motive (some val)) β (Nat.hasNotBit 2 t.ctorIdx β motive t) β motive t
|
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_cos_sq._simp_1_3
|
Mathlib.Analysis.SpecialFunctions.Integrals.Basic
|
β {Ξ± : Type u_2} [inst : Zero Ξ±] [inst_1 : OfNat Ξ± 4] [NeZero 4], (4 = 0) = False
|
Subgroup.exists_smul_eq
|
Mathlib.GroupTheory.SchurZassenhaus
|
β {G : Type u_1} [inst : Group G] {H : Subgroup G} [inst_1 : IsMulCommutative β₯H] [inst_2 : H.FiniteIndex]
[inst_3 : H.Normal], (Nat.card β₯H).Coprime H.index β β (Ξ± Ξ² : H.QuotientDiff), β h, h β’ Ξ± = Ξ²
|
Std.ExtTreeSet.getD_inter_of_not_mem_left
|
Std.Data.ExtTreeSet.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.ExtTreeSet Ξ± cmp} [inst : Std.TransCmp cmp] {k fallback : Ξ±},
k β tβ β (tβ β© tβ).getD k fallback = fallback
|
Field.Emb.Cardinal.strictMono_leastExt
|
Mathlib.FieldTheory.CardinalEmb
|
β {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 β€ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
StrictMono (Field.Emb.Cardinal.leastExt F E)
|
RelEmbedding._sizeOf_1
|
Mathlib.Order.RelIso.Basic
|
{Ξ± : Type u_5} β
{Ξ² : Type u_6} β
{r : Ξ± β Ξ± β Prop} β
{s : Ξ² β Ξ² β Prop} β
[SizeOf Ξ±] β [SizeOf Ξ²] β [(a a_1 : Ξ±) β SizeOf (r a a_1)] β [(a a_1 : Ξ²) β SizeOf (s a a_1)] β r βͺr s β β
|
Configuration.ProjectivePlane.ctorIdx
|
Mathlib.Combinatorics.Configuration
|
{P : Type u_1} β {L : Type u_2} β {inst : Membership P L} β Configuration.ProjectivePlane P L β β
|
CategoryTheory.sum.inlCompAssociator_hom_app
|
Mathlib.CategoryTheory.Sums.Associator
|
β (C : Type uβ) [inst : CategoryTheory.Category.{vβ, uβ} C] (D : Type uβ) [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
(E : Type uβ) [inst_2 : CategoryTheory.Category.{vβ, uβ} E] (X : C β D),
(CategoryTheory.sum.inlCompAssociator C D E).hom.app X =
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Sum.inl_ C (D β E)).sum'
((CategoryTheory.Sum.inl_ D E).comp (CategoryTheory.Sum.inr_ C (D β E)))).obj
X)
|
Lean.Compiler.LCNF.SpecState.specInfo
|
Lean.Compiler.LCNF.SpecInfo
|
Lean.Compiler.LCNF.SpecState β Lean.PHashMap Lean.Name (Array Lean.Compiler.LCNF.SpecParamInfo)
|
Std.Internal.IO.Process.totalMemory
|
Std.Internal.Async.Process
|
IO UInt64
|
Aesop.RuleBuilderInput._sizeOf_1
|
Aesop.Builder.Basic
|
Aesop.RuleBuilderInput β β
|
Int8.le_of_lt
|
Init.Data.SInt.Lemmas
|
β {a b : Int8}, a < b β a β€ b
|
CategoryTheory.Endofunctor.algebraPreadditive_homGroup_nsmul_f
|
Mathlib.CategoryTheory.Preadditive.EndoFunctor
|
β (C : Type uβ) [inst : CategoryTheory.Category.{vβ, uβ} C] [inst_1 : CategoryTheory.Preadditive C]
(F : CategoryTheory.Functor C C) [inst_2 : F.Additive] (Aβ Aβ : CategoryTheory.Endofunctor.Algebra F) (n : β)
(Ξ± : Aβ βΆ Aβ), (n β’ Ξ±).f = n β’ Ξ±.f
|
IndexedPartition.piecewise_apply
|
Mathlib.Data.Setoid.Partition
|
β {ΞΉ : Type u_1} {Ξ± : Type u_2} {s : ΞΉ β Set Ξ±} (hs : IndexedPartition s) {Ξ² : Type u_3} {f : ΞΉ β Ξ± β Ξ²} (x : Ξ±),
hs.piecewise f x = f (hs.index x) x
|
fourier_coe_apply'
|
Mathlib.Analysis.Fourier.AddCircle
|
β {T : β} {n : β€} {x : β}, β(AddCircle.toCircle (n β’ βx)) = Complex.exp (2 * βReal.pi * Complex.I * βn * βx / βT)
|
_private.Mathlib.Data.Finset.Sum.0.Finset.disjSum_eq_empty._simp_1_1
|
Mathlib.Data.Finset.Sum
|
β {Ξ± : Type u_1} {sβ sβ : Finset Ξ±}, (sβ = sβ) = β (a : Ξ±), a β sβ β a β sβ
|
bUnion_mem_nhdsSet
|
Mathlib.Topology.NhdsSet
|
β {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} {t : X β Set X},
(β x β s, t x β nhds x) β β x β s, t x β nhdsSet s
|
three'_nsmul
|
Mathlib.Algebra.Group.Defs
|
β {M : Type u_2} [inst : AddMonoid M] (a : M), 3 β’ a = a + a + a
|
Mathlib.Tactic.Ring.mul_pf_right
|
Mathlib.Tactic.Ring.Basic
|
β {R : Type u_1} [inst : CommSemiring R] {a bβ c : R} (bβ : R) (bβ : β), a * bβ = c β a * (bβ ^ bβ * bβ) = bβ ^ bβ * c
|
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjId_hom_app_snd_app
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic
|
β {A : Type uβ} {B : Type uβ} {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} A]
[inst_1 : CategoryTheory.Category.{vβ, uβ} B] [inst_2 : CategoryTheory.Category.{vβ, uβ} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type uβ)
[inst_3 : CategoryTheory.Category.{vβ, uβ} X] (X_1 : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X)
(X_2 : X),
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjId F G X).hom.app X_1).snd.app X_2 =
CategoryTheory.CategoryStruct.id (X_1.snd.obj X_2)
|
Con.gi.eq_1
|
Mathlib.GroupTheory.Congruence.Defs
|
β (M : Type u_1) [inst : Mul M], Con.gi M = { choice := fun r x => conGen r, gc := β―, le_l_u := β―, choice_eq := β― }
|
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.ΞΌ_bddAbove
|
Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm
|
β {R : Type u_1} [inst : CommRing R] (ΞΌ : RingSeminorm R),
ΞΌ 1 β€ 1 β
β {s : β β β},
(β (n : β), s n β€ n) β β (x : R) (Ο : β β β), BddAbove (Set.range fun n => ΞΌ (x ^ s (Ο n)) ^ (1 / β(Ο n)))
|
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.cos_angle_mul_norm_mul_norm._simp_1_1
|
Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic
|
β {a b c : Prop}, (a β¨ b β c) = ((a β c) β§ (b β c))
|
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_3
|
Mathlib.AlgebraicGeometry.IdealSheaf.Basic
|
β {X : AlgebraicGeometry.Scheme} (Z : TopologicalSpace.Closeds β₯X) (U : βX.affineOpens),
β x β βU,
x β βZ β
x β
X.zeroLocus
β(PrimeSpectrum.vanishingIdeal
(β(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.IsAffineOpen.fromSpec β―).base) β»ΒΉ' βZ))
|
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.mkProdEqQ.makeRHS._sunfold
|
Mathlib.Data.Fin.Tuple.Reflection
|
{u : Lean.Level} β
{Ξ± : Q(Type u)} β Q(CommMonoid Β«$Ξ±Β») β (n : β) β Q(Fin Β«$nΒ» β Β«$Ξ±Β») β Q(NeZero Β«$nΒ») β β β Lean.MetaM Q(Β«$Ξ±Β»)
|
List.partition.loop.eq_2
|
Init.Data.List.Lemmas
|
β {Ξ± : Type u} (p : Ξ± β Bool) (a : Ξ±) (as bs cs : List Ξ±),
List.partition.loop p (a :: as) (bs, cs) =
match p a with
| true => List.partition.loop p as (a :: bs, cs)
| false => List.partition.loop p as (bs, a :: cs)
|
Polynomial.hilbertPoly_mul_one_sub_succ
|
Mathlib.RingTheory.Polynomial.HilbertPoly
|
β {F : Type u_1} [inst : Field F] [CharZero F] (p : Polynomial F) (d : β),
(p * (1 - Polynomial.X)).hilbertPoly (d + 1) = p.hilbertPoly d
|
Mathlib.Tactic.Bicategory.MorβOfExpr
|
Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes
|
Lean.Expr β Mathlib.Tactic.Bicategory.BicategoryM Mathlib.Tactic.BicategoryLike.Morβ
|
Computation.Mem
|
Mathlib.Data.Seq.Computation
|
{Ξ± : Type u} β Computation Ξ± β Ξ± β Prop
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.