name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Lean.Lsp.DependencyBuildMode._sizeOf_inst
|
Lean.Data.Lsp.Extra
|
SizeOf Lean.Lsp.DependencyBuildMode
|
CategoryTheory.Limits.Trident.ΞΉ
|
Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers
|
{J : Type w} β
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
{X Y : C} β
{f : J β (X βΆ Y)} β
(t : CategoryTheory.Limits.Trident f) β
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj t.pt).obj
CategoryTheory.Limits.WalkingParallelFamily.zero βΆ
(CategoryTheory.Limits.parallelFamily f).obj CategoryTheory.Limits.WalkingParallelFamily.zero
|
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_toInt_lt_neg_two_pow_iff._proof_1_8
|
Init.Data.BitVec.Lemmas
|
β (w : β) {x y : BitVec (w + 1)},
((w + 1) * 2 - 2 < (w + 1) * 2 - 1 β 2 ^ ((w + 1) * 2 - 2) < 2 ^ ((w + 1) * 2 - 1)) β
x.toInt * y.toInt β€ 2 ^ ((w + 1) * 2 - 2) β Β¬x.toInt * y.toInt * 2 < 2 ^ ((w + 1) * 2 - 1) * 2 β False
|
AlgebraicGeometry.Scheme.OpenCover.finiteSubcover_X
|
Mathlib.AlgebraicGeometry.Cover.Open
|
β {X : AlgebraicGeometry.Scheme} (π° : X.OpenCover) [H : CompactSpace β₯X] (x : β₯β―.choose),
π°.finiteSubcover.X x = π°.X (AlgebraicGeometry.Scheme.Cover.idx π° βx)
|
Lean.RBNode.leaf
|
Lean.Data.RBMap
|
{Ξ± : Type u} β {Ξ² : Ξ± β Type v} β Lean.RBNode Ξ± Ξ²
|
Multiset.countP_congr
|
Mathlib.Data.Multiset.Count
|
β {Ξ± : Type u_1} {s s' : Multiset Ξ±},
s = s' β
β {p p' : Ξ± β Prop} [inst : DecidablePred p] [inst_1 : DecidablePred p'],
(β x β s, p x = p' x) β Multiset.countP p s = Multiset.countP p' s'
|
instToStringFloat32
|
Init.Data.Float32
|
ToString Float32
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput.lhs
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv
|
{Ξ± : Type} β
[inst : Hashable Ξ±] β
[inst_1 : DecidableEq Ξ±] β
{aig : Std.Sat.AIG Ξ±} β
{len : β} β Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput aig len β aig.RefVec len
|
Lean.Server.RequestHandler._sizeOf_inst
|
Lean.Server.Requests
|
SizeOf Lean.Server.RequestHandler
|
BddOrd.instConcreteCategoryBoundedOrderHomCarrier._proof_2
|
Mathlib.Order.Category.BddOrd
|
β {X Y : BddOrd} (f : X βΆ Y), { hom' := f.hom' } = f
|
Set.coe_snd_biUnionEqSigmaOfDisjoint
|
Mathlib.Data.Set.Pairwise.Lattice
|
β {Ξ± : Type u_5} {ΞΉ : Type u_6} {s : Set ΞΉ} {f : ΞΉ β Set Ξ±} (h : s.PairwiseDisjoint f) (x : β(β i β s, f i)),
β((Set.biUnionEqSigmaOfDisjoint h) x).snd = βx
|
Quaternion.instNormedAddCommGroupReal._proof_3
|
Mathlib.Analysis.Quaternion
|
β (x y : Quaternion β) (r : β), (r β’ x * star y).re = (starRingEnd β) r * (x * star y).re
|
Aesop.TraceOption.mk.noConfusion
|
Aesop.Tracing
|
(P : Sort u) β
(traceClass : Lean.Name) β
(option : Lean.Option Bool) β
(traceClass' : Lean.Name) β
(option' : Lean.Option Bool) β
{ traceClass := traceClass, option := option } = { traceClass := traceClass', option := option' } β
(traceClass = traceClass' β option = option' β P) β P
|
torusMap_zero_radius
|
Mathlib.MeasureTheory.Integral.TorusIntegral
|
β {n : β} (c : Fin n β β), torusMap c 0 = Function.const (Fin n β β) c
|
Ordinal.inductionOnWellOrder
|
Mathlib.SetTheory.Ordinal.Basic
|
β {C : Ordinal.{u_1} β Prop} (o : Ordinal.{u_1}),
(β (Ξ± : Type u_1) [inst : LinearOrder Ξ±] [inst_1 : WellFoundedLT Ξ±], C (Ordinal.type fun x1 x2 => x1 < x2)) β C o
|
MeasureTheory.MemLp.exists_boundedContinuous_integral_rpow_sub_le
|
Mathlib.MeasureTheory.Function.ContinuousMapDense
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [NormalSpace Ξ±] [inst_2 : MeasurableSpace Ξ±] [BorelSpace Ξ±] {E : Type u_2}
[inst_4 : NormedAddCommGroup E] {ΞΌ : MeasureTheory.Measure Ξ±} [NormedSpace β E] [ΞΌ.WeaklyRegular] {p : β},
0 < p β
β {f : Ξ± β E},
MeasureTheory.MemLp f (ENNReal.ofReal p) ΞΌ β
β {Ξ΅ : β}, 0 < Ξ΅ β β g, β« (x : Ξ±), βf x - g xβ ^ p βΞΌ β€ Ξ΅ β§ MeasureTheory.MemLp (βg) (ENNReal.ofReal p) ΞΌ
|
ContinuousOpenMap._sizeOf_inst
|
Mathlib.Topology.Hom.Open
|
(Ξ± : Type u_6) β
(Ξ² : Type u_7) β
{inst : TopologicalSpace Ξ±} β {inst_1 : TopologicalSpace Ξ²} β [SizeOf Ξ±] β [SizeOf Ξ²] β SizeOf (Ξ± βCO Ξ²)
|
indicator_ae_eq_zero_of_restrict_ae_eq_zero
|
Mathlib.MeasureTheory.Measure.Restrict
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±} {s : Set Ξ±} {f : Ξ± β Ξ²}
[inst_1 : Zero Ξ²], MeasurableSet s β f =α΅[ΞΌ.restrict s] 0 β s.indicator f =α΅[ΞΌ] 0
|
CategoryTheory.CommMon.X
|
Mathlib.CategoryTheory.Monoidal.CommMon_
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
[inst_1 : CategoryTheory.MonoidalCategory C] β
[inst_2 : CategoryTheory.BraidedCategory C] β CategoryTheory.CommMon C β C
|
CategoryTheory.Limits.WalkingMulticospan.ctorElim
|
Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
|
{J : CategoryTheory.Limits.MulticospanShape} β
{motive : CategoryTheory.Limits.WalkingMulticospan J β Sort u} β
(ctorIdx : β) β
(t : CategoryTheory.Limits.WalkingMulticospan J) β
ctorIdx = t.ctorIdx β CategoryTheory.Limits.WalkingMulticospan.ctorElimType ctorIdx β motive t
|
AddMonoidAlgebra.single_mem_grade
|
Mathlib.Algebra.MonoidAlgebra.Grading
|
β {M : Type u_1} {R : Type u_4} [inst : CommSemiring R] (i : M) (r : R), (funβ | i => r) β AddMonoidAlgebra.grade R i
|
Lean.Doc.Block.brecOn_7
|
Lean.DocString.Types
|
{i : Type u} β
{b : Type v} β
{motive_1 : Lean.Doc.Block i b β Sort u_1} β
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) β Sort u_1} β
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) β Sort u_1} β
{motive_4 : Array (Lean.Doc.Block i b) β Sort u_1} β
{motive_5 : List (Lean.Doc.ListItem (Lean.Doc.Block i b)) β Sort u_1} β
{motive_6 : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) β Sort u_1} β
{motive_7 : List (Lean.Doc.Block i b) β Sort u_1} β
{motive_8 : Lean.Doc.ListItem (Lean.Doc.Block i b) β Sort u_1} β
{motive_9 : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b) β Sort u_1} β
(t : Lean.Doc.ListItem (Lean.Doc.Block i b)) β
((t : Lean.Doc.Block i b) β t.below β motive_1 t) β
((t : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) β
Lean.Doc.Block.below_1 t β motive_2 t) β
((t : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) β
Lean.Doc.Block.below_2 t β motive_3 t) β
((t : Array (Lean.Doc.Block i b)) β Lean.Doc.Block.below_3 t β motive_4 t) β
((t : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) β
Lean.Doc.Block.below_4 t β motive_5 t) β
((t : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) β
Lean.Doc.Block.below_5 t β motive_6 t) β
((t : List (Lean.Doc.Block i b)) β Lean.Doc.Block.below_6 t β motive_7 t) β
((t : Lean.Doc.ListItem (Lean.Doc.Block i b)) β
Lean.Doc.Block.below_7 t β motive_8 t) β
((t : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) β
Lean.Doc.Block.below_8 t β motive_9 t) β
motive_8 t
|
Ideal.pointwise_smul_toAddSubGroup
|
Mathlib.RingTheory.Ideal.Pointwise
|
β {M : Type u_1} [inst : Monoid M] {R : Type u_3} [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (a : M)
(S : Ideal R), (Function.Surjective fun r => a β’ r) β Submodule.toAddSubgroup (a β’ S) = a β’ Submodule.toAddSubgroup S
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_3
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {x : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} {k : Ξ±},
(k β t) = (Std.DTreeMap.Internal.Impl.contains k t = true)
|
Equiv.invFun
|
Mathlib.Logic.Equiv.Defs
|
{Ξ± : Sort u_1} β {Ξ² : Sort u_2} β Ξ± β Ξ² β Ξ² β Ξ±
|
Mathlib.TacticAnalysis.Pass._sizeOf_inst
|
Mathlib.Tactic.TacticAnalysis
|
SizeOf Mathlib.TacticAnalysis.Pass
|
Matrix.vecMul_empty
|
Mathlib.LinearAlgebra.Matrix.Notation
|
β {Ξ± : Type u} {n' : Type uβ} [inst : NonUnitalNonAssocSemiring Ξ±] [inst_1 : Fintype n'] (v : n' β Ξ±)
(B : Matrix n' (Fin 0) Ξ±), Matrix.vecMul v B = ![]
|
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_24
|
Mathlib.Data.List.Cycle
|
β {Ξ± : Type u_1} [inst : (a b : Ξ±) β Decidable (a = b)] {l : List Ξ±} {a : Ξ±},
a β l β
β (hl : Β¬l = []),
a β l.dropLast β
l.length - (l.dropLast.length + [l.getLast β―].dropLast.length + 1) < [[l.getLast β―].getLast β―].length
|
NumberField.basisOfFractionalIdeal._proof_2
|
Mathlib.NumberTheory.NumberField.FractionalIdeal
|
β (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)Λ£),
LinearMap.CompatibleSMul (β₯ββI) K β€ (NumberField.RingOfIntegers K)
|
AddUnits.leftOfAdd.eq_1
|
Mathlib.Algebra.Group.Commute.Units
|
β {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = βu) (hc : AddCommute a b),
u.leftOfAdd a b hu hc = { val := a, neg := b + β(-u), val_neg := β―, neg_val := β― }
|
Subring.instField._proof_13
|
Mathlib.Algebra.Ring.Subring.Basic
|
β {K : Type u_1} [inst : DivisionRing K] (q : β), βq = βq
|
List.prod_inv_reverse
|
Mathlib.Algebra.BigOperators.Group.List.Basic
|
β {G : Type u_7} [inst : Group G] (L : List G), L.prodβ»ΒΉ = (List.map (fun x => xβ»ΒΉ) L).reverse.prod
|
Equiv.prodAssoc.match_3
|
Mathlib.Logic.Equiv.Prod
|
β (Ξ± : Type u_1) (Ξ² : Type u_3) (Ξ³ : Type u_2) (motive : Ξ± Γ Ξ² Γ Ξ³ β Prop) (x : Ξ± Γ Ξ² Γ Ξ³),
(β (fst : Ξ±) (fst_1 : Ξ²) (snd : Ξ³), motive (fst, fst_1, snd)) β motive x
|
Ordinal.CNF.rec_pos
|
Mathlib.SetTheory.Ordinal.CantorNormalForm
|
β (b : Ordinal.{u_2}) {o : Ordinal.{u_2}} {C : Ordinal.{u_2} β Sort u_1} (ho : o β 0) (H0 : C 0)
(H : (o : Ordinal.{u_2}) β o β 0 β C (o % b ^ Ordinal.log b o) β C o),
Ordinal.CNF.rec b H0 H o = H o ho (Ordinal.CNF.rec b H0 H (o % b ^ Ordinal.log b o))
|
Bundle.TotalSpace.toProd._proof_1
|
Mathlib.Data.Bundle
|
β (B : Type u_1) (F : Type u_2) (x : Bundle.TotalSpace F fun x => F),
{ proj := (x.proj, x.snd).1, snd := (x.proj, x.snd).2 } = { proj := (x.proj, x.snd).1, snd := (x.proj, x.snd).2 }
|
_private.Mathlib.Algebra.BigOperators.ModEq.0.Int.prod_modEq_single._simp_1_1
|
Mathlib.Algebra.BigOperators.ModEq
|
β (a b : β€) (c : β), (a β‘ b [ZMOD βc]) = (βa = βb)
|
CategoryTheory.Comma.unopFunctor_map
|
Mathlib.CategoryTheory.Comma.Basic
|
β {A : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} A] {B : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} B]
{T : Type uβ} [inst_2 : CategoryTheory.Category.{vβ, uβ} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) {X Y : CategoryTheory.Comma L.op R.op} (f : X βΆ Y),
(CategoryTheory.Comma.unopFunctor L R).map f = Opposite.op { left := f.right.unop, right := f.left.unop, w := β― }
|
AddCommMonCat.recOn
|
Mathlib.Algebra.Category.MonCat.Basic
|
{motive : AddCommMonCat β Sort u_1} β
(t : AddCommMonCat) β
((carrier : Type u) β [str : AddCommMonoid carrier] β motive { carrier := carrier, str := str }) β motive t
|
Subfield.sInf_toSubring
|
Mathlib.Algebra.Field.Subfield.Basic
|
β {K : Type u} [inst : DivisionRing K] (s : Set (Subfield K)), (sInf s).toSubring = β¨
t β s, t.toSubring
|
WeierstrassCurve.Projective.negDblY_eq'
|
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula
|
β {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P : Fin 3 β R},
W'.Equation P β
W'.negDblY P * P 2 ^ 2 =
-(MvPolynomial.eval P) W'.polynomialX *
((MvPolynomial.eval P) W'.polynomialX ^ 2 -
W'.aβ * (MvPolynomial.eval P) W'.polynomialX * P 2 * (P 1 - W'.negY P) -
W'.aβ * P 2 ^ 2 * (P 1 - W'.negY P) ^ 2 -
2 * P 0 * P 2 * (P 1 - W'.negY P) ^ 2 -
P 0 * P 2 * (P 1 - W'.negY P) ^ 2) +
P 1 * P 2 ^ 2 * (P 1 - W'.negY P) ^ 3
|
himp_iff_imp._simp_1
|
Mathlib.Order.Heyting.Basic
|
β (p q : Prop), p β¨ q = (p β q)
|
HasFiniteFPowerSeriesOnBall.rec
|
Mathlib.Analysis.Analytic.CPolynomialDef
|
{π : 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] β
{f : E β F} β
{p : FormalMultilinearSeries π E F} β
{x : E} β
{n : β} β
{r : ENNReal} β
{motive : HasFiniteFPowerSeriesOnBall f p x n r β Sort u} β
((toHasFPowerSeriesOnBall : HasFPowerSeriesOnBall f p x r) β
(finite : β (m : β), n β€ m β p m = 0) β motive β―) β
(t : HasFiniteFPowerSeriesOnBall f p x n r) β motive t
|
Set.biUnion_diff_biUnion_eq
|
Mathlib.Data.Set.Pairwise.Lattice
|
β {Ξ± : Type u_1} {ΞΉ : Type u_2} {s t : Set ΞΉ} {f : ΞΉ β Set Ξ±},
(s βͺ t).PairwiseDisjoint f β (β i β s, f i) \ β i β t, f i = β i β s \ t, f i
|
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.image.map_id._simp_1_1
|
Mathlib.CategoryTheory.Limits.Shapes.Images
|
β {Ξ± : Sort u_1} [Subsingleton Ξ±] (x y : Ξ±), (x = y) = True
|
_private.Mathlib.Data.Finset.NAry.0.Finset.mem_imageβ._simp_1_2
|
Mathlib.Data.Finset.NAry
|
β {a b c : Prop}, ((a β§ b) β§ c) = (a β§ b β§ c)
|
Mathlib.Tactic.WLOGResult.reductionGoal
|
Mathlib.Tactic.WLOG
|
Mathlib.Tactic.WLOGResult β Lean.MVarId
|
NumberField.RingOfIntegers.mapAlgEquiv._proof_1
|
Mathlib.NumberTheory.NumberField.Basic
|
β {k : Type u_2} {K : Type u_3} {L : Type u_4} {E : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra k K] [inst_4 : Algebra k L] [inst_5 : EquivLike E K L] [AlgEquivClass E k K L], AlgHomClass E k K L
|
Std.HashMap.getD_eq_fallback_of_contains_eq_false
|
Std.Data.HashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.HashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±] {a : Ξ±}
{fallback : Ξ²}, m.contains a = false β m.getD a fallback = fallback
|
CategoryTheory.Functor.isoWhiskerRight_twice
|
Mathlib.CategoryTheory.Whiskering
|
β {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] {B : Type uβ}
[inst_3 : CategoryTheory.Category.{vβ, uβ} B] {H K : CategoryTheory.Functor B C} (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) (Ξ± : H β
K),
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.Functor.isoWhiskerRight Ξ± F) G =
H.associator F G βͺβ« CategoryTheory.Functor.isoWhiskerRight Ξ± (F.comp G) βͺβ« (K.associator F G).symm
|
ContinuousMap.concat
|
Mathlib.Topology.ContinuousMap.Interval
|
{Ξ± : Type u_1} β
[inst : LinearOrder Ξ±] β
[inst_1 : TopologicalSpace Ξ±] β
[OrderTopology Ξ±] β
{a b c : Ξ±} β
[Fact (a β€ b)] β
[Fact (b β€ c)] β
{E : Type u_2} β
[inst_5 : TopologicalSpace E] β C(β(Set.Icc a b), E) β C(β(Set.Icc b c), E) β C(β(Set.Icc a c), E)
|
GaussianInt.abs_natCast_norm
|
Mathlib.NumberTheory.Zsqrtd.GaussianInt
|
β (x : GaussianInt), β(Zsqrtd.norm x).natAbs = Zsqrtd.norm x
|
StarAlgEquiv.trans_apply
|
Mathlib.Algebra.Star.StarAlgHom
|
β {R : Type u_2} {A : Type u_3} {B : Type u_4} {C : Type u_5} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (eβ : A βββ[R] B) (eβ : B βββ[R] C) (x : A),
(eβ.trans eβ) x = eβ (eβ x)
|
NNRat.instIsScalarTowerRight
|
Mathlib.Algebra.Ring.Action.Rat
|
β {R : Type u_1} [inst : DivisionSemiring R], IsScalarTower ββ₯0 R R
|
Id.instLawfulMonadLiftTOfLawfulMonad
|
Init.Control.Lawful.MonadLift.Instances
|
β {m : Type u β Type v} [inst : Monad m] [LawfulMonad m], LawfulMonadLiftT Id m
|
DistribLattice.ctorIdx
|
Mathlib.Order.Lattice
|
{Ξ± : Type u_1} β DistribLattice Ξ± β β
|
RelIso.instGroup._proof_2
|
Mathlib.Algebra.Order.Group.End
|
β {Ξ± : Type u_1} {r : Ξ± β Ξ± β Prop} (x : r βr r), 1 * x = x
|
Std.Tactic.BVDecide.BVExpr.replicate.injEq
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Basic
|
β {w w' : β} (n : β) (expr : Std.Tactic.BVDecide.BVExpr w) (h : w' = w * n) (w_1 n_1 : β)
(expr_1 : Std.Tactic.BVDecide.BVExpr w_1) (h_1 : w' = w_1 * n_1),
(Std.Tactic.BVDecide.BVExpr.replicate n expr h = Std.Tactic.BVDecide.BVExpr.replicate n_1 expr_1 h_1) =
(w = w_1 β§ n = n_1 β§ expr β expr_1)
|
Prod.map_iterate
|
Mathlib.Data.Prod.Basic
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} (f : Ξ± β Ξ±) (g : Ξ² β Ξ²) (n : β), (Prod.map f g)^[n] = Prod.map f^[n] g^[n]
|
WeierstrassCurve.Projective.addXYZ_Z
|
Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula
|
β {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P Q : Fin 3 β R), W'.addXYZ P Q 2 = W'.addZ P Q
|
String.Legacy.Iterator.s
|
Init.Data.String.Iterator
|
String.Legacy.Iterator β String
|
PseudoMetric.coe_le_coe
|
Mathlib.Topology.MetricSpace.BundledFun
|
β {X : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : Add R] [inst_2 : LE R] {d d' : PseudoMetric X R},
βd β€ βd' β d β€ d'
|
AlgebraicGeometry.morphismRestrictStalkMap._proof_2
|
Mathlib.AlgebraicGeometry.Restrict
|
β {X Y : AlgebraicGeometry.Scheme} (f : X βΆ Y) (U : Y.Opens) (x : β₯β((TopologicalSpace.Opens.map f.base).obj U)),
CategoryTheory.CategoryStruct.comp
(U.stalkIso ((CategoryTheory.ConcreteCategory.hom (f β£_ U).base) x) βͺβ« Y.presheaf.stalkCongr β―).hom
(AlgebraicGeometry.Scheme.Hom.stalkMap f βx) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.stalkMap (f β£_ U) x)
(((TopologicalSpace.Opens.map f.base).obj U).stalkIso x).hom
|
CategoryTheory.NatTrans.naturality
|
Mathlib.CategoryTheory.NatTrans
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
{F G : CategoryTheory.Functor C D} (self : CategoryTheory.NatTrans F G) β¦X Y : Cβ¦ (f : X βΆ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.app X) (G.map f)
|
_private.Mathlib.Data.Finset.Union.0.Finset.bind_toFinset._simp_1_2
|
Mathlib.Data.Finset.Union
|
β {Ξ± : Type u_1} {Ξ² : Type v} {b : Ξ²} {s : Multiset Ξ±} {f : Ξ± β Multiset Ξ²}, (b β s.bind f) = β a β s, b β f a
|
FreeSimplexQuiver.homRel.recOn
|
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic
|
β {motive : β¦X Y : CategoryTheory.Paths FreeSimplexQuiverβ¦ β (a a_1 : X βΆ Y) β FreeSimplexQuiver.homRel a a_1 β Prop}
β¦X Y : CategoryTheory.Paths FreeSimplexQuiverβ¦ {a a_1 : X βΆ Y} (t : FreeSimplexQuiver.homRel a a_1),
(β {n : β} {i j : Fin (n + 2)} (H : i β€ j),
motive
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i.castSucc)))
β―) β
(β {n : β} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i β€ j.castSucc),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i)))
β―) β
(β {n : β} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
β―) β
(β {n : β} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
β―) β
(β {n : β} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο j.castSucc)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ξ΄ i)))
β―) β
(β {n : β} {i j : Fin (n + 1)} (H : i β€ j),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο j)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο j.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.Ο i)))
β―) β
motive a a_1 t
|
GrpCat.toAddGrp._proof_1
|
Mathlib.Algebra.Category.Grp.EquivalenceGroupAddGroup
|
β (X : GrpCat),
AddGrpCat.ofHom (MonoidHom.toAdditive (GrpCat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id (AddGrpCat.of (Additive βX))
|
Algebra.traceMatrix._proof_1
|
Mathlib.RingTheory.Trace.Basic
|
β (A : Type u_1) [inst : CommRing A], SMulCommClass A A A
|
Real.strictAntiOn_rpow_Ioi_of_exponent_neg
|
Mathlib.Analysis.SpecialFunctions.Pow.Real
|
β {r : β}, r < 0 β StrictAntiOn (fun x => x ^ r) (Set.Ioi 0)
|
antisymm_of
|
Mathlib.Order.Defs.Unbundled
|
β {Ξ± : Type u_1} (r : Ξ± β Ξ± β Prop) [IsAntisymm Ξ± r] {a b : Ξ±}, r a b β r b a β a = b
|
isPurelyInseparable_iff
|
Mathlib.FieldTheory.PurelyInseparable.Basic
|
β {F : Type u_1} {E : Type u_2} [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E],
IsPurelyInseparable F E β β (x : E), IsIntegral F x β§ (IsSeparable F x β x β (algebraMap F E).range)
|
instCommRingCorner._proof_12
|
Mathlib.RingTheory.Idempotents
|
β {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (idem : IsIdempotentElem e) (n : β) (x : idem.Corner),
Semiring.npow (n + 1) x = Semiring.npow n x * x
|
Cardinal.mk_finsupp_lift_of_infinite'
|
Mathlib.SetTheory.Cardinal.Finsupp
|
β (Ξ± : Type u) (Ξ² : Type v) [Nonempty Ξ±] [inst : Zero Ξ²] [Infinite Ξ²],
Cardinal.mk (Ξ± ββ Ξ²) = max (Cardinal.lift.{v, u} (Cardinal.mk Ξ±)) (Cardinal.lift.{u, v} (Cardinal.mk Ξ²))
|
Batteries.PairingHeap.headI
|
Batteries.Data.PairingHeap
|
{Ξ± : Type u} β {le : Ξ± β Ξ± β Bool} β [Inhabited Ξ±] β Batteries.PairingHeap Ξ± le β Ξ±
|
ContinuousMap.instStar
|
Mathlib.Topology.ContinuousMap.Star
|
{Ξ± : Type u_2} β
{Ξ² : Type u_3} β
[inst : TopologicalSpace Ξ±] β [inst_1 : TopologicalSpace Ξ²] β [inst_2 : Star Ξ²] β [ContinuousStar Ξ²] β Star C(Ξ±, Ξ²)
|
FiberBundleCore.localTriv._proof_6
|
Mathlib.Topology.FiberBundle.Basic
|
β {ΞΉ : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ΞΉ B F) (i : ΞΉ),
β p β (Z.localTrivAsPartialEquiv i).source,
(β{ toPartialEquiv := Z.localTrivAsPartialEquiv i, open_source := β―, open_target := β―, continuousOn_toFun := β―,
continuousOn_invFun := β― }
p).1 =
Z.proj p
|
antitoneOn_of_le_sub_one
|
Mathlib.Algebra.Order.SuccPred
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : PartialOrder Ξ±] [inst_1 : Preorder Ξ²] [inst_2 : Sub Ξ±] [inst_3 : One Ξ±]
[inst_4 : PredSubOrder Ξ±] [IsPredArchimedean Ξ±] {s : Set Ξ±} {f : Ξ± β Ξ²},
s.OrdConnected β (β (a : Ξ±), Β¬IsMin a β a β s β a - 1 β s β f a β€ f (a - 1)) β AntitoneOn f s
|
_private.Mathlib.Computability.PostTuringMachine.0.Turing.TM1to1.stepAux_write._simp_1_2
|
Mathlib.Computability.PostTuringMachine
|
β {a b : β}, (a.succ = b.succ) = (a = b)
|
CommGroup.toDistribLattice._proof_1
|
Mathlib.Algebra.Order.Group.Lattice
|
β (Ξ± : Type u_1) [inst : Lattice Ξ±] [inst_1 : CommGroup Ξ±] [MulLeftMono Ξ±] (x y z : Ξ±), (x β y) β (x β z) β€ x β y β z
|
Lean.Elab.Term.ToDepElimPattern.State._sizeOf_inst
|
Lean.Elab.Match
|
SizeOf Lean.Elab.Term.ToDepElimPattern.State
|
SimpleGraph.Hom.ofLE_apply
|
Mathlib.Combinatorics.SimpleGraph.Maps
|
β {V : Type u_1} {Gβ Gβ : SimpleGraph V} (h : Gβ β€ Gβ) (v : V), (SimpleGraph.Hom.ofLE h) v = v
|
AdjoinRoot.instNumberFieldRat
|
Mathlib.NumberTheory.NumberField.Basic
|
β {f : Polynomial β} [hf : Fact (Irreducible f)], NumberField (AdjoinRoot f)
|
Int.le_add_of_sub_left_le
|
Init.Data.Int.Order
|
β {a b c : β€}, a - b β€ c β a β€ b + c
|
Lean.ResolveName.resolveNamespaceUsingOpenDecls
|
Lean.ResolveName
|
Lean.Environment β Lean.Name β List Lean.OpenDecl β List Lean.Name
|
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.map_eq_iff._simp_1_1
|
Mathlib.Algebra.DirectSum.Basic
|
β {ΞΉ : Type v} {Ξ² : ΞΉ β Type w} [inst : (i : ΞΉ) β AddCommMonoid (Ξ² i)] {x y : DirectSum ΞΉ Ξ²},
(x = y) = β (i : ΞΉ), x i = y i
|
SkewMonoidAlgebra.algHom_ext
|
Mathlib.Algebra.SkewMonoidAlgebra.Basic
|
β {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : CommSemiring k] {A : Type u_3} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
β¦Οβ Οβ : SkewMonoidAlgebra k G ββ[k] Aβ¦,
(β (x : G), Οβ (SkewMonoidAlgebra.single x 1) = Οβ (SkewMonoidAlgebra.single x 1)) β Οβ = Οβ
|
Mathlib.Meta.FunProp.LambdaTheoremArgs.ctorIdx
|
Mathlib.Tactic.FunProp.Theorems
|
Mathlib.Meta.FunProp.LambdaTheoremArgs β β
|
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Complex.cos_eq_cos_iff._simp_1_3
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex
|
β {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b)
|
Algebra.FormallyUnramified.localization_base
|
Mathlib.RingTheory.Unramified.Basic
|
β {R : Type u_1} {Rβ : Type u_3} {Sβ : Type u_4} [inst : CommRing R] [inst_1 : CommRing Rβ] [inst_2 : CommRing Sβ]
(M : Submonoid R) [inst_3 : Algebra R Sβ] [inst_4 : Algebra R Rβ] [inst_5 : Algebra Rβ Sβ] [IsScalarTower R Rβ Sβ]
[Algebra.FormallyUnramified R Sβ], Algebra.FormallyUnramified Rβ Sβ
|
_private.Batteries.Data.MLList.Basic.0.MLList.specImpl
|
Batteries.Data.MLList.Basic
|
(m : Type u_1 β Type u_1) β MLList.Specβ m
|
Lean.Omega.LinearCombo.sub
|
Init.Omega.LinearCombo
|
Lean.Omega.LinearCombo β Lean.Omega.LinearCombo β Lean.Omega.LinearCombo
|
AddCommMonCat.FilteredColimits.M
|
Mathlib.Algebra.Category.MonCat.FilteredColimits
|
{J : Type v} β
[inst : CategoryTheory.SmallCategory J] β
[CategoryTheory.IsFiltered J] β CategoryTheory.Functor J AddCommMonCat β AddMonCat
|
Vector.findFinIdx?_singleton._proof_1
|
Init.Data.Vector.Find
|
β {Ξ± : Type u_1} {a : Ξ±}, 0 < #[a].size
|
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_6
|
Std.Time.Date.ValidDate
|
β (idx : Std.Time.Month.Ordinal) (acc : β€),
12 β€ βidx β β (ordinal : Std.Time.Day.Ordinal.OfYear true), βordinal β€ 366 β 366 < βordinal β False
|
_private.Mathlib.Data.Nat.Cast.NeZero.0.NeZero.one_le._proof_1_1
|
Mathlib.Data.Nat.Cast.NeZero
|
β {n : β}, n β 0 β 1 β€ n
|
CategoryTheory.Preadditive.toCommGrp_obj_grp
|
Mathlib.CategoryTheory.Preadditive.CommGrp_
|
β (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C] (X : C),
((CategoryTheory.Preadditive.toCommGrp C).obj X).grp = CategoryTheory.Preadditive.instGrpObj X
|
Plausible.Gen.oneOfWithDefault
|
Plausible.Gen
|
{Ξ± : Type} β Plausible.Gen Ξ± β List (Plausible.Gen Ξ±) β Plausible.Gen Ξ±
|
CategoryTheory.FinCategory.objAsTypeToAsType
|
Mathlib.CategoryTheory.FinCategory.AsType
|
(Ξ± : Type u_1) β
[inst : Fintype Ξ±] β
[inst_1 : CategoryTheory.SmallCategory Ξ±] β
[inst_2 : CategoryTheory.FinCategory Ξ±] β
CategoryTheory.Functor (CategoryTheory.FinCategory.ObjAsType Ξ±) (CategoryTheory.FinCategory.AsType Ξ±)
|
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_4
|
Mathlib.CategoryTheory.Limits.FormalCoproducts
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X βΆ Z) (g : Y βΆ Z) (T : CategoryTheory.Limits.FormalCoproduct C)
(s : { p // CategoryTheory.CategoryStruct.comp p.1 f = CategoryTheory.CategoryStruct.comp p.2 g }) (i : T.I),
CategoryTheory.CategoryStruct.comp ((βs).1.Ο i)
(CategoryTheory.CategoryStruct.comp (f.Ο (ββ¨((βs).1.f i, (βs).2.f i), β―β©).1) (CategoryTheory.eqToHom β―)) =
CategoryTheory.CategoryStruct.comp ((βs).2.Ο i) (g.Ο (ββ¨((βs).1.f i, (βs).2.f i), β―β©).2)
|
Lean.Server.FileWorker.WorkerState.importCachingTask?
|
Lean.Server.FileWorker
|
Lean.Server.FileWorker.WorkerState β
Option (Lean.Server.ServerTask (Except IO.Error Lean.Server.FileWorker.AvailableImportsCache))
|
LinearOrder.mkOfAddGroupCone.eq_1
|
Mathlib.Algebra.Order.Group.Cone
|
β {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] (C : S) [inst_2 : AddGroupConeClass S G]
[inst_3 : HasMemOrNegMem C] [inst_4 : DecidablePred fun x => x β C],
LinearOrder.mkOfAddGroupCone C =
{ toPartialOrder := PartialOrder.mkOfAddGroupCone C, min := fun a b => if a β€ b then a else b,
max := fun a b => if a β€ b then b else a, compare := fun a b => compareOfLessAndEq a b, le_total := β―,
toDecidableLE := fun x b => inst_4 (b - x), toDecidableEq := decidableEqOfDecidableLE,
toDecidableLT := decidableLTOfDecidableLE, min_def := β―, max_def := β―, compare_eq_compareOfLessAndEq := β― }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.