name
string | module
string | type
string |
|---|---|---|
Turing.EvalsTo.mk.inj
|
Mathlib.Computability.TMComputable
|
β {Ο : Type u_1} {f : Ο β Option Ο} {a : Ο} {b : Option Ο} {steps : β}
{evals_in_steps : (flip bind f)^[steps] (some a) = b} {steps_1 : β}
{evals_in_steps_1 : (flip bind f)^[steps_1] (some a) = b},
{ steps := steps, evals_in_steps := evals_in_steps } = { steps := steps_1, evals_in_steps := evals_in_steps_1 } β
steps = steps_1
|
AddAction.prodOfVAddCommClass.eq_1
|
Mathlib.Algebra.Group.Action.Prod
|
β (M : Type u_1) (N : Type u_2) (Ξ± : Type u_5) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddAction M Ξ±]
[inst_3 : AddAction N Ξ±] [inst_4 : VAddCommClass M N Ξ±],
AddAction.prodOfVAddCommClass M N Ξ± = { vadd := fun mn a => mn.1 +α΅₯ mn.2 +α΅₯ a, add_vadd := β―, zero_vadd := β― }
|
Finpartition.empty._proof_1
|
Mathlib.Order.Partition.Finpartition
|
β (Ξ± : Type u_1) [inst : Lattice Ξ±] [inst_1 : OrderBot Ξ±], β
.SupIndep id
|
IsFractionRing.ringEquivOfRingEquiv_algebraMap
|
Mathlib.RingTheory.Localization.FractionRing
|
β {A : Type u_8} {K : Type u_9} {B : Type u_10} {L : Type u_11} [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : CommRing K] [inst_3 : CommRing L] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K]
[inst_6 : Algebra B L] [inst_7 : IsFractionRing B L] (h : A β+* B) (a : A),
(IsFractionRing.ringEquivOfRingEquiv h) ((algebraMap A K) a) = (algebraMap B L) (h a)
|
Matrix.nonAssocSemiring
|
Mathlib.Data.Matrix.Mul
|
{n : Type u_3} β {Ξ± : Type v} β [NonAssocSemiring Ξ±] β [Fintype n] β [DecidableEq n] β NonAssocSemiring (Matrix n n Ξ±)
|
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_nhds._simp_1_4
|
Mathlib.Topology.Separation.Hausdorff
|
β {a b : Prop}, (Β¬a β b) = (Β¬b β a)
|
Lean.Elab.Tactic.BVDecide.LRAT.trim.M.markUsed
|
Lean.Elab.Tactic.BVDecide.LRAT.Trim
|
β β Lean.Elab.Tactic.BVDecide.LRAT.trim.M Unit
|
Lean.Lsp.instToJsonCompletionClientCapabilities.toJson
|
Lean.Data.Lsp.Capabilities
|
Lean.Lsp.CompletionClientCapabilities β Lean.Json
|
measurableSet_le'
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Order
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] {mΞ± : MeasurableSpace Ξ±} [OpensMeasurableSpace Ξ±] [inst_2 : PartialOrder Ξ±]
[OrderClosedTopology Ξ±] [SecondCountableTopology Ξ±], MeasurableSet {p | p.1 β€ p.2}
|
Std.TreeMap.Raw.Equiv.getElem_eq
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.TreeMap.Raw Ξ± Ξ² cmp} [inst : Std.TransCmp cmp] {k : Ξ±}
{hk : k β tβ} (hβ : tβ.WF) (hβ : tβ.WF) (h : tβ.Equiv tβ), tβ[k] = tβ[k]
|
CategoryTheory.SmallObject.functorMapSrc._proof_1
|
Mathlib.CategoryTheory.SmallObject.Construction
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I β C} (f : (i : I) β A i βΆ B i)
{S T X Y : C} {ΟX : X βΆ S} {ΟY : Y βΆ T} (Ο : CategoryTheory.Arrow.mk ΟX βΆ CategoryTheory.Arrow.mk ΟY)
(x : CategoryTheory.SmallObject.FunctorObjIndex f ΟX),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp x.t Ο.left) ΟY =
CategoryTheory.CategoryStruct.comp (f x.i) (CategoryTheory.CategoryStruct.comp x.b Ο.right)
|
dif_eq_if
|
Init.ByCases
|
β (c : Prop) {h : Decidable c} {Ξ± : Sort u} (t e : Ξ±), (if x : c then t else e) = if c then t else e
|
List.forall_getElem
|
Init.Data.List.Lemmas
|
β {Ξ± : Type u_1} {l : List Ξ±} {p : Ξ± β Prop}, (β (i : β) (h : i < l.length), p l[i]) β β a β l, p a
|
Std.HashSet.Raw.get?_union
|
Std.Data.HashSet.RawLemmas
|
β {Ξ± : Type u} [inst : BEq Ξ±] [inst_1 : Hashable Ξ±] {mβ mβ : Std.HashSet.Raw Ξ±} [EquivBEq Ξ±] [LawfulHashable Ξ±],
mβ.WF β mβ.WF β β {k : Ξ±}, (mβ βͺ mβ).get? k = (mβ.get? k).or (mβ.get? k)
|
AddCommGrpCat.Hom.hom.eq_1
|
Mathlib.Algebra.Category.Grp.Basic
|
β {X Y : AddCommGrpCat} (f : X.Hom Y), f.hom = CategoryTheory.ConcreteCategory.hom f
|
Lean.Data.AC.EvalInformation.arbitrary
|
Init.Data.AC
|
{Ξ± : Sort u} β {Ξ² : Sort v} β [self : Lean.Data.AC.EvalInformation Ξ± Ξ²] β Ξ± β Ξ²
|
_private.Init.PropLemmas.0.and_right_comm.match_1_1
|
Init.PropLemmas
|
β {a b c : Prop} (motive : (a β§ b) β§ c β Prop) (x : (a β§ b) β§ c), (β (ha : a) (hb : b) (hc : c), motive β―) β motive x
|
CommRingCat.Colimits.Prequotient.recOn
|
Mathlib.Algebra.Category.Ring.Colimits
|
{J : Type v} β
[inst : CategoryTheory.SmallCategory J] β
{F : CategoryTheory.Functor J CommRingCat} β
{motive : CommRingCat.Colimits.Prequotient F β Sort u} β
(t : CommRingCat.Colimits.Prequotient F) β
((j : J) β (x : β(F.obj j)) β motive (CommRingCat.Colimits.Prequotient.of j x)) β
motive CommRingCat.Colimits.Prequotient.zero β
motive CommRingCat.Colimits.Prequotient.one β
((a : CommRingCat.Colimits.Prequotient F) β motive a β motive a.neg) β
((a a_1 : CommRingCat.Colimits.Prequotient F) β motive a β motive a_1 β motive (a.add a_1)) β
((a a_1 : CommRingCat.Colimits.Prequotient F) β motive a β motive a_1 β motive (a.mul a_1)) β
motive t
|
ZNum.zero.sizeOf_spec
|
Mathlib.Data.Num.Basic
|
sizeOf ZNum.zero = 1
|
Pi.borelSpace
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
|
β {ΞΉ : Type u_6} {X : ΞΉ β Type u_7} [Countable ΞΉ] [inst : (i : ΞΉ) β TopologicalSpace (X i)]
[inst_1 : (i : ΞΉ) β MeasurableSpace (X i)] [β (i : ΞΉ), SecondCountableTopology (X i)] [β (i : ΞΉ), BorelSpace (X i)],
BorelSpace ((i : ΞΉ) β X i)
|
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Balanced.reverse.match_1_1
|
Batteries.Data.RBMap.WF
|
β {Ξ± : Type u_1} (motive : (n : β) β (c : Batteries.RBColor) β (t : Batteries.RBNode Ξ±) β t.Balanced c n β Prop) (n : β)
(c : Batteries.RBColor) (t : Batteries.RBNode Ξ±) (x : t.Balanced c n),
(β (a : Unit), motive 0 Batteries.RBColor.black Batteries.RBNode.nil β―) β
(β (x : Batteries.RBNode Ξ±) (cβ : Batteries.RBColor) (n : β) (y : Batteries.RBNode Ξ±) (cβ : Batteries.RBColor)
(v : Ξ±) (hl : x.Balanced cβ n) (hr : y.Balanced cβ n),
motive (n + 1) Batteries.RBColor.black (Batteries.RBNode.node Batteries.RBColor.black x v y) β―) β
(β (n : β) (x y : Batteries.RBNode Ξ±) (v : Ξ±) (hl : x.Balanced Batteries.RBColor.black n)
(hr : y.Balanced Batteries.RBColor.black n),
motive n Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red x v y) β―) β
motive n c t x
|
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Basic.0.IntermediateField.exists_finset_of_mem_adjoin._simp_1_1
|
Mathlib.FieldTheory.IntermediateField.Adjoin.Basic
|
β {Ξ± : Type u_1} [inst : CompleteLattice Ξ±] {ΞΉ : Type u_8} (s : Set ΞΉ) (f : ΞΉ β Ξ±), β¨ t β s, f t = β¨ i, f βi
|
ENorm
|
Mathlib.Analysis.Normed.Group.Basic
|
Type u_8 β Type u_8
|
MvPowerSeries.hasSum_evalβ
|
Mathlib.RingTheory.MvPowerSeries.Evaluation
|
β {Ο : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : UniformSpace R] {S : Type u_3} [inst_2 : CommRing S]
[inst_3 : UniformSpace S] {Ο : R β+* S} {a : Ο β S} [IsTopologicalSemiring R] [IsUniformAddGroup R]
[IsUniformAddGroup S] [CompleteSpace S] [T2Space S] [IsTopologicalRing S] [IsLinearTopology S S],
Continuous βΟ β
MvPowerSeries.HasEval a β
β (f : MvPowerSeries Ο R),
HasSum (fun d => Ο ((MvPowerSeries.coeff d) f) * d.prod fun s e => a s ^ e) (MvPowerSeries.evalβ Ο a f)
|
Lean.Meta.InductionSubgoal.mk
|
Lean.Meta.Tactic.Induction
|
Lean.MVarId β Array Lean.Expr β Lean.Meta.FVarSubst β Lean.Meta.InductionSubgoal
|
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.evalCodeActionProviderUnsafe
|
Lean.Server.CodeActions.Basic
|
{M : Type β Type} β
[Lean.MonadEnv M] β
[Lean.MonadOptions M] β [Lean.MonadError M] β [Monad M] β Lean.Name β M Lean.Server.CodeActionProvider
|
_private.Init.Data.Range.Polymorphic.Iterators.0.Std.Rio.Internal.isPlausibleIndirectOutput_iter_iff._simp_1_1
|
Init.Data.Range.Polymorphic.Iterators
|
β {Ξ± : Type u} {inst : Std.PRange.UpwardEnumerable Ξ±} {inst_1 : LT Ξ±} [self : Std.PRange.LawfulUpwardEnumerableLT Ξ±]
(a b : Ξ±), (a < b) = Std.PRange.UpwardEnumerable.LT a b
|
Subalgebra.LinearDisjoint.rank_inf_eq_one_of_commute_of_flat_right_of_inj
|
Mathlib.RingTheory.LinearDisjoint
|
β {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {A B : Subalgebra R S},
A.LinearDisjoint B β
β [Module.Flat R β₯B],
(β (a b : β₯(A β B)), Commute βa βb) β Function.Injective β(algebraMap R S) β Module.rank R β₯(A β B) = 1
|
Subalgebra.toSubmoduleEquiv
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
{R : Type u} β
{A : Type v} β
[inst : CommSemiring R] β
[inst_1 : Semiring A] β [inst_2 : Algebra R A] β (S : Subalgebra R A) β β₯(Subalgebra.toSubmodule S) ββ[R] β₯S
|
ENat.coe_sSup
|
Mathlib.Data.ENat.Lattice
|
β {s : Set β}, BddAbove s β β(sSup s) = β¨ a β s, βa
|
_private.Aesop.Util.UnorderedArraySet.0.Aesop.UnorderedArraySet.mk.inj
|
Aesop.Util.UnorderedArraySet
|
β {Ξ± : Type u_1} {inst : BEq Ξ±} {rep rep_1 : Array Ξ±}, { rep := rep } = { rep := rep_1 } β rep = rep_1
|
StandardEtalePresentation._sizeOf_inst
|
Mathlib.RingTheory.Etale.StandardEtale
|
(R : Type u_4) β
(S : Type u_5) β
{inst : CommRing R} β
{inst_1 : CommRing S} β {inst_2 : Algebra R S} β [SizeOf R] β [SizeOf S] β SizeOf (StandardEtalePresentation R S)
|
_private.Lean.Environment.0.Lean.Visibility.private.elim
|
Lean.Environment
|
{motive : Lean.Visibilityβ β Sort u} β
(t : Lean.VisibilityβΒΉ) β Lean.Visibility.ctorIdxβ t = 0 β motive Lean.Visibility.privateβ β motive t
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_add
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc
|
Lean.Meta.Simp.Simproc
|
Equiv.Perm.extendDomain_apply_subtype
|
Mathlib.Logic.Equiv.Basic
|
β {Ξ±' : Type u_9} {Ξ²' : Type u_10} (e : Equiv.Perm Ξ±') {p : Ξ²' β Prop} [inst : DecidablePred p] (f : Ξ±' β Subtype p)
{b : Ξ²'} (h : p b), (e.extendDomain f) b = β(f (e (f.symm β¨b, hβ©)))
|
Nat.ModEq.add_iff_left._simp_1
|
Mathlib.Data.Nat.ModEq
|
β {n a b c d : β}, a β‘ b [MOD n] β (a + c β‘ b + d [MOD n]) = (c β‘ d [MOD n])
|
Int8.toInt32_neg_of_ne
|
Init.Data.SInt.Lemmas
|
β {x : Int8}, x β -128 β (-x).toInt32 = -x.toInt32
|
_private.Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule.0.Lean.Meta.Grind.Arith.Linear.ofNatModule'._unsafe_rec
|
Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule
|
Lean.Expr β Lean.Meta.Grind.Arith.Linear.OfNatModuleM (Lean.Expr Γ Lean.Expr)
|
Ideal.mem_prod
|
Mathlib.RingTheory.Ideal.Prod
|
β {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (I : Ideal R) (J : Ideal S) {x : R Γ S},
x β I.prod J β x.1 β I β§ x.2 β J
|
MeasurableEquiv.coe_mulLeft
|
Mathlib.MeasureTheory.Group.MeasurableEquiv
|
β {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g : G),
β(MeasurableEquiv.mulLeft g) = fun x => g * x
|
MeasureTheory.toOuterMeasure_eq_inducedOuterMeasure
|
Mathlib.MeasureTheory.Measure.MeasureSpaceDef
|
β {Ξ± : Type u_1} [inst : MeasurableSpace Ξ±] {ΞΌ : MeasureTheory.Measure Ξ±},
ΞΌ.toOuterMeasure = MeasureTheory.inducedOuterMeasure (fun s x => ΞΌ s) β― β―
|
_private.Lean.Elab.CheckTactic.0.Lean.Elab.CheckTactic.elabCheckTactic._sparseCasesOn_5
|
Lean.Elab.CheckTactic
|
{Ξ± : Type u} β {motive : List Ξ± β Sort u_1} β (t : List Ξ±) β motive [] β (t.ctorIdx β 0 β motive t) β motive t
|
ProofWidgets.Penrose.DiagramBuilderM.addEmbed
|
ProofWidgets.Component.PenroseDiagram
|
String β String β ProofWidgets.Html β ProofWidgets.Penrose.DiagramBuilderM Unit
|
String.Pos.Raw.Valid.mk
|
Batteries.Data.String.Lemmas
|
β (cs cs' : List Char) {p : String.Pos.Raw},
p.byteIdx = String.utf8Len cs β String.Pos.Raw.Valid (String.ofList (cs ++ cs')) p
|
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.lintegral_withDensity_eq_lintegral_mulβ'._simp_1_2
|
Mathlib.MeasureTheory.Measure.WithDensity
|
β {Ξ± : Type u} (s : Set Ξ±) (x : Ξ±), (x β sαΆ) = (x β s)
|
ProbabilityTheory.condVar_of_sigmaFinite
|
Mathlib.Probability.CondVar
|
β {Ξ© : Type u_1} {mβ m : MeasurableSpace Ξ©} {hm : m β€ mβ} {X : Ξ© β β} {ΞΌ : MeasureTheory.Measure Ξ©}
[inst : MeasureTheory.SigmaFinite (ΞΌ.trim hm)],
ProbabilityTheory.condVar m X ΞΌ =
if MeasureTheory.Integrable (fun Ο => (X Ο - ΞΌ[X|m] Ο) ^ 2) ΞΌ then
if MeasureTheory.StronglyMeasurable fun Ο => (X Ο - ΞΌ[X|m] Ο) ^ 2 then fun Ο => (X Ο - ΞΌ[X|m] Ο) ^ 2
else MeasureTheory.AEStronglyMeasurable.mk ββ(MeasureTheory.condExpL1 hm ΞΌ fun Ο => (X Ο - ΞΌ[X|m] Ο) ^ 2) β―
else 0
|
Std.DTreeMap.Internal.Impl.foldrM.eq_1
|
Std.Data.DTreeMap.Internal.WF.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {Ξ΄ : Type w} {m : Type w β Type u_1} [inst : Monad m] (f : (a : Ξ±) β Ξ² a β Ξ΄ β m Ξ΄)
(init : Ξ΄), Std.DTreeMap.Internal.Impl.foldrM f init Std.DTreeMap.Internal.Impl.leaf = pure init
|
OrderDual.instLocallyFiniteOrderTop
|
Mathlib.Order.Interval.Finset.Defs
|
{Ξ± : Type u_1} β [inst : Preorder Ξ±] β [LocallyFiniteOrderBot Ξ±] β LocallyFiniteOrderTop Ξ±α΅α΅
|
ContractingWith.edist_efixedPoint_lt_top
|
Mathlib.Topology.MetricSpace.Contracting
|
β {Ξ± : Type u_1} [inst : EMetricSpace Ξ±] {K : NNReal} {f : Ξ± β Ξ±} [inst_1 : CompleteSpace Ξ±] (hf : ContractingWith K f)
{x : Ξ±} (hx : edist x (f x) β β€), edist x (ContractingWith.efixedPoint f hf x hx) < β€
|
CategoryTheory.LocallyDiscrete.mkPseudofunctor._proof_1
|
Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete
|
β {Bβ : Type u_5} {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_5} Bβ] [inst_1 : CategoryTheory.Bicategory C]
(obj : Bβ β C) (map : {b b' : Bβ} β (b βΆ b') β (obj b βΆ obj b')) {bβ bβ bβ bβ : Bβ} (f : bβ βΆ bβ) (g : bβ βΆ bβ)
(h : bβ βΆ bβ),
map (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h) =
map (CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
|
CategoryTheory.Grothendieck.forget
|
Mathlib.CategoryTheory.Grothendieck
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
(F : CategoryTheory.Functor C CategoryTheory.Cat) β CategoryTheory.Functor (CategoryTheory.Grothendieck F) C
|
CategoryTheory.Monoidal.induced._simp_4
|
Mathlib.CategoryTheory.Monoidal.Transport
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y β
X) (g g' : Y βΆ Z),
(CategoryTheory.CategoryStruct.comp f.inv g = CategoryTheory.CategoryStruct.comp f.inv g') = (g = g')
|
Lean.Lsp.ParameterInformationLabel.range.elim
|
Lean.Data.Lsp.LanguageFeatures
|
{motive : Lean.Lsp.ParameterInformationLabel β Sort u} β
(t : Lean.Lsp.ParameterInformationLabel) β
t.ctorIdx = 1 β
((startUtf16Offset endUtf16Offset : β) β
motive (Lean.Lsp.ParameterInformationLabel.range startUtf16Offset endUtf16Offset)) β
motive t
|
ENat.one_epow
|
Mathlib.Data.ENat.Pow
|
β {y : ββ}, 1 ^ y = 1
|
AlgebraicGeometry.Scheme.OpenCover.ext_elem
|
Mathlib.AlgebraicGeometry.Cover.Open
|
β {X : AlgebraicGeometry.Scheme} {U : X.Opens} (f g : β(X.presheaf.obj (Opposite.op U))) (π° : X.OpenCover),
(β (i : π°.Iβ),
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.app (π°.f i) U)) f =
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.app (π°.f i) U)) g) β
f = g
|
Std.Internal.List.containsKey_of_perm
|
Std.Data.Internal.List.Associative
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : BEq Ξ±] [PartialEquivBEq Ξ±] {l l' : List ((a : Ξ±) Γ Ξ² a)} {k : Ξ±},
l.Perm l' β Std.Internal.List.containsKey k l = Std.Internal.List.containsKey k l'
|
tendsto_inv_atTop_nhds_zero_nat
|
Mathlib.Analysis.SpecificLimits.Basic
|
β {π : Type u_4} [inst : DivisionSemiring π] [inst_1 : CharZero π] [inst_2 : TopologicalSpace π] [ContinuousSMul ββ₯0 π],
Filter.Tendsto (fun n => (βn)β»ΒΉ) Filter.atTop (nhds 0)
|
UpperSet.isTotal_le
|
Mathlib.Order.UpperLower.CompleteLattice
|
β {Ξ± : Type u_1} [inst : LinearOrder Ξ±], IsTotal (UpperSet Ξ±) fun x1 x2 => x1 β€ x2
|
instNoMinOrderElemIoc
|
Mathlib.Order.Interval.Set.Basic
|
β (Ξ± : Type u_1) [inst : Preorder Ξ±] [DenselyOrdered Ξ±] {x y : Ξ±}, NoMinOrder β(Set.Ioc x y)
|
_private.Mathlib.NumberTheory.DiophantineApproximation.Basic.0.Real.invariant._simp_1_3
|
Mathlib.NumberTheory.DiophantineApproximation.Basic
|
β {Ξ± : Type u_2} [inst : Zero Ξ±] [inst_1 : OfNat Ξ± 4] [NeZero 4], (4 = 0) = False
|
CommGroupWithZero.zpow._inherited_default
|
Mathlib.Algebra.GroupWithZero.Defs
|
{Gβ : Type u_2} β (Gβ β Gβ β Gβ) β Gβ β (Gβ β Gβ) β β€ β Gβ β Gβ
|
MvPolynomial.renameEquiv_trans
|
Mathlib.Algebra.MvPolynomial.Rename
|
β {Ο : Type u_1} {Ο : Type u_2} {Ξ± : Type u_3} (R : Type u_4) [inst : CommSemiring R] (e : Ο β Ο) (f : Ο β Ξ±),
(MvPolynomial.renameEquiv R e).trans (MvPolynomial.renameEquiv R f) = MvPolynomial.renameEquiv R (e.trans f)
|
Units.instMulDistribMulAction._proof_1
|
Mathlib.Algebra.GroupWithZero.Action.Units
|
β {M : Type u_1} {Ξ± : Type u_2} [inst : Monoid M] [inst_1 : Monoid Ξ±] [inst_2 : MulDistribMulAction M Ξ±] (m : MΛ£)
(bβ bβ : Ξ±), βm β’ (bβ * bβ) = βm β’ bβ * βm β’ bβ
|
Polynomial.isOpenMap_comap_C
|
Mathlib.RingTheory.Spectrum.Prime.Polynomial
|
β {R : Type u_1} [inst : CommRing R], IsOpenMap β(PrimeSpectrum.comap Polynomial.C)
|
_private.Mathlib.Data.Fintype.EquivFin.0.Function.Embedding.exists_of_card_eq_finset._simp_1_1
|
Mathlib.Data.Fintype.EquivFin
|
β {Ξ± : Type u_1} {sβ sβ : Finset Ξ±}, (sβ β sβ) = (βsβ β βsβ)
|
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_11
|
Lean.Elab.Tactic.Simp
|
(motive : Lean.Elab.Tactic.ElabSimpArgResult β Sort u_1) β
(arg : Lean.Elab.Tactic.ElabSimpArgResult) β
((entries : Array Lean.Meta.SimpEntry) β motive (Lean.Elab.Tactic.ElabSimpArgResult.addEntries entries)) β
((fvarId : Lean.FVarId) β motive (Lean.Elab.Tactic.ElabSimpArgResult.addLetToUnfold fvarId)) β
((declName : Lean.Name) β
(post : Bool) β motive (Lean.Elab.Tactic.ElabSimpArgResult.addSimproc declName post)) β
((origin : Lean.Meta.Origin) β motive (Lean.Elab.Tactic.ElabSimpArgResult.erase origin)) β
((name : Lean.Name) β motive (Lean.Elab.Tactic.ElabSimpArgResult.eraseSimproc name)) β
((simpExt? : Option Lean.Meta.SimpExtension) β
(simprocExt? : Option Lean.Meta.Simp.SimprocExtension) β
(h : (simpExt?.isSome || simprocExt?.isSome) = true) β
motive (Lean.Elab.Tactic.ElabSimpArgResult.ext simpExt? simprocExt? h)) β
(Unit β motive Lean.Elab.Tactic.ElabSimpArgResult.star) β
(Unit β motive Lean.Elab.Tactic.ElabSimpArgResult.none) β motive arg
|
Module.Presentation.cokernelRelations_R
|
Mathlib.Algebra.Module.Presentation.Cokernel
|
β {A : Type u} [inst : Ring A] {Mβ : Type vβ} {Mβ : Type vβ} [inst_1 : AddCommGroup Mβ] [inst_2 : Module A Mβ]
[inst_3 : AddCommGroup Mβ] [inst_4 : Module A Mβ] (presβ : Module.Presentation A Mβ) {f : Mβ ββ[A] Mβ} {ΞΉ : Type wβ}
{gβ : ΞΉ β Mβ} (data : presβ.CokernelData f gβ), (presβ.cokernelRelations data).R = (presβ.R β ΞΉ)
|
BooleanAlgebra.toHImp
|
Mathlib.Order.BooleanAlgebra.Defs
|
{Ξ± : Type u} β [self : BooleanAlgebra Ξ±] β HImp Ξ±
|
DiscreteQuotient.map_continuous
|
Mathlib.Topology.DiscreteQuotient
|
β {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{A : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B),
Continuous (DiscreteQuotient.map f cond)
|
instIsCancelVAdd
|
Mathlib.Algebra.Group.Action.Defs
|
β (G : Type u_9) [inst : AddCancelMonoid G], IsCancelVAdd G G
|
AddCommMonCat.Hom.recOn
|
Mathlib.Algebra.Category.MonCat.Basic
|
{A B : AddCommMonCat} β
{motive : A.Hom B β Sort u_1} β (t : A.Hom B) β ((hom' : βA β+ βB) β motive { hom' := hom' }) β motive t
|
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.le_singleton._simp_1_1
|
Mathlib.Data.Multiset.ZeroCons
|
β {Ξ± : Type u_1} (a : Ξ±), {a} = β[a]
|
Lean.Syntax.topDown
|
Lean.Syntax
|
Lean.Syntax β optParam Bool false β Lean.Syntax.TopDown
|
MultilinearMap.uncurry_curryRight
|
Mathlib.LinearAlgebra.Multilinear.Curry
|
β {R : Type uR} {n : β} {M : Fin n.succ β Type v} {Mβ : Type vβ} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) β AddCommMonoid (M i)] [inst_2 : AddCommMonoid Mβ]
[inst_3 : (i : Fin n.succ) β Module R (M i)] [inst_4 : Module R Mβ] (f : MultilinearMap R M Mβ),
f.curryRight.uncurryRight = f
|
Lean.Grind.IntModule.OfNatModule.r
|
Init.Grind.Module.Envelope
|
(Ξ± : Type u) β [Lean.Grind.NatModule Ξ±] β Ξ± Γ Ξ± β Ξ± Γ Ξ± β Prop
|
SeparationQuotient.surjective_mk
|
Mathlib.Topology.Inseparable
|
β {X : Type u_1} [inst : TopologicalSpace X], Function.Surjective SeparationQuotient.mk
|
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorRefVecBlastClz
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Clz
|
β {Ξ± : Type} [inst : Hashable Ξ±] [inst_1 : DecidableEq Ξ±],
Std.Sat.AIG.LawfulVecOperator Ξ± Std.Sat.AIG.RefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastClz
|
_private.Mathlib.Computability.PostTuringMachine.0.Turing.TM1to0.trAux.match_1.eq_1
|
Mathlib.Computability.PostTuringMachine
|
β {Ξ : Type u_1} {Ξ : Type u_2} {Ο : Type u_3} (motive : Turing.TM1.Stmt Ξ Ξ Ο β Ο β Sort u_4) (d : Turing.Dir)
(q : Turing.TM1.Stmt Ξ Ξ Ο) (v : Ο)
(h_1 : (d : Turing.Dir) β (q : Turing.TM1.Stmt Ξ Ξ Ο) β (v : Ο) β motive (Turing.TM1.Stmt.move d q) v)
(h_2 : (a : Ξ β Ο β Ξ) β (q : Turing.TM1.Stmt Ξ Ξ Ο) β (v : Ο) β motive (Turing.TM1.Stmt.write a q) v)
(h_3 : (a : Ξ β Ο β Ο) β (q : Turing.TM1.Stmt Ξ Ξ Ο) β (v : Ο) β motive (Turing.TM1.Stmt.load a q) v)
(h_4 : (p : Ξ β Ο β Bool) β (qβ qβ : Turing.TM1.Stmt Ξ Ξ Ο) β (v : Ο) β motive (Turing.TM1.Stmt.branch p qβ qβ) v)
(h_5 : (l : Ξ β Ο β Ξ) β (v : Ο) β motive (Turing.TM1.Stmt.goto l) v) (h_6 : (v : Ο) β motive Turing.TM1.Stmt.halt v),
(match Turing.TM1.Stmt.move d q, v with
| Turing.TM1.Stmt.move d q, v => h_1 d q v
| Turing.TM1.Stmt.write a q, v => h_2 a q v
| Turing.TM1.Stmt.load a q, v => h_3 a q v
| Turing.TM1.Stmt.branch p qβ qβ, v => h_4 p qβ qβ v
| Turing.TM1.Stmt.goto l, v => h_5 l v
| Turing.TM1.Stmt.halt, v => h_6 v) =
h_1 d q v
|
Std.DTreeMap.Internal.Impl.minKeyD_erase_eq_of_not_compare_minKeyD_eq
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {instOrd : Ord Ξ±} {t : Std.DTreeMap.Internal.Impl Ξ± Ξ²} [Std.TransOrd Ξ±] (h : t.WF)
{k fallback : Ξ±},
(Std.DTreeMap.Internal.Impl.erase k t β―).impl.isEmpty = false β
Β¬compare k (t.minKeyD fallback) = Ordering.eq β
(Std.DTreeMap.Internal.Impl.erase k t β―).impl.minKeyD fallback = t.minKeyD fallback
|
CochainComplex.HomComplex.Cochain.single_v
|
Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C β€} {p q : β€} (f : K.X p βΆ L.X q) (n : β€) (hpq : p + n = q),
(CochainComplex.HomComplex.Cochain.single f n).v p q hpq = f
|
LLVM.CodegenFileType.ctorIdx
|
Lean.Compiler.IR.LLVMBindings
|
LLVM.CodegenFileType β β
|
HeytingAlgebra.ctorIdx
|
Mathlib.Order.Heyting.Basic
|
{Ξ± : Type u_4} β HeytingAlgebra Ξ± β β
|
frequently_gt_nhds
|
Mathlib.Topology.Order.LeftRight
|
β {Ξ± : Type u_1} [inst : TopologicalSpace Ξ±] [inst_1 : Preorder Ξ±] (a : Ξ±) [(nhdsWithin a (Set.Ioi a)).NeBot],
βαΆ (x : Ξ±) in nhds a, a < x
|
_private.Init.Data.SInt.Bitwise.0.Int8.not_eq_comm._simp_1_1
|
Init.Data.SInt.Bitwise
|
β {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec)
|
Set.biUnionEqSigmaOfDisjoint.eq_1
|
Mathlib.Data.Set.Pairwise.Lattice
|
β {Ξ± : Type u_1} {ΞΉ : Type u_2} {s : Set ΞΉ} {f : ΞΉ β Set Ξ±} (h : s.PairwiseDisjoint f),
Set.biUnionEqSigmaOfDisjoint h = (Equiv.setCongr β―).trans (Set.unionEqSigmaOfDisjoint β―)
|
Relation.map_map
|
Mathlib.Logic.Relation
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {Ξ΄ : Type u_4} {Ξ΅ : Type u_5} {ΞΆ : Type u_6} (r : Ξ± β Ξ² β Prop)
(fβ : Ξ± β Ξ³) (gβ : Ξ² β Ξ΄) (fβ : Ξ³ β Ξ΅) (gβ : Ξ΄ β ΞΆ),
Relation.Map (Relation.Map r fβ gβ) fβ gβ = Relation.Map r (fβ β fβ) (gβ β gβ)
|
MeasureTheory.measure_eq_measure_smaller_of_between_null_diff
|
Mathlib.MeasureTheory.Measure.MeasureSpace
|
β {Ξ± : Type u_1} {m : MeasurableSpace Ξ±} {ΞΌ : MeasureTheory.Measure Ξ±} {sβ sβ sβ : Set Ξ±},
sβ β sβ β sβ β sβ β ΞΌ (sβ \ sβ) = 0 β ΞΌ sβ = ΞΌ sβ
|
Subgroup.orderIsoCon
|
Mathlib.GroupTheory.QuotientGroup.Defs
|
{G : Type u_1} β [inst : Group G] β { N // N.Normal } βo Con G
|
CommMonCat.forgetβCreatesLimit._proof_11
|
Mathlib.Algebra.Category.MonCat.Limits
|
β {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} β(F.comp (CategoryTheory.forget CommMonCat)).sections]
(x : CategoryTheory.Limits.Cone F),
(CategoryTheory.forgetβ CommMonCat MonCat).map
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
β((F.comp (CategoryTheory.forgetβ CommMonCat MonCat)).comp (CategoryTheory.forget MonCat)).sections)
β¨fun j =>
((CategoryTheory.forget MonCat).mapCone ((CategoryTheory.forgetβ CommMonCat MonCat).mapCone x)).Ο.app
j v,
β―β©,
map_one' := β―, map_mul' := β― } } =
(CategoryTheory.forgetβ CommMonCat MonCat).map
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
β((F.comp (CategoryTheory.forgetβ CommMonCat MonCat)).comp (CategoryTheory.forget MonCat)).sections)
β¨fun j =>
((CategoryTheory.forget MonCat).mapCone ((CategoryTheory.forgetβ CommMonCat MonCat).mapCone x)).Ο.app
j v,
β―β©,
map_one' := β―, map_mul' := β― } }
|
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Rawβ.expand.go.induct
|
Std.Data.DHashMap.Internal.WF
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} [inst : Hashable Ξ±]
(motive : β β Array (Std.DHashMap.Internal.AssocList Ξ± Ξ²) β { d // 0 < d.size } β Prop),
(β (i : β) (source : Array (Std.DHashMap.Internal.AssocList Ξ± Ξ²)) (target : { d // 0 < d.size })
(h : i < source.size),
have es := source[i];
have source_1 := source.set i Std.DHashMap.Internal.AssocList.nil h;
have target_1 := Std.DHashMap.Internal.AssocList.foldl (Std.DHashMap.Internal.Rawβ.reinsertAux hash) target es;
motive (i + 1) source_1 target_1 β motive i source target) β
(β (i : β) (source : Array (Std.DHashMap.Internal.AssocList Ξ± Ξ²)) (target : { d // 0 < d.size }),
Β¬i < source.size β motive i source target) β
β (i : β) (source : Array (Std.DHashMap.Internal.AssocList Ξ± Ξ²)) (target : { d // 0 < d.size }),
motive i source target
|
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.Ordered.memP_iff_lowerBound?.match_1_5
|
Batteries.Data.RBMap.Lemmas
|
β (motive : Ordering.eq = Ordering.lt β Prop) (x : Ordering.eq = Ordering.lt), motive x
|
ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl.congr_simp
|
Mathlib.Analysis.Calculus.Implicit
|
β {π : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField π]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace π E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace π G] [inst_7 : CompleteSpace E] [inst_8 : CompleteSpace (F Γ G)]
(f f_1 : E βL[π] F) (e_f : f = f_1) (g g_1 : E βL[π] G) (e_g : g = g_1) (hf : LinearMap.range f = β€)
(hg : LinearMap.range g = β€) (hfg : IsCompl (LinearMap.ker f) (LinearMap.ker g)),
f.equivProdOfSurjectiveOfIsCompl g hf hg hfg = f_1.equivProdOfSurjectiveOfIsCompl g_1 β― β― β―
|
Std.Sat.AIG.RelabelNat.State.noConfusionType
|
Std.Sat.AIG.RelabelNat
|
{Ξ± : Type} β
[inst : DecidableEq Ξ±] β
[inst_1 : Hashable Ξ±] β
{decls : Array (Std.Sat.AIG.Decl Ξ±)} β
{idx : β} β
Sort u β Std.Sat.AIG.RelabelNat.State Ξ± decls idx β Std.Sat.AIG.RelabelNat.State Ξ± decls idx β Sort u
|
hasSum_nat_jacobiTheta
|
Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable
|
β {Ο : β}, 0 < Ο.im β HasSum (fun n => Complex.exp (βReal.pi * Complex.I * (βn + 1) ^ 2 * Ο)) ((jacobiTheta Ο - 1) / 2)
|
Std.Sat.AIG.denote_idx_gate
|
Std.Sat.AIG.Lemmas
|
β {Ξ± : Type} [inst : Hashable Ξ±] [inst_1 : DecidableEq Ξ±] {start : β} {assign : Ξ± β Bool} {invert : Bool}
{lhs rhs : Std.Sat.AIG.Fanin} {aig : Std.Sat.AIG Ξ±} {hstart : start < aig.decls.size}
(h : aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs),
β¦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }β§ =
(β¦assign, { aig := aig, ref := { gate := lhs.gate, invert := lhs.invert, hgate := β― } }β§ &&
β¦assign, { aig := aig, ref := { gate := rhs.gate, invert := rhs.invert, hgate := β― } }β§ ^^
invert)
|
TopologicalSpace.DiscreteTopology.metrizableSpace
|
Mathlib.Topology.Metrizable.Basic
|
β {X : Type u_2} [inst : TopologicalSpace X] [DiscreteTopology X], TopologicalSpace.MetrizableSpace X
|
CategoryTheory.Limits.isLimitOfHasBinaryProductOfPreservesLimit
|
Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts
|
{C : Type uβ} β
[inst : CategoryTheory.Category.{vβ, uβ} C] β
{D : Type uβ} β
[inst_1 : CategoryTheory.Category.{vβ, uβ} D] β
(G : CategoryTheory.Functor C D) β
(X Y : C) β
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] β
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G] β
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (G.map CategoryTheory.Limits.prod.fst)
(G.map CategoryTheory.Limits.prod.snd))
|
Real.fourierIntegralInv_comp_linearIsometry
|
Mathlib.Analysis.Fourier.FourierTransform
|
β {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace β E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace β V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] {W : Type u_3}
[inst_6 : NormedAddCommGroup W] [inst_7 : InnerProductSpace β W] [inst_8 : MeasurableSpace W] [inst_9 : BorelSpace W]
[inst_10 : FiniteDimensional β W] [inst_11 : FiniteDimensional β V] (A : W ββα΅’[β] V) (f : V β E) (w : W),
FourierTransformInv.fourierInv (f β βA) w = FourierTransformInv.fourierInv f (A w)
|
convexHull_empty_iff
|
Mathlib.Analysis.Convex.Hull
|
β {π : Type u_1} {E : Type u_2} [inst : Semiring π] [inst_1 : PartialOrder π] [inst_2 : AddCommMonoid E]
[inst_3 : Module π E] {s : Set E}, (convexHull π) s = β
β s = β
|
CategoryTheory.ShortComplex.Splitting.mk._flat_ctor
|
Mathlib.Algebra.Homology.ShortComplex.Exact
|
{C : Type u_1} β
[inst : CategoryTheory.Category.{u_3, u_1} C] β
[inst_1 : CategoryTheory.Preadditive C] β
{S : CategoryTheory.ShortComplex C} β
(r : S.Xβ βΆ S.Xβ) β
(s : S.Xβ βΆ S.Xβ) β
autoParam (CategoryTheory.CategoryStruct.comp S.f r = CategoryTheory.CategoryStruct.id S.Xβ)
CategoryTheory.ShortComplex.Splitting.f_r._autoParam β
autoParam (CategoryTheory.CategoryStruct.comp s S.g = CategoryTheory.CategoryStruct.id S.Xβ)
CategoryTheory.ShortComplex.Splitting.s_g._autoParam β
autoParam
(CategoryTheory.CategoryStruct.comp r S.f + CategoryTheory.CategoryStruct.comp S.g s =
CategoryTheory.CategoryStruct.id S.Xβ)
CategoryTheory.ShortComplex.Splitting.id._autoParam β
S.Splitting
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.