name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BitVec.getLsbD_rotateLeftAux_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {r i : ℕ}, i < r → (x.rotateLeftAux r).getLsbD i = x.getLsbD (w - r + i) | Accessing bits in `x.rotateLeft r` the range `[0, r)` is equal to
accessing bits `x` in the range `[w - r, w)`.
Proof by example:
Let x := <6 5 4 3 2 1 0> : BitVec 7.
x.rotateLeft 2 = (<6 5 | 4 3 2 1 0>).rotateLeft 2 = <3 2 1 0 | 6 5>
(x.rotateLeft 2).getLsbD ⟨i, i < 2⟩
= <3 2 1 0 | 6 5>.getLsbD ⟨i, i < 2⟩
= <6 5>[i]... | true |
_private.Mathlib.Data.Vector.Basic.0.List.Vector.mOfFn.match_1.splitter | Mathlib.Data.Vector.Basic | {m : Type u_3 → Type u_2} →
{α : Type u_3} →
(motive : (x : ℕ) → (Fin x → m α) → Sort u_1) →
(x : ℕ) →
(x_1 : Fin x → m α) →
((x : Fin 0 → m α) → motive 0 x) → ((n : ℕ) → (f : Fin (n + 1) → m α) → motive n.succ f) → motive x x_1 | null | true |
Lean.Elab.Tactic.Try.evalTryTrace | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Tactic | null | true |
List.length_mapFinIdx_go | Init.Data.List.MapIdx | ∀ {α : Type u_1} {as : List α} {α_1 : Type u_2} {f : (i : ℕ) → α → i < as.length → α_1} {bs : List α} {acc : Array α_1}
{h : bs.length + acc.size = as.length}, (List.mapFinIdx.go as f bs acc h).length = as.length | null | true |
USize.zero_or | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 ||| a = a | null | true |
Lean.Grind.AC.eq_erase_dup_cert | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Bool | null | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.getFVarId.match_1 | Lean.Meta.CongrTheorems | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((h : Lean.Expr) → motive (some h)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
ContinuousMap.homotopicRel_empty | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)},
f₀.HomotopicRel f₁ ∅ ↔ f₀.Homotopic f₁ | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.sliceTo_le_sliceTo_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
Manifold.riemannianEDist_comm | Mathlib.Geometry.Manifold.Riemannian.PathELength | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : (x : M) → ENorm (TangentSpace I x)] [∀ (x : M), ENormSMulClass ℝ (TangentSpace I x)] ... | null | true |
CategoryTheory.ProjectiveResolution.isoExt._proof_2 | Mathlib.CategoryTheory.Abelian.Ext | ∀ {R : Type u_2} [inst : Ring R], CategoryTheory.CategoryWithHomology (ModuleCat R)ᵒᵖ | null | false |
LieModule.isNilpotent_quotient_iff | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (N : LieSubmodule R L M)
[inst_6 : LieModule R L M], LieModule.IsNilpotent L (M ⧸ N) ↔ ∃ k, LieModule.lowerCentralSeries R L M k ≤ ... | null | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_add_add_add_map._abel_1_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_2} {N : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (Q : QuadraticMap R M N) (x y z : M) (B : LinearMap.BilinMap R M N),
Q x + Q y + (B x) y + Q z + ((B x) z + (B y) z) + (Q x + Q y + Q z) =
Q x ... | null | false |
Lean.ReducibilityStatus.semireducible.sizeOf_spec | Lean.ReducibilityAttrs | sizeOf Lean.ReducibilityStatus.semireducible = 1 | null | true |
Lean.Order.PProd.chain.snd | Init.Internal.Order.Basic | {α : Sort u} → {β : Sort v} → [Lean.Order.CCPO α] → [Lean.Order.CCPO β] → (α ×' β → Prop) → β → Prop | null | true |
ContinuousAffineEquiv.continuous | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(... | null | true |
Vector.scanlM_pure | Batteries.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {n : ℕ} {init : β} [inst : Monad m] [LawfulMonad m]
{f : β → α → β} {as : Vector α n}, Vector.scanlM (fun x1 x2 => pure (f x1 x2)) init as = pure (Vector.scanl f init as) | null | true |
CategoryTheory.Limits.cokernelBiprodInlIso_inv | 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.cokernelBiprodInlIso.inv =
(CategoryTheory.Limits.biprod.isCokernelInlCokernelFork X Y).desc
(CategoryTh... | null | true |
Std.DHashMap.Raw.Equiv.diff_left | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ m₃ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₃.WF → m₁.Equiv m₂ → (m₁ \ m₃).Equiv (m₂ \ m₃) | null | true |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.eq_one_of_not_dvd._simp_1_3 | Mathlib.NumberTheory.Ostrowski | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (0 < -a) = (a < 0) | null | false |
Cardinal.ofENat_le_ofNat | Mathlib.SetTheory.Cardinal.ENat | ∀ {m : ℕ∞} {n : ℕ} [inst : n.AtLeastTwo], ↑m ≤ OfNat.ofNat n ↔ m ≤ OfNat.ofNat n | null | true |
Float.Model.instDiv | Init.Data.Float.Model.Float | Div Float.Model | null | true |
UpperSet.Ici_strictMono | Mathlib.Order.UpperLower.Principal | ∀ (α : Type u_1) [inst : Preorder α], StrictMono UpperSet.Ici | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.core.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{a b : Lean.Expr} →
{ea eb : Lean.Grind.AC.Expr} →
{a' b' : Lean.Expr} →
{ea' eb' : Lean.Grind.AC.Expr} →
Lean.Meta.Grind.AC.EqCnstrProof.core a b ea eb = Lean.Meta.Grind.AC.EqCnstrProof.core a' b' ea' eb' →
(a = a' → b = b' → ea = ea' → eb = eb' → P) → P | null | false |
CategoryTheory.Idempotents.instFaithfulKaroubiFunctorKaroubiFunctorCategoryEmbedding | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C],
(CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C).Faithful | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan.0.Real.tan_sub._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {z w : ℝ}, (z = w) = (↑z = ↑w) | null | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.Iterators.Types.DropWhile.instIterator.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} (out : β)
(motive : Subtype (P out).Property → Sort u_3) (h'' : (P out).Property { down := false })
(h_1 : (h'' : (P out).Property { down := true }) → motive ⟨{ down := true }, h''⟩)
(h_2 : (h'' : (P out).Pro... | null | true |
MeasureTheory.L1.SimpleFunc.negPart_toSimpleFunc | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : ↥(α →₁ₛ[μ] ℝ)),
⇑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.L1.SimpleFunc.negPart f)) =ᵐ[μ]
⇑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f).negPart | null | true |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons._proof_1_8 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {a : α},
List.countPBefore p (a :: xs) 0 =
if 0 = 0 then 0 else if p a = true then List.countPBefore p xs (0 - 1) + 1 else List.countPBefore p xs (0 - 1) | null | false |
_private.Mathlib.SetTheory.Ordinal.FundamentalSequence.0.Ordinal.IsFundamentalSeq.iSup_add_one_eq._simp_1_2 | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {α : Type u_1} {x y : α} [inst : Preorder α] [inst_1 : Add α] [inst_2 : One α] [SuccAddOrder α] [NoMaxOrder α],
(x + 1 ≤ y) = (x < y) | null | false |
FirstOrder.presburgerFunc.one.elim | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | {motive : (a : ℕ) → FirstOrder.presburgerFunc a → Sort u} →
{a : ℕ} → (t : FirstOrder.presburgerFunc a) → t.ctorIdx = 1 → motive 0 FirstOrder.presburgerFunc.one → motive a t | null | false |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_some_iff._simp_1_2 | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90.0.groupCohomology.exists_div_of_norm_eq_one._simp_1_4 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Rack.toEnvelGroup.mapAux.eq_3 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G))
(a b : Rack.PreEnvelGroup R),
Rack.toEnvelGroup.mapAux f (a.mul b) = Rack.toEnvelGroup.mapAux f a * Rack.toEnvelGroup.mapAux f b | null | true |
Filter.frequently_atTop | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∃ᶠ (x : α) in Filter.atTop, p x) ↔ ∀ (a : α), ∃ b, a ≤ b ∧ p b | null | true |
groupCohomology.mapShortComplexH2._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G H : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u_2, u_1, u_1} k H}
{B : Rep.{u_2, u_1, u_1} k G} (f : G →* H) (φ : Rep.res f A ⟶ B),
CategoryTheory.CategoryStruct.comp (groupCohomology.cochainsMap₁ f φ) (groupCohomology.shortComplexH2 B).f =
CategoryTheory.CategoryStruc... | null | false |
QuadraticMap.Isometry.comp._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Isometry | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
balancedCore_subset_balancedCoreAux | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{s : Set E}, balancedCore 𝕜 s ⊆ balancedCoreAux 𝕜 s | null | true |
_private.Mathlib.NumberTheory.ModularForms.RamanujanFormula.0.Derivative.serreDerivativeOneE2._proof_1 | Mathlib.NumberTheory.ModularForms.RamanujanFormula | ∀ x ∈ (Matrix.SpecialLinearGroup.mapGL ℝ).range,
SlashAction.map 4 x (Derivative.serreDerivative 1 EisensteinSeries.E2) =
Derivative.serreDerivative 1 EisensteinSeries.E2 | null | false |
CategoryTheory.ParametrizedAdjunction.unit_whiskerRight_map_assoc | Mathlib.CategoryTheory.Adjunction.Parametrized | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} ... | null | true |
CategoryTheory.Functor.commShift₂_comm_assoc | 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} {inst_4 : CategoryTheory.HasShift C₁ M} {inst_5 : CategoryTheory.HasShift C₂ M}
... | This alias for `Functor.CommShift₂.comm` allows to use the dot notation. | true |
GradedMonoid.GMulAction.mk._flat_ctor | Mathlib.Algebra.GradedMulAction | {ιA : Type u_1} →
{ιM : Type u_3} →
{A : ιA → Type u_4} →
{M : ιM → Type u_5} →
[inst : AddMonoid ιA] →
[inst_1 : VAdd ιA ιM] →
[inst_2 : GradedMonoid.GMonoid A] →
(smul : {i : ιA} → {j : ιM} → A i → M j → M (i +ᵥ j)) →
(∀ (b : GradedMonoid M), 1 •... | null | false |
Group.Presentation.lift_rel_eq_one | Mathlib.GroupTheory.Presentation | ∀ {G : Type u_1} {ι : Type u_2} [inst : Group G] (P : Group.Presentation G ι) {r : FreeGroup ι},
r ∈ P.rel → P.lift r = 1 | A relator as a free group element always maps to the identity under the canonical surjection. | true |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0._aux_Mathlib_NumberTheory_ModularForms_QExpansion___unexpand_Function_Periodic_qParam_1 | Mathlib.NumberTheory.ModularForms.QExpansion | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Star.0.SimpleGraph.IsCompleteBetween.starGraph._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Star | ∀ {V : Type u_1} (r : V), (SimpleGraph.starGraph r).IsCompleteBetween {r} {r}ᶜ | null | false |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Basic.0.AlgebraicGeometry.Scheme.ker_ideal_of_isPullback_of_isOpenImmersion._simp_1_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
{K : Ideal S} [inst_3 : RingHomClass F R S] {x : R}, (x ∈ Ideal.comap f K) = (f x ∈ K) | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.π_comp_homologyIso_inv_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] (h : S.LeftHomologyData) {Z : C} (h_1 : S.homology ⟶ Z),
CategoryTheory.CategoryStruct.comp h.π (CategoryTheory.CategoryStruct.comp h.homologyIso.... | null | true |
AddMonoid.End.coe_pow | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M] (f : AddMonoid.End M) (n : ℕ), ⇑(f ^ n) = (⇑f)^[n] | null | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.takeBackticksFn | Lean.DocString.Parser | ℕ → Lean.Parser.ParserFn | null | true |
SkewMonoidAlgebra.liftNCAlgHom._proof_2 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_4} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u_3} {B : Type u_1}
[inst_2 : Semiring A] [inst_3 : Algebra k A] [inst_4 : Semiring B] [inst_5 : Algebra k B]
[inst_6 : MulSemiringAction G A] [inst_7 : SMulCommClass G k A] (f : A →ₐ[k] B) (g : G →* B)
(h_comm : ∀ {x : A} {y : ... | null | false |
ContinuousMap.specializes_coe._simp_1 | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)},
⇑f ⤳ ⇑g = f ⤳ g | null | false |
Std.TransCmp.gt_of_eq_of_gt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.gt → cmp a c = Ordering.gt | null | true |
AlgebraicGeometry.StructureSheaf.toStalkₗ._proof_2 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (x_1 y : M),
(CategoryTheory.ConcreteCategory.hom
(TopCat.Presheaf.germ (AlgebraicGeometry.moduleStructurePresheaf R M).presheaf ⊤ x ⋯))
((AlgebraicGeometry.StructureSh... | null | false |
Lean.Compiler.LCNF.CacheAuxDeclResult.rec | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.CacheAuxDeclResult → Sort u} →
motive Lean.Compiler.LCNF.CacheAuxDeclResult.new →
((declName : Lean.Name) → motive (Lean.Compiler.LCNF.CacheAuxDeclResult.alreadyCached declName)) →
(t : Lean.Compiler.LCNF.CacheAuxDeclResult) → motive t | null | false |
Real.arccos_of_le_neg_one | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, x ≤ -1 → Real.arccos x = Real.pi | null | true |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁ | Mathlib.CategoryTheory.Localization.Prod | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{E : Type u₅} →
[inst_2 : CategoryTheory.Categ... | Auxiliary definition for `prodLift`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_union_of_contains_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Multiset.noncommFold | Mathlib.Data.Finset.NoncommProd | {α : Type u_3} →
(op : α → α → α) →
[assoc : Std.Associative op] → (s : Multiset α) → ({x | x ∈ s}.Pairwise fun x y => op x y = op y x) → α → α | Fold of a `s : Multiset α` with an associative `op : α → α → α`, given a proofs that `op`
is commutative on all elements `x ∈ s`. | true |
ContinuousLinearMap.monoidWithZero._proof_5 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_2} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁], autoParam (∀ (n : ℕ) (x : M₁ →L[R₁] M₁), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._autoParam | null | false |
AlgebraicGeometry.Scheme.zeroLocus_eq_univ_iff_subset_nilradical | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X : AlgebraicGeometry.Scheme} [CompactSpace ↥X] (s : Set ↑(X.presheaf.obj (Opposite.op ⊤))),
X.zeroLocus s = Set.univ ↔ s ⊆ ↑(nilradical ↑(X.presheaf.obj (Opposite.op ⊤))) | The zero locus of a set of sections over a compact open of a scheme is `X` if and only if
`s` is contained in the nilradical of `Γ(X, U)`. | true |
ContinuousMultilinearMap.instAddMonoid._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_1} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_4} [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₂]
[inst_7 : Continuous... | null | false |
CategoryTheory.Functor.id_hcomp | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
{G H : CategoryTheory.Functor D E} (α : G ⟶ H), CategoryTheory.CategoryStruct.id F ◫ α = F.whiskerLeft ... | null | true |
GradedAlgebra.instAlgebraSubtypeTensorProductMemSubmoduleBaseChangeOfNat_1._proof_1 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {ι : Type u_1} {R : Type u_4} {A : Type u_2} {S : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : DecidableEq ι] [inst_4 : AddCommMonoid ι] [inst_5 : CommSemiring A]
[inst_6 : Algebra R A] (𝒜 : ι → Submodule R A) [GradedAlgebra 𝒜],
SetLike.GradedMonoid fun i => Sub... | null | false |
Finset.filter_inter_distrib | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : DecidableEq α] (s t : Finset α),
Finset.filter p (s ∩ t) = Finset.filter p s ∩ Finset.filter p t | null | true |
TopCat.of.noConfusion | Mathlib.Topology.Category.TopCat.Basic | {P : Sort u_1} →
{carrier : Type u} →
{str : TopologicalSpace carrier} →
{carrier' : Type u} →
{str' : TopologicalSpace carrier'} → ↧carrier = ↧carrier' → (carrier = carrier' → str ≍ str' → P) → P | null | false |
Con.subgroup._proof_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (c : Con G) {a b : G}, a ∈ {x | c x 1} → b ∈ {x | c x 1} → a * b ∈ {x | c x 1} | null | false |
irrational_pi._simp_1 | Mathlib.Analysis.Real.Pi.Irrational | Irrational Real.pi = True | null | false |
Lean.Meta.Iterator.head | Lean.Meta.Iterator | {α : Type} → Lean.Meta.Iterator α → Lean.MetaM α | Find the first value in the iterator while resetting state or call `failure`
if empty.
| true |
_private.Mathlib.RingTheory.Filtration.0.Ideal.Filtration.submodule_eq_span_le_iff_stable_ge._simp_1_3 | Mathlib.RingTheory.Filtration | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
_private.Mathlib.LinearAlgebra.Complex.Module.0.Complex.isSelfAdjoint_I_smul_iff_mem_skewAdjoint._simp_1_1 | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [StarModule ℂ A] {a : A},
IsSelfAdjoint a = (Complex.I • a ∈ skewAdjoint A) | null | false |
Float32.instDecidableEqModel.decEq._proof_2 | Init.Data.Float.Model.Float32 | ∀ (a : UInt32) (a_1 : Float.Model.Format.binary32.Valid a.toBitVec),
{ toBits := a, valid := a_1 } = { toBits := a, valid := a_1 } | null | false |
Int32.toBitVec.inj | Init.Data.SInt.Basic | ∀ {x y : Int32}, x.toBitVec = y.toBitVec → x = y | null | true |
threeAPFree_pi | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {ι : Type u_4} {α : ι → Type u_5} [inst : (i : ι) → AddMonoid (α i)] {s : (i : ι) → Set (α i)},
(∀ (i : ι), ThreeAPFree (s i)) → ThreeAPFree (Set.univ.pi s) | null | true |
TypeVec.casesCons | Mathlib.Data.TypeVec | (n : ℕ) →
{β : TypeVec.{u_2} (n + 1) → Sort u_1} →
((t : Type u_2) → (v : TypeVec.{u_2} n) → β (v ::: t)) → (v : TypeVec.{u_2} (n + 1)) → β v | cases distinction for (n+1)-length type vector | true |
BoundedContinuousFunction.norm_integral_le_norm | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] (μ : MeasureTheory.Measure X) {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [OpensMeasurableSpace X] [SecondCountableTopology E] [inst_5 : MeasurableSpace E]
[BorelSpace E] [inst_7 : NormedSpace ℝ E] [MeasureTheory.IsProbabilityMeasure μ] (f... | null | true |
_private.Init.Data.Array.BasicAux.0.Array.of_push_eq_push.match_1_1 | Init.Data.Array.BasicAux | ∀ {α : Type u_1} {a b : α} {as bs : Array α} (motive : as.toList = bs.toList ∧ a = b → Prop)
(x : as.toList = bs.toList ∧ a = b), (∀ (h₁ : as.toList = bs.toList) (h₂ : a = b), motive ⋯) → motive x | null | false |
Stream'.WSeq.join_ret | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} (s : Stream'.WSeq α), (Stream'.WSeq.ret s).join ~ʷ s | null | true |
Std.Sat.AIG.RefVec.ite.go._unary._proof_2 | Std.Sat.AIG.If | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(discr : aig.Ref) (lhs rhs : aig.RefVec w) (s : aig.RefVec curr) (hcurr_1 : curr < w)
(this :
aig.decls.size ≤
(aig.mkIfCached { discr := discr, lhs := lhs.get curr hcurr_1, rhs := rhs.get... | null | false |
ModularForm.instGCommRing | Mathlib.NumberTheory.ModularForms.Basic | (Γ : Subgroup (GL (Fin 2) ℝ)) → [Γ.HasDetPlusMinusOne] → DirectSum.GCommRing (ModularForm Γ) | null | true |
Mathlib.Tactic.BicategoryLike.MonadNormalExpr.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {P : Sort u} →
{m : Type → Type} →
{t : Mathlib.Tactic.BicategoryLike.MonadNormalExpr m} →
{m' : Type → Type} →
{t' : Mathlib.Tactic.BicategoryLike.MonadNormalExpr m'} →
m = m' → t ≍ t' → Mathlib.Tactic.BicategoryLike.MonadNormalExpr.noConfusionType P t t' | null | false |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsGT_iff_exists_Ioo_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (motive : (∃ b, a < b) → Prop) (x : ∃ b, a < b),
(∀ (_u' : α) (hu' : a < _u'), motive ⋯) → motive x | null | false |
FreeAddMonoid.length.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} (a : FreeAddMonoid α), a.length = (FreeAddMonoid.toList a).length | null | true |
Std.DTreeMap.Equiv.constMinEntryD_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{fallback : α × β}, t₁.Equiv t₂ → Std.DTreeMap.Const.minEntryD t₁ fallback = Std.DTreeMap.Const.minEntryD t₂ fallback | null | true |
BotHom.instOrderBot | Mathlib.Order.Hom.Bounded | {α : Type u_2} → {β : Type u_3} → [inst : Bot α] → [inst_1 : LE β] → [inst_2 : OrderBot β] → OrderBot (BotHom α β) | null | true |
Set.Iio_subset_Iio | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → Set.Iio a ⊆ Set.Iio b | If `a ≤ b`, then `(-∞, a) ⊆ (-∞, b)`. In preorders, this is just an implication. If you need
the equivalence in linear orders, use `Iio_subset_Iio_iff`. | true |
_private.Lean.Environment.0.Lean.Environment.asyncConstsMap | Lean.Environment | Lean.Environment → Lean.VisibilityMap✝ Lean.AsyncConsts✝ | Container of asynchronously elaborated declarations. For consistency, `Lean.addDecl` makes sure
this contains constants added even synchronously, i.e. `base ⨃ asyncConsts` is the set of
constants known on the current environment branch, which is a subset of `checked`.
Private view should correspond to kernel map. Publ... | true |
Lean.Meta.CaseValuesSubgoal.mk.sizeOf_spec | Lean.Meta.Match.CaseValues | ∀ (mvarId : Lean.MVarId) (newHs : Array Lean.FVarId) (subst : Lean.Meta.FVarSubst),
sizeOf { mvarId := mvarId, newHs := newHs, subst := subst } = 1 + sizeOf mvarId + sizeOf newHs + sizeOf subst | null | true |
IsUpperModularLattice | Mathlib.Order.ModularLattice | (α : Type u_2) → [Lattice α] → Prop | An upper modular lattice, aka semimodular lattice, is a lattice where `a ⊔ b` covers `a` and `b`
if either `a` or `b` covers `a ⊓ b`. | true |
CategoryTheory.MonoidalCategory.ofTensorHom | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategoryStruct C] →
autoParam
(∀ (X₁ X₂ : C),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂) =
... | A constructor for monoidal categories that requires `tensorHom` instead of `whiskerLeft` and
`whiskerRight`.
| true |
TopologicalSpace.OpenNhds.val_apply | Mathlib.Topology.Category.TopCat.OpenNhds | ∀ {X : TopCat} {x : ↑X} {U V : TopologicalSpace.OpenNhds x} (f : U ⟶ V) (y : ↥↑U), ↑(f y) = ↑y | null | true |
Finset.map_swap_product | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β),
Finset.map { toFun := Prod.swap, inj' := ⋯ } (t ×ˢ s) = s ×ˢ t | null | true |
ImportGraph.Lake.instFromJsonWorkspaceSummary | ImportGraph.WorkspaceModel.Summary.Core | Lean.FromJson ImportGraph.Lake.WorkspaceSummary | null | true |
Std.Sat.AIG.mkBEqCached._proof_1 | Std.Sat.AIG.CachedGates | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (input : aig.BinaryInput),
aig.decls.size ≤ (aig.mkGateCached (input.invert false true)).aig.decls.size | null | false |
Subgroup.pi_empty | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_5} {f : η → Type u_6} [inst : (i : η) → Group (f i)] (H : (i : η) → Subgroup (f i)), Subgroup.pi ∅ H = ⊤ | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.EpiMono.0.CategoryTheory.Abelian.SpectralObject.isIso_mapFourδ₂Toδ₁'._proof_1_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ⟨0, CategoryTheory.Abelian.SpectralObject.isIso_mapFourδ₂Toδ₁'._proof_1_3✝⟩ ≤
⟨1, CategoryTheory.Abelian.SpectralObject.isIso_mapFourδ₂Toδ₁'._proof_1_4✝⟩ | null | false |
LowerSemicontinuousAt.add' | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_5} [inst_1 : AddCommMonoid γ] [inst_2 : LinearOrder γ]
[IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] {f g : α → γ},
LowerSemicontinuousAt f x →
LowerSemicontinuousAt g x →
ContinuousAt (fun p => p.1 + p.2) (f x, g x)... | The sum of two lower semicontinuous functions is lower semicontinuous. Formulated with an
explicit continuity assumption on addition, for application to `EReal`. The unprimed version of
the lemma uses `[ContinuousAdd]`. | true |
LinearMap.pi_comp | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M₂ : Type w} {M₃ : Type y} {ι : Type x} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M₃] {φ : ι → Type i}
[inst_5 : (i : ι) → AddCommMonoid (φ i)] [inst_6 : (i : ι) → Module R (φ i)] (f : (i : ι) → M₂ →ₗ[R] φ i)
(g : M₃ →ₗ[R]... | null | true |
WittVector.mk | Mathlib.RingTheory.WittVector.Defs | (p : ℕ) → {R : Type u_1} → (ℕ → R) → WittVector p R | Construct a Witt vector `mk p x : 𝕎 R` from a sequence `x` of elements of `R`.
This is preferred over `WittVector.mk'` because it has `p` explicit.
| true |
SetLike.gring._proof_1 | Mathlib.Algebra.DirectSum.Internal | ∀ {σ : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : SetLike σ R] [AddSubgroupClass σ R], AddSubmonoidClass σ R | null | false |
_private.Mathlib.AlgebraicGeometry.OpenImmersion.0.AlgebraicGeometry.IsOpenImmersion.instIsIsoCommRingCatStalkMap._proof_1 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] (x : ↥X),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap f x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.