name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddCon.coe_inf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {c d : AddCon M}, ⇑c ⊓ ⇑d = ⇑(c ⊓ d) | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_7 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq pq' : κ) (hr : r₀ ≤ r),
(c r).Rel pq pq' → data.i₀ r pq ⋯ = data.i₂ pq' | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRevM.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRevM f init b =
Array.foldrM (fun l acc => Std.DHashMap.Internal.AssocList.foldrM (fun a b d => f d a b) acc l) init b.buckets | null | true |
Mathlib.Tactic.Echelon.EntryCertifier._sizeOf_1 | Mathlib.Tactic.Echelon.Core | {u : Lean.Level} → {α : Q(Type u)} → Mathlib.Tactic.Echelon.EntryCertifier α → ℕ | null | false |
CategoryTheory.Triangulated.AbelianSubcategory.isLimitKernelFork._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_4} {A : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C]... | null | false |
Lean.Meta.Grind.GoalState.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{nextDeclIdx : ℕ} →
{enodeMap : Lean.Meta.Grind.ENodeMap} →
{exprs : Lean.PArray Lean.Expr} →
{parents : Lean.Meta.Grind.ParentMap} →
{congrTable : Lean.Meta.Grind.CongrTable enodeMap} →
{appMap : Lean.PHashMap Lean.HeadIndex (List Lean.Expr)} →
{in... | null | false |
continuousMultilinearCurryFin0._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G : Type u_2) (G' : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G'] (x x_1 : G [×0]→L[𝕜] G'),
(x + x_1).curry0 = (x + x_1).curry0 | null | false |
WithZero.instRepr | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → [Repr α] → Repr (WithZero α) | null | true |
CategoryTheory.MorphismProperty.Comma.mapRightIso_inverse_map_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
Lean.PersistentArrayNode.brecOn.eq | Lean.Data.PersistentArray | ∀ {α : Type u} {motive_1 : Lean.PersistentArrayNode α → Sort u_1}
{motive_2 : Array (Lean.PersistentArrayNode α) → Sort u_1} {motive_3 : List (Lean.PersistentArrayNode α) → Sort u_1}
(t : Lean.PersistentArrayNode α) (F_1 : (t : Lean.PersistentArrayNode α) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Persistent... | null | true |
ContinuousLinearMap.bilinearRestrictScalars_eq_restrictScalars_restrictScalarsL_comp | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_8} {G : Type u_12} {𝕜' : Type u_16} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedAddCommGroup E]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E]
... | null | true |
Module.Basis.ofIsLocalizedModule_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
[inst_2 : Algebra R Rₛ] [inst_3 : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid Mₛ] [inst_7 : Module R Mₛ] [inst_8 : Module Rₛ Mₛ]
[i... | null | true |
Nat.dist_tri_right' | Mathlib.Data.Nat.Dist | ∀ (n m : ℕ), n ≤ m + n.dist m | null | true |
ClusterPt.mono | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {f g : Filter X}, ClusterPt x f → f ≤ g → ClusterPt x g | null | true |
Lean.PersistentHashMap.mapMAux | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type u} →
{m : Type u → Type w} →
[Monad m] → (β → m σ) → Lean.PersistentHashMap.Node α β → m (Lean.PersistentHashMap.Node α σ) | null | true |
Std.TreeMap.getKey_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Inhabited α] {k : α}
{f : Option β → Option β} {hc : k ∈ t.alter k f}, (t.alter k f).getKey k hc = k | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.InvLog.0.Real.not_differentiableAt_inv_log_zero.match_1_6 | Mathlib.Analysis.SpecialFunctions.Log.InvLog | ∀ (x : ℝ) (motive : x ∈ Set.Ioo (-1) 0 → Prop) (x_1 : x ∈ Set.Ioo (-1) 0),
(∀ (hx₁ : -1 < x) (hx₂ : x < 0), motive ⋯) → motive x_1 | null | false |
DFinsupp.erase_single | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (j i : ι) (x : β i),
(DFinsupp.erase j fun₀ | i => x) = if i = j then 0 else fun₀ | i => x | null | true |
CategoryTheory.Center.ofBraided | Mathlib.CategoryTheory.Monoidal.Center | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.Functor C (CategoryTheory.Center C) | The functor lifting a braided category to its center, using the braiding as the half-braiding.
| true |
Std.Format.FlattenAllowability.allow.elim | Init.Data.Format.Basic | {motive : Std.Format.FlattenAllowability → Sort u} →
(t : Std.Format.FlattenAllowability) →
t.ctorIdx = 0 → ((fits : Bool) → motive (Std.Format.FlattenAllowability.allow fits)) → motive t | null | false |
CategoryTheory.MonoidalCategory.rightUnitor_tensor_inv | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLe... | null | true |
Nat.ceil_int | Mathlib.Algebra.Order.Floor.Defs | Nat.ceil = Int.toNat | null | true |
AddAction.IsBlock.vadd_eq_or_disjoint | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {B : Set X},
AddAction.IsBlock G B → ∀ (g : G), g +ᵥ B = B ∨ Disjoint (g +ᵥ B) B | **Alias** of the forward direction of `AddAction.isBlock_iff_vadd_eq_or_disjoint`. | true |
Std.TreeMap.getElem!_erase_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited β]
{k : α}, (t.erase k)[k]! = default | null | true |
Lean.Elab.Term.CoeExpansionTrace.mk._flat_ctor | Lean.Elab.Term.TermElabM | List Lean.Name → Lean.Elab.Term.CoeExpansionTrace | null | false |
CategoryTheory.Limits.BinaryFan.rightUnitor | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)} →
CategoryTheory.Limits.IsLimit s →
{t : CategoryTheory.Limits.BinaryFan X s.pt} → CategoryTheory.Limits.IsLimit t → (t.pt ≅ X) | Construct a right unitor from specified limit cones. | true |
LinearMap.coe_toContinuousLinearMap_symm | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | null | true |
Lean.Meta.SplitKind.ctorIdx | Lean.Meta.Tactic.SplitIf | Lean.Meta.SplitKind → ℕ | null | false |
Lean.Elab.Tactic.saveTacticInfoForToken | Lean.Elab.Tactic.Basic | Lean.Syntax → Lean.Elab.Tactic.TacticM Unit | Save the current tactic state for a token `stx`.
This method is a no-op if `stx` has no position information.
We use this method to save the tactic state at punctuation such as `;`
| true |
HurwitzZeta.hasSum_hurwitzZeta_of_one_lt_re | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ {a : ℝ}, a ∈ Set.Icc 0 1 → ∀ {s : ℂ}, 1 < s.re → HasSum (fun n => 1 / (↑n + ↑a) ^ s) (HurwitzZeta.hurwitzZeta (↑a) s) | Formula for `hurwitzZeta s` as a Dirichlet series in the convergence range. We
restrict to `a ∈ Icc 0 1` to simplify the statement. | true |
_private.Mathlib.Algebra.Group.Commute.Defs.0.Commute.div_pow._simp_1_3 | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} [inst : Mul G] [IsLeftCancelMul G] (a : G) {b c : G}, (a * b = a * c) = (b = c) | null | false |
CategoryTheory.Localization.homEquiv.congr_simp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C : Type u_1} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_5, u_5} D₁] [inst_2 : CategoryTheory.Category.{v_6, u_6} D₂]
(W W_1 : CategoryTheory.MorphismProperty C) (e_W : W = W_1) (L₁ : CategoryTheory.Functor C D₁)
[inst_3 : L₁.IsLocalizatio... | null | true |
ContinuousMap.instPow._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Monoid β]
[ContinuousMul β] (f : C(α, β)) (n : ℕ), Continuous (⇑f ^ n) | null | false |
CategoryTheory.Preadditive.RightFreyd.rightFunctor._proof_4 | Mathlib.CategoryTheory.Preadditive.FreydCategory.RightFreyd | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (X : V),
CategoryTheory.Arrow.homMk 0 (CategoryTheory.CategoryStruct.id X) ⋯ =
CategoryTheory.CategoryStruct.id (CategoryTheory.Arrow.mk 0) | null | false |
_private.Init.Data.Range.Polymorphic.UpwardEnumerable.0.Std.PRange.UpwardEnumerable.succMany_succ_eq_succ_succMany._simp_1_1 | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {n : ℕ} {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
Std.PRange.succMany n (Std.PRange.succ a) = Std.PRange.succMany (n + 1) a | null | false |
ContinuousLinearMap.toSeminormedRing._proof_2 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (a b : E →L[𝕜] E), a + b = b + a | null | false |
Lean.Elab.Term.Do.extendUpdatedVars | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.CodeBlock → Lean.Elab.Term.Do.VarSet → Lean.Elab.TermElabM Lean.Elab.Term.Do.CodeBlock | Extend the set of updated variables. It assumes `ws` is a super set of `c.uvars`.
We **cannot** simply update the field `c.uvars`, because `c` may have shadowed some variable in `ws`.
See discussion at `pullExitPoints`.
| true |
MeasurableSet.map_coe_volume | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} [inst : MeasureTheory.MeasureSpace α] {s : Set α},
MeasurableSet s → MeasureTheory.Measure.map Subtype.val MeasureTheory.volume = MeasureTheory.volume.restrict s | null | true |
Vector.eq_iff_flatten_eq | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xss xss' : Vector (Vector α n) m}, xss = xss' ↔ xss.flatten = xss'.flatten | Two vectors of constant length vectors are equal iff their flattens coincide. | true |
Lean.Elab.InfoTree._sizeOf_4 | Lean.Elab.InfoTree.Types | Array Lean.Elab.InfoTree → ℕ | null | false |
Set.smul_set_mono | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {s t : Set β} {a : α}, s ⊆ t → a • s ⊆ a • t | null | true |
Units.divp_sub_divp | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : CommRing α] (a b : α) (u₁ u₂ : αˣ), a /ₚ u₁ - b /ₚ u₂ = (a * ↑u₂ - ↑u₁ * b) /ₚ (u₁ * u₂) | null | true |
stableUnderGeneralization_empty | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X], StableUnderGeneralization ∅ | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr.mk.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{d : ℤ} →
{p : Int.Internal.Linear.Poly} →
{h : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof} →
{d' : ℤ} →
{p' : Int.Internal.Linear.Poly} →
{h' : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof} →
{ d := d, p := p, h := h } = { d := d', p := p', h := h' }... | null | false |
LieAlgebra.SemiDirectSum.instLieRing._proof_2 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_3} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_2}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x x_1 x_2 : K ⋊⁅ψ⁆ L),
⁅x + x_1, x_2⁆ = ⁅x, x_2⁆ + ⁅x_1, x_2⁆ | null | false |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.expandLinearCombo.match_12 | Mathlib.Tactic.LinearCombination | (motive : Mathlib.Tactic.LinearCombination.Expanded → Mathlib.Tactic.LinearCombination.Expanded → Sort u_1) →
(__do_lift __do_lift_1 : Mathlib.Tactic.LinearCombination.Expanded) →
((c₁ c₂ : Lean.Term) →
motive (Mathlib.Tactic.LinearCombination.Expanded.const c₁)
(Mathlib.Tactic.LinearCombination... | null | false |
Stream'.Seq.zip_nil_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α}, s.zip Stream'.Seq.nil = Stream'.Seq.nil | null | true |
CategoryTheory.OverPresheafAux.YonedaCollection.map₂_id | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
{F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} {X : C},
CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F (CategoryTheory.CategoryStruct.id X) = id | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.map_edgeFinset_induce._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
Module.End.IsSemisimple.mul_of_commute | Mathlib.LinearAlgebra.Semisimple | ∀ {M : Type u_2} [inst : AddCommGroup M] {K : Type u_3} [inst_1 : Field K] [inst_2 : Module K M] {f g : Module.End K M}
[FiniteDimensional K M] [PerfectField K], Commute f g → f.IsSemisimple → g.IsSemisimple → (f * g).IsSemisimple | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.insertListIfNew.eq_def | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l toInsert : List ((a : α) × β a)),
Std.Internal.List.insertListIfNew l toInsert =
match toInsert with
| [] => l
| ⟨k, v⟩ :: tl => Std.Internal.List.insertListIfNew (Std.Internal.List.insertEntryIfNew k v l) tl | null | true |
_private.Init.Data.List.Range.0.List.mem_range'._simp_1_7 | Init.Data.List.Range | ∀ {m n : ℕ}, (m.succ ≤ n) = (m < n) | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.finrank._proof_2 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {S : AlgebraicGeometry.Scheme} (s : ↥S),
AlgebraicGeometry.IsAffine (AlgebraicGeometry.Spec (S.affineOpenCover.X (S.affineOpenCover.idx s))) | null | false |
TypeVec.splitFun_inj | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)} {α' : TypeVec.{u_2} (n + 1)} {f f' : α.drop.Arrow α'.drop}
{g g' : α.last → α'.last}, TypeVec.splitFun f g = TypeVec.splitFun f' g' → f = f' ∧ g = g' | null | true |
AddSemigrp.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : AddSemigrp}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | null | true |
OrderMonoidHom.cancel_right | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] {g₁ g₂ : β →*o γ} {f : α →*o β},
Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
WithTop.ofDual_le_ofDual_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithTop αᵒᵈ}, WithTop.ofDual y ≤ WithTop.ofDual x ↔ x ≤ y | null | true |
Lean.Omega.Constraint.exact.eq_1 | Init.Omega.Constraint | ∀ (r : ℤ), Lean.Omega.Constraint.exact r = { lowerBound := some r, upperBound := some r } | null | true |
StarAddMonoid.recOn | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : AddMonoid R] →
{motive : StarAddMonoid R → Sort u_1} →
(t : StarAddMonoid R) →
([toInvolutiveStar : InvolutiveStar R] →
(star_add : ∀ (r s : R), star (r + s) = star r + star s) →
motive { toInvolutiveStar := toInvolutiveStar, star_add := star_add }) →... | null | false |
CategoryTheory.Limits.isoZeroOfMonoZero._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp 0 0) 0 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | null | false |
CategoryTheory.Functor.IsRightDerivedFunctor.instCompShiftFunctorPostcomposeShiftNatTrans | Mathlib.CategoryTheory.Functor.Derived.RightDerivedCommShift | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} H]
(RF : CategoryTheory.Functor H D) {F : CategoryTheory.Functor C D} {L : CategoryTheory.Functor C H}
(α : F ⟶ L.comp RF) (W : ... | null | true |
Std.ExtTreeMap.getD_ofList_of_contains_eq_false | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false → (Std.ExtTreeMap.ofList l cmp).getD k fallback = fallback | null | true |
CategoryTheory.Presheaf.isIso_of_isLeftKanExtension | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ]
{A : CategoryTheory.Functor C ℰ} [CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.HasPointwiseLeftKanExtension A]
(L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) ℰ)
(... | null | true |
AddOpposite.instCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [CommSemigroup α] → CommSemigroup αᵃᵒᵖ | null | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁.match_1.eq_5 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (motive : Turing.TM1.Stmt Γ Λ σ → Sort u_4) (Q : Turing.TM1.Stmt Γ Λ σ)
(h_1 :
(Q : Turing.TM1.Stmt Γ Λ σ) →
(a : Turing.Dir) → (q : Turing.TM1.Stmt Γ Λ σ) → Q = Turing.TM1.Stmt.move a q → motive (Turing.TM1.Stmt.move a q))
(h_2 :
(Q : Turing.TM1.Stmt Γ Λ... | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_7 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {n : ℕ} ⦃x : ↥{0}ᶜ⦄, ¬↑x = 0 | null | false |
ExteriorAlgebra.induction | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{C : ExteriorAlgebra R M → Prop},
(∀ (r : R), C ((algebraMap R (ExteriorAlgebra R M)) r)) →
(∀ (x : M), C ((ExteriorAlgebra.ι R) x)) →
(∀ (a b : ExteriorAlgebra R M), C a → C b → C (a * b)) →
(∀ (a b ... | If `C` holds for the `algebraMap` of `r : R` into `ExteriorAlgebra R M`, the `ι` of `x : M`,
and is preserved under addition and multiplication, then it holds for all of `ExteriorAlgebra R M`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Operations.0.SimpleGraph.edgeSet_replaceVertex_of_not_adj._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u} (G : SimpleGraph V) {a b c : V}, (s(b, c) ∈ G.incidenceSet a) = (G.Adj b c ∧ (a = b ∨ a = c)) | null | false |
Set.IsSelfInv.of_compl | Mathlib.Algebra.Group.Pointwise.Set.SelfInv | ∀ {α : Type u_1} [inst : Inv α] {s : Set α}, IsSelfInv sᶜ → IsSelfInv s | **Alias** of the forward direction of `Set.isSelfInv_compl_iff`. | true |
Pi.isLeftRegular_iff | Mathlib.Algebra.Regular.Pi | ∀ {ι : Type u_1} {R : ι → Type u_3} [inst : (i : ι) → Mul (R i)] {a : (i : ι) → R i},
IsLeftRegular a ↔ ∀ (i : ι), IsLeftRegular (a i) | null | true |
List.le_minIdxOn_of_apply_getElem_lt_apply_getElem | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [inst_2 : LT β] [Std.IsLinearPreorder β]
[Std.LawfulOrderLT β] {f : α → β} {xs : List α} (h : xs ≠ []) {i : ℕ} (hi : i < xs.length),
(∀ (j : ℕ) (x : j < i), f xs[i] < f xs[j]) → i ≤ List.minIdxOn f xs h | null | true |
LinearMap.BilinForm.mul_toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
(B : LinearMap.BilinForm R₁ M₁) (M : Matrix n n R₁),
M * (LinearMap.BilinForm.toMatrix b) B =
(LinearMap.BilinF... | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified.0.AlgebraicGeometry.FormallyUnramified.of_hom_ext._simp_1_3 | Mathlib.AlgebraicGeometry.Morphisms.FormallyUnramified | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B), (↑φ₁).comp ↑φ₂ = ↑(φ₁.comp φ₂) | null | false |
continuum_le_cardinal_of_module | Mathlib.Topology.Algebra.Module.Cardinality | ∀ (𝕜 : Type u) (E : Type v) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : AddCommGroup E] [Module 𝕜 E]
[Nontrivial E], Cardinal.continuum ≤ Cardinal.mk E | A nontrivial module over a complete nontrivially normed field has cardinality at least
continuum. | true |
HomogeneousIdeal.toIdeal_iInf₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} (s : (i : κ) → κ' i → HomogeneousIdeal 𝒜), (⨅ i, ⨅ j, s i j).toIdeal = ... | null | true |
Std.PRange.UpwardEnumerable.exists_of_succ_lt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT (Std.PRange.succ a) b →
∃ b', b = Std.PRange.succ b' ∧ Std.PRange.UpwardEnumerable.LT a b' | null | true |
isRelPrime_one_right | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : CommMonoid α] {x : α}, IsRelPrime x 1 | null | true |
CircularPreorder.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} →
{t : CircularPreorder α} →
{α' : Type u_1} → {t' : CircularPreorder α'} → α = α' → t ≍ t' → CircularPreorder.noConfusionType P t t' | null | false |
le_of_tendsto' | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIicTopology α] {f : β → α}
{a b : α} {x : Filter β} [hx : x.NeBot], Filter.Tendsto f x (nhds a) → (∀ (c : β), f c ≤ b) → a ≤ b | null | true |
Lean.LLVM.Builder._sizeOf_1 | Lean.Compiler.IR.LLVMBindings | {Context : Sort u_1} → {ctx : Context} → [SizeOf Context] → Lean.LLVM.Builder ctx → ℕ | null | false |
ContinuousOpenMap.comp._proof_1 | Mathlib.Topology.Hom.Open | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : β →CO γ) (g : α →CO β), IsOpenMap (f.toFun ∘ ⇑g.toContinuousMap) | null | false |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj._proof_3 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_8} {C₂ : Type u_10} {C₃ : Type u_6} {C₄ : Type u_3} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_9, u_10} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_2, u_3} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Funct... | null | false |
Std.ExtTreeSet.size_diff_le_size_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
(t₁ \ t₂).size ≤ t₁.size | null | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.downMulHom | Mathlib.Algebra.Group.UniqueProds.Basic | (G : Type u) → [inst : Mul G] → ULift.{u_1, u} G →ₙ* G | null | true |
RingCon.comapQuotientEquivOfSurj._proof_5 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring N] (c : RingCon M) (f : N →+* M)
{d : RingCon N}, d = c.comap f → d = (RingCon.ker (c.mk'.comp f)).comap (RingEquiv.refl N) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.isNClique_one._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {s : Finset α}, (s.card = 1) = ∃ a, s = {a} | null | false |
Std.ExtHashMap.getD_modify_self | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β} {f : β → β},
(m.modify k f).getD k fallback = (Option.map f m[k]?).getD fallback | null | true |
Frm.hasForgetToLat | Mathlib.Order.Category.Frm | CategoryTheory.HasForget₂ Frm Lat | null | true |
Partition.IsRepFun.idem | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {u : Set α} {P : Partition u} {f : α → α} {a : α}, P.IsRepFun f → f (f a) = f a | null | true |
Polynomial.degreeLT.basis_repr | Mathlib.RingTheory.Polynomial.DegreeLT | ∀ {R : Type u_1} [inst : Semiring R] {n : ℕ} (i : Fin n) (P : ↥(Polynomial.degreeLT R n)),
((Polynomial.degreeLT.basis R n).repr P) i = (↑P).coeff ↑i | null | true |
norm_indicator_eq_indicator_norm | Mathlib.Analysis.Normed.Group.Indicator | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedAddGroup E] {s : Set α} (f : α → E) (a : α),
‖s.indicator f a‖ = s.indicator (fun a => ‖f a‖) a | null | true |
Metric.minimalCover.eq_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (ε : NNReal) (A : Set X),
Metric.minimalCover ε A = if h : Metric.coveringNumber ε A ≠ ⊤ then ⋯.choose else ∅ | null | true |
MeasureTheory.Measure.withDensity._proof_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal), ∫⁻ (a : α) in ∅, f a ∂μ = 0 | null | false |
_private.Aesop.Util.Basic.0.Aesop.hasSorry.go._unsafe_rec | Aesop.Util.Basic | Lean.MetavarContext → Lean.Expr → Bool | null | false |
Lie.Derivation.ofDerivation._proof_3 | Mathlib.Algebra.Lie.Derivation.BaseChange | ∀ {R : Type u_3} [inst : CommRing R] {A : Type u_1} [inst_1 : CommRing A] [inst_2 : Algebra R A] (L : Type u_2)
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (d : Derivation R A A) (x y : TensorProduct R A L),
{ toFun := ⇑(LinearMap.rTensor L ↑d), map_add' := ⋯, map_smul' := ⋯ } ⁅x, y⁆ =
⁅x, { toFun := ⇑(Linea... | null | false |
LinearEquiv.finrank_fixedSubmodule_mul_dilatransvection_le | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {K : Type u_1} [inst : DivisionRing K] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[Module.Finite K V] (e f : V ≃ₗ[K] V),
f ∈ LinearEquiv.dilatransvections K V →
Module.finrank K ↥(↑(e * f)).fixedSubmodule ≤ 1 + Module.finrank K ↥(↑e).fixedSubmodule | null | true |
_private.Lean.Elab.InfoTree.Main.0.Lean.Elab.formatElabInfo | Lean.Elab.InfoTree.Main | Lean.Elab.ContextInfo → Lean.Elab.ElabInfo → Std.Format | null | true |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_4 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M) {x : M}, (x ∈ ↑N) = (x ∈ N) | null | false |
CategoryTheory.MorphismProperty.HasLocalization.noConfusion | Mathlib.CategoryTheory.Localization.HasLocalization | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{t : W.HasLocalization} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{W' : CategoryTheory.MorphismProperty C'} →
... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.sliceFrom_le_sliceFrom_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.