name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.SimpM.run.match_1 | Lean.Meta.Tactic.Simp.Types | {α : Type} →
(motive : α × Lean.Meta.Simp.State → Sort u_1) →
(x : α × Lean.Meta.Simp.State) → ((r : α) → (s : Lean.Meta.Simp.State) → motive (r, s)) → motive x | null | false |
Bundle.ContinuousAlternatingMap.instVectorBundle | Mathlib.Topology.VectorBundle.ContinuousAlternatingMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : Fintype ι] {B : Type u_3}
[inst_2 : TopologicalSpace B] {F₁ : Type u_4} [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
{E₁ : B → Type u_5} [inst_5 : (x : B) → AddCommGroup (E₁ x)] [inst_6 : (x : B) → Module 𝕜 (E₁ x)]
[i... | The continuous `σ`-semilinear maps between two vector bundles form a vector bundle. | true |
Batteries.Tactic.PrintPrefixConfig.imported._default | Batteries.Tactic.PrintPrefix | Bool | null | false |
Qq.unpackParensIdent | Qq.Match | Lean.Syntax → Option Lean.Syntax | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting'._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Homeomorph.funUnique_apply | Mathlib.Topology.Homeomorph.Lemmas | ∀ (ι : Type u_5) (X : Type u_6) [inst : Unique ι] [inst_1 : TopologicalSpace X],
⇑(Homeomorph.funUnique ι X) = fun f => f default | null | true |
Finmap.lookup_eq_none | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s : Finmap β}, Finmap.lookup a s = none ↔ a ∉ s | null | true |
even_neg._simp_1 | Mathlib.Algebra.Group.Even | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | null | false |
PowerSeries.constantCoeff_substInvOfIsUnit | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (P : PowerSeries R) (hP' : IsUnit ((PowerSeries.coeff 1) P)),
PowerSeries.constantCoeff (P.substInvOfIsUnit hP') = 0 | null | true |
Lean.Elab.Info.format | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.Info → IO Std.Format | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions.0.SimpleGraph.cycleGraph.bicoloring_of_even._simp_3 | Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) | null | false |
Int64.toISize_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ^^^ b).toISize = a.toISize ^^^ b.toISize | null | true |
CategoryTheory.Limits.coprod.inl_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct X Y] {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
(CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
_private.Mathlib.Algebra.Module.Submodule.Invariant.0.Module.End.invtSubmodule_inf_invtSubmodule_le_invtSubmodule_add.match_1_1 | Mathlib.Algebra.Module.Submodule.Invariant | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.End R M) (p : Submodule R M) (motive : p ∈ f.invtSubmodule ⊓ g.invtSubmodule → Prop)
(x : p ∈ f.invtSubmodule ⊓ g.invtSubmodule),
(∀ (hfp : p ∈ ↑f.invtSubmodule) (hgp : p ∈ ↑g.invtSubmodule), motive ... | null | false |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.restrict_fixedField._simp_1_6 | Mathlib.FieldTheory.Galois.Infinite | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Bool.not_eq_eq_eq_not | Init.SimpLemmas | ∀ {a b : Bool}, (!a) = b ↔ a = !b | We move `!` from the left hand side of an equality to the right hand side.
This helps confluence, and also helps combining pairs of `!`s.
| true |
MeasureTheory.OuterMeasure.map._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (m : MeasureTheory.OuterMeasure α) (s : ℕ → Set β),
m (f ⁻¹' ⋃ i, s i) ≤ ∑' (i : ℕ), m (f ⁻¹' s i) | null | false |
Std.WP.WPMonad.bind_le_wp_bind | Std.WP.Monad.Basic | ∀ {m : Type u → Type v} {Pred : outParam (Type w)} {EPred : outParam (Type w')} {inst : Monad m}
{inst_1 : Std.WP.Assertion Pred} {inst_2 : Std.WP.Assertion EPred} [self : Std.WP.WPMonad m Pred EPred] {α β : Type u}
(x : m α) (f : α → m β) (post : β → Pred) (epost : EPred),
Lean.Order.PartialOrder.rel (Std.WP.wp ... | Soundness of `bind`: composing weakest preconditions is at least as strong as the weakest
precondition of `>>=`. | true |
_private.Lean.Elab.Do.Control.0.Lean.Elab.Do.ControlStack.exceptT.stM | Lean.Elab.Do.Control | Lean.Elab.Do.MonadInfo → Lean.Elab.Do.DoElabM Lean.Elab.Do.ReturnCont → Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr | null | true |
MeasureTheory.Measure.restrict_apply_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α), (μ.restrict s) s = μ s | null | true |
AlgebraicTopology.DoldKan.degeneraciesVanish_iff_QInfty_f_comp | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {n : ℕ} {T : C} (f : X.obj (Opposite.op { len := n }) ⟶ T),
AlgebraicTopology.DoldKan.DegeneraciesVanish f ↔
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKa... | null | true |
Array.filter_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool}, Array.filter p #[] = #[] | null | true |
_private.Plausible.Gen.0.Plausible.Gen.permutationOf._proof_7 | Plausible.Gen | ∀ {α : Type u_1} (ys : List α), ¬0 ≤ ys.length → False | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.SpectralNorm.0.spectralNorm.spectralMulAlgNorm_eq_of_mem_roots._simp_1_3 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) | null | false |
HurwitzZeta.hasSum_int_oddKernel | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : ℝ) {x : ℝ},
0 < x → HasSum (fun n => (↑n + a) * Real.exp (-Real.pi * (↑n + a) ^ 2 * x)) (HurwitzZeta.oddKernel (↑a) x) | null | true |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.eraseDecl.match_1 | Lean.Meta.Tactic.Grind.Theorems | (motive : Option (Array Lean.Name) → Sort u_1) →
(__do_lift : Option (Array Lean.Name)) →
((eqns : Array Lean.Name) → motive (some eqns)) → ((x : Option (Array Lean.Name)) → motive x) → motive __do_lift | null | false |
CategoryTheory.PreZeroHypercover.pullbackCoverOfLeftIsoPullback₁._proof_3 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
{Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst f g) (E.f i)]
[inst_3 : ∀... | null | false |
Algebra.Extension.noConfusion | Mathlib.RingTheory.Extension.Basic | {P : Sort u_1} →
{R : Type u} →
{S : Type v} →
{inst : CommRing R} →
{inst_1 : CommRing S} →
{inst_2 : Algebra R S} →
{t : Algebra.Extension R S} →
{R' : Type u} →
{S' : Type v} →
{inst' : CommRing R'} →
{inst'... | null | false |
Lean.Omega.Fin.lt_of_not_le | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, ¬i ≤ j → j < i | null | true |
CategoryTheory.Limits.coproductIsCoproduct'._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
[inst_1 : CategoryTheory.Limits.HasCoproduct fun j => X.obj { as := j }] (s : CategoryTheory.Limits.Cocone X)
(m : (CategoryTheory.Limits.Sigma.cocone X).pt ⟶ s.pt),
(∀ (j : C... | null | false |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofGoal.match_3 | Aesop.Tree.ExtractProof | (motive : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment) → Sort u_1) →
(__x : Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment)) →
((postNormGoal : Lean.MVarId) →
(children : Array Aesop.RappRef) →
(postNormEnv : Lean.Environment) → motive (some (postNormGoal, children... | null | false |
QuotientGroup.fintypeQuotientRightRel | Mathlib.GroupTheory.Coset.Card | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → [Fintype (α ⧸ s)] → Fintype (Quotient (QuotientGroup.rightRel s)) | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Reify.0.Lean.Meta.Grind.Arith.Linear.reify?.isOfNatZero | Lean.Meta.Tactic.Grind.Arith.Linear.Reify | Lean.Expr → Lean.Meta.Grind.Arith.Linear.LinearM Bool | null | true |
_private.Mathlib.Tactic.Echelon.Reflection.0.Mathlib.Tactic.Echelon.pivotOfList_mono_of_sortedLT._proof_1_1 | Mathlib.Tactic.Echelon.Reflection | ∀ {n : ℕ} {cols : List (Fin n)} (i : ℕ),
(Mathlib.Tactic.Echelon.pivotOfList cols i.succ ≠ ⊤ →
Mathlib.Tactic.Echelon.pivotOfList cols i < Mathlib.Tactic.Echelon.pivotOfList cols i.succ) →
Mathlib.Tactic.Echelon.pivotOfList cols i ≤ Mathlib.Tactic.Echelon.pivotOfList cols (i + 1) | null | false |
Lean.Omega.IntList.mul_get | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList) (i : ℕ), (xs * ys).get i = xs.get i * ys.get i | null | true |
Lean.Elab.MonadAutoImplicits.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t | null | false |
lift_nhds_left | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] {x : α} {g : Set α → Filter β},
Monotone g → (nhds x).lift g = (uniformity α).lift fun s => g (UniformSpace.ball x s) | null | true |
Option.get!_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α], none.get! = default | null | true |
_private.Mathlib.Data.Set.Prod.0.Set.pi_inter_distrib._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t t₁ : (i : ι) → Set (α i)},
(s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestImpl.throwExs | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Array Lean.Elab.Tactic.EvalTacticFailure → Lean.Elab.Tactic.Try.TryTacticM (Lean.TSyntax `tactic) | null | true |
sub_lt_comm | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, a - b < c ↔ a - c < b | null | true |
SimpleGraph.Walk.take_add_eq | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (n m : ℕ),
p.take (n + m) = ((p.take n).append ((p.drop n).take m)).copy ⋯ ⋯ | null | true |
PadicInt.withValIntegersRingEquiv | Mathlib.NumberTheory.Padics.WithVal | {p : ℕ} → [inst : Fact (Nat.Prime p)] → ↥(Valued.integer (Rat.padicValuation p).Completion) ≃+* ℤ_[p] | The `p`-adic integers are ring isomorphic to the integers of the uniform completion
of the rationals at the `p`-adic valuation. | true |
sup_sdiff_cancel'._to_dual_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, b ≤ a → c ≤ b → b ⊓ (a ⇨ c) = c | null | false |
DiscreteTiling.PlacedTile.coe_nonempty_iff | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} {pt : DiscreteTiling.PlacedTile ps}, (↑pt).Nonempty ↔ (↑(↑ps pt.index)).Nonempty | null | true |
Std.PRange.Least?.recOn | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
(t : Std.PRange.Least? α) → ((least? : Option α) → motive { least? := least? }) → motive t | null | false |
ContinuousMap.Homotopy.casesOn | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} →
{motive : f₀.Homotopy f₁ → Sort u_1} →
(t : f₀.Homotopy f₁) →
((toContinuousMap : C(↑unitInterval × X, Y)) →
(map_zero_left : ∀ (x : X... | null | false |
AddHomClass.toAddHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_add' := ⋯ } | null | true |
TopologicalSpace.NonemptyCompacts.coe_map | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
(hf : Continuous f) (s : TopologicalSpace.NonemptyCompacts α),
↑(TopologicalSpace.NonemptyCompacts.map f hf s) = f '' ↑s | null | true |
_private.Mathlib.Analysis.InnerProductSpace.GramMatrix.0.Matrix.posSemidef_opNorm_smul_gram_sub_gram._proof_1_3 | Mathlib.Analysis.InnerProductSpace.GramMatrix | ∀ {E : Type u_4} {n : Type u_2} {𝕜 : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(v : n → E) (f : E →L[𝕜] F) (c : n →₀ 𝕜),
∑ y ∈ c.support, ∑ x ∈ c.support, (starRingEnd 𝕜) (c x)... | null | false |
Std.PreorderPackage.ofLE._proof_3 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (args : Std.Packages.PreorderOfLEArgs α), Std.IsPreorder α | null | false |
_private.Mathlib.Analysis.Convex.Function.0.strictConvexOn_iff_div._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | null | false |
Subring.mem_mk'._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubgroup R} (ha : ↑sa = s)
{x : R}, (x ∈ Subring.mk' s sm sa hm ha) = (x ∈ s) | null | false |
instPartialOrderGroupCone | Mathlib.Algebra.Order.Group.Cone | (G : Type u_1) → [inst : CommGroup G] → PartialOrder (GroupCone G) | null | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCycles_f | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | true |
IsLowerSet.null_frontier | Mathlib.MeasureTheory.Order.UpperLower | ∀ {ι : Type u_1} [inst : Fintype ι] {s : Set (ι → ℝ)}, IsLowerSet s → MeasureTheory.volume (frontier s) = 0 | null | true |
_private.Aesop.RuleSet.0.Aesop.BaseRuleSet.merge.match_1 | Aesop.RuleSet | (motive : Option (Aesop.UnorderedArraySet Aesop.RuleName) → Sort u_1) →
(x : Option (Aesop.UnorderedArraySet Aesop.RuleName)) →
(Unit → motive none) → ((ns : Aesop.UnorderedArraySet Aesop.RuleName) → motive (some ns)) → motive x | null | false |
MulEquiv.symmEquiv_apply_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ (P : Type u_9) (Q : Type u_10) [inst : Mul P] [inst_1 : Mul Q] (h : P ≃* Q) (a : Q),
((MulEquiv.symmEquiv P Q) h) a = h.symm a | null | true |
CategoryTheory.Oplax.OplaxTrans.naturality_comp_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.OplaxTrans F G) {a b c : B} (f : a ⟶ b)
(g : b ⟶ c) {Z : F.obj a ⟶ G.obj c}
(h : CategoryTheory.CategoryStruct.comp (self.app a) (CategoryT... | null | true |
MeasureTheory.measureUnivNNReal | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {m0 : MeasurableSpace α} → MeasureTheory.Measure α → NNReal | The measure of the whole space with respect to a finite measure, considered as `ℝ≥0`. | true |
isPRadical_iff | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} [inst : CommSemiring K] [inst_1 : CommSemiring L] (i : K →+* L) (p : ℕ),
IsPRadical i p ↔ (∀ (x : L), ∃ n y, i y = x ^ p ^ n) ∧ RingHom.ker i ≤ pNilradical K p | null | true |
BoundingSieve.selbergTerms | Mathlib.NumberTheory.SelbergSieve | {s : BoundingSieve} → ArithmeticFunction ℝ | These are the terms that appear in the sum `S` in the main term of the fundamental theorem.
$$S = \sum_{l \mid P, l \le \sqrt{y}} g(l)$$ | true |
Filter.Tendsto.nonpos_add_atBot | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedAddMonoid M] {l : Filter α}
{f g : α → M},
(∀ (x : α), f x ≤ 0) → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x + g x) l Filter.atBot | null | true |
MeasureTheory.eLpNorm_conj | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {m : MeasurableSpace α} {𝕜 : Type u_5} [inst : RCLike 𝕜] (f : α → 𝕜) (p : ENNReal)
(μ : MeasureTheory.Measure α), MeasureTheory.eLpNorm ((starRingEnd (α → 𝕜)) f) p μ = MeasureTheory.eLpNorm f p μ | null | true |
String.Pos.toSlice_nextn | Init.Data.String.Lemmas.Basic | ∀ {n : ℕ} {s : String} {p : s.Pos}, (p.nextn n).toSlice = p.toSlice.nextn n | null | true |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_3 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(s : Set (Submodule R M)) (w : Submodule R M) (compl : IsCompl N w)
(motive : (∃ m ∈ s, N.projectionOnto w compl ∘ₗ m.subtype ≠ 0) → Prop)
(x : ∃ m ∈ s, N.projectionOnto w compl ∘ₗ m.subtype ≠ 0),
... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction.0.SSet.Truncated.liftOfStrictSegal.f₂._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | 2 ≤ 1 + 1 | null | false |
IsNilpotent.charpoly_eq_X_pow_finrank | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {R : Type u_1} {M : Type u_3} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inst_4 : Module.Finite R M] [inst_5 : Module.Free R M] {φ : Module.End R M},
IsNilpotent φ → LinearMap.charpoly φ = Polynomial.X ^ Module.finrank R M | null | true |
Std.TreeSet.get?_erase | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a : α},
(t.erase k).get? a = if cmp k a = Ordering.eq then none else t.get? a | null | true |
Std.Internal.IndexMultiMap.getAll? | Std.Http.Internal.IndexMultiMap | {α : Type u} →
{β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.Internal.IndexMultiMap α β → α → Option (Array β) | Retrieves all values for the given key, or `none` if the key is absent.
| true |
Subsemiring.instCompleteLattice._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (x x_1 : Subsemiring R) (x_2 : R), x_2 ∈ ↑x ∧ x_2 ∈ ↑x_1 → x_2 ∈ ↑x | null | false |
BitVec.toInt_neg_of_msb_true | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x.msb = true → x.toInt < 0 | null | true |
BoundedContinuousFunction.toContinuousMapₐ_apply_apply | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} {γ : Type w} (𝕜 : Type u_1) [inst : NormedField 𝕜] [inst_1 : TopologicalSpace α] [inst_2 : NormedRing γ]
[inst_3 : NormedAlgebra 𝕜 γ] (f : BoundedContinuousFunction α γ) (a : α),
((BoundedContinuousFunction.toContinuousMapₐ 𝕜) f) a = f a | null | true |
CategoryTheory.Limits.HasZeroObject.instMono | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] {X : C}
(f : 0 ⟶ X), CategoryTheory.Mono f | null | true |
Qq.getLevelQ | Mathlib.Util.Qq | Lean.Expr → Lean.MetaM ((u : Lean.Level) × Q(Sort u)) | If `e` has type `Sort u` for some level `u`, return `u` and `e : Q(Sort u)`. | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.jacobson_eq_top_iff.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} (x : Ideal R) (motive : x ∈ {J | I ≤ J ∧ J.IsMaximal} → Prop)
(x_1 : x ∈ {J | I ≤ J ∧ J.IsMaximal}), (∀ (hij : I ≤ x) (right : x.IsMaximal), motive ⋯) → motive x_1 | null | false |
_private.Mathlib.Combinatorics.Additive.Dissociation.0.Set.indicator.eq_1 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] (s : Set α) (f : α → M) (x : α),
s.indicator f x = if x ∈ s then f x else 0 | null | true |
ProbabilityTheory.Kernel.instIsSMulApplyNatMeasure | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β},
IsSMulApply ℕ (ProbabilityTheory.Kernel α β) α (MeasureTheory.Measure β) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.ctorElim | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | {motive : Nat.NatOffset✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Nat.NatOffset✝) → ctorIdx = Nat.NatOffset.ctorIdx✝ t → Nat.NatOffset.ctorElimType✝ ctorIdx → motive t | null | false |
CategoryTheory.Equivalence.counitInv_app_tensor_comp_functor_map_δ_inverse_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] (X Y : C) {Z : D}
... | null | true |
_private.Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue.0.MeasureTheory.Measure.add_sub_of_mutuallySingular._abel_1_1 | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν ξ : MeasureTheory.Measure α} (h : μ.MutuallySingular ξ),
μ.restrict h.nullSet + μ.restrict h.nullSetᶜ + (ν - ξ).restrict h.nullSet + (ν - ξ).restrict h.nullSetᶜ =
μ.restrict h.nullSet + (ν - ξ).restrict h.nullSet + (μ.restrict h.nullSetᶜ + (ν - ξ).restrict h.nullSetᶜ) | null | false |
Std.DTreeMap.Raw.min?_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Min α] [inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.WF → t.keys.min? = t.minKey? | null | true |
UpperSet.instAddCommMonoid._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a b c : UpperSet α),
a + b + c = a + (b + c) | null | false |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformSpace.hausdorff.uniformContinuous_prod.match_1_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] (U : Set (α × α)) (V : Set (β × β))
(motive : (U, V).1 ∈ uniformity α ∧ (U, V).2 ∈ uniformity β → Prop)
(x : (U, V).1 ∈ uniformity α ∧ (U, V).2 ∈ uniformity β),
(∀ (hU : (U, V).1 ∈ uniformity α) (hV : (U, V).2 ∈ uniformity β), motiv... | null | false |
IntermediateField.subsingleton_of_rank_adjoin_eq_one | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
(∀ (x : E), Module.rank F ↥F⟮x⟯ = 1) → Subsingleton (IntermediateField F E) | null | true |
Aesop.GoalWithMVars.ctorIdx | Aesop.Script.GoalWithMVars | Aesop.GoalWithMVars → ℕ | null | false |
AddUnits.leftOfAdd._proof_2 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M), a + b = ↑u → AddCommute a b → b + ↑(-u) + a = 0 | null | false |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.MulArchimedeanClass.orderHom_injective._simp_1_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk a = MulArchimedeanClass.mk b) = ((∃ m, |b|ₘ ≤ |a|ₘ ^ m) ∧ ∃ n, |a|ₘ ≤ |b|ₘ ^ n) | null | false |
Sum.Lex.denselyOrdered_of_noMaxOrder | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [DenselyOrdered α] [DenselyOrdered β] [NoMaxOrder α],
DenselyOrdered (α ⊕ₗ β) | null | true |
Lean.Lsp.FileChangeType._sizeOf_inst | Lean.Data.Lsp.Workspace | SizeOf Lean.Lsp.FileChangeType | null | false |
OrderAddMonoidHom.addCommute_inl_inr | Mathlib.Algebra.Order.Monoid.Lex | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (m : α) (n : β), AddCommute ((OrderAddMonoidHom.inl α β) m) ((OrderAddMonoidHom.inr α β) n) | null | true |
Subgroup.transferFocal.quotientKerMulEquivQuotientFocalSubroupOf._proof_1 | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} (P : Sylow p G), (↑P).focalSubgroupOf.Normal | null | false |
Std.DHashMap.Raw.getKey?_insert_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insert k v).getKey? k = some k | null | true |
sup_sdiff | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a ⊔ b) \ c = a \ c ⊔ b \ c | null | true |
Lean.Lsp.CompletionItemKind.enumMember | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItemKind | null | true |
Lean.Server.References.removeWorkerRefs | Lean.Server.References | Lean.Server.References → Lean.Name → Lean.Server.References | Erases all worker references in `self` for the worker managing `name`. | true |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.integral_isMulLeftInvariant_isMulRightInvariant_combo._simp_1_6 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | null | false |
AddOpposite.instSubtractionMonoid.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubtractionMonoid α],
AddOpposite.instSubtractionMonoid =
{ toSubNegMonoid := AddOpposite.instSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } | null | true |
CategoryTheory.Functor.OplaxMonoidal.comp_δ | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
... | null | true |
Algebra.QuasiFinite.iff_finite_primesOver | Mathlib.RingTheory.QuasiFinite.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S], Algebra.QuasiFinite R S ↔ ∀ (I : Ideal R), I.IsPrime → (I.primesOver S).Finite | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.