name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
dvd_lcm_left | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] (a b : α), a ∣ lcm a b | null | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go._unary.eq_def | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (_x : (_ : List α) ×' (_ : List α) ×' List α),
List.MergeSort.Internal.mergeTR.go._unary✝ le _x =
PSigma.casesOn _x fun a a_1 =>
PSigma.casesOn a_1 fun a_2 a_3 =>
match a, a_2, a_3 with
| [], l₂, acc => acc.reverseAux l₂
| l₁, [], acc => acc.rever... | null | false |
CategoryTheory.Limits.IsColimit.hom_desc._proof_2 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cocone F}
{W : C} (m : t.pt ⟶ W) ⦃X Y : J⦄ (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (... | null | false |
Lean.Meta.Simp.Arith.Nat.ToLinear.run | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | {α : Type} → Lean.Meta.Simp.Arith.Nat.ToLinear.M α → Lean.MetaM (α × Array Lean.Expr) | null | true |
Std.ExtTreeSet.isEmpty_eq_size_beq_zero | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp}, t.isEmpty = (t.size == 0) | null | true |
Function.Injective.commGroupWithZero | Mathlib.Algebra.GroupWithZero.InjSurj | {G₀ : Type u_2} →
{G₀' : Type u_4} →
[inst : CommGroupWithZero G₀] →
[inst_1 : Zero G₀'] →
[inst_2 : Mul G₀'] →
[inst_3 : One G₀'] →
[inst_4 : Inv G₀'] →
[inst_5 : Div G₀'] →
[inst_6 : Pow G₀' ℕ] →
[inst_7 : Pow G₀' ℤ] →
... | Pull back a `CommGroupWithZero` along an injective function.
See note [reducible non-instances]. | true |
_private.Mathlib.RingTheory.MvPolynomial.Groebner.0.MonomialOrder.degree_sub_LTerm_lt._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Groebner | ∀ {F : Sort u_1} {α : Sort u_2} {β : Sort u_3} [inst : FunLike F α β] [i : EmbeddingLike F α β] (f : F) {x y : α},
(f x = f y) = (x = y) | null | false |
Inclusion.Coarsen.casesOn | Mathlib.Tactic.Inclusion.Core.ToSet | {Iα : Type u_1} →
{α : Type u_2} →
[inst : Inclusion.ToSet Iα α] →
{motive : Inclusion.Coarsen Iα α → Sort u} →
(t : Inclusion.Coarsen Iα α) →
((coarsen : Iα → Iα → Iα) →
(mem_coarsen_left : ∀ {x : α} {s t : Iα}, x ∈ s → x ∈ coarsen s t) →
(mem_coarsen_right :... | null | false |
_private.Lean.Meta.Tactic.Grind.Cases.0.Lean.Meta.Grind.cases.throwInductiveExpected | Lean.Meta.Tactic.Grind.Cases | Lean.MVarId → Lean.Expr → {α : Type} → Lean.Expr → Lean.MetaM α | null | true |
measurable_piEquivPiSubtypeProd | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {δ : Type u_4} (X : δ → Type u_6) [inst : (a : δ) → MeasurableSpace (X a)] (p : δ → Prop) [inst_1 : DecidablePred p],
Measurable ⇑(Equiv.piEquivPiSubtypeProd p X) | null | true |
Bool.and_eq_false_imp | Init.Data.Bool | ∀ {x y : Bool}, (x && y) = false ↔ x = true → y = false | null | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Datatypes.0.Mathlib.Tactic.BicategoryLike.mkContext.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {ρ : Type} →
(motive : Option ρ → Sort u_1) →
(__do_lift : Option ρ) → ((c : ρ) → motive (some c)) → (Unit → motive none) → motive __do_lift | null | false |
ContinuousAffineEquiv.pointReflection_involutive | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁] [inst_5 : TopologicalSpace V₁]
[inst_6 : IsTopologicalAddTorsor P₁] (x : P₁), Function.Involutive ⇑(ContinuousAffineEquiv.pointReflection k x) | null | true |
Std.Http.Method.checkin.elim | Std.Http.Data.Method | {motive : Std.Http.Method → Sort u} → (t : Std.Http.Method) → t.ctorIdx = 3 → motive Std.Http.Method.checkin → motive t | null | false |
lp.instAlgebraSubtypePreLpMemAddSubgroupTopENNReal._proof_3 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_3} {I : Type u_1} {B : I → Type u_2} [inst : NormedField 𝕜] [inst_1 : (i : I) → NormedRing (B i)]
[inst_2 : (i : I) → NormedAlgebra 𝕜 (B i)] [inst_3 : ∀ (i : I), NormOneClass (B i)] (r : 𝕜) (x : ↥(lp B ⊤)),
lp.instAlgebraSubtypePreLpMemAddSubgroupTopENNReal._aux_1 r * x =
x * lp.instAlgebraSub... | null | false |
CategoryTheory.nerve.homEquiv._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {x y : CategoryTheory.ComposableArrows C 0}
(e : SSet.Edge x y),
(fun f => SSet.Edge.mk (CategoryTheory.ComposableArrows.mk₁ f) ⋯ ⋯)
((fun e =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.Cat... | null | false |
BoolAlg.hom_ofHom | Mathlib.Order.Category.BoolAlg | ∀ {X Y : Type u} [inst : BooleanAlgebra X] [inst_1 : BooleanAlgebra Y] (f : BoundedLatticeHom X Y),
BoolAlg.Hom.hom (BoolAlg.ofHom f) = f | null | true |
Lean.MessageData.andList | Lean.Message | List Lean.MessageData → Lean.MessageData | Puts `MessageData` into a comma-separated list with `"and"` at the back (with the serial comma).
Best used on non-empty lists; returns `"– none –"` for an empty list.
| true |
groupHomology.isoCycles₁_hom_comp_i_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) {Z : ModuleCat k}
(h : (groupHomology.shortComplexH1 A).X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupHomology.isoCycles₁ A).hom
(CategoryTheory.CategoryStruct.comp (groupHomology.shortComplexH1 A).moduleCatLeftHomologyData.i ... | null | true |
PreValuationRing | Mathlib.RingTheory.Valuation.ValuationRing | (A : Type u) → [Mul A] → Prop | A magma is called a `PreValuationRing` provided that for any pair
of elements `a b : A`, either `a` divides `b` or vice versa. | true |
Lean.Meta.Grind.HomoPredTheorem.mk.inj | Lean.Meta.Tactic.Grind.Homo | ∀ {declName : Lean.Name} {arity : ℕ} {declName_1 : Lean.Name} {arity_1 : ℕ},
{ declName := declName, arity := arity } = { declName := declName_1, arity := arity_1 } →
declName = declName_1 ∧ arity = arity_1 | null | true |
CategoryTheory.IsCofilteredOrEmpty.of_initial | 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) [F.Initial] [CategoryTheory.IsCofilteredOrEmpty C],
CategoryTheory.IsCofilteredOrEmpty D | Initial functors preserve cofilteredness.
This can be seen as a generalization of `IsCofiltered.of_left_adjoint` (which states that left
adjoints preserve cofilteredness), as right adjoints are always initial,
see `initial_of_adjunction`.
| true |
Complex.interior_setOfPred_le_im | Mathlib.Analysis.Complex.ReImTopology | ∀ (a : ℝ), interior {z | a ≤ z.im} = {z | a < z.im} | null | true |
CategoryTheory.ShortComplex.homologyMap_zero | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S₁ S₂ : CategoryTheory.ShortComplex C) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.ShortComplex.homologyMap 0 = 0 | null | true |
String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestMatchAt_iff_extract | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos₁ pos₂ : s.Pos},
pat.isEmpty = false →
(String.Slice.Pattern.Model.IsLongestMatchAt pat pos₁ pos₂ ↔
s.copy.toByteArray.extract pos₁.offset.byteIdx pos₂.offset.byteIdx = pat.copy.toByteArray) | null | true |
Batteries.Random.MersenneTwister.Config._sizeOf_1 | Batteries.Data.Random.MersenneTwister | Batteries.Random.MersenneTwister.Config → ℕ | null | false |
AddCommGrpCat.Forget₂.createsLimit._proof_9 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(s : CategoryTheory.Limits.Cone F)
(x :
↑(((CategoryTheory.forget₂ AddCommGrpCat AddGrpCat).comp (CategoryTheory.forget₂ AddGrpCat AddMonCat)).mapCone s).1)
{j j' : J} (f : j ⟶ j'),
(CategoryTheory.Co... | null | false |
SimpleGraph.isNIndepSet_induce | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {F : Set α} {s : Finset { x // x ∈ F }} {n : ℕ},
(⊤.induce F).coe.IsNIndepSet n s ↔ G.IsNIndepSet n (Finset.map { toFun := Subtype.val, inj' := ⋯ } s) | The embedding of an `n`-independent set of an induced subgraph of the subgraph `G` is an
`n`-independent set in `G` and vice versa. | true |
ContinuousMapZero.id_toFun | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {R : Type u_3} [inst : Zero R] [inst_1 : TopologicalSpace R] (s : Set R) [inst_2 : Fact (0 ∈ s)] (a : ↑s),
(ContinuousMapZero.id s) a = ↑a | null | true |
_private.Mathlib.Algebra.Colimit.Module.0.Module.DirectLimit.induction_on.match_1_1 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_3} [inst : Semiring R] {ι : Type u_1} [inst_1 : Preorder ι] {G : ι → Type u_2}
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[inst_4 : DecidableEq ι] (z : Module.DirectLimit G f)
(motive : (∃ i x, (Module.DirectLimit.of R ι G f i... | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.LTSeries.0._aux_Mathlib_RingTheory_Spectrum_Prime_LTSeries___unexpand_IsLocalRing_maximalIdeal_1 | Mathlib.RingTheory.Spectrum.Prime.LTSeries | Lean.PrettyPrinter.Unexpander | null | false |
DiscreteQuotient.fiber_subset_ofLE | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} [inst : TopologicalSpace X] {A B : DiscreteQuotient X} (h : A ≤ B) (a : Quotient A.toSetoid),
A.proj ⁻¹' {a} ⊆ B.proj ⁻¹' {DiscreteQuotient.ofLE h a} | null | true |
Lean.Compiler.LCNF.Internalize.Context.ctorIdx | Lean.Compiler.LCNF.Internalize | Lean.Compiler.LCNF.Internalize.Context → ℕ | null | false |
Field.insepDegree_top_le_insepDegree_of_isScalarTower | Mathlib.FieldTheory.SeparableClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type v) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K], Field.insepDegree E K ≤ Field.insepDegree F K | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.restrictNonposSeq_lt | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α} (n : ℕ),
¬MeasureTheory.VectorMeasure.restrict s
(i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq✝ s i k) ≤
MeasureTheory.VectorMeasure.restrict 0
(i \ ⋃ k, ⋃ (_ : k ≤ n), Meas... | null | true |
liminf_add_le._auto_3 | Mathlib.Topology.Algebra.Order.LiminfLimsup | Lean.Syntax | null | false |
BddBelow.isBoundedUnder_of_range | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] {f : Filter β} {u : β → α},
BddBelow (Set.range u) → Filter.IsBoundedUnder (fun x1 x2 => x2 ≤ x1) f u | A bounded below function `u` is in particular eventually bounded below. | true |
_private.Mathlib.Tactic.Basify.Attr.0.Mathlib.Tactic.Basify.analyzeOp.match_1 | Mathlib.Tactic.Basify.Attr | (motive : Option (Lean.Name × Lean.Name) → Sort u_1) →
(__do_lift : Option (Lean.Name × Lean.Name)) →
((pair : Lean.Name × Lean.Name) → motive (some pair)) →
((x : Option (Lean.Name × Lean.Name)) → motive x) → motive __do_lift | null | false |
Int16.toUInt16 | Init.Data.SInt.Basic | Int16 → UInt16 | Converts an 16-bit signed integer into the 16-bit unsigned integer that is its two's complement
encoding.
| true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{c c' : Lean.Meta.Grind.Arith.Cutsat.EqCnstr} →
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm c = Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm c' →
(c = c' → P) → P | null | false |
CategoryTheory.Functor.whiskeringRight₂_obj_obj_obj_obj | Mathlib.CategoryTheory.Functor.Currying | ∀ (B : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} B] (C : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} C]
(D : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} D] (E : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
(X_1 : Categor... | null | true |
_private.Lean.Meta.Injective.0.Lean.Meta.mkHInjType?.match_1 | Lean.Meta.Injective | (motive : Option (Array Lean.Expr) → Sort u_1) →
(__x : Option (Array Lean.Expr)) →
((idxs2 : Array Lean.Expr) → motive (some idxs2)) → ((x : Option (Array Lean.Expr)) → motive x) → motive __x | null | false |
AddSubgroup.normal_addSubgroupOf_sup_of_le_normalizer | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H N : AddSubgroup G},
H ≤ AddSubgroup.normalizer ↑N → (N.addSubgroupOf (H ⊔ N)).Normal | null | true |
NonUnitalRing.mul_assoc | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [self : NonUnitalRing α] (a b c : α), a * b * c = a * (b * c) | Multiplication is associative | true |
MeasureTheory.norm_resolvent_le_inv_infDist_support | Mathlib.MeasureTheory.Measure.ResolventTransform | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : MeasurableSpace 𝕜] [CompleteSpace 𝕜]
[inst_3 : NormedDivisionRing A] [inst_4 : NormedAlgebra 𝕜 A] {μ : MeasureTheory.Measure 𝕜} {a : A},
a ∉ ⇑(algebraMap 𝕜 A) '' μ.support →
∀ {x : 𝕜}, x ∈ μ.support → ‖resolvent a x‖ ≤ (Metric.... | null | true |
Fin.findSomeRev?_succ | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {f : Fin (n + 1) → Option α},
Fin.findSomeRev? f = (f (Fin.last n)).or (Fin.findSomeRev? fun i => f i.castSucc) | null | true |
Lean.Expr.getArg! | Lean.Expr | (e : Lean.Expr) → ℕ → optParam ℕ e.getAppNumArgs → Lean.Expr | Given `f a₀ a₁ ... aₙ`, returns the `i`th argument or panics if out of bounds. | true |
CategoryTheory.Limits.biprod.map_eq | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} {f : W ⟶ Y} {g : X ⟶ Z},
CategoryTheory.Limits.biprod.map f g =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.fst
(Categ... | null | true |
OrderDual.instRing._proof_4 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : Ring R],
autoParam (∀ (n : ℕ) (a : Rᵒᵈ), Int.negSucc n • a = -(↑n.succ • a)) SubNegMonoid.zsmul_neg'._autoParam | null | false |
FunLike.hasDistribNeg | Mathlib.Algebra.Ring.FunLike | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Neg F] →
[inst_2 : Mul F] →
[inst_3 : Mul β] → [inst_4 : HasDistribNeg β] → [IsNegApply F α β] → [IsMulApply F α β] → HasDistribNeg F | A `FunLike` type with `(f * g) x = f x * g x` is a `HasDistribNeg` if `β` is a
`HasDistribNeg`. | true |
Lean.Lsp.RpcReleaseParams.mk.inj | Lean.Data.Lsp.Extra | ∀ {uri : Lean.Lsp.DocumentUri} {sessionId : UInt64} {refs : Array Lean.Json} {uri_1 : Lean.Lsp.DocumentUri}
{sessionId_1 : UInt64} {refs_1 : Array Lean.Json},
{ uri := uri, sessionId := sessionId, refs := refs } = { uri := uri_1, sessionId := sessionId_1, refs := refs_1 } →
uri = uri_1 ∧ sessionId = sessionId_1... | null | true |
Mathlib.Ineq.WithStrictness.eq | Mathlib.Tactic.LinearCombination.Lemmas | Mathlib.Ineq.WithStrictness | null | true |
lightCondSetToTopCat._proof_1 | Mathlib.Condensed.Light.TopCatAdjunction | ∀ (X : LightCondSet),
LightCondSet.toTopCatMap (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id X.toTopCat | null | false |
IsIntegralClosure.finite | Mathlib.RingTheory.DedekindDomain.IntegralClosure | ∀ (A : Type u_1) (K : Type u_2) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K] [IsFractionRing A K]
(L : Type u_3) [inst_4 : Field L] (C : Type u_4) [inst_5 : CommRing C] [inst_6 : Algebra K L] [inst_7 : Algebra A L]
[IsScalarTower A K L] [inst_9 : Algebra C L] [IsIntegralClosure C A L] [inst_11 : Al... | If `L` is a finite separable extension of `K = Frac(A)`, where `A` is
integrally closed and Noetherian, the integral closure `C` of `A` in `L` is
finite over `A`. | true |
Equiv.instFintype._proof_2 | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_2} {β : Type u_1} [inst : Fintype β] (a : β ≃ Fin (Fintype.card β)), Subsingleton (Fintype (α ≃ β)) | null | false |
isLUB_sSup | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] (s : Set α), IsLUB s (sSup s) | null | true |
IsCompl.IicOrderIsoIci | Mathlib.Order.ModularLattice | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : BoundedOrder α] → [IsModularLattice α] → {a b : α} → IsCompl a b → ↑(Set.Iic a) ≃o ↑(Set.Ici b) | The diamond isomorphism between the intervals `Set.Iic a` and `Set.Ici b`. | true |
Polynomial.natCast_mul_comp | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p r : Polynomial R} {n : ℕ}, (↑n * p).comp r = ↑n * p.comp r | null | true |
Lean.Compiler.LCNF.CtorFieldInfo.void | Lean.Compiler.LCNF.ToImpureType | Lean.Compiler.LCNF.CtorFieldInfo | null | true |
MeasureTheory.Lp.toTemperedDistributionCLM.congr_simp | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_3} (F : Type u_4) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] [inst_4 : CompleteSpace F] [inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E]
(μ : MeasureTheory.Measure E) [inst_7 : μ.HasTemperateGrowth] (p : ENNReal) [hp : Fact (... | null | true |
isSMulRegular_algebraMap_iff | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A] {M : Type u_3}
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [IsScalarTower R A M] {r : R},
IsSMulRegular M ((algebraMap R A) r) ↔ IsSMulRegular M r | null | true |
_private.Init.Data.Slice.Lemmas.0.Std.Slice.foldl_toArray._simp_1_2 | Init.Data.Slice.Lemmas | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id] {f : γ → β → γ} {init : γ} {it : Std.Iter β},
Std.Iter.fold f init it = Array.foldl f init it.toArray | null | false |
Submodule.fst_map_snd | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂], Submodule.map (LinearMap.snd R M M₂) (Submodule.fst R M M₂) = ⊥ | null | true |
MeasureTheory.measure_mono | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α] {μ : F}
{s t : Set α}, s ⊆ t → μ s ≤ μ t | null | true |
SummationFilter.instDecidablePredMemSetSupportOfLeAtTop._proof_1 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_1} (L : SummationFilter β) [L.LeAtTop] (b : β), (fun x => x ∈ L.support) b | null | false |
Module.Presentation.mk._flat_ctor | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] →
(G : Type w₀) →
(R : Type w₁) →
(relation : R → G →₀ A) →
(var : G → M) →
(linearCombination_var_relation : ∀ (r : R), (Finsupp.li... | null | false |
_private.Mathlib.MeasureTheory.Integral.CurveIntegral.Basic.0.HasFDerivAt.curveIntegral_segment_source'._simp_1_1 | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α → β) (x : α),
ContinuousWithinAt f Set.univ x = ContinuousAt f x | null | false |
CategoryTheory.Functor.isLimitMapConeBinaryFanOfPreservesKernels._proof_2 | Mathlib.CategoryTheory.Preadditive.LeftExact | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [F.PreservesZeroMorphisms] {X Y Z : C} (π₁ : Z ⟶ X) (π₂ : Z ⟶ Y)
(i : Categ... | null | false |
himp_eq_top_iff._simp_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, (a ⇨ b = ⊤) = (a ≤ b) | null | false |
Turing.ToPartrec.Cont.comp.sizeOf_spec | Mathlib.Computability.TuringMachine.Config | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.ToPartrec.Cont),
sizeOf (Turing.ToPartrec.Cont.comp a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
Mathlib.Tactic.BicategoryLike.MkEvalWhiskerRight.mkEvalWhiskerRightNil | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MkEvalWhiskerRight m] →
Mathlib.Tactic.BicategoryLike.Structural → Mathlib.Tactic.BicategoryLike.Mor₁ → m Lean.Expr | Evaluate `α ▷ f` | true |
OrderDual.gradeMinOrder | Mathlib.Order.Grade | {𝕆 : Type u_1} →
{α : Type u_3} → [inst : Preorder 𝕆] → [inst_1 : Preorder α] → [GradeMaxOrder 𝕆 α] → GradeMinOrder 𝕆ᵒᵈ αᵒᵈ | null | true |
Lean.Grind.NoopConfig.inj._inherited_default | Init.Grind.Config | Bool | null | false |
Lean.Compiler.LCNF.eraseLetDecl | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.CompilerM Unit | null | true |
_private.Init.Data.SInt.Bitwise.0.ISize.not_eq_comm._simp_1_2 | Init.Data.SInt.Bitwise | ∀ {w : ℕ} {x y : BitVec w}, (~~~x = y) = (x = ~~~y) | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_368 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Lean.Meta.Structural.isInstHAddInt | Lean.Meta.IntInstTesters | Lean.Expr → Lean.MetaM Bool | null | true |
Polynomial.degreeLT.basis | Mathlib.RingTheory.Polynomial.DegreeLT | (R : Type u_1) → [inst : Semiring R] → (n : ℕ) → Module.Basis (Fin n) R ↥(Polynomial.degreeLT R n) | Basis for `R[X]_n` given by `X^i` with `i < n`. | true |
MeasureTheory.integral_indicator₀ | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{f : X → E} {s : Set X} {μ : MeasureTheory.Measure X},
MeasureTheory.NullMeasurableSet s μ → ∫ (x : X), s.indicator f x ∂μ = ∫ (x : X) in s, f x ∂μ | null | true |
MulOpposite.nnnorm_unop | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_3} [inst : SeminormedAddGroup E] (a : Eᵐᵒᵖ), ‖MulOpposite.unop a‖₊ = ‖a‖₊ | null | true |
instCharacteristicCommutator | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G], (commutator G).Characteristic | null | true |
Rep.invariantsFunctor_obj_carrier | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u) (G : Type v) [inst : CommRing k] [inst_1 : Group G] (A : Rep.{w, u, v} k G),
↑((Rep.invariantsFunctor k G).obj A) = { x // ∀ (g : G), (A.ρ g) x = x } | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.attachCodeDecls.go._unary._proof_6 | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (i : ℕ) (code : Lean.Compiler.LCNF.Code pu),
i > 0 →
∀ (fvarId : Lean.FVarId) (idx offset : ℕ) (y : Lean.FVarId) (ty : Lean.Expr)
(h : pu = Lean.Compiler.LCNF.Purity.impure),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i code => i)
⟨i - 1, ... | null | false |
_private.Mathlib.CategoryTheory.Sites.IsSheafFor.0.CategoryTheory.Presieve.isSheafFor_bind._proof_1_5 | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type u_1))
(U : CategoryTheory.Sieve X) (B : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → U.arrows f → CategoryTheory.Sieve Y)
(s : CategoryTheory.Presieve.FamilyOfElements P (CategoryTheory.Sieve.bind U.arrows B).arrows),
(∀ ⦃Y : ... | null | false |
StarSubalgebra.subtype._proof_4 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) (x x_1 : ↥S),
↑(x + x_1) = ↑(x + x_1) | null | false |
CompactlySupportedContinuousMap.instSMulWithZeroOfContinuousConstSMul._proof_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
{R : Type u_3} [inst_3 : Zero R] [inst_4 : SMulWithZero R β] [inst_5 : ContinuousConstSMul R β] (a : R), a • 0 = 0 | null | false |
SimpleGraph.toTopEdgeLabeling | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | {V : Type u_1} → (G : SimpleGraph V) → [DecidableRel G.Adj] → SimpleGraph.TopEdgeLabeling V (Fin 2) | From a simple graph on `V`, construct the edge labeling on the complete graph of `V` given where
edges are labeled `1` and non-edges are labeled `0`.
| true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorInr.eq_1 | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
T.tensorInr =
CategoryTheory.Limits.pushout.inr
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.residueFieldCongr ⋯).inv
(AlgebraicGeometry.Scheme.Hom.residueFieldMap f T.x... | null | true |
CategoryTheory.PreGaloisCategory.IsConnected.casesOn | Mathlib.CategoryTheory.Galois.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{X : C} →
{motive : CategoryTheory.PreGaloisCategory.IsConnected X → Sort u} →
(t : CategoryTheory.PreGaloisCategory.IsConnected X) →
((notInitial : ∀ (a : CategoryTheory.Limits.IsInitial X), False) →
(noTrivialCom... | null | false |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Basic.0.IsTopologicalAddGroup.tendstoLocallyUniformlyOn_iff.match_1_3 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [u : UniformSpace G] [inst_1 : IsTopologicalAddGroup G] (x : Set (G × G))
(motive : x ∈ uniformity G → Prop) (x_1 : x ∈ uniformity G),
(∀ (u_1 : Set G) (hu : u_1 ∈ nhds 0) (hv : (fun p => p.2 + -p.1) ⁻¹' u_1 ⊆ x), motive ⋯) → motive x_1 | null | false |
VectorField.mpullbackWithin_mlieBracketWithin' | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | The pullback commutes with the Lie bracket of vector fields on manifolds. Version where one
assumes that the map is smooth on a larger set `u` (so that the
condition `x₀ ∈ closure (interior u)`, needed to guarantee the symmetry of the second derivative,
becomes easier to check.) | true |
Lean.Widget.TaggedText._sizeOf_inst | Lean.Widget.TaggedText | (α : Type u) → [SizeOf α] → SizeOf (Lean.Widget.TaggedText α) | null | false |
FirstOrder.Language.Theory.coe_of | Mathlib.ModelTheory.Bundled | ∀ {L : FirstOrder.Language} {T : L.Theory} {M : Type w} [inst : L.Structure M] [inst_1 : Nonempty M] (h : M ⊨ T),
↑h.bundled = M | null | true |
MulChar.mulEquivToUnitHom_symm_apply | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ),
MulChar.mulEquivToUnitHom.symm f = MulChar.equivToUnitHom.symm f | null | true |
_private.Lean.Compiler.LCNF.CompatibleTypes.0.Lean.Compiler.LCNF.compatibleTypesQuick._sparseCasesOn_1 | Lean.Compiler.LCNF.CompatibleTypes | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((binderName : Lean.... | null | false |
_private.Mathlib.Algebra.Ring.Invertible.0.neg_add_eq_mul_invOf_mul_same_iff._proof_1_1 | Mathlib.Algebra.Ring.Invertible | ∀ {R : Type u_1} [inst : Ring R] {a b : R} [inst_1 : Invertible b], -(b + a) = a * ⅟b * a → -a = b + a * ⅟b * a | null | false |
Subfield.botEquivZMod_symm_apply | Mathlib.FieldTheory.PrimeField | ∀ {K : Type u_1} [inst : Field K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Algebra (ZMod p) K]
[inst_3 : Algebra (ZMod p) ↥⊥] (x : ZMod p), (Subfield.botEquivZMod K p).symm x = (algebraMap (ZMod p) ↥⊥) x | null | true |
SemiRingCat.HasLimits.limitConeIsLimit._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J SemiRingCat)
(s : CategoryTheory.Limits.Cone F) (v : ((CategoryTheory.forget SemiRingCat).mapCone s).pt) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct.comp (((CategoryT... | null | false |
Bitraversable.tfst_eq_fst_id | Mathlib.Control.Bitraversable.Lemmas | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [LawfulBitraversable t] {α α' β : Type u} (f : α → α')
(x : t α β), Bitraversable.tfst (pure ∘ f) x = pure (Bifunctor.fst f x) | null | true |
Std.DHashMap.Raw.Const.unitOfList | Std.Data.DHashMap.Raw | {α : Type u} → [BEq α] → [Hashable α] → List α → Std.DHashMap.Raw α fun x => Unit | Creates a hash map from a list of keys, associating the value `()` with each key.
This is mainly useful to implement `HashSet.ofList`, so if you are considering using this,
`HashSet` or `HashSet.Raw` might be a better fit for you. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.