name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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) | null | 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) →
... | null | true |
BitVec.ofFin_le | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x : Fin (2 ^ n)} {y : BitVec n}, { toFin := x } ≤ y ↔ x ≤ y.toFin | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.denselyOrdered_iff_denselyOrdered_units_and_nontrivial_units._simp_1_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | null | false |
ContinuousAffineMap.noConfusion | Mathlib.Topology.Algebra.ContinuousAffineMap | {P : Sort u} →
{R : Type u_1} →
{V : Type u_2} →
{W : Type u_3} →
{P_1 : Type u_4} →
{Q : Type u_5} →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P_1} →
{ins... | null | false |
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 | null | true |
FirstOrder.Language.Equiv.coe_toElementaryEmbedding | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Equiv M N), ⇑f.toElementaryEmbedding = ⇑f | null | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Graded.External.0.TensorProduct.term𝒜ℬ | Mathlib.LinearAlgebra.TensorProduct.Graded.External | Lean.ParserDescr | null | true |
Lean.Elab.Tactic.evalSym | Lean.Elab.Tactic.Grind.Main | Lean.Elab.Tactic.Tactic | null | 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
... | We verify that the presheaf representing natural transformations
between `Type v`-enriched functors is actually represented by
the usual type of natural transformations!
| true |
Nat.pairEquiv_symm_apply | Mathlib.Data.Nat.Pairing | ⇑Nat.pairEquiv.symm = Nat.unpair | null | true |
_private.Init.Data.Array.Lemmas.0.Array.getElem?_size._simp_1_1 | Init.Data.Array.Lemmas | ∀ (n : ℕ), (n < n) = False | null | 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},
... | Lift the convexity of a set up through a scalar tower. | true |
Std.Time.instReprOffsetO.repr | Std.Time.Format.Basic | Std.Time.OffsetO → ℕ → Std.Format | null | true |
CategoryTheory.Functor.mapHomologicalComplex._proof_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_5} {W₁ : Type u_4} {W₂ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} W₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (F : CategoryTheory.Functor W₁ W₂) [F.PreservesZeroMorphisms]
(... | null | false |
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 | null | true |
_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 | null | 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 | A set is ample iff its affine translation is. | 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 | null | false |
Lean.Meta.hcongrThmSuffixBase | Lean.Meta.CongrTheorems | String | null | true |
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) | null | 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 : α}, ... | null | 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) | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.matchExpr._regBuiltin.Lean.Parser.Term.matchExpr_1 | Lean.Parser.Term | IO Unit | null | false |
Lean.IR.Alt.ctorElim | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
(ctorIdx : ℕ) → (t : Lean.IR.Alt) → ctorIdx = t.ctorIdx → Lean.IR.Alt.ctorElimType ctorIdx → motive_1 t | null | false |
Std.Time.WallTime.instHSubOffset_2 | Std.Time.DateTime.WallTime | HSub Std.Time.WallTime Std.Time.Hour.Offset Std.Time.WallTime | null | true |
ProbabilityTheory.mgf_zero_fun | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {t : ℝ},
ProbabilityTheory.mgf 0 μ t = μ.real Set.univ | null | true |
Lean.Meta.Grind.Arith.CommRing.State.reportedMaxDegreeIssue._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Bool | null | false |
denseRange_stoneCechUnit | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} [inst : TopologicalSpace α], DenseRange stoneCechUnit | The image of `stoneCechUnit` is dense. (But `stoneCechUnit` need
not be an embedding, for example if the original space is not Hausdorff.) | true |
Function.instIsStrictWeakOrderOnFun | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (r : β → β → Prop) (f : α → β) [IsStrictWeakOrder β r],
IsStrictWeakOrder α (Function.onFun r f) | null | true |
CategoryTheory.Limits.widePullback.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C)
(arrows arrows_1 : (j : J) → objs j ⟶ B) (e_arrows : arrows = arrows_1)
[inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows],
CategoryTheory.Limits.widePullback B objs arrows = CategoryTheory.Limits.widePullback... | null | true |
Lean.Parser.Attr.class.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer | null | true |
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),
... | null | false |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.meromorphicOrderAt_canonicalFactor._proof_1_1 | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {R : ℝ} {w : ℂ}, ‖w‖ < R → ¬R = ‖w‖ | null | false |
_private.Mathlib.LinearAlgebra.Span.Basic.0.Submodule.biSup_comap_subtype_eq_top.match_1_1 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_3}
(s : Set ι) (p : ι → Submodule R M) (motive : (x : ↥(⨆ i ∈ s, p i)) → x ∈ ⊤ → Prop) (x : ↥(⨆ i ∈ s, p i))
(x_1 : x ∈ ⊤), (∀ (x : M) (hx : x ∈ ⨆ i ∈ s, p i) (x_2 : ⟨x, hx⟩ ∈ ⊤), motive ⟨x, hx⟩ x_2) → m... | null | 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 | null | 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),
↑(NNReal.mk ((fun p q => (GromovHausdorff.optimalGHDist✝ X Y) (p, q)) x y) ⋯) =
ENNReal.ofReal ((GromovHausdorff.optimalG... | null | 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) | null | true |
CategoryTheory.Functor.Initial.extendCone_obj_pt | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [inst_2 : F.Initial] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cone (F.comp G)),
(C... | null | 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 | null | false |
IsLocalRing.ResidueField.instMulSemiringAction | Mathlib.RingTheory.LocalRing.ResidueField.Basic | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : IsLocalRing R] →
(G : Type u_4) → [inst_2 : Group G] → [MulSemiringAction G R] → MulSemiringAction G (IsLocalRing.ResidueField R) | If `G` acts on `R` as a `MulSemiringAction`, then it also acts on `IsLocalRing.ResidueField R`.
| true |
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 | null | false |
LinearMap.isUnit_toMatrix_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_4} [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M₁ : Type u_5}
[inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] (v₁ : Module.Basis n R M₁) {f : M₁ →ₗ[R] M₁},
IsUnit ((LinearMap.toMatrix v₁ v₁) f) = IsUnit f | null | false |
FinPartOrd.id_apply | Mathlib.Order.Category.FinPartOrd | ∀ (X : FinPartOrd) (x : ↑X.toPartOrd), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x | null | true |
IO.FS.Mode.append | Init.System.IO | IO.FS.Mode | The file should be opened for writing.
If the file does not already exist, it is created. If the file already exists, it is opened, and
the read/write cursor is positioned at the end of the file.
* `open` flags: `O_WRONLY | O_CREAT | O_APPEND`
* `fdopen` mode: `a`
| true |
Int.sub_one_lt_of_le | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → a - 1 < b | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0.Lean.Meta.Grind.Arith.isNormNatNum | Lean.Meta.Tactic.Grind.Arith.Simproc | Lean.Expr → Lean.Expr → Lean.Expr → Bool | Returns `true`, if `@OfNat.ofNat α n inst` is the standard way we represent `Nat` numerals in Lean.
| 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 // (CategoryTheory.ConcreteCategory.hom (F.map f)) W.snd = X.snd })
(g : { f // (CategoryTheory.ConcreteCategory.hom (F.map f)) X.snd = Y.snd })
(h : { f // (CategoryTheory.Conc... | null | false |
tendsto_nhds_unique_of_eventuallyEq | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T2Space X] {f g : Y → X} {l : Filter Y} {a b : X}
[l.NeBot], Filter.Tendsto f l (nhds a) → Filter.Tendsto g l (nhds b) → f =ᶠ[l] g → a = b | null | true |
Lean.LibrarySuggestions.localSymbolFrequency | Lean.LibrarySuggestions.SymbolFrequency | Lean.Name → Lean.MetaM ℕ | Return the number of times a `Name` appears
in the signatures of (non-internal) theorems in the current module,
skipping instance arguments and proofs.
Note that this is cached, and so returns the frequency within theorems that had been elaborated
when the function is first called (with any argument).
| true |
Lean.Elab.DefView._sizeOf_inst | Lean.Elab.DefView | SizeOf Lean.Elab.DefView | null | false |
CategoryTheory.Idempotents.Karoubi.decomposition._proof_2 | Mathlib.CategoryTheory.Idempotents.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift P.decompId_p P.complement.decompId_p)
(CategoryTheory.Limits.biprod.desc P.decompId_i P.compl... | null | false |
Lean.Syntax.node2 | Init.Prelude | Lean.SourceInfo → Lean.SyntaxNodeKind → Lean.Syntax → Lean.Syntax → Lean.Syntax | Create syntax node with 2 children | true |
LowerSet.instOne | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} → [CommGroup α] → [inst : Preorder α] → One (LowerSet α) | null | 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) | null | false |
CategoryTheory.Iso.inv_ext._to_dual_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : X ⟶ Y},
CategoryTheory.CategoryStruct.comp g f.inv = CategoryTheory.CategoryStruct.id X → f.hom = g | null | 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 : ... | Constructor for `Adjunction.IsTriangulated`.
| 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)) | The **Chinese remainder theorem**, elementary version for `ZMod`. See also
`Mathlib/Data/ZMod/Basic.lean` for versions involving only two numbers. | true |
sdiff_sdiff_sup_sdiff' | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], z \ (x \ y ⊔ y \ x) = z ⊓ x ⊓ y ⊔ z \ x ⊓ z \ y | null | true |
RingHom.smulOneHom | Mathlib.Algebra.Module.RingHom | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] → [inst_1 : NonAssocSemiring S] → [inst_2 : Module R S] → [IsScalarTower R S S] → R →+* S | If the module action of `R` on `S` is compatible with multiplication on `S`, then
`fun x ↦ x • 1` is a ring homomorphism from `R` to `S`.
This is the `RingHom` version of `MonoidHom.smulOneHom`.
When `R` is commutative, usually `algebraMap` should be preferred. | true |
CategoryTheory.SimplicialObject.equivalenceLeftToRight | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] →
(X : CategoryTheory.SimplicialObject.Augmented C) →
(F : CategoryTheory.Arrow C) →
... | A helper function used in defining the Čech adjunction. | true |
Complex.cos | Mathlib.Analysis.Complex.Trigonometric | ℂ → ℂ | The complex cosine function, defined via `exp` | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Combination.0.Finset.sum_affineCombinationLineMapWeights._simp_1_4 | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i | null | false |
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 | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.DerivIntegrable.0.MonotoneOn.exists_tendsto_deriv_liminf_lintegral_enorm_le._proof_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.DerivIntegrable | ∀ {f : ℝ → ℝ} {a b : ℝ},
a ≤ b →
ENNReal.ofReal ((fun x => f (max a (min x b))) b - (fun x => f (max a (min x b))) a) = ENNReal.ofReal (f b - f a) | null | false |
AffineSubspace.mem_perpBisector_iff_dist_eq' | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P}, c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ dist p₁ c = dist p₂ c | null | 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 | null | 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) | null | 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 | null | 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 | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._simp_6 | Init.Data.String.Pattern.String | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
_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 | null | false |
String.length_ofList | Init.Data.String.Length | ∀ {l : List Char}, (String.ofList l).length = l.length | null | true |
Mathlib.Meta.FunProp.instBEqTheoremForm | Mathlib.Tactic.FunProp.Theorems | BEq Mathlib.Meta.FunProp.TheoremForm | null | true |
String.empty_ne_singleton | Init.Data.String.Lemmas.Basic | ∀ {c : Char}, "" ≠ String.singleton c | null | true |
Ideal.absNorm_dvd_absNorm_of_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : IsDedekindDomain S] [inst_2 : Module.Free ℤ S] {I J : Ideal S},
J ≤ I → Ideal.absNorm I ∣ Ideal.absNorm J | null | 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) | null | false |
Mathlib.Meta.FunProp.instInhabitedConfig.default | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Config | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.recOn | Lean.Util.ParamMinimizer | {m : Type → Type} →
{motive : Lean.Util.ParamMinimizer.Context✝ m → Sort u} →
(t : Lean.Util.ParamMinimizer.Context✝ m) →
((initialMask : Array Bool) →
(test : Array Bool → m Bool) →
(maxCalls : ℕ) → motive { initialMask := initialMask, test := test, maxCalls := maxCalls }) →
m... | null | false |
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)) | null | true |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.instIsDiscreteValuationRingSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._simp_5 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
Lean.Linter.isDeprecated | Lean.Linter.Deprecated | Lean.Environment → Lean.Name → Bool | null | 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 } | If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M` | 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 | null | false |
AddSubsemigroup.instSetLike.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M], AddSubsemigroup.instSetLike = { coe := AddSubsemigroup.carrier, coe_injective := ⋯ } | null | true |
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 | null | false |
Lean.Elab.Structural.IndGroupInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → ℕ | null | 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 | null | true |
NumberField.instCommRingInfiniteAdeleRing._proof_11 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | ∀ (K : Type u_1) [inst : Field K],
autoParam
(∀ (n : ℕ) (x : NumberField.InfiniteAdeleRing K),
NumberField.instCommRingInfiniteAdeleRing._aux_8 K (n + 1) x =
NumberField.instCommRingInfiniteAdeleRing._aux_8 K n x + x)
AddMonoid.nsmul_succ._autoParam | null | false |
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}... | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Bounds.0.BddAbove.range_comp_of_nonneg._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Bounds | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
Lean.Server.StatefulRequestHandler.mk | Lean.Server.Requests | (Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)) →
(Lean.Lsp.DidChangeTextDocumentParams → StateT Dy... | null | true |
Aesop.RulePatternIndex.getCore | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) | Get all substitutions of the rule patterns that match a subexpression of
`e`. Subexpressions containing bound variables are not considered. The returned
array may contain duplicates. | true |
NormedAddGroupHom.Equalizer.liftEquiv._proof_4 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_3} {V₁ : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W},
Function.RightInverse (fun ψ => ⟨(NormedAddGroupHom.Equalizer.ι f g).comp ψ, ⋯⟩) fun φ =>
NormedAddGroupHom.Equalizer.lift ↑φ ... | null | false |
ULift.divisionRing._proof_1 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : DivisionRing α] (a b : ULift.{u_1, u_2} α), a / b = a * b⁻¹ | null | false |
Std.DTreeMap.Internal.Impl.find?_toArray_eq_some_iff_get?_eq_some | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] {k : α} {v : β k},
t.WF → (Array.find? (fun x => compare x.fst k == Ordering.eq) t.toArray = some ⟨k, v⟩ ↔ t.get? k = some v) | null | 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' | null | false |
Batteries.AssocList.replace._f | Batteries.Data.AssocList | {α : Type u_1} →
{β : Type u_2} →
[BEq α] → α → β → (x : Batteries.AssocList α β) → Batteries.AssocList.below x → Batteries.AssocList α β | null | 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) | null | true |
CategoryTheory.Limits.PushoutCocone.inl | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} → {f : X ⟶ Y} → {g : X ⟶ Z} → (t : CategoryTheory.Limits.PushoutCocone f g) → Y ⟶ t.pt | The first inclusion of a pushout cocone. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.