name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Sym.DSimp.Result.ctorElimType | Lean.Meta.Sym.DSimp.DSimpM | {motive : Lean.Meta.Sym.DSimp.Result → Sort u} → ℕ → Sort (max 1 u) | null | false |
Lean.Grind.NoopConfig.splits._default | Init.Grind.Config | ℕ | null | false |
NonemptyInterval.instCommSemiringOfCanonicallyOrderedAdd._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommSemiring α] [inst_1 : PartialOrder α] [inst_2 : CanonicallyOrderedAdd α],
autoParam (∀ (x : NonemptyInterval α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
one_le_cfc_iff._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
_private.Lean.Class.0.Lean.init | Lean.Class | IO Unit | Registers an inductive type or structure as a type class. Using `class` or `class inductive` is
generally preferred over using `@[class] structure` or `@[class] inductive` directly.
| true |
OrderIso.dualAntisymmetrization._proof_8 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a b : (Antisymmetrization α fun x1 x2 => x1 ≤ x2)ᵒᵈ),
{ toFun := Quotient.map' id ⋯, invFun := Quotient.map' id ⋯, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := Quotient.map' id ⋯, invFun := Quotient.map' id ⋯, left_inv := ⋯, right_inv := ⋯ } b ↔
a ≤ b | null | false |
_private.Init.Data.Array.Lemmas.0.Array.push_eq_push._simp_1_1 | Init.Data.Array.Lemmas | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
BitVec.getElem_signExtend | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {v i : ℕ} (h : i < v), (BitVec.signExtend v x)[i] = if h : i < w then x[i] else x.msb | null | true |
div_eq_zero_iff._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, (a / b = 0) = (a = 0 ∨ b = 0) | null | false |
Lean.Grind.CommRing.d_normEq0 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (k : ℤ) (c : ℕ)
(init p₁ p₂ p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.d_normEq0_cert c p₁ p₂ p = true →
↑k * Lean.Grind.CommRing.Poly.denote ctx init = Lean.Grind.CommRing.Poly.denote ctx p₁ →
Lean.Grind.CommRin... | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodySum_volume._simp_1_9 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] {L : Type u_5} [inst_4 : RCLike L]
(f : α → L) (g : β → L), (∫ (x : α), f x ∂μ) * ∫ (y : β), g y ∂ν = ∫ (z : α × β),... | null | false |
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α], IsOrderedAddMonoid (Additive αᵒᵈ) | null | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.newDepHyp.noConfusion | Lean.Meta.Tactic.Grind.Intro | {P : Sort u} →
{goal goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntroResult.newDepHyp✝ goal = Lean.Meta.Grind.IntroResult.newDepHyp✝ goal' → (goal = goal' → P) → P | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.where._regBuiltin.Lean.Parser.Command.where_1 | Lean.Parser.Command | IO Unit | null | false |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_1 | Mathlib.RingTheory.LittleWedderburn | ∀ {D : Type u_1} [inst : DivisionRing D] {R : Subring D}, IsDomain ↥R | null | false |
exists_mem_nhdsSet_isClosed_subset | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [NormalSpace X] {u s : Set X},
s ∈ nhdsSet u → IsClosed u → ∃ t ∈ nhdsSet u, IsClosed t ∧ t ⊆ s | null | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_cons_aux | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {x : α} {xs : List α}
{f : α → β} (hxs : xs ≠ []),
List.minIdxOn f (x :: xs) ⋯ = List.combineMinIdxOn✝ f (List.minIdxOn f [x] ⋯) (List.minIdxOn f xs hxs) ⋯ ⋯ | null | true |
Unitization.instMulOneClass._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_2} {A : Type u_1} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : DistribMulAction R A]
(x : Unitization R A), (1 * x).toProd.2 = x.toProd.2 | null | false |
Lean.Grind.OrderedAdd.add_le_add | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommMonoid M] [Lean.Grind.OrderedAdd M]
{a b c d : M}, a ≤ b → c ≤ d → a + c ≤ b + d | null | true |
Lean.MessageData.instCoeFormat | Lean.Message | Coe Std.Format Lean.MessageData | null | true |
CategoryTheory.Functor.preservesZeroMorphisms_of_isLeftAdjoint | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [F.IsLeftAdjoint], F.PreservesZeroMorphisms | null | true |
contDiffWithinAt_infty | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E}, ContDiffWithinAt 𝕜 (↑⊤) f s x ↔ ∀ (n : ℕ), ContDiffWithinAt 𝕜 (↑n) f s x | null | true |
CategoryTheory.Triangulated.Octahedron.rec | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : Ca... | null | false |
WithCStarModule.instNormedAddCommGroupForall._proof_19 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_1} {E : ι → Type u_2}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [StarOrderedRing A],
autoP... | null | false |
Equiv.Perm.IsCycleOn.of_inv | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {s : Set α}, f⁻¹.IsCycleOn s → f.IsCycleOn s | **Alias** of the forward direction of `Equiv.Perm.isCycleOn_inv`. | true |
Equiv.symm_preimage_preimage | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set β), ⇑e.symm ⁻¹' ⇑e ⁻¹' s = s | null | true |
AlgebraicGeometry.Proj.zero_apply | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {V : (TopologicalSpace.Opens ↑(ProjectiveSpectrum.top 𝒜))ᵒᵖ} (x : ↥(Opposite.unop V)),
↑0 x = 0 | null | true |
Std.HashMap.Raw.isEmpty_inter_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.isEmpty = true → (m₁ ∩ m₂).isEmpty = true | null | true |
List.length_filter_pos_iff._simp_1 | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (0 < (List.filter p l).length) = ∃ x ∈ l, p x = true | null | false |
CategoryTheory.MorphismProperty.colimitsOfShape | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.MorphismProperty C →
(J : Type u_1) → [CategoryTheory.Category.{v_1, u_1} J] → CategoryTheory.MorphismProperty C | The class of morphisms in `C` that are colimits of shape `J` of
natural transformations involving morphisms in `W`. | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology.0.ProjectiveSpectrum.instPartialOrder._simp_3 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {a : Prop}, (a → a) = True | null | false |
CategoryTheory.GrothendieckTopology.Cover.Relation.mk.inj | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} {fst snd : S.Arrow} {r : fst.Relation snd} {fst_1 snd_1 : S.Arrow} {r_1 : fst_1.Relation snd_1},
{ fst := fst, snd := snd, r := r } = { fst := fst_1, snd := snd_1, r := r_1 } → fst = fst_1 ∧ ... | null | true |
CategoryTheory.Lax.OplaxTrans.rightUnitor | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
(η : F ⟶ G) → CategoryTheory.CategoryStruct.comp η (CategoryTheory.CategoryStruct.id G) ≅ η | Right unitor for the vertical composition of oplax natural transformations. | true |
Lean.Grind.ConfigInteractive.gen._inherited_default | Init.Grind.Config | ℕ | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.quasiIsoAt_π._simp_1_5 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i : ι) [inst_2 : K.HasHomology i],
CategoryTheory.CategoryStruct.id (K.homology i) =
HomologicalComplex.homologyMap (CategoryTheory... | null | false |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.Result.no.elim | Lean.Meta.Tactic.Grind.PP | {motive : Lean.Meta.Grind.Result✝ → Sort u} →
(t : Lean.Meta.Grind.Result✝) → Lean.Meta.Grind.Result.ctorIdx✝ t = 2 → motive Lean.Meta.Grind.Result.no✝ → motive t | null | false |
_private.Mathlib.Analysis.Normed.Module.Ball.Homeomorph.0.OpenPartialHomeomorph.univUnitBall._simp_6 | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Polynomial.natDegree_removeFactor' | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] {f : Polynomial K} {n : ℕ}, f.natDegree = n + 1 → f.removeFactor.natDegree = n | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.maxChild_ge_right._proof_1_12 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {sz : ℕ} (a : Vector α sz) (i : Fin sz), 2 * ↑i + 2 < sz → 2 * ↑i + 2 < sz | null | false |
AddMonCat.adjoinZero._proof_2 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X Y Z : AddSemigrp} (x : X ⟶ Y) (x_1 : Y ⟶ Z),
AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp x x_1))) =
CategoryTheory.CategoryStruct.comp (AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom x)))
(AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom x... | null | false |
AddCommGrpCat.forget_createsLimitsOfSize.eq_1 | Mathlib.Algebra.Category.Grp.Limits | AddCommGrpCat.forget_createsLimitsOfSize =
{ CreatesLimitsOfShape := fun {J} [CategoryTheory.Category.{w, v} J] => inferInstance } | null | true |
FirstOrder.Language.IsOrdered.casesOn | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{motive : L.IsOrdered → Sort u_1} →
(t : L.IsOrdered) → ((leSymb : L.Relations 2) → motive { leSymb := leSymb }) → motive t | null | false |
CategoryTheory.uliftFunctorTrivial._proof_1 | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u_1} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftFunctor.{u_1, u_1}.map f)
(CategoryTheory.uliftTrivial Y).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftTrivial X).hom
((CategoryTheory.Functor.id (Type u_1)).map f) | null | false |
Module.IsTorsionBySet.hasSMul._proof_1 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R},
Module.IsTorsionBySet R M ↑I → Submodule.toAddSubgroup I ≤ (smulAddHom R M).ker | null | false |
IsSemiprimaryRing.isSemisimpleRing | Mathlib.RingTheory.Jacobson.Semiprimary | ∀ {R : Type u_1} {inst : Ring R} [self : IsSemiprimaryRing R], IsSemisimpleRing (R ⧸ Ring.jacobson R) | null | true |
ContinuousMap.instMulZeroClassOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : MulZeroClass β] → [ContinuousMul β] → MulZeroClass C(α, β) | null | true |
Std.HashMap.Raw.«term_~m_» | Std.Data.HashMap.Raw | Lean.TrailingParserDescr | Two hash maps are equivalent in the sense of `Equiv` iff
all the keys and values are equal.
| true |
Path.extend_of_le_zero | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a b : X} (γ : Path a b) {t : ℝ}, t ≤ 0 → γ.extend t = a | null | true |
inv_mul_le_one_of_le₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b : G₀}
[ZeroLEOneClass G₀], a ≤ b → 0 ≤ b → b⁻¹ * a ≤ 1 | null | true |
IsZLattice.basis._proof_2 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] (L : Submodule ℤ (ι → ℝ)) [DiscreteTopology ↥L], Module.Free ℤ ↥L | null | false |
CategoryTheory.Presieve.CoverByImageStructure.mk.inj | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {D : Type u_2}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {G : CategoryTheory.Functor C D} {V U : D} {f : V ⟶ U} {obj : C}
{lift : V ⟶ G.obj obj} {map : G.obj obj ⟶ U}
{fac :
autoParam (CategoryTheory.CategoryStruct.comp lift map = f)
C... | null | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.match_1 | Lean.Environment | (motive : Option Lean.RealizationContext✝ → Sort u_1) →
(x : Option Lean.RealizationContext✝) →
((ctx : Lean.RealizationContext✝) → motive (some ctx)) → (Unit → motive none) → motive x | null | false |
ContMDiffAt.clm_comp | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F₁ : Type u_8} [inst_6 : NormedAddComm... | null | true |
CliffordAlgebra.even.lift.aux | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] → CliffordAlgebra.EvenHom Q A → ↥(CliffordAlgebra.even... | The final auxiliary construction for `CliffordAlgebra.even.lift`. This map is the forwards
direction of that equivalence, but not in the fully-bundled form. | true |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Basic.0.Lean.Meta.Simp.Arith.Int.ToLinear.run.match_1 | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {α : Type} →
(motive : α × Lean.Meta.Simp.Arith.Int.ToLinear.State → Sort u_1) →
(x : α × Lean.Meta.Simp.Arith.Int.ToLinear.State) →
((a : α) → (s : Lean.Meta.Simp.Arith.Int.ToLinear.State) → motive (a, s)) → motive x | null | false |
Std.instAntisymmLeOfIsPartialOrder | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [Std.IsPartialOrder α], Std.Antisymm fun x1 x2 => x1 ≤ x2 | null | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mem_support_finsetSum.match_1_3 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {ι : Type u_3} {M : Type u_2} [inst : AddCommMonoid M] {s : Finset ι} {h : ι → α →₀ M} (a : α)
(motive : (∃ f ∈ Multiset.map (fun c => h c) s.val, a ∈ f.support) → Prop)
(x : ∃ f ∈ Multiset.map (fun c => h c) s.val, a ∈ f.support),
(∀ (w : α →₀ M) (hf : w ∈ Multiset.map (fun c => h c) s.val) (hfa... | null | false |
Lean.Lsp.instFromJsonReferenceParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.ReferenceParams | null | true |
Std.DTreeMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.DTreeMap α (fun x => Unit) cmp} [Std.TransCmp cmp] {l : List α}
{k k' : α},
cmp k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
k ∈ l → (Std.DTreeMap.Const.insertManyIfNewUnit t l).getKey? k' = some k | null | true |
op_smul_mul | Mathlib.Algebra.Group.Action.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid α] [inst_1 : MulAction αᵐᵒᵖ β] (b : β) (a₁ a₂ : α),
MulOpposite.op (a₁ * a₂) • b = MulOpposite.op a₂ • MulOpposite.op a₁ • b | null | true |
Module.IsReflexive.of_split | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Module.IsReflexive R M] (i : N →ₗ[R] M)
(s : M →ₗ[R] N), s ∘ₗ i = LinearMap.id → Module.IsReflexive R N | A direct summand of a reflexive module is reflexive. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastDivSubtractShiftOutput.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} →
{w : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastDivSubtractShiftOutput old w →
{α' : Type} →
[inst' : Hashable α'] →
[inst... | null | false |
Topology.WithUpperSet.map | Mathlib.Topology.Order.UpperLowerSetTopology | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] → [inst_1 : Preorder β] → (α →o β) → C(Topology.WithUpperSet α, Topology.WithUpperSet β) | A monotone map between preorders spaces induces a continuous map between themselves considered
with the upper set topology. | true |
DomMulAct.map_mk_nhds | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M] (x : M), Filter.map (⇑DomMulAct.mk) (nhds x) = nhds (DomMulAct.mk x) | null | true |
CategoryTheory.CartesianCopyDiscard.ofCartesianMonoidalCategory | Mathlib.CategoryTheory.CopyDiscardCategory.Cartesian | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.CopyDiscardCategory C | Cartesian categories have copy-discard structure. | true |
small_plift | Mathlib.Logic.Small.Defs | ∀ (α : Type u) [Small.{v, u} α], Small.{v, u + 1} (PLift α) | null | true |
Mathlib.Tactic._aux_Mathlib_Tactic_CasesM___elabRules_Mathlib_Tactic_casesM_1 | Mathlib.Tactic.CasesM | Lean.Elab.Tactic.Tactic | `casesm p` searches for the first hypothesis `h : type` where `type` matches the term `p`,
and splits the main goal by cases on `h`. Use holes in `p` to indicate arbitrary subexpressions,
for example `casesm _ ∧ _` will match any conjunction. `casesm p` fails if no hypothesis type
matches `p`.
* `casesm p_1, ..., p_n`... | false |
CategoryTheory.Limits.WalkingReflexivePair.Hom.right | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | CategoryTheory.Limits.WalkingReflexivePair.one.Hom CategoryTheory.Limits.WalkingReflexivePair.zero | null | true |
CategoryTheory.zigzag_equivalence | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J], Equivalence CategoryTheory.Zigzag | null | true |
AffineMap.homothety._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} [inst : CommRing k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1],
SMulCommClass k k V1 | null | false |
OrderIso.refl_apply | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} [inst : LE α] (x : α), (OrderIso.refl α) x = x | null | true |
_private.Std.Sat.CNF.Negation.0.Std.Sat.CNF.Clause.mem_negate_iff._simp_1_3 | Std.Sat.CNF.Negation | ∀ {β : Type u_1} {α : Type u_2} {b : β} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β},
(b ∈ xs.mapFinIdx f) = ∃ i, ∃ (h : i < xs.size), f i xs[i] h = b | null | false |
CategoryTheory.Discrete.addMonoidal._proof_11 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : AddMonoid M] (X : CategoryTheory.Discrete M), X.as + 0 = X.as | null | false |
CommCStarAlgebra.toNonUnitalCommCStarAlgebra._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ (A : Type u_1) [inst : CommCStarAlgebra A], IsScalarTower ℂ A A | null | false |
ChartedSpace.liftPropWithinAt_subtypeVal_comp_iff | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H → H') → Set H → H → Prop}
{U : TopologicalSpace.Opens M'} (f : M... | null | true |
UniformCauchySeqOn.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {s : Set β},
UniformCauchySeqOn f l s → UniformCauchySeqOn f' l s → UniformCauchySeqOn (fun i i_1 => f i i_1 - f' i i_1) l s | Eta-expanded form of `UniformCauchySeqOn.sub` | true |
Finset.image₂_congr' | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f f' : α → β → γ} {s : Finset α} {t : Finset β},
(∀ (a : α) (b : β), f a b = f' a b) → Finset.image₂ f s t = Finset.image₂ f' s t | A common special case of `image₂_congr` | true |
List.getElem?_partialProds | Batteries.Data.List.Scan | ∀ {α : Type u_1} {i : ℕ} [inst : Mul α] [inst_1 : One α] [Std.Associative fun x1 x2 => x1 * x2]
[Std.LawfulIdentity (fun x1 x2 => x1 * x2) 1] {l : List α},
l.partialProds[i]? = if i ≤ l.length then some (List.take i l).prod else none | null | true |
CategoryTheory.instPreadditiveOpposite._proof_13 | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (x x_1 x_2 : Cᵒᵖ)
(f : x ⟶ x_1) (g g' : x_1 ⟶ x_2),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g' | null | false |
CategoryTheory.MorphismProperty.Comma.mapRightIso_unitIso_hom_app_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 |
SSet.oneTruncation₂_obj | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ (S : SSet.Truncated 2), SSet.oneTruncation₂.obj S = ↧(SSet.OneTruncation₂ S) | null | true |
nullMeasurableSet_region_between_cc | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {f g : α → ℝ},
AEMeasurable f μ →
AEMeasurable g μ →
∀ {s : Set α},
MeasureTheory.NullMeasurableSet s μ →
MeasureTheory.NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Icc (f p.1) (g p.1)} (μ.prod MeasureTheory.volume) | The region between two a.e.-measurable functions on a null-measurable set is null-measurable;
a version for the region together with the graphs of both functions. | true |
AddCircle.homeomorphCircle'_apply | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ (θ : Real.Angle), AddCircle.homeomorphCircle' θ = θ.toCircle | null | true |
Std.Http.Server.Handler.onFailure._default | Std.Http.Server.Handler | {σ : Type} → σ → IO.Error → Std.Async.Async Unit | null | false |
Lean.Meta.Simp.mainCore | Lean.Meta.Tactic.Simp.Main | Lean.Expr →
Lean.Meta.Simp.Context →
optParam Lean.Meta.Simp.State { } →
optParam Lean.Meta.Simp.Methods { } → Lean.MetaM (Lean.Meta.Simp.Result × Lean.Meta.Simp.State) | null | true |
NormedSpace.induced._proof_2 | Mathlib.Analysis.Normed.Module.Basic | ∀ {F : Type u_1} (𝕜 : Type u_4) (E : Type u_2) (G : Type u_3) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : FunLike F E G]
[LinearMapClass F 𝕜 E G], AddMonoidHomClass F E G | null | false |
NonUnitalAlgHomClass.toNonUnitalAlgHom | Mathlib.Algebra.Algebra.NonUnitalHom | {F : Type u_3} →
{R : Type u_4} →
[inst : Monoid R] →
{A : Type u_5} →
{B : Type u_6} →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : NonUnitalNonAssocSemiring B] →
[inst_4 : DistribMulAction R B] →
... | Turn an element of a type `F` satisfying `NonUnitalAlgHomClass F R A B` into an actual
@[coe]
`NonUnitalAlgHom`. This is declared as the default coercion from `F` to `A →ₛₙₐ[R] B`. | true |
NNRat.coe_div._simp_1 | Mathlib.Algebra.Field.Rat | ∀ (p q : ℚ≥0), ↑p / ↑q = ↑(p / q) | null | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.next.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.next = { s := s, i := String.Pos.Raw.next s i } | null | true |
Lean.Language.Lean.HeaderProcessedSnapshot.mk._flat_ctor | Lean.Language.Lean.Types | autoParam String Lean.Language.Snapshot.desc._autoParam →
Lean.Language.Snapshot.Diagnostics →
Option Lean.Elab.InfoTree →
Lean.TraceState →
Bool →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Option Lean.Language.Lean.HeaderProcessedState → Lean.Language.Lean.Header... | null | false |
Vector.swap_perm | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (h₁ : i < n) (h₂ : j < n), (xs.swap i j h₁ h₂).Perm xs | null | true |
CategoryTheory.Limits.pullback.congrHom_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂)
(h₂ : g₁ = g₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ g₁] [inst_2 : CategoryTheory.Limits.HasPullback f₂ g₂],
(CategoryTheory.Limits.pullback.congrHom h₁ h₂).inv =
CategoryTheory.Limits.pu... | null | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofEpiOfIsIsoOfMono._proof_4 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₁.LeftHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
CategoryTh... | null | false |
RegularExpression.deriv_star | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} [inst : DecidableEq α] (P : RegularExpression α) (a : α), P.star.deriv a = P.deriv a * P.star | null | true |
ModelWithCorners.continuous_toFun._autoParam | Mathlib.Geometry.Manifold.IsManifold.Basic | Lean.Syntax | null | false |
Filter.isBoundedUnder_le_abs | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {f : Filter β}
{u : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun a => |u a|) ↔
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x2 ≤ x1) f u | null | true |
IsSublattice.image | Mathlib.Order.SupClosed | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : Lattice α] [inst_1 : Lattice β] {s : Set α}
[inst_2 : FunLike F α β] [LatticeHomClass F α β], IsSublattice s → ∀ (f : F), IsSublattice (⇑f '' s) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.keys_filter_key._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.JsonRpc.MessageMetaData.notification.injEq | Lean.Data.JsonRpc | ∀ (method method_1 : String),
(Lean.JsonRpc.MessageMetaData.notification method = Lean.JsonRpc.MessageMetaData.notification method_1) =
(method = method_1) | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.BaseChange.0.Algebra.tensorH1CotangentOfFlat._proof_8 | Mathlib.RingTheory.Extension.Cotangent.BaseChange | ∀ (R : Type u_3) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_2)
[inst_3 : CommRing T] [inst_4 : Algebra R T],
IsScalarTower (TensorProduct R T S) (TensorProduct R T S)
(Algebra.Generators.baseChange T (Algebra.Generators.self R S)).toExtension.Cotangent | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.