name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
MvFunctor.exists_iff_exists_of_mono | Mathlib.Control.Functor.Multivariate | ∀ {n : ℕ} {α β : TypeVec.{u} n} (F : TypeVec.{u} n → Type v) [inst : MvFunctor F] [LawfulMvFunctor F] {P : F α → Prop}
{q : F β → Prop} (f : α.Arrow β) (g : β.Arrow α),
TypeVec.comp f g = TypeVec.id → (∀ (u : F α), P u ↔ q (MvFunctor.map f u)) → ((∃ u, P u) ↔ ∃ u, q u) |
Lean.Lsp.SemanticTokenType.ctorElimType | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenType → Sort u} → ℕ → Sort (max 1 u) |
Subgroup.HasDetOne.recOn | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | {n : Type u_1} →
[inst : Fintype n] →
[inst_1 : DecidableEq n] →
{R : Type u_2} →
[inst_2 : CommRing R] →
{Γ : Subgroup (GL n R)} →
{motive : Γ.HasDetOne → Sort u} →
(t : Γ.HasDetOne) →
((det_eq : ∀ {g : GL n R}, g ∈ Γ → Matrix.GeneralLinearGroup.det g = 1) → motive ⋯) → motive t |
String.Pos.next.congr_simp | Init.Data.String.Basic | ∀ {s : String} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.endPos), pos.next h = pos_1.next ⋯ |
IO.Error.illegalOperation.sizeOf_spec | Init.System.IOError | ∀ (osCode : UInt32) (details : String),
sizeOf (IO.Error.illegalOperation osCode details) = 1 + sizeOf osCode + sizeOf details |
ENNReal.div_eq_div_iff | Mathlib.Data.ENNReal.Inv | ∀ {a b c d : ENNReal}, a ≠ 0 → a ≠ ⊤ → b ≠ 0 → b ≠ ⊤ → (c / b = d / a ↔ a * c = b * d) |
_private.Mathlib.Topology.Order.LeftRightNhds.0.TFAE_mem_nhdsGE.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (s : Set α) (motive : (∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s) → Prop)
(x : ∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s),
(∀ (u : α) (umem : u ∈ Set.Ioc a b) (hu : Set.Ico a u ⊆ s), motive ⋯) → motive x |
CategoryTheory.ObjectProperty.instIsTriangulatedMinOfIsClosedUnderIsomorphisms | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P P' : CategoryTheory.ObjectProperty C) [P.IsTriangulated] [P.IsClosedUnderIsomorphisms] [P'.IsTriangulated],
(P ⊓ P').IsTriangulated |
CauSeq.Completion.Cauchy.ring._proof_32 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_1}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : ℤ),
CauSeq.Completion.mk ↑x = CauSeq.Completion.mk ↑x |
FourierPair.fourierInv_fourier_eq | Mathlib.Analysis.Fourier.Notation | ∀ {E : Type u_5} {F : Type u_6} {inst : FourierTransform E F} {inst_1 : FourierTransformInv F E}
[self : FourierPair E F] (f : E), FourierTransformInv.fourierInv (FourierTransform.fourier f) = f |
Complex.log_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | Complex.log 0 = 0 |
CategoryTheory.Functor.rightDerived_fac_assoc | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_3} {D : Type u_1} {H : Type u_2} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Category.{v_3, u_1} D] [inst_2 : CategoryTheory.Category.{v_5, u_2} H]
(RF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF) (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : RF.IsRightDerivedFunctor α W] (G : CategoryTheory.Functor D H) (β : F ⟶ L.comp G)
{Z : CategoryTheory.Functor C H} (h : L.comp G ⟶ Z),
CategoryTheory.CategoryStruct.comp α
(CategoryTheory.CategoryStruct.comp (L.whiskerLeft (RF.rightDerivedDesc α W G β)) h) =
CategoryTheory.CategoryStruct.comp β h |
PadicInt.instIsDiscreteValuationRing | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], IsDiscreteValuationRing ℤ_[p] |
DivInvMonoid.mk | Mathlib.Algebra.Group.Defs | {G : Type u} →
[toMonoid : Monoid G] →
[toInv : Inv G] →
[toDiv : Div G] →
autoParam (∀ (a b : G), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam →
(zpow : ℤ → G → G) →
autoParam (∀ (a : G), zpow 0 a = 1) DivInvMonoid.zpow_zero'._autoParam →
autoParam (∀ (n : ℕ) (a : G), zpow (↑n.succ) a = zpow (↑n) a * a) DivInvMonoid.zpow_succ'._autoParam →
autoParam (∀ (n : ℕ) (a : G), zpow (Int.negSucc n) a = (zpow (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam →
DivInvMonoid G |
CategoryTheory.PreservesImage.hom_comp_map_image_ι | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Images | ∀ {A : Type u₁} {B : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Limits.HasEqualizers A] [inst_3 : CategoryTheory.Limits.HasImages A]
[inst_4 : CategoryTheory.StrongEpiCategory B] [inst_5 : CategoryTheory.Limits.HasImages B]
(L : CategoryTheory.Functor A B)
[inst_6 :
∀ {X Y Z : A} (f : X ⟶ Z) (g : Y ⟶ Z), CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) L]
[inst_7 :
∀ {X Y Z : A} (f : X ⟶ Y) (g : X ⟶ Z), CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) L]
{X Y : A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.PreservesImage.iso L f).hom
(L.map (CategoryTheory.Limits.image.ι f)) =
CategoryTheory.Limits.image.ι (L.map f) |
Lean.Meta.ExtractLets.LocalDecl'.noConfusion | Lean.Meta.Tactic.Lets | {P : Sort u} →
{t t' : Lean.Meta.ExtractLets.LocalDecl'} → t = t' → Lean.Meta.ExtractLets.LocalDecl'.noConfusionType P t t' |
Std.ExtTreeMap.getElem?_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a b : α},
cmp a b = Ordering.eq → t[a]? = t[b]? |
Sym.eq_nil_of_card_zero | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} (s : Sym α 0), s = Sym.nil |
_private.Mathlib.Analysis.InnerProductSpace.MeanErgodic.0.«_aux_Mathlib_Analysis_InnerProductSpace_MeanErgodic___macroRules__private_Mathlib_Analysis_InnerProductSpace_MeanErgodic_0_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.MeanErgodic | Lean.Macro |
Lean.KeyedDeclsAttribute.OLeanEntry._sizeOf_1 | Lean.KeyedDeclsAttribute | Lean.KeyedDeclsAttribute.OLeanEntry → ℕ |
Std.TreeMap.Raw.getEntryGED | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → α × β → α × β |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup_pure._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} (a : α), pure a = Filter.principal {a} |
CategoryTheory.Preadditive.mk.noConfusion | Mathlib.CategoryTheory.Preadditive.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{P : Sort u_1} →
{homGroup : autoParam ((P Q : C) → AddCommGroup (P ⟶ Q)) CategoryTheory.Preadditive.homGroup._autoParam} →
{add_comp :
autoParam
(∀ (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
CategoryTheory.CategoryStruct.comp (f + f') g =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f' g)
CategoryTheory.Preadditive.add_comp._autoParam} →
{comp_add :
autoParam
(∀ (P Q R : C) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g')
CategoryTheory.Preadditive.comp_add._autoParam} →
{homGroup' : autoParam ((P Q : C) → AddCommGroup (P ⟶ Q)) CategoryTheory.Preadditive.homGroup._autoParam} →
{add_comp' :
autoParam
(∀ (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
CategoryTheory.CategoryStruct.comp (f + f') g =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f' g)
CategoryTheory.Preadditive.add_comp._autoParam} →
{comp_add' :
autoParam
(∀ (P Q R : C) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g')
CategoryTheory.Preadditive.comp_add._autoParam} →
{ homGroup := homGroup, add_comp := add_comp, comp_add := comp_add } =
{ homGroup := homGroup', add_comp := add_comp', comp_add := comp_add' } →
(homGroup ≍ homGroup' → P) → P |
CategoryTheory.Limits.IsLimit.binaryFanSwap | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{s : CategoryTheory.Limits.BinaryFan X Y} → CategoryTheory.Limits.IsLimit s → CategoryTheory.Limits.IsLimit s.swap |
AffineMap.ofMapMidpoint._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {V : Type u_2} {P : Type u_4} {W : Type u_1} {Q : Type u_3} [inst : SeminormedAddCommGroup V]
[inst_1 : PseudoMetricSpace P] [inst_2 : NormedAddTorsor V P] [inst_3 : NormedAddCommGroup W] [inst_4 : MetricSpace Q]
[inst_5 : NormedAddTorsor W Q] [inst_6 : NormedSpace ℝ V] [inst_7 : NormedSpace ℝ W] (f : P → Q),
(⇑(AffineEquiv.vaddConst ℝ (f (Classical.arbitrary P))).symm ∘ f ∘ ⇑(AffineEquiv.vaddConst ℝ (Classical.arbitrary P)))
0 =
0 |
CategoryTheory.Bicategory.Adjunction.homEquiv₂.eq_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c},
adj.homEquiv₂ =
{
toFun := fun α =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft g adj.unit)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator g l r).inv
(CategoryTheory.Bicategory.whiskerRight α r))),
invFun := fun γ =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight γ l)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator h r l).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft h adj.counit)
(CategoryTheory.Bicategory.rightUnitor h).hom)),
left_inv := ⋯, right_inv := ⋯ } |
CategoryTheory.yonedaEquiv_symm_naturality_right | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) {F F' : CategoryTheory.Functor Cᵒᵖ (Type v₁)}
(f : F ⟶ F') (x : F.obj (Opposite.op X)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.yonedaEquiv.symm x) f =
CategoryTheory.yonedaEquiv.symm (f.app (Opposite.op X) x) |
Nat.prod_primeFactorsList | Mathlib.Data.Nat.Factors | ∀ {n : ℕ}, n ≠ 0 → n.primeFactorsList.prod = n |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.splittingProcedure.match_14 | Lean.Elab.Tactic.NormCast | (motive : Lean.Expr → Sort u_1) →
(expr : Lean.Expr) → ((op x y : Lean.Expr) → motive ((op.app x).app y)) → ((x : Lean.Expr) → motive x) → motive expr |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {n : ℕ} (hn : autoParam ((SimplexCategory.mk n).len ≤ 2) SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_1)
(hn' : autoParam ((SimplexCategory.mk (n + 1)).len ≤ 2) SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_3),
CategoryTheory.CategoryStruct.comp (SimplexCategory.Truncated.δ₂ 1 hn hn') (SimplexCategory.Truncated.σ₂ 0 hn' hn) =
CategoryTheory.CategoryStruct.id { obj := SimplexCategory.mk n, property := hn } |
instContinuousAddULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M], ContinuousAdd (ULift.{u, u_3} M) |
Std.Tactic.BVDecide.LRAT.Internal.Clause.unit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} → {β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → Std.Sat.Literal α → β |
CochainComplex.shiftFunctorZero_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n = (HomologicalComplex.XIsoOfEq K ⋯).hom |
instMonoidalClosedLightCondSet._proof_1 | Mathlib.Condensed.Light.CartesianClosed | CategoryTheory.EssentiallySmall.{u_1, u_1, u_1 + 1} LightProfiniteᵒᵖ |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.extract'._simp_1_7 | Batteries.Data.String.Lemmas | ∀ {m k n : ℕ}, (n + m ≤ n + k) = (m ≤ k) |
Std.Iter.find?_eq_findSome? | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.IteratorLoop α Id Id] [Std.Iterators.Finite α Id]
{it : Std.Iter β} {f : β → Bool}, it.find? f = it.findSome? fun x => if f x = true then some x else none |
Lean.Elab.Info.ofChoiceInfo.injEq | Lean.Elab.InfoTree.Types | ∀ (i i_1 : Lean.Elab.ChoiceInfo), (Lean.Elab.Info.ofChoiceInfo i = Lean.Elab.Info.ofChoiceInfo i_1) = (i = i_1) |
Equiv.nonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β] (x y : α),
e (e.symm (e x + e y)) = e x + e y |
Lean.Omega.Constraint.not_sat_of_isImpossible | Init.Omega.Constraint | ∀ {c : Lean.Omega.Constraint}, c.isImpossible = true → ∀ {t : ℤ}, ¬c.sat t = true |
CategoryTheory.IsVanKampenColimit | Mathlib.CategoryTheory.Limits.VanKampen | {J : Type v'} →
[inst : CategoryTheory.Category.{u', v'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor J C} → CategoryTheory.Limits.Cocone F → Prop |
Matrix.reindex_isTotallyUnimodular | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {m : Type u_1} {m' : Type u_2} {n : Type u_3} {n' : Type u_4} {R : Type u_5} [inst : CommRing R] (A : Matrix m n R)
(em : m ≃ m') (en : n ≃ n'), ((Matrix.reindex em en) A).IsTotallyUnimodular ↔ A.IsTotallyUnimodular |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic.0.CFC.posPart_negPart_unique._simp_1_4 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Star R} {inst_1 : Star S}
{inst_2 : FunLike F R S} [self : StarHomClass F R S] (f : F) (r : R), star (f r) = f (star r) |
IsLocallyInjective_iff_isOpenEmbedding | Mathlib.Topology.SeparatedMap | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
IsLocallyInjective f ↔ Topology.IsOpenEmbedding (toPullbackDiag f) |
Lean.IR.Checker.CheckerContext.mk.sizeOf_spec | Lean.Compiler.IR.Checker | ∀ (localCtx : Lean.IR.LocalContext) (currentDecl : Lean.IR.Decl) (decls : Array Lean.IR.Decl),
sizeOf { localCtx := localCtx, currentDecl := currentDecl, decls := decls } =
1 + sizeOf localCtx + sizeOf currentDecl + sizeOf decls |
Profinite.NobelingProof.Products.lt_ord_of_lt | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u} [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {l m : Profinite.NobelingProof.Products I}
{o : Ordinal.{u}},
m < l → (∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o) → ∀ i ∈ ↑m, Profinite.NobelingProof.ord I i < o |
Std.TreeMap.get_union_of_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
(mem : k ∈ t₂), (t₁ ∪ t₂).get k ⋯ = t₂.get k mem |
_private.Mathlib.Algebra.Group.Submonoid.Units.0.Subgroup.mem_units_iff_val_mem._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {S : Type u_3} {G : Type u_4} [inst : InvolutiveInv G] {x : SetLike S G} [InvMemClass S G] {H : S} {x_1 : G},
(x_1⁻¹ ∈ H) = (x_1 ∈ H) |
_private.Mathlib.Data.Num.ZNum.0.ZNum.mul_comm | Mathlib.Data.Num.ZNum | ∀ (a b : ZNum), a * b = b * a |
Lean.Lsp.ServerInfo._sizeOf_inst | Lean.Data.Lsp.InitShutdown | SizeOf Lean.Lsp.ServerInfo |
Function.Bijective.finite_iff | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → (Finite α ↔ Finite β) |
IntervalIntegrable.comp_add_left_iff._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax |
IsUltrametricDist.ball_openAddSubgroup.eq_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedAddGroup S] [inst_1 : IsUltrametricDist S] {r : ℝ} (hr : 0 < r),
IsUltrametricDist.ball_openAddSubgroup S hr =
{ carrier := Metric.ball 0 r, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯, isOpen' := ⋯ } |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage._proof_1 | Mathlib.CategoryTheory.Limits.Types.Images | ∀ {F : CategoryTheory.Functor ℕᵒᵖ (Type u_1)},
(∀ (n : ℕ), Function.Surjective (F.map (CategoryTheory.homOfLE ⋯).op)) →
∀ (n : ℕ) (x : Nat.below n.succ), ∃ a, F.map (CategoryTheory.homOfLE ⋯).op a = x.1 |
Lean.Grind.CommRing.Mon.below | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Mon → Sort u} → Lean.Grind.CommRing.Mon → Sort (max 1 u) |
_private.Mathlib.Algebra.Central.End.0.LinearEquiv.conjAlgEquiv_ext_iff._simp_1_2 | Mathlib.Algebra.Central.End | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_8} {M₂ : Type u_9} {M₃ : Type u_10} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} {σ₃₁ : R₃ →+* R₁} {σ₃₂ : R₃ →+* R₂} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁}
{re₂₁ : RingHomInvPair σ₂₁ σ₁₂} [inst_6 : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁] {e₁₂ : M₁ ≃ₛₗ[σ₁₂] M₂}
[inst_7 : RingHomCompTriple σ₃₁ σ₁₂ σ₃₂] (f : M₃ →ₛₗ[σ₃₁] M₁) (g : M₃ →ₛₗ[σ₃₂] M₂),
(↑e₁₂ ∘ₛₗ f = g) = (f = ↑e₁₂.symm ∘ₛₗ g) |
ValuationSubring.algebra | Mathlib.RingTheory.Valuation.AlgebraInstances | {K : Type u_1} →
[inst : Field K] →
(v : Valuation K (WithZero (Multiplicative ℤ))) →
(L : Type u_2) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
(E : Type u_3) →
[inst_3 : Field E] →
[inst_4 : Algebra K E] →
[inst_5 : Algebra L E] →
[IsScalarTower K L E] →
Algebra ↥(integralClosure (↥v.valuationSubring) L) ↥(integralClosure (↥v.valuationSubring) E) |
WeierstrassCurve.Projective.addXYZ_of_Z_eq_zero_left | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P → P 2 = 0 → W'.addXYZ P Q = (P 1 ^ 2 * Q 2) • Q |
MeasureTheory.Measure.restrict_le_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, μ.restrict s ≤ μ |
Int16.instUpwardEnumerable | Init.Data.Range.Polymorphic.SInt | Std.PRange.UpwardEnumerable Int16 |
instReprSymbol.repr | Mathlib.Computability.Language | {T : Type u_4} → {N : Type u_5} → [Repr T] → [Repr N] → Symbol T N → ℕ → Std.Format |
Representation.ofDistribMulAction_apply_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {A : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid A]
[inst_3 : Module k A] [inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (g : G) (a : A),
((Representation.ofDistribMulAction k G A) g) a = g • a |
Fin.ctorIdx | Init.Prelude | {n : ℕ} → Fin n → ℕ |
MeasurableSpace.comap_le_comap_pi | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {β : Type u_2} {δ : Type u_4} {X : δ → Type u_6} [inst : (a : δ) → MeasurableSpace (X a)] {g : (a : δ) → β → X a}
(a : δ), MeasurableSpace.comap (g a) inferInstance ≤ MeasurableSpace.comap (fun b c => g c b) MeasurableSpace.pi |
Equiv.addLeft | Mathlib.Algebra.Group.Units.Equiv | {G : Type u_5} → [AddGroup G] → G → Equiv.Perm G |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.degree_mod_lt._simp_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic = (p.leadingCoeff = 1) |
Polynomial.lsum._proof_2 | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Semiring A] [inst_2 : AddCommMonoid M]
[inst_3 : Module R A] [inst_4 : Module R M] (f : ℕ → A →ₗ[R] M) (p q : Polynomial A),
((p + q).sum fun x1 x2 => (f x1) x2) = (p.sum fun x1 x2 => (f x1) x2) + q.sum fun x1 x2 => (f x1) x2 |
Lean.Omega.Constraint.addInequality_sat | Init.Omega.Constraint | ∀ {c : ℤ} {x y : Lean.Omega.Coeffs}, c + x.dot y ≥ 0 → { lowerBound := some (-c), upperBound := none }.sat' x y = true |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.top_caratheodory._simp_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True |
Frm.instCategory._proof_3 | Mathlib.Order.Category.Frm | ∀ {W X Y Z : Frm} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } |
Turing.PartrecToTM2.K'.elim.eq_2 | Mathlib.Computability.TMToPartrec | ∀ (a b c d : List Turing.PartrecToTM2.Γ'), Turing.PartrecToTM2.K'.elim a b c d Turing.PartrecToTM2.K'.rev = b |
Order.IsPredLimit.dual | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α], Order.IsPredLimit a → Order.IsSuccLimit (OrderDual.toDual a) |
List.«_aux_Init_Data_List_Basic___macroRules_List_term_<+__1» | Init.Data.List.Basic | Lean.Macro |
Multiset.exists_max_image | Mathlib.Data.Finset.Max | ∀ {α : Type u_7} {R : Type u_8} [inst : LinearOrder R] (f : α → R) {s : Multiset α}, s ≠ 0 → ∃ y ∈ s, ∀ z ∈ s, f z ≤ f y |
WeierstrassCurve.Affine.CoordinateRing.basis | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} →
[inst : CommRing R] → (W' : WeierstrassCurve.Affine R) → Module.Basis (Fin 2) (Polynomial R) W'.CoordinateRing |
LinOrd._sizeOf_inst | Mathlib.Order.Defs.LinearOrder | SizeOf LinOrd |
Option.mem_filter_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {a : α} {o : Option α}, a ∈ Option.filter p o ↔ a ∈ o ∧ p a = true |
NumberField.RingOfIntegers.instSMulDistribClass | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] {G : Type u_3} [inst_1 : Group G] [inst_2 : MulSemiringAction G K],
SMulDistribClass G (NumberField.RingOfIntegers K) K |
Lean.Meta.Grind.Methods.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (propagateUp propagateDown : Lean.Meta.Grind.Propagator) (evalTactic : Lean.Meta.Grind.EvalTactic),
sizeOf { propagateUp := propagateUp, propagateDown := propagateDown, evalTactic := evalTactic } = 1 |
Lean.Meta.Origin.other.sizeOf_spec | Lean.Meta.Tactic.Simp.SimpTheorems | ∀ (name : Lean.Name), sizeOf (Lean.Meta.Origin.other name) = 1 + sizeOf name |
iteratedDeriv_const_smul | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {R : Type u_3} [inst_3 : DistribSMul R F] [SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F] {n : ℕ} {f : 𝕜 → F},
ContDiffAt 𝕜 (↑n) f x → ∀ (c : R), iteratedDeriv n (c • f) x = c • iteratedDeriv n f x |
isAddRightRegular_toDual | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : α}, IsAddRightRegular (OrderDual.toDual a) ↔ IsAddRightRegular a |
_private.Lean.Meta.Tactic.Grind.AC.PP.0.Lean.Meta.Grind.AC.instMonadGetStructM | Lean.Meta.Tactic.Grind.AC.PP | Lean.Meta.Grind.AC.MonadGetStruct Lean.Meta.Grind.AC.M✝ |
Filter.eventually_all_finset | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Type u_2} (I : Finset ι) {l : Filter α} {p : ι → α → Prop},
(∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.append.match_1.eq_5 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (motive : Batteries.RBNode α → Batteries.RBNode α → Sort u_2) (l : Batteries.RBNode α) (v : α)
(r b : Batteries.RBNode α) (x : α) (c : Batteries.RBNode α)
(h_1 : (x : Batteries.RBNode α) → motive Batteries.RBNode.nil x)
(h_2 : (x : Batteries.RBNode α) → motive x Batteries.RBNode.nil)
(h_3 :
(a : Batteries.RBNode α) →
(x : α) →
(b c : Batteries.RBNode α) →
(y : α) →
(d : Batteries.RBNode α) →
motive (Batteries.RBNode.node Batteries.RBColor.red a x b)
(Batteries.RBNode.node Batteries.RBColor.red c y d))
(h_4 :
(a : Batteries.RBNode α) →
(x : α) →
(b c : Batteries.RBNode α) →
(y : α) →
(d : Batteries.RBNode α) →
motive (Batteries.RBNode.node Batteries.RBColor.black a x b)
(Batteries.RBNode.node Batteries.RBColor.black c y d))
(h_5 :
(a l : Batteries.RBNode α) →
(v : α) →
(r : Batteries.RBNode α) →
a = Batteries.RBNode.node Batteries.RBColor.black l v r →
(b : Batteries.RBNode α) →
(x : α) →
(c : Batteries.RBNode α) →
motive (Batteries.RBNode.node Batteries.RBColor.black l v r)
(Batteries.RBNode.node Batteries.RBColor.red b x c))
(h_6 :
(a : Batteries.RBNode α) →
(x : α) →
(b c l : Batteries.RBNode α) →
(v : α) →
(r : Batteries.RBNode α) →
c = Batteries.RBNode.node Batteries.RBColor.black l v r →
motive (Batteries.RBNode.node Batteries.RBColor.red a x b)
(Batteries.RBNode.node Batteries.RBColor.black l v r)),
(match Batteries.RBNode.node Batteries.RBColor.black l v r, Batteries.RBNode.node Batteries.RBColor.red b x c with
| Batteries.RBNode.nil, x => h_1 x
| x, Batteries.RBNode.nil => h_2 x
| Batteries.RBNode.node Batteries.RBColor.red a x b, Batteries.RBNode.node Batteries.RBColor.red c y d =>
h_3 a x b c y d
| Batteries.RBNode.node Batteries.RBColor.black a x b, Batteries.RBNode.node Batteries.RBColor.black c y d =>
h_4 a x b c y d
| a@h:(Batteries.RBNode.node Batteries.RBColor.black l v r), Batteries.RBNode.node Batteries.RBColor.red b x c =>
h_5 a l v r h b x c
| Batteries.RBNode.node Batteries.RBColor.red a x b, c@h:(Batteries.RBNode.node Batteries.RBColor.black l v r) =>
h_6 a x b c l v r h) =
h_5 (Batteries.RBNode.node Batteries.RBColor.black l v r) l v r ⋯ b x c |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Piecewise.0.Finset.prod_dite_of_true._proof_1_6 | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {s : Finset ι} {p : ι → Prop}, (∀ i ∈ s, p i) → ∀ a ∈ s, p a |
LinearMap.addCommGroup._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₂ : Type u_1} {N₂ : Type u_2} [inst : Semiring R₂] [inst_1 : AddCommGroup N₂] [inst_2 : Module R₂ N₂],
SMulCommClass R₂ ℤ N₂ |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.toACExpr.toPreExpr | Lean.Meta.Tactic.AC.Main | Lean.Expr → Lean.Expr → StateT Lean.ExprSet Lean.MetaM Lean.Meta.AC.PreExpr |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.succ_mem_succ_succ_iff._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LinearlyUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.Rxo.IsAlwaysFinite α] [Std.PRange.LawfulUpwardEnumerable α]
{lo hi a : α}, (a ∈ (Std.PRange.succ lo)<...Std.PRange.succ hi) = ∃ a', a = Std.PRange.succ a' ∧ a' ∈ lo<...hi |
Unitization.instSemiring | Mathlib.Algebra.Algebra.Unitization | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] → [IsScalarTower R A A] → [SMulCommClass R A A] → Semiring (Unitization R A) |
Batteries.PairingHeapImp.instDecidableNoSibling | Batteries.Data.PairingHeap | {α : Type u_1} → {s : Batteries.PairingHeapImp.Heap α} → Decidable s.NoSibling |
AddSubgroupClass.coe_zmod_smul | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G]
{K : S} [inst_3 : Module (ZMod n) G] (a : ZMod n) (x : ↥K), ↑(a • x) = a • ↑x |
Std.Tactic.BVDecide.LRAT.Internal.Entails.eval | Std.Tactic.BVDecide.LRAT.Internal.Entails | {α : Type u} → {β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Entails α β] → (α → Bool) → β → Prop |
Geometry.SimplicialComplex.ofSubcomplex_faces | Mathlib.Analysis.Convex.SimplicialComplex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (K : Geometry.SimplicialComplex 𝕜 E) (faces : Set (Finset E)) (subset : faces ⊆ K.faces)
(down_closed : IsLowerSet faces), (K.ofSubcomplex faces subset down_closed).faces = faces |
Lean.Server.Test.Runner.Client.normalizedRef | Lean.Server.Test.Runner | Lean.Lsp.RpcRef → Lean.Server.Test.Runner.Client.NormalizeM Lean.Lsp.RpcRef |
SetRel.rightDual_mem_leftFixedPoint | Mathlib.Order.Rel.GaloisConnection | ∀ {α : Type u_1} {β : Type u_2} (R : SetRel α β) (I : Set β), R.rightDual I ∈ R.leftFixedPoints |
ProofWidgets.GetExprPresentationParams.rec | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.GetExprPresentationParams → Sort u} →
((expr : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx) →
(name : Lean.Name) → motive { expr := expr, name := name }) →
(t : ProofWidgets.GetExprPresentationParams) → motive t |
String.instLEPos_1 | Init.Data.String.Defs | {s : String.Slice} → LE s.Pos |
Turing.PartrecToTM2.copy_ok | Mathlib.Computability.TMToPartrec | ∀ (q : Turing.PartrecToTM2.Λ') (s : Option Turing.PartrecToTM2.Γ') (a b c d : List Turing.PartrecToTM2.Γ'),
StateTransition.Reaches₁ (Turing.TM2.step Turing.PartrecToTM2.tr)
{ l := some q.copy, var := s, stk := Turing.PartrecToTM2.K'.elim a b c d }
{ l := some q, var := none, stk := Turing.PartrecToTM2.K'.elim (b.reverseAux a) [] c (b.reverseAux d) } |
hfdifferential._proof_10 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_6} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_5}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_2} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_3} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_4} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : ContMDiffMap I I' M M' ↑⊤} {x : M}
{y : M'} (x_1 : 𝕜) (x_2 : PointDerivation I x) (g g' : PointedContMDiffMap 𝕜 I' M' (↑⊤) y),
(x_1 • x_2) (ContMDiffMap.comp (g + g') f) =
(x_1 • x_2) (ContMDiffMap.comp g f) + (x_1 • x_2) (ContMDiffMap.comp g' f) |
ProbabilityTheory.Kernel.IsProper.setLIntegral_eq_indicator_mul_lintegral | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X} {B : Set X} {f : X → ENNReal},
π.IsProper →
𝓑 ≤ 𝓧 →
Measurable f → MeasurableSet B → ∀ (x₀ : X), ∫⁻ (x : X) in B, f x ∂π x₀ = B.indicator 1 x₀ * ∫⁻ (x : X), f x ∂π x₀ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.