name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
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 | true |
_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) | false |
Lean.Meta.CaseArraySizesSubgoal | Lean.Meta.Match.CaseArraySizes | Type | true |
_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 | false |
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 : IsSc... | false |
Batteries.BinomialHeap.Imp.HeapNode.rankTR.go | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} → Batteries.BinomialHeap.Imp.HeapNode α → ℕ → ℕ | true |
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 φ ⋯ | true |
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 (Oppo... | false |
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 | true |
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' | false |
_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✝ | true |
List.rdrop.eq_1 | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (l : List α) (n : ℕ), l.rdrop n = List.take (l.length - n) l | true |
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.... | true |
_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 | false |
Lean.Lsp.DocumentSymbolAux.children?._default | Lean.Data.Lsp.LanguageFeatures | {Self : Type} → Option (Array Self) | false |
UInt8.ofNat_eq_iff_mod_eq_toNat | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt8), UInt8.ofNat a = b ↔ a % 2 ^ 8 = b.toNat | true |
_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
| [... | true |
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) | true |
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 → ℕ | false |
_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) | false |
TensorialAt.mkHom._proof_6 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | false |
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) | true |
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) →
... | true |
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 | true |
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
... | true |
_private.Init.Data.Array.Lemmas.0.Array.getElem?_size._simp_1_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), (n < n) = False | 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},
... | true |
Std.Time.instReprOffsetO.repr | Std.Time.Format.Basic | Std.Time.OffsetO → ℕ → Std.Format | true |
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 | true |
_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 | false |
_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 | true |
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 | true |
_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 | false |
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) | false |
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 : α}, ... | false |
_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) | false |
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),
... | false |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.meromorphicOrderAt_canonicalFactor._proof_1_1 | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {R : ℝ} {w : ℂ}, ‖w‖ < R → ¬R = ‖w‖ | false |
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 | true |
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... | false |
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) | true |
_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 | false |
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 | false |
IO.FS.Mode.append | Init.System.IO | IO.FS.Mode | true |
Int.sub_one_lt_of_le | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → a - 1 < b | true |
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 ↑... | false |
Lean.LibrarySuggestions.localSymbolFrequency | Lean.LibrarySuggestions.SymbolFrequency | Lean.Name → Lean.MetaM ℕ | true |
Lean.Elab.DefView._sizeOf_inst | Lean.Elab.DefView | SizeOf Lean.Elab.DefView | false |
Lean.Syntax.node2 | Init.Prelude | Lean.SourceInfo → Lean.SyntaxNodeKind → Lean.Syntax → Lean.Syntax → Lean.Syntax | true |
LowerSet.instOne | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} → [CommGroup α] → [inst : Preorder α] → One (LowerSet α) | true |
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) | false |
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 : ... | true |
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)) | true |
Complex.cos | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | true |
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 | true |
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 | true |
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) | false |
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 | false |
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 | true |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.firstExpr?.match_3 | Mathlib.Lean.MessageData.ForExprs | (motive : Lean.PPContext × Lean.Expr → Sort u_1) →
(x : Lean.PPContext × Lean.Expr) → ((ppCtx : Lean.PPContext) → (e : Lean.Expr) → motive (ppCtx, e)) → motive x | false |
Mathlib.Meta.FunProp.instBEqTheoremForm | Mathlib.Tactic.FunProp.Theorems | BEq Mathlib.Meta.FunProp.TheoremForm | true |
String.empty_ne_singleton | Init.Data.String.Lemmas.Basic | ∀ {c : Char}, "" ≠ String.singleton c | true |
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 | true |
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) | false |
Mathlib.Meta.FunProp.instInhabitedConfig.default | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Config | true |
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)) | true |
Lean.Linter.isDeprecated | Lean.Linter.Deprecated | Lean.Environment → Lean.Name → Bool | true |
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 } | true |
Subrepresentation.instLattice._proof_2 | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring 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 | false |
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 | false |
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 | true |
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}... | true |
Aesop.RulePatternIndex.getCore | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) | true |
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' | false |
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) | true |
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 ... | true |
MagmaCat.of.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ (M : Type u) [inst : Mul M], MagmaCat.of M = { carrier := M, str := inst } | true |
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 | true |
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₂⟧ | true |
MeasureTheory.Measure.Regular.smul | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular]
{x : ENNReal}, x ≠ ⊤ → (x • μ).Regular | true |
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 | false |
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... | true |
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 | false |
_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 | false |
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 | true |
NumberField.RingOfIntegers.coe_mk | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {x : K} (hx : x ∈ integralClosure ℤ K), ↑⟨x, hx⟩ = x | true |
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) | true |
WeierstrassCurve.ΨSq_two | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R), W.ΨSq 2 = W.Ψ₂Sq | true |
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 | true |
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 | false |
_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 | true |
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 α | true |
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) | true |
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 | true |
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) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Util.0.Int.Linear.Poly.pp.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | (motive : Int.Linear.Poly → Sort u_1) →
(p : Int.Linear.Poly) →
((k : ℤ) → motive (Int.Linear.Poly.num k)) →
((x : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add 1 x p)) →
((k : ℤ) → (x : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.add k x p)) → motive p | false |
IsLocalRing.map_mkQ_eq | Mathlib.RingTheory.LocalRing.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] {N₁ N₂ : Submodule R M},
N₁ ≤ N₂ →
N₂.FG →
(Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₁ = Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₂ ↔
N₁ = N₂) | true |
CategoryTheory.ShiftedHom.id_map | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y : C} {a : M} (f : CategoryTheory.ShiftedHom X Y a),
f.map (CategoryTheory.Functor.id C) = f | true |
CategoryTheory.GrothendieckTopology.le_canonical | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) [J.Subcanonical],
J ≤ CategoryTheory.Sheaf.canonicalTopology C | true |
Algebra.Extension.Hom.algebraMap_toRingHom | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R' S']
{P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S'] (self : P.Hom... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.