name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Canonicalizer.State | Lean.Meta.Canonicalizer | Type | State for the `CanonM` monad.
| true |
_private.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.replaceRecApps.loop.match_8 | Lean.Elab.PreDefinition.Structural.BRecOn | (recArgInfos : Array Lean.Elab.Structural.RecArgInfo) →
(motive : Option (Fin recArgInfos.size) → Sort u_1) →
(x : Option (Fin recArgInfos.size)) →
((fnIdx : Fin recArgInfos.size) → motive (some fnIdx)) →
((x : Option (Fin recArgInfos.size)) → motive x) → motive x | null | false |
LieHom.coe_mk | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L₁ → L₂) (h₁ : ∀ (x y : L₁), f (x + y) = f x + f y)
(h₂ :
∀ (m : R) (x : L₁),
{ toFun := f, map_add' := h₁ }.toFun (m • x) = (RingHom.id R) ... | null | true |
Valuation.instLinearOrderedCommGroupWithZeroMrange._proof_8 | Mathlib.RingTheory.Valuation.Archimedean | ∀ {F : Type u_2} {Γ₀ : Type u_1} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation F Γ₀},
autoParam (∀ (n : ℕ) (a : ↥(MonoidHom.mrange v)), a ^ ↑n.succ = a ^ ↑n * a) DivInvMonoid.zpow_succ'._autoParam | null | false |
_private.Mathlib.LinearAlgebra.Center.0.LinearMap.mem_center_of_apply_eq_smul._simp_1_1 | Mathlib.LinearAlgebra.Center | ∀ {M : Type u_1} [inst : Mul M] {z : M}, (z ∈ Set.center M) = IsMulCentral z | null | false |
Lean.Meta.Sym.Simp.MethodsRef.toMethods | Lean.Meta.Sym.Simp.SimpM | Lean.Meta.Sym.Simp.MethodsRef → Lean.Meta.Sym.Simp.Methods | null | true |
Mathlib.Meta.NormNum.nat_gcd_helper_dvd_right | Mathlib.Tactic.NormNum.GCD | ∀ (x y : ℕ), x % y = 0 → x.gcd y = y | null | true |
MeasureTheory.Integrable.uniformIntegrable_condExp | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Type u_2} [MeasureTheory.IsFiniteMeasure μ]
{g : α → ℝ},
MeasureTheory.Integrable g μ →
∀ {ℱ : ι → MeasurableSpace α}, (∀ (i : ι), ℱ i ≤ m0) → MeasureTheory.UniformIntegrable (fun i => μ[g | ℱ i]) 1 μ | Given an integrable function `g`, the conditional expectations of `g` with respect to
a sequence of sub-σ-algebras is uniformly integrable. | true |
CategoryTheory.Functor.CommShift₂.mk._flat_ctor | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] →
[inst_2 : CategoryTheory.Category.{v_5, u_5} D] →
{M : Type u_6} →
[inst_3 : AddCommMonoid M] →
... | null | false |
AddCommMagma | Mathlib.Algebra.Group.Semigroup | Type u_2 → Type u_2 | A commutative additive magma is a type with an addition which commutes. | true |
Nat.Partrec'.below.comp | Mathlib.Computability.PartrecBasis | ∀ {motive : {n : ℕ} → (a : List.Vector ℕ n →. ℕ) → Nat.Partrec' a → Prop} {m n : ℕ} {f : List.Vector ℕ n →. ℕ}
(g : Fin n → List.Vector ℕ m →. ℕ) (a : Nat.Partrec' f) (a_1 : ∀ (i : Fin n), Nat.Partrec' (g i)),
Nat.Partrec'.below a →
motive f a → (∀ (i : Fin n), Nat.Partrec'.below ⋯) → (∀ (i : Fin n), motive (g ... | null | true |
FirstOrder.Language.BoundedFormula.realize_liftAt_one | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {n m : ℕ} {φ : L.BoundedFormula α n}
{v : α → M} {xs : Fin (n + 1) → M},
m ≤ n →
((FirstOrder.Language.BoundedFormula.liftAt 1 m φ).Realize v xs ↔
φ.Realize v (xs ∘ fun i => if ↑i < m then i.castSucc else i.succ)) | null | true |
Shrink.continuousLinearEquiv_symm_apply | Mathlib.Topology.Algebra.Module.TransferInstance | ∀ (R : Type u_1) (α : Type u_2) [inst : Small.{v, u_2} α] [inst_1 : AddCommMonoid α] [inst_2 : TopologicalSpace α]
[inst_3 : Semiring R] [inst_4 : Module R α] (a : α), (Shrink.continuousLinearEquiv R α).symm a = (equivShrink α) a | null | true |
Std.HashSet.get!_inter_of_not_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∉ m₂ → (m₁ ∩ m₂).get! k = default | null | true |
CategoryTheory.Functor.constComp | Mathlib.CategoryTheory.Functor.Const | (J : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} D] →
(X : C) →
(F : CategoryTheory.Functor C D) →
((CategoryThe... | These are actually equal, of course, but not definitionally equal
(the equality requires `F.map (𝟙 _) = 𝟙 _`). A natural isomorphism is
more convenient than an equality between functors (compare id_to_iso). | true |
IncidenceAlgebra.moduleRight._proof_4 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_3} {𝕝 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Semiring 𝕜] [inst_2 : AddCommMonoid 𝕝]
[inst_3 : Module 𝕜 𝕝] (c : 𝕜) (f : IncidenceAlgebra 𝕝 α), ⇑(c • f) = c • ⇑f | null | false |
PreInnerProductSpace.Core.conj_inner_symm | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_4} {F : Type u_5} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
(self : PreInnerProductSpace.Core 𝕜 F) (x y : F), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y | The inner product is *Hermitian*, taking the `conj` swaps the arguments. | true |
CategoryTheory.Cat.chosenTerminalIsTerminal._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Cat | ∀ (x : CategoryTheory.Cat) (x_1 : x ⟶ CategoryTheory.Cat.chosenTerminal), x_1 = x_1 | null | false |
AddHom.noConfusionType | Mathlib.Algebra.Group.Hom.Defs | Sort u →
{M : Type u_10} →
{N : Type u_11} →
[inst : Add M] →
[inst_1 : Add N] →
(M →ₙ+ N) → {M' : Type u_10} → {N' : Type u_11} → [inst' : Add M'] → [inst'_1 : Add N'] → (M' →ₙ+ N') → Sort u | null | false |
Std.DTreeMap.Internal.Impl.getKey!_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKey! k = default | null | true |
Matrix.IsTotallyNonneg.smul | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg | ∀ {ι : Type u_1} {R : Type u_3} [inst : PartialOrder ι] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
[IsOrderedRing R] {M : Matrix ι ι R}, M.IsTotallyNonneg → ∀ {c : R}, 0 ≤ c → (c • M).IsTotallyNonneg | null | true |
CategoryTheory.MonoidalCategory.Limits.preservesLimit_of_braided_and_preservesLimit_tensor_left | Mathlib.CategoryTheory.Monoidal.Limits.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{J : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.BraidedCategory C] (c : C)
[CategoryTheory.Limits.PreservesLimit F (CategoryTheory.MonoidalCat... | When `C` is braided and `tensorLeft c` preserves a limit, then so does `tensorRight k`. | true |
Module.Relations.Solution.casesOn | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{relations : Module.Relations A} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] →
{motive : relations.Solution M → Sort u_1} →
(t : relations.Solution M) →
((var : relations.G → M) →
... | null | false |
Pi.rightCancelMonoid.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → RightCancelMonoid (f i)],
Pi.rightCancelMonoid =
{ toOne := Pi.monoid.toOne, toMul := Pi.rightCancelSemigroup.toMul, mul_assoc := ⋯, one_mul := ⋯, mul_one := ⋯,
toNPow := Pi.monoid.toNPow, npow_zero := ⋯, npow_succ := ⋯, toIsRightCancelMul := ⋯ } | null | true |
Matroid.mem_closure_diff_singleton_iff_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X : Set α} {e : α},
e ∈ X →
autoParam (e ∈ M.E) Matroid.mem_closure_sdiff_singleton_iff_closure._auto_1 →
(e ∈ M.closure (X \ {e}) ↔ M.closure (X \ {e}) = M.closure X) | **Alias** of `Matroid.mem_closure_sdiff_singleton_iff_closure`. | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData._sizeOf_1 | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.PendingSolverPropagationsData✝ → ℕ | null | false |
Lean.Lsp.DeclarationParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toTextDocumentPositionParams toTextDocumentPositionParams_1 : Lean.Lsp.TextDocumentPositionParams},
{ toTextDocumentPositionParams := toTextDocumentPositionParams } =
{ toTextDocumentPositionParams := toTextDocumentPositionParams_1 } →
toTextDocumentPositionParams = toTextDocumentPositionParams_1 | null | true |
FirstOrder.Language.LHom.onRelation | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → (L →ᴸ L') → ⦃n : ℕ⦄ → L.Relations n → L'.Relations n | The mapping of relations | true |
Con.comap | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} →
{N : Type u_2} →
[inst : Mul M] → [inst_1 : Mul N] → (f : M → N) → (∀ (x y : M), f (x * y) = f x * f y) → Con N → Con M | Given types with multiplications `M, N` and a congruence relation `c` on `N`, a
multiplication-preserving map `f : M → N` induces a congruence relation on `f`'s domain
defined by '`x ≈ y` iff `f(x)` is related to `f(y)` by `c`.' | true |
CategoryTheory.Limits.biprod.isKernelSndKernelFork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.biprod.sndKernelFork X Y) | The fork `biprod.sndKernelFork` is indeed a limit. | true |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.ArchimedeanClass.mk_le_mk_iff_lt.match_1_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M}
(motive : ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → Prop) (x : ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b),
(∀ (n : ℕ) (hn : |ArchimedeanOrder.val (ArchimedeanOrder.of b)| ≤ n • |ArchimedeanOrder.val... | null | false |
Std.DTreeMap.Internal.Impl.minKeyD.match_1.congr_eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → α → Sort u_3)
(x : Std.DTreeMap.Internal.Impl α β) (x_1 : α)
(h_1 : (fallback : α) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Impl... | null | true |
ImportGraph.Lake.BaseLibrary.mk._flat_ctor | ImportGraph.WorkspaceModel.Base | Lean.Name → System.FilePath → Array Lean.Name → Array Lake.Glob → ImportGraph.Lake.BaseLibrary | null | false |
Lean.Meta.Grind.CheckResult.ctorIdx | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult → ℕ | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.numbering.go._f | Lean.DocString.Parser | (x : List Lean.Doc.Parser.OrderedListType) → List.below x → Lean.Parser.ParserFn | null | false |
_private.Mathlib.Algebra.Order.Ring.GeomSum.0.geom_sum_alternating_of_lt_neg_one._simp_1_2 | Mathlib.Algebra.Order.Ring.GeomSum | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | null | false |
CategoryTheory.Lax.OplaxTrans.Hom.of.injEq | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (as as_1 : CategoryTheory.Lax.OplaxTrans.Modification η θ),
({ as := as } = { as := as_1 }) = (as = as_1) | null | true |
_private.Mathlib.Algebra.Group.Subsemigroup.Membership.0.Subsemigroup.isMulCommutative_iSup._simp_1_2 | Mathlib.Algebra.Group.Subsemigroup.Membership | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
IsCoprime.mul_add_right_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → ∀ (z : R), IsCoprime x (z * x + y) | null | true |
Std.Time.Awareness.only.sizeOf_spec | Std.Time.Format.Basic | ∀ (a : Std.Time.TimeZone), sizeOf (Std.Time.Awareness.only a) = 1 + sizeOf a | null | true |
WithTopology.noConfusionType | Mathlib.Topology.Defs.Basic | Sort u →
{X : Type u_1} →
{t : TopologicalSpace X} →
WithTopology X t → {X' : Type u_1} → {t' : TopologicalSpace X'} → WithTopology X' t' → Sort u | null | false |
Std.Time.DateFormatSymbols.dayPeriodNarrow | Std.Time.Format.DateFormat | Std.Time.DateFormatSymbols → Std.Time.DayPeriodSymbols | Narrow day-period strings for the `b` pattern (AM, PM, noon, midnight).
Used by `bbbbb`.
| true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.μ_limsup_le_one._simp_1_4 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_toNat_iff_getLsbD_eq_true._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {i : ℕ} (w : ℕ) {x : BitVec (w + 1)}, i < w + 1 → ¬w - i + (i + 1) = w + 1 → False | null | false |
AddGroupWithOne.noConfusion | Mathlib.Data.Int.Cast.Defs | {P : Sort u_1} →
{R : Type u} →
{t : AddGroupWithOne R} →
{R' : Type u} → {t' : AddGroupWithOne R'} → R = R' → t ≍ t' → AddGroupWithOne.noConfusionType P t t' | null | false |
RestrictedProduct.instGroupCoeOfSubgroupClass._proof_10 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Group (R i)] [inst_2 : ∀ (i : ι), SubgroupClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (x_1 : ℤ), ⇑(x ^ x_1) = ⇑(x ^ x_1) | null | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.explainStuckTypeclassProblem._sparseCasesOn_7 | Lean.Elab.SyntheticMVars | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
HomologicalComplex.HomologySequence.snakeInput._proof_15 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i : ι), (S.X₁.sc i).HasHomology | null | false |
Equiv.image_symm_apply_coe | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set α) (y : ↑(⇑e '' s)), ↑((e.image s).symm y) = e.symm ↑y | null | true |
Std.TreeSet.get_get? | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{h : (t.get? k).isSome = true}, (t.get? k).get h = t.get k ⋯ | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_7 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y z : V},
0 ≤ Real.sin (InnerProductGeometry.angle x y) / ‖z‖ | null | false |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{S : CategoryTheory.Sieve X} {E : J.OneHypercover X}, E.sieve₀ ≤ S → ∀ (i : E.multicospanShape.L), S.arrows (E.f i) | null | false |
Lex.instDivisionRing._aux_9 | Mathlib.Algebra.Field.Basic | {K : Type u_1} → [DivisionRing K] → ℚ≥0 → Lex K → Lex K | null | false |
Std.Time.WallTime.instHSubDuration_1 | Std.Time.DateTime.WallTime | HSub Std.Time.WallTime Std.Time.WallTime Std.Time.Duration | null | true |
instCoeTailNatOfNatCast | Init.Data.Cast | {R : Type u_1} → [NatCast R] → CoeTail ℕ R | null | true |
_private.Mathlib.Analysis.Analytic.Constructions.0.Finset.analyticWithinAt_sum._simp_1_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
Lean.Elab.TerminationHints._sizeOf_inst | Lean.Elab.PreDefinition.TerminationHint | SizeOf Lean.Elab.TerminationHints | null | false |
Set.image_prod | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) {s : Set α} {t : Set β},
(fun x => f x.1 x.2) '' s ×ˢ t = Set.image2 f s t | null | true |
AEMeasurable.sum_measure | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
[Countable ι] {μ : ι → MeasureTheory.Measure α},
(∀ (i : ι), AEMeasurable f (μ i)) → AEMeasurable f (MeasureTheory.Measure.sum μ) | null | true |
Pi.single | Mathlib.Algebra.Notation.Pi.Basic | {ι : Type u_1} → {M : ι → Type u_4} → [(i : ι) → Zero (M i)] → [DecidableEq ι] → (i : ι) → M i → (j : ι) → M j | The function supported at `i`, with value `x` there, and `0` elsewhere. | true |
CovBySMul.of_subset._simp_2 | Mathlib.Combinatorics.Additive.CovBySMul | ∀ {M : Type u_1} {X : Type u_3} [inst : Monoid M] [inst_1 : MulAction M X] {A B : Set X},
A ⊆ B → CovBySMul M 1 A B = True | null | false |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory._aux_Mathlib_MeasureTheory_Integral_DivergenceTheorem___macroRules__private_Mathlib_MeasureTheory_Integral_DivergenceTheorem_0_MeasureTheory_termFrontFace__1 | Mathlib.MeasureTheory.Integral.DivergenceTheorem | Lean.Macro | null | false |
_private.Mathlib.Combinatorics.Enumerative.Partition.YoungDiagram.0.YoungDiagram.rowLens_ofPartition_eq_sort_parts._proof_1_2 | Mathlib.Combinatorics.Enumerative.Partition.YoungDiagram | IsTrans ℕ fun x1 x2 => x2 ≤ x1 | null | false |
CategoryTheory.IsEquivalenceRelation.casesOn | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.IsEquivalenceRelation p₁ p₂ → Sort u} →
(t : CategoryTheory.IsEquivalenceRelation p₁ p₂) →
((nonempty_equivalenceRelation : Nonempty (CategoryTheory.Equivalen... | null | false |
RingHom.eqLocus | Mathlib.Algebra.Ring.Subring.Basic | {R : Type u} → [inst : NonAssocRing R] → {S : Type v} → [inst_1 : Semiring S] → (R →+* S) → (R →+* S) → Subring R | The subring of elements `x : R` such that `f x = g x`, i.e.,
the equalizer of f and g as a subring of R | true |
IntermediateField.extendScalars._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{F E : IntermediateField K L}, F ≤ E → F.toSubfield ≤ E.toSubfield | null | false |
Turing.PartrecToTM2.K'.main.sizeOf_spec | Mathlib.Computability.TuringMachine.ToPartrec | sizeOf Turing.PartrecToTM2.K'.main = 1 | null | true |
SimpleGraph.Subgraph.instCompleteLattice._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (x : Set G.Subgraph), sSup x ∈ upperBounds x ∧ sSup x ∈ lowerBounds (upperBounds x) | null | false |
connectedComponents_lift_unique' | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] {β : Sort u_3} {g₁ g₂ : ConnectedComponents α → β},
g₁ ∘ ConnectedComponents.mk = g₂ ∘ ConnectedComponents.mk → g₁ = g₂ | null | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff_left._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (sᶜ ∈ f) = Disjoint (Filter.principal s) f | null | false |
WeierstrassCurve.a₁_of_isCharNeTwoNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsCharNeTwoNF], W.a₁ = 0 | null | true |
pow_succ_nonneg._f | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [PosMulMono M₀],
0 ≤ a → ∀ (x : ℕ) (f : Nat.below x), 0 ≤ a ^ (x + 1) | null | false |
_private.Std.Do.WP.Sound.0.Std.Do.PredTrans.pushOption.match_1.splitter | Std.Do.WP.Sound | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x | null | true |
WType.rec | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{motive : WType β → Sort u} →
((a : α) → (f : β a → WType β) → ((a : β a) → motive (f a)) → motive (WType.mk a f)) → (t : WType β) → motive t | null | false |
_private.Init.Data.Array.InsertIdx.0.Array.getElem?_insertIdx_self._proof_1_1 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {xs : Array α} {i : ℕ}, i < i → False | null | false |
ContinuousMul.casesOn | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : ContinuousMul M → Sort u} →
(t : ContinuousMul M) → ((continuous_mul : Continuous fun p => p.1 * p.2) → motive ⋯) → motive t | null | false |
CategoryTheory.Limits.isLimitConeOfHasLimitCurryCompLim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_6} {K : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(G : CategoryTheory.Functor (J × K) C) [CategoryTheory.Limits.HasLimitsOfShape K C] (j : J),
CategoryTheory.Limits.HasLimit (... | null | false |
MvPolynomial.weightedDecomposition | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | (R : Type u_1) →
{M : Type u_2} →
[inst : CommSemiring R] →
{σ : Type u_3} →
(w : σ → M) →
[inst_1 : AddCommMonoid M] →
[inst_2 : DecidableEq M] → DirectSum.Decomposition (MvPolynomial.weightedHomogeneousSubmodule R w) | Given a weight `w`, the decomposition of `MvPolynomial σ R` into weighted homogeneous
submodules | true |
_private.Std.Time.Notation.0.Std.Time.convertZoneId | Std.Time.Notation | Std.Time.ZoneId → Lean.MacroM (Lean.TSyntax `term) | null | true |
WeierstrassCurve.Projective.addXYZ | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R | The coordinates of a representative of `P + Q` for two distinct projective point representatives
`P` and `Q` on a Weierstrass curve.
If the representatives of `P` and `Q` are equal, then this returns the value `![0, 0, 0]`. | true |
ContinuousMultilinearMap.continuousMapClass | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂],
ContinuousMapClass (Conti... | null | true |
Int.Internal.Linear.Poly.isValidEq | Init.Data.Int.Linear | Int.Internal.Linear.Poly → Bool | null | true |
_private.Lean.Elab.Util.0.Lean.Elab.nestedExceptionToMessageData.match_1 | Lean.Elab.Util | (motive : Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw) → (Unit → motive none) → ((exPos : String.Pos.Raw) → motive (some exPos)) → motive x | null | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.sub_scalar_sq_eq_discr._simp_1_6 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Vector.getElem?_extract | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {as : Vector α n} {start stop : ℕ},
(as.extract start stop)[i]? = if i < min stop n - start then as[start + i]? else none | null | true |
SummableUniformlyOn.exists | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α], SummableUniformlyOn f s → ∃ g, HasSumUniformlyOn f g s | null | true |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.getLiteral.go | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Compiler.LCNF.UnreachableBranches.Value →
Lean.Compiler.LCNF.CompilerM (Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) × Lean.FVarId) | null | true |
Equiv.prodShear._proof_2 | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : Type u_1} {β₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂),
Function.LeftInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2) | null | false |
CategoryTheory.braiding_rightUnitor_aux₂ | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(β_ (... | null | true |
Std.Internal.USquash.rec | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
[small : Std.Internal.Small α] →
{motive : Std.Internal.USquash α → Sort u_1} →
((inner : Std.Internal.ComputableSmall.Target α) → motive { inner := inner }) →
(t : Std.Internal.USquash α) → motive t | null | false |
_private.Lake.Util.Version.0.Lake.VerComponent.casesOn | Lake.Util.Version | {motive : Lake.VerComponent✝ → Sort u} →
(t : Lake.VerComponent✝) →
motive Lake.VerComponent.none✝ →
motive Lake.VerComponent.wild✝ → ((n : ℕ) → motive (Lake.VerComponent.nat✝ n)) → motive t | null | false |
_private.Mathlib.Order.Filter.Lift.0.Filter.lift'_neBot_iff._simp_1_1 | Mathlib.Order.Filter.Lift | ∀ {α : Type u} {s : Set α}, (Filter.principal s).NeBot = s.Nonempty | null | false |
coe_toIdeal | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] [inst_5 : GradedRing 𝒜]
(I : HomogeneousIdeal 𝒜), ↑I.toIdeal = ↑I | null | true |
Aesop.Script.TacticState.getVisibleGoalIndex? | Aesop.Script.TacticState | Aesop.Script.TacticState → Lean.MVarId → Option ℕ | null | true |
CategoryTheory.Cokleisli.Hom._sizeOf_inst | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{U : CategoryTheory.Comonad C} → (c c' : CategoryTheory.Cokleisli U) → [SizeOf C] → SizeOf (c.Hom c') | null | false |
_private.Mathlib.Topology.UniformSpace.Equicontinuity.0.Filter.HasBasis.uniformEquicontinuous_iff._simp_1_1 | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
_private.Init.Data.Array.Find.0.Array.idxOf.eq_1 | Init.Data.Array.Find | ∀ {α : Type u} [inst : BEq α] (a : α), Array.idxOf a = Array.findIdx fun x => x == a | null | true |
Std.DTreeMap.size_add_size_eq_size_union_add_size_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t₁.size + t₂.size = (t₁ ∪ t₂).size + (t₁ ∩ t₂).size | null | true |
HomologicalComplex.dgoToHomologicalComplex._proof_4 | Mathlib.Algebra.Homology.DifferentialObject | ∀ {β : Type u_3} [inst : AddCommGroup β] (b : β) (V : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} V]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V]
{X Y : CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V)} (f : X ⟶ Y) (i j : β),
(ComplexShape.up' b).Rel i j →
Categ... | null | false |
SupBotHom.instSemilatticeSup | Mathlib.Order.Hom.BoundedLattice | {α : Type u_2} →
{β : Type u_3} →
[inst : Max α] →
[inst_1 : Bot α] → [inst_2 : SemilatticeSup β] → [inst_3 : OrderBot β] → SemilatticeSup (SupBotHom α β) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.