name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Compiler.ExternAttr.0.Lean.parseOptNum._sunfold | Lean.Compiler.ExternAttr | ℕ → (pattern : String) → pattern.Pos → ℕ → pattern.Pos × ℕ |
differentiableAt_comp_const_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {a b : 𝕜},
DifferentiableAt 𝕜 (fun x => f (b - x)) a ↔ DifferentiableAt 𝕜 f (b - a) |
MeasureTheory.Measure.IsNegInvariant.recOn | Mathlib.MeasureTheory.Group.Measure | {G : Type u_1} →
[inst : MeasurableSpace G] →
[inst_1 : Neg G] →
{μ : MeasureTheory.Measure G} →
{motive : μ.IsNegInvariant → Sort u} →
(t : μ.IsNegInvariant) → ((neg_eq_self : μ.neg = μ) → motive ⋯) → motive t |
ContinuousMap.Homotopy.comp._proof_2 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_3} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Y, Z)} (G : g₀.Homotopy g₁) (F : f₀.Homotopy f₁),
Continuous fun x => G (x.1, F x) |
_private.Mathlib.Tactic.ITauto.0.Mathlib.Tactic.ITauto.search._sparseCasesOn_16 | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(t : Mathlib.Tactic.ITauto.IProp) →
((a a_1 : Mathlib.Tactic.ITauto.IProp) → motive (a.or a_1)) → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
Hyperreal.isSt_refl_real | Mathlib.Analysis.Real.Hyperreal | ∀ (r : ℝ), (↑r).IsSt r |
Nat.bodd_one | Mathlib.Data.Nat.Bits | Nat.bodd 1 = true |
Subgroup.inclusion_inj | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (h : H ≤ K) {x y : ↥H},
(Subgroup.inclusion h) x = (Subgroup.inclusion h) y ↔ x = y |
_private.Mathlib.AlgebraicGeometry.Morphisms.Affine.0.AlgebraicGeometry.isAffine_of_isAffineOpen_basicOpen._simp_1_2 | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {R : CommRingCat} (f : ↑R),
PrimeSpectrum.basicOpen f =
(AlgebraicGeometry.Spec R).basicOpen
((CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.ΓSpecIso R).inv) f) |
Lean.Meta.CaseArraySizesSubgoal | Lean.Meta.Match.CaseArraySizes | Type |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.needsExplicit._sparseCasesOn_4 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) →
motive Lean.BinderInfo.implicit →
motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 10 t.ctorIdx → motive t) → motive t |
RootPairing.restrictScalars'._proof_5 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_5} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_2)
[inst_5 : Field K] [inst_6 : Algebra K L] [inst_7 : Module K M] [inst_8 : Module K N] [inst_9 : IsScalarTower K L M]
[inst_10 : IsScalarTower K L N] [inst_11 : P.IsValuedIn K] (i j : ι),
{ toFun := fun i => ⟨P.root i, ⋯⟩, inj' := ⋯ } j -
(((Submodule.span K (Set.range ⇑P.root)).subtype.restrictScalarsRange₂
(Submodule.span K (Set.range ⇑P.coroot)).subtype (Algebra.linearMap K L) ⋯ P.toLinearMap ⋯)
({ toFun := fun i => ⟨P.root i, ⋯⟩, inj' := ⋯ } j))
({ toFun := fun i => ⟨P.coroot i, ⋯⟩, inj' := ⋯ } i) •
{ toFun := fun i => ⟨P.root i, ⋯⟩, inj' := ⋯ } i =
{ toFun := fun i => ⟨P.root i, ⋯⟩, inj' := ⋯ } ((P.reflectionPerm i) j) |
Batteries.BinomialHeap.Imp.HeapNode.rankTR.go | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} → Batteries.BinomialHeap.Imp.HeapNode α → ℕ → ℕ |
QuotientAddGroup.lift.eq_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_4} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M) (HN : N ≤ φ.ker), QuotientAddGroup.lift N φ HN = (QuotientAddGroup.con N).lift φ ⋯ |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_2 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules) (f : (↑R)ᵒᵖ),
IsLocalizedModule (Submonoid.powers (Opposite.unop f))
(ModuleCat.Hom.hom
(AlgebraicGeometry.tilde.toOpen ((AlgebraicGeometry.modulesSpecToSheaf.obj M).obj.obj (Opposite.op ⊤))
(PrimeSpectrum.basicOpen (Opposite.unop f)))) |
AddSubmonoid.subPairs.eq_1 | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (f : ⊤.LocalizationMap G)
(s : AddSubmonoid G), AddSubmonoid.subPairs f s = AddSubmonoid.comap (subAddMonoidHom.comp ((↑f).prodMap ↑f)) s |
Lean.Server.CodeActionResolveData.noConfusion | Lean.Server.CodeActions.Basic | {P : Sort u} →
{t t' : Lean.Server.CodeActionResolveData} → t = t' → Lean.Server.CodeActionResolveData.noConfusionType P t t' |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.State.mk | Lean.Elab.Structure | Array Lean.Elab.Command.Structure.StructParentInfo →
Array Lean.Elab.Command.Structure.StructFieldInfo →
Lean.NameMap ℕ → Lean.NameMap ℕ → Lean.FVarIdMap ℕ → Lean.Elab.Command.Structure.State✝ |
List.rdrop.eq_1 | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (l : List α) (n : ℕ), l.rdrop n = List.take (l.length - n) l |
CategoryTheory.Limits.MulticospanIndex.multicospan_map | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) {x y : CategoryTheory.Limits.WalkingMulticospan J} (f : x ⟶ y),
I.multicospan.map f =
match x, y, f with
| x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
CategoryTheory.CategoryStruct.id
(match x with
| CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
| CategoryTheory.Limits.WalkingMulticospan.right b => I.right b)
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.fst b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.fst b => I.fst b
| .(CategoryTheory.Limits.WalkingMulticospan.left (J.snd b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
CategoryTheory.Limits.WalkingMulticospan.Hom.snd b => I.snd b |
_private.Aesop.Forward.State.0.Aesop.VariableMap.modifyM.match_1 | Aesop.Forward.State | {α : Type u_1} →
(motive : Aesop.InstMap × α → Sort u_2) →
(__discr : Aesop.InstMap × α) → ((m : Aesop.InstMap) → (a : α) → motive (m, a)) → motive __discr |
Lean.Lsp.DocumentSymbolAux.children?._default | Lean.Data.Lsp.LanguageFeatures | {Self : Type} → Option (Array Self) |
UInt8.ofNat_eq_iff_mod_eq_toNat | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt8), UInt8.ofNat a = b ↔ a % 2 ^ 8 = b.toNat |
_private.Init.Data.List.Sort.Impl.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [a], x => h_2 a x
| a :: b :: xs, le => h_3 a b xs le) =
h_2 a x |
CategoryTheory.MorphismProperty.map_mem_map | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(P : CategoryTheory.MorphismProperty C) (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y),
P f → P.map F (F.map f) |
CategoryTheory.PreZeroHypercover.Hom._sizeOf_1 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{S : C} →
{E : CategoryTheory.PreZeroHypercover S} → {F : CategoryTheory.PreZeroHypercover S} → [SizeOf C] → E.Hom F → ℕ |
_private.Mathlib.Order.Monotone.Basic.0.not_monotone_not_antitone_iff_exists_lt_lt._simp_1_1 | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β},
(¬Monotone f ∧ ¬Antitone f) = ∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) |
TensorialAt.mkHom._proof_6 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {A : Type u_2} [inst_1 : AddCommGroup A] [inst_2 : Module 𝕜 A],
SMulCommClass 𝕜 𝕜 A |
Matroid.eRk_union_closure_right_eq | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X Y : Set α), M.eRk (X ∪ M.closure Y) = M.eRk (X ∪ Y) |
PolynomialLaw.mk | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_2} →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
(toFun' :
(S : Type u) →
[inst_5 : CommSemiring S] → [inst_6 : Algebra R S] → TensorProduct R S M → TensorProduct R S N) →
autoParam
(∀ {S : Type u} [inst_5 : CommSemiring S] [inst_6 : Algebra R S] {S' : Type u}
[inst_7 : CommSemiring S'] [inst_8 : Algebra R S'] (φ : S →ₐ[R] S'),
⇑(LinearMap.rTensor N φ.toLinearMap) ∘ toFun' S =
toFun' S' ∘ ⇑(LinearMap.rTensor M φ.toLinearMap))
PolynomialLaw.isCompat'._autoParam →
M →ₚₗ[R] N |
AlgebraicGeometry.StructureSheaf.const_algebraMap | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R A : Type u} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (f : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu : U ≤ PrimeSpectrum.basicOpen f),
AlgebraicGeometry.StructureSheaf.const ((algebraMap R A) f) f U hu = 1 |
CategoryTheory.enrichedNatTransYonedaTypeIsoYonedaNatTrans | Mathlib.CategoryTheory.Enriched.Basic | {C : Type v} →
[inst : CategoryTheory.EnrichedCategory (Type v) C] →
{D : Type v} →
[inst_1 : CategoryTheory.EnrichedCategory (Type v) D] →
(F G : CategoryTheory.EnrichedFunctor (Type v) C D) →
CategoryTheory.enrichedNatTransYoneda F G ≅
CategoryTheory.yoneda.obj
(CategoryTheory.enrichedFunctorTypeEquivFunctor F ⟶ CategoryTheory.enrichedFunctorTypeEquivFunctor G) |
_private.Init.Data.Array.Lemmas.0.Array.getElem?_size._simp_1_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), (n < n) = False |
Convex.lift | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : Module 𝕜 E] (R : Type u_5) [inst_5 : Semiring R] [inst_6 : PartialOrder R]
[inst_7 : Module R E] [inst_8 : Module R 𝕜] [IsScalarTower R 𝕜 E] [SMulPosMono R 𝕜] {s : Set E},
Convex 𝕜 s → Convex R s |
Std.Time.instReprOffsetO.repr | Std.Time.Format.Basic | Std.Time.OffsetO → ℕ → Std.Format |
Filter.EventuallyEq.of_eventually_mem_of_forall_separating_preimage | Mathlib.Order.Filter.CountableSeparatingOn | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop) {s : Set β}
[HasCountableSeparatingOn β p s],
(∀ᶠ (x : α) in l, f x ∈ s) → (∀ᶠ (x : α) in l, g x ∈ s) → (∀ (U : Set β), p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U) → f =ᶠ[l] g |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.simpJpCases?.visitJmp?.match_5 | Lean.Compiler.LCNF.Simp.JpCases | (motive : Option Lean.Compiler.LCNF.Simp.CtorInfo → Sort u_1) →
(__discr : Option Lean.Compiler.LCNF.Simp.CtorInfo) →
((ctorInfo : Lean.Compiler.LCNF.Simp.CtorInfo) → motive (some ctorInfo)) →
((x : Option Lean.Compiler.LCNF.Simp.CtorInfo) → motive x) → motive __discr |
_private.Mathlib.RingTheory.WittVector.FrobeniusFractionField.0.WittVector.frobeniusRotationCoeff.match_1.eq_2 | Mathlib.RingTheory.WittVector.FrobeniusFractionField | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n |
AmpleSet.vadd_iff | Mathlib.Analysis.Convex.AmpleSet | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [ContinuousAdd E]
{s : Set E} {y : E}, AmpleSet (y +ᵥ s) ↔ AmpleSet s |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.IsOpen.exists_iUnion_isClosed._simp_1_4 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
Set.Ioc.coe_sup._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeSup α] {a b : α} {x y : ↑(Set.Ioc a b)}, ↑x ⊔ ↑y = ↑(x ⊔ y) |
Std.LawfulBCmp.rec | Batteries.Classes.Order | {α : Type u_1} →
[inst : LE α] →
[inst_1 : LT α] →
[inst_2 : BEq α] →
{cmp : α → α → Ordering} →
{motive : Std.LawfulBCmp cmp → Sort u} →
([toTransCmp : Std.TransCmp cmp] →
[toLawfulBEqCmp : Std.LawfulBEqCmp cmp] →
(eq_lt_iff_lt : ∀ {x y : α}, cmp x y = Ordering.lt ↔ x < y) →
(isLE_iff_le : ∀ {x y : α}, (cmp x y).isLE = true ↔ x ≤ y) → motive ⋯) →
(t : Std.LawfulBCmp cmp) → motive t |
_private.Init.Data.String.PosRaw.0.String.Pos.Raw.offsetBy_unoffsetBy_of_le._simp_1_1 | Init.Data.String.PosRaw | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) |
CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(H : CategoryTheory.Functor C D) {F G : CategoryTheory.Functor J C} {α : F ≅ G} {c : CategoryTheory.Limits.Cone F}
(j : J),
(H.mapCone ((CategoryTheory.Limits.Cone.postcomposeEquivalence α).functor.obj c)).π.app j =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl (H.mapCone ((CategoryTheory.Limits.Cone.postcomposeEquivalence α).functor.obj c)).pt).hom
(((CategoryTheory.Limits.Cone.postcomposeEquivalence (CategoryTheory.Functor.isoWhiskerRight α H)).functor.obj
(H.mapCone c)).π.app
j) |
Filter.EventuallyEq.trans_le | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f g h : α → β}, f =ᶠ[l] g → g ≤ᶠ[l] h → f ≤ᶠ[l] h |
GromovHausdorff.premetricOptimalGHDist._proof_1 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ (X : Type u_1) (Y : Type u_2) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
[inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y] (x y : X ⊕ Y),
↑⟨(fun p q => (GromovHausdorff.optimalGHDist✝ X Y) (p, q)) x y, ⋯⟩ =
ENNReal.ofReal ((GromovHausdorff.optimalGHDist✝¹ X Y) (x, y)) |
CategoryTheory.MorphismProperty.LeftFraction.Localization.instIsIsoQinv | 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) (hs : W s),
CategoryTheory.IsIso (CategoryTheory.MorphismProperty.LeftFraction.Localization.Qinv s hs) |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.RingHom.rangeSRestrict_surjective.match_1_3 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S)
(motive : ↥f.rangeS → Prop) (x : ↥f.rangeS), (∀ (val : S) (hy : val ∈ f.rangeS), motive ⟨val, hy⟩) → motive x |
RingHom.inverse._proof_6 | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S → R)
(h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f), (↑((↑f).inverse g h₁ h₂)).toFun 0 = 0 |
IO.FS.Mode.append | Init.System.IO | IO.FS.Mode |
Int.sub_one_lt_of_le | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → a - 1 < b |
CategoryTheory.categoryOfElements._proof_8 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1))
{W X Y Z : F.Elements} (f : { f // F.map f W.snd = X.snd }) (g : { f // F.map f X.snd = Y.snd })
(h : { f // F.map f Y.snd = Z.snd }),
⟨CategoryTheory.CategoryStruct.comp ↑⟨CategoryTheory.CategoryStruct.comp ↑f ↑g, ⋯⟩ ↑h, ⋯⟩ =
⟨CategoryTheory.CategoryStruct.comp ↑f ↑⟨CategoryTheory.CategoryStruct.comp ↑g ↑h, ⋯⟩, ⋯⟩ |
Lean.LibrarySuggestions.localSymbolFrequency | Lean.LibrarySuggestions.SymbolFrequency | Lean.Name → Lean.MetaM ℕ |
Lean.Elab.DefView._sizeOf_inst | Lean.Elab.DefView | SizeOf Lean.Elab.DefView |
Lean.Syntax.node2 | Init.Prelude | Lean.SourceInfo → Lean.SyntaxNodeKind → Lean.Syntax → Lean.Syntax → Lean.Syntax |
LowerSet.instOne | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} → [CommGroup α] → [inst : Preorder α] → One (LowerSet α) |
Std.DHashMap.Raw.Const.find?_toList_eq_none_iff_not_mem._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {k : α}, (List.find? (fun x => x.1 == k) (Std.DHashMap.Raw.Const.toList m) = none) = (k ∉ m) |
CategoryTheory.Adjunction.IsTriangulated.mk'' | Mathlib.CategoryTheory.Triangulated.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.Limits.HasZeroObject D] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : CategoryTheory.Preadditive D] [inst_6 : CategoryTheory.HasShift C ℤ] [inst_7 : CategoryTheory.HasShift D ℤ]
[inst_8 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_9 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor D n).Additive] [inst_10 : CategoryTheory.Pretriangulated C]
[inst_11 : CategoryTheory.Pretriangulated D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) [inst_12 : F.CommShift ℤ] [inst_13 : G.CommShift ℤ] [adj.CommShift ℤ] [G.IsTriangulated],
adj.IsTriangulated |
ZMod.prodEquivPi | Mathlib.Data.ZMod.QuotientRing | {ι : Type u_3} →
[inst : Fintype ι] →
(a : ι → ℕ) → Pairwise (Function.onFun Nat.Coprime a) → ZMod (∏ i, a i) ≃+* ((i : ι) → ZMod (a i)) |
Complex.cos | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ |
Filter.bliminf_not_inf | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteDistribLattice α] {f : Filter β} {p : β → Prop} {u : β → α},
(Filter.bliminf u f fun x => ¬p x) ⊓ Filter.bliminf u f p = Filter.liminf u f |
Std.DHashMap.Raw.get!_diff | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α],
m₁.WF → m₂.WF → ∀ {k : α} [inst_3 : Inhabited (β k)], (m₁ \ m₂).get! k = if k ∈ m₂ then default else m₁.get! k |
CliffordAlgebra.foldr'._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Fold | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticForm R M), SMulCommClass R R (CliffordAlgebra Q × N) |
Finsupp.embDomain.addMonoidHom._proof_1 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_3} {F : Type u_1} {M : Type u_2} [inst : AddZeroClass M] (f : ι ↪ F), Finsupp.embDomain f 0 = 0 |
RingQuot.ringQuot_ext' | Mathlib.Algebra.RingQuot | ∀ (S : Type uS) [inst : CommSemiring S] {A : Type uA} [inst_1 : Semiring A] [inst_2 : Algebra S A] {B : Type u₄}
[inst_3 : Semiring B] [inst_4 : Algebra S B] {s : A → A → Prop} (f g : RingQuot s →ₐ[S] B),
f.comp (RingQuot.mkAlgHom S s) = g.comp (RingQuot.mkAlgHom S s) → f = g |
Mathlib.Meta.FunProp.instBEqTheoremForm | Mathlib.Tactic.FunProp.Theorems | BEq Mathlib.Meta.FunProp.TheoremForm |
String.empty_ne_singleton | Init.Data.String.Lemmas.Basic | ∀ {c : Char}, "" ≠ String.singleton c |
Ideal.absNorm_dvd_absNorm_of_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : Nontrivial S] [inst_2 : IsDedekindDomain S] [inst_3 : Module.Free ℤ S]
{I J : Ideal S}, J ≤ I → Ideal.absNorm I ∣ Ideal.absNorm J |
MeasureTheory.measure_symmDiff_eq_zero_iff._simp_1 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, (μ (symmDiff s t) = 0) = (s =ᵐ[μ] t) |
Mathlib.Meta.FunProp.instInhabitedConfig.default | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Config |
AlgHom.IsArithFrobAt.isArithFrobAt_localize | Mathlib.RingTheory.Frobenius | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {φ : S →ₐ[R] S}
{Q : Ideal S} (H : φ.IsArithFrobAt Q) [inst_3 : Q.IsPrime],
H.localize.IsArithFrobAt (IsLocalRing.maximalIdeal (Localization.AtPrime Q)) |
Lean.Linter.isDeprecated | Lean.Linter.Deprecated | Lean.Environment → Lean.Name → Bool |
IsLocalization.orderIsoOfPrime | Mathlib.RingTheory.Localization.Ideal | {R : Type u_1} →
[inst : CommSemiring R] →
(M : Submonoid R) →
(S : Type u_2) →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] → [IsLocalization M S] → { p // p.IsPrime } ≃o { p // p.IsPrime ∧ Disjoint ↑M ↑p } |
Subrepresentation.instLattice._proof_2 | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : CommRing A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} {x y : Subrepresentation ρ},
x.toSubmodule < y.toSubmodule ↔ x.toSubmodule < y.toSubmodule |
Aesop.Frontend.BuilderOption.pattern.noConfusion | Aesop.Frontend.RuleExpr | {P : Sort u} →
{stx stx' : Lean.Term} →
Aesop.Frontend.BuilderOption.pattern stx = Aesop.Frontend.BuilderOption.pattern stx' → (stx = stx' → P) → P |
Ordinal.opow_lt_opow_left_of_succ | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b c : Ordinal.{u_1}}, a < b → a ^ Order.succ c < b ^ Order.succ c |
ContinuousAffineMap.ext_iff | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] {f g : P →ᴬ[R] Q},
f = g ↔ ∀ (x : P), f x = g x |
Aesop.RulePatternIndex.getCore | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.noConfusion | Mathlib.Tactic.Translate.UnfoldBoundary | {P : Sort u} →
{t t' : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries} →
t = t' → Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.noConfusionType P t t' |
Turing.TM1to0.tr.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} [inst : Inhabited Λ] {σ : Type u_3} [inst_1 : Inhabited σ]
(M : Λ → Turing.TM1.Stmt Γ Λ σ) (x : Γ) (q : Turing.TM1.Stmt Γ Λ σ) (v : σ),
Turing.TM1to0.tr M (some q, v) x = some (Turing.TM1to0.trAux M x q v) |
CategoryTheory.Functor.CoconeTypes.precompose_ι | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} (c : F.CoconeTypes)
{G : CategoryTheory.Functor J (Type w₀')} (app : (j : J) → G.obj j → F.obj j)
(naturality : ∀ {j j' : J} (f : j ⟶ j'), app j' ∘ G.map f = F.map f ∘ app j),
(c.precompose app naturality).ι = fun j => c.ι j ∘ app j |
MagmaCat.of.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ (M : Type u) [inst : Mul M], MagmaCat.of M = { carrier := M, str := inst } |
LipschitzWith.mul_edist_le | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x y : α), (↑K)⁻¹ * edist (f x) (f y) ≤ edist x y |
Path.Homotopic.hpath_hext | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} {p₁ : Path x₀ x₁} {p₂ : Path x₂ x₃},
(∀ (t : ↑unitInterval), p₁ t = p₂ t) → ⟦p₁⟧ ≍ ⟦p₂⟧ |
MeasureTheory.Measure.Regular.smul | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular]
{x : ENNReal}, x ≠ ⊤ → (x • μ).Regular |
PiTensorProduct.tprodMonoidHom._proof_1 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_2) {A : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → NonAssocSemiring (A i)]
[inst_2 : (i : ι) → Module R (A i)], (PiTensorProduct.tprod R) 1 = (PiTensorProduct.tprod R) 1 |
CochainComplex.mkHom_f_succ_succ | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(P Q : CochainComplex V ℕ) (zero : P.X 0 ⟶ Q.X 0) (one : P.X 1 ⟶ Q.X 1)
(one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one)
(succ :
(n : ℕ) →
(p :
(f : P.X n ⟶ Q.X n) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') →
(f'' : P.X (n + 2) ⟶ Q.X (n + 2)) ×'
CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'')
(n : ℕ),
(P.mkHom Q zero one one_zero_comm succ).f (n + 2) =
(succ n ⟨(P.mkHom Q zero one one_zero_comm succ).f n, ⟨(P.mkHom Q zero one one_zero_comm succ).f (n + 1), ⋯⟩⟩).fst |
Lean.Doc.DocHighlight.const.elim | Lean.Elab.DocString.Builtin | {motive : Lean.Doc.DocHighlight → Sort u} →
(t : Lean.Doc.DocHighlight) →
t.ctorIdx = 0 →
((name : Lean.Name) → (signature : Std.Format) → motive (Lean.Doc.DocHighlight.const name signature)) → motive t |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.isContained_iff_exists_iso_subgraph.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_1} {β : Type u_2} {A : SimpleGraph α} {B : SimpleGraph β} (motive : A.IsContained B → Prop)
(x : A.IsContained B), (∀ (f : A.Copy B), motive ⋯) → motive x |
CategoryTheory.ChosenPullbacksAlong.ofHasPullbacksAlong | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y X : C} → (f : Y ⟶ X) → [CategoryTheory.Limits.HasPullbacksAlong f] → CategoryTheory.ChosenPullbacksAlong f |
NumberField.RingOfIntegers.coe_mk | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {x : K} (hx : x ∈ integralClosure ℤ K), ↑⟨x, hx⟩ = x |
IsLocalizedModule.instIsTorsionFreeLocalizationLocalizedModuleOfIsDomain | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [IsDomain R]
(S : Submonoid R) [Module.IsTorsionFree R M], Module.IsTorsionFree (Localization S) (LocalizedModule S M) |
WeierstrassCurve.ΨSq_two | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R), W.ΨSq 2 = W.Ψ₂Sq |
Filter.map_eq_comap_of_inverse | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {n : β → α},
m ∘ n = id → n ∘ m = id → Filter.map m f = Filter.comap n f |
MeasureTheory.OuterMeasure.instSMul._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_2} {R : Type u_1} [inst : SMul R ENNReal] [IsScalarTower R ENNReal ENNReal] (c : R)
(m : MeasureTheory.OuterMeasure α), c • m ∅ = 0 |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.unwantedUnicode.inj | Mathlib.Tactic.Linter.TextBased | ∀ {c c_1 : Char},
Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c = Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝¹ c_1 →
c = c_1 |
Matrix.addMonoidHomMulLeft | Mathlib.Data.Matrix.Mul | {l : Type u_1} →
{m : Type u_2} →
{n : Type u_3} →
{α : Type v} → [inst : NonUnitalNonAssocSemiring α] → [Fintype m] → Matrix l m α → Matrix m n α →+ Matrix l n α |
Array.range'_eq_append_iff | Init.Data.Array.Range | ∀ {s n : ℕ} {xs ys : Array ℕ},
Array.range' s n = xs ++ ys ↔ ∃ k ≤ n, xs = Array.range' s k ∧ ys = Array.range' (s + k) (n - k) |
Multiset.cons_product | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (a : α) (s : Multiset α) (t : Multiset β),
(a ::ₘ s) ×ˢ t = Multiset.map (Prod.mk a) t + s ×ˢ t |
LinearMap.BilinForm.tensorDistrib._proof_3 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_2) (A : Type u_1) {M₁ : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : Algebra R A] [inst_4 : Module A M₁], SMulCommClass A R (M₁ →ₗ[A] A) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.