name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Congr!.Config.closePost | Mathlib.Tactic.CongrExclamation | Congr!.Config → Bool | If `closePost := true`, then try to close goals that remain after no more congruence
lemmas can be applied, using the same tactics as `closePre`. These tactics are applied
with the transparency level specified by `postTransparency`, which is currently default
transparency but in the future will become `.reducible` by d... | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.twoCocycleAux._proof_15 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_2} {L : Type u_4} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing M] [inst_4 : LieAlgebra R M] (E : LieAlgebra.Extension R M L) {s : L →ₗ[R] E.L},
Function.LeftInverse ⇑E.proj ⇑s →
∀ (x : R) (x_1 x_2 x_3 : L), ⁅s (x • x_1), s (x_2 + x_3)⁆ - s ⁅x ... | null | false |
MonotoneOn.intervalIntegrable_slope | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {f : ℝ → ℝ} {a b c : ℝ},
MonotoneOn f (Set.Icc a (b + c)) →
a ≤ b → 0 ≤ c → IntervalIntegrable (fun x => slope f x (x + c)) MeasureTheory.volume a b | If `f` is monotone on `a..(b + c)` where `a ≤ b` and `0 ≤ c`, then
`fun x ↦ slope f x (x + c)` is interval integrable on `a..b`. | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.mk.inj | Lean.Elab.Tactic.Induction | ∀ {view : Lean.Elab.Tactic.ElimTargetView} {expr : Lean.Expr} {arg? : Option Lean.Meta.GeneralizeArg}
{view_1 : Lean.Elab.Tactic.ElimTargetView} {expr_1 : Lean.Expr} {arg?_1 : Option Lean.Meta.GeneralizeArg},
{ view := view, expr := expr, arg? := arg? } = { view := view_1, expr := expr_1, arg? := arg?_1 } →
vie... | null | true |
MeasureTheory.laverage_const | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] [h : NeZero μ]
(c : ENNReal), ⨍⁻ (_x : α), c ∂μ = c | null | true |
_private.Mathlib.Tactic.ApplyFun.0.Mathlib.Tactic.maybeProveInjective.match_1 | Mathlib.Tactic.ApplyFun | (motive : Option Lean.Expr → Sort u_1) →
(using? : Option Lean.Expr) →
((u : Lean.Expr) → motive (some u)) → ((x : Option Lean.Expr) → motive x) → motive using? | null | false |
eq_of_forall_symmetric | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} [inst : UniformSpace α] [T0Space α] {x y : α},
(∀ {V : Set (α × α)}, V ∈ uniformity α → SetRel.IsSymm V → (x, y) ∈ V) → x = y | null | true |
Set.countable_setOf_nonempty_of_disjoint | Mathlib.Data.Set.Countable | ∀ {α : Type u} {β : Type v} {f : β → Set α},
Pairwise (Function.onFun Disjoint f) →
∀ {s : Set α}, (∀ (t : β), f t ⊆ s) → s.Countable → {t | (f t).Nonempty}.Countable | **Alias** of `Set.countable_ofPred_nonempty_of_disjoint`.
---
If a family of disjoint sets is included in a countable set, then only countably many of
them are nonempty. | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofAbelian._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.lift S.g S.f ⋯)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limi... | null | false |
Matrix.kroneckerStarAlgEquiv._proof_1 | Mathlib.RingTheory.MatrixAlgebra | ∀ (m : Type u_1) (n : Type u_3) (R : Type u_2) [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] [inst_5 : StarRing R] (x : Matrix m m R) (y : Matrix n n R),
(Matrix.kroneckerAlgEquiv m n R) (star (x ⊗ₜ[R] y)) = star ((Matrix.kroneckerAlgEquiv m n R)... | null | false |
IO.Error.unsatisfiedConstraints.inj | Init.System.IOError | ∀ {osCode : UInt32} {details : String} {osCode_1 : UInt32} {details_1 : String},
IO.Error.unsatisfiedConstraints osCode details = IO.Error.unsatisfiedConstraints osCode_1 details_1 →
osCode = osCode_1 ∧ details = details_1 | null | true |
Std.WP.RepeatInvariant.eq_1 | Std.WP.Triple.SpecLemmas | ∀ (α β : Type u) (Pred : Type uₚ), Std.WP.RepeatInvariant α β Pred = (α ⊕ β → Pred) | null | true |
Lean.Elab.Term.instInhabitedArg | Lean.Elab.Arg | Inhabited Lean.Elab.Term.Arg | null | true |
Nat.finMulAntidiag_one | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {d : ℕ}, d.finMulAntidiag 1 = {fun x => 1} | null | true |
CategoryTheory.MorphismProperty.LeftFractionRel.op | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
{z₁ z₂ : W.LeftFraction X Y},
CategoryTheory.MorphismProperty.LeftFractionRel z₁ z₂ → CategoryTheory.MorphismProperty.RightFractionRel z₁.op z₂.op | null | true |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Sort u → Std.Tactic.BVDecide.BVExpr.PackedBitVec → Std.Tactic.BVDecide.BVExpr.PackedBitVec → Sort u | null | false |
Std.HashMap.contains_insert_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, (m.insert k v).contains k = true | null | true |
Std.OrientedCmp.not_isLE_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, cmp a b = Ordering.lt → ¬(cmp b a).isLE = true | null | true |
DFinsupp.sumAddHom | Mathlib.Data.DFinsupp.BigOperators | {ι : Type u} →
{γ : Type w} →
{β : ι → Type v} →
[DecidableEq ι] →
[inst : (i : ι) → AddZeroClass (β i)] →
[inst_1 : AddCommMonoid γ] → ((i : ι) → β i →+ γ) → (Π₀ (i : ι), β i) →+ γ | When summing over an `AddMonoidHom`, the decidability assumption is not needed, and the result is
also an `AddMonoidHom`.
| true |
Lean.ForEachExprWhere.ForEachM | Lean.Util.ForEachExprWhere | {ω : Type} → (m : Type → Type) → [STWorld ω m] → Type → Type | null | true |
RightCancelMonoid.pow_eq_pow_iff_modEq | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {x : G} {m n : ℕ}, x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x] | null | true |
_private.Mathlib.Algebra.CharP.Defs.0.CharP.char_is_prime_or_zero.match_1_1 | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : NonAssocSemiring R] (motive : (p : ℕ) → CharP R p → Prop) (p : ℕ) (hc : CharP R p),
(∀ (x : CharP R 0), motive 0 x) →
(∀ (hc : CharP R 1), motive 1 hc) → (∀ (m : ℕ) (hc : CharP R (m + 2)), motive m.succ.succ hc) → motive p hc | null | false |
Rep.quotientToCoinvariantsFunctor._proof_5 | Mathlib.RepresentationTheory.Coinvariants | ∀ (k : Type u_2) {G : Type u_3} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal]
{X Y Z : Rep.{u_1, u_2, u_3} k G} (f : X ⟶ Y) (g : Y ⟶ Z),
Rep.ofHom
{
toLinearMap :=
ModuleCat.Hom.hom
((Rep.coinvariantsFunctor k ↥S).map
((Rep.resFunctor S... | null | false |
MeasureTheory.eventually_sub_right_iff | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant] (t : G) {p : G → Prop}, (∀ᵐ (x : G) ∂μ, p (x - t)) ↔ ∀ᵐ (x : G) ∂μ, p x | null | true |
AlternatingMap.map_basis_eq_zero_iff | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_5}
[Finite ι] (e : Module.Basis ι R M) (f : M [⋀^ι]→ₗ[R] R), f ⇑e = 0 ↔ f = 0 | null | true |
CategoryTheory.ShortComplex.Exact.moduleCat_of_range_eq_ker._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] {X₁ X₂ X₃ : ModuleCat R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
(ModuleCat.Hom.hom f).range = (ModuleCat.Hom.hom g).ker → (ModuleCat.Hom.hom f).range ≤ (ModuleCat.Hom.hom g).ker | null | false |
Std.Time.instHAddOffsetOffset_8 | Std.Time.Date.Basic | HAdd Std.Time.Millisecond.Offset Std.Time.Minute.Offset Std.Time.Millisecond.Offset | null | true |
Filter.map_neg' | Mathlib.Order.Filter.Pointwise | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : SubtractionMonoid β]
[inst_2 : FunLike F α β] [AddMonoidHomClass F α β] (m : F) {f : Filter α}, Filter.map (⇑m) (-f) = -Filter.map (⇑m) f | null | true |
Asymptotics.isBigOWith_map | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E}
{g : α → F} {k : β → α} {l : Filter β},
Asymptotics.IsBigOWith c (Filter.map k l) f g ↔ Asymptotics.IsBigOWith c l (f ∘ k) (g ∘ k) | null | true |
Matroid.IsColoop.insert_indep_of_indep | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.IsColoop e → M.Indep I → M.Indep (insert e I) | null | true |
integrableOn_Ico_iff_integrableOn_Ioo'._auto_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | Lean.Syntax | null | false |
Filter.Germ.instMulZeroClass._proof_2 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {R : Type u_2} [inst : MulZeroClass R] (q : Quotient (l.germSetoid R)), q * 0 = 0 | null | false |
AddSubmonoidClass.finsuppSum_mem | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] {S : Type u_16}
[inst_2 : SetLike S N] [AddSubmonoidClass S N] (s : S) (f : α →₀ M) (g : α → M → N),
(∀ (c : α), f c ≠ 0 → g c (f c) ∈ s) → f.sum g ∈ s | null | true |
CategoryTheory.Functor.CommShift.isoZero | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
(A : Type u_4) →
[inst_2 : AddMonoid A] →
[inst_3 : CategoryTheory.HasShift C A] →
... | For any functor `F : C ⥤ D`, this is the obvious isomorphism
`shiftFunctor C (0 : A) ⋙ F ≅ F ⋙ shiftFunctor D (0 : A)` deduced from the
isomorphisms `shiftFunctorZero` on both categories `C` and `D`. | true |
SkewMonoidAlgebra.of._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ (k : Type u_1) (G : Type u_2) [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] (a b : G),
SkewMonoidAlgebra.single (a * b) 1 = SkewMonoidAlgebra.single a 1 * SkewMonoidAlgebra.single b 1 | null | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.Fintype.not_linearIndependent_iffₒₛ._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_ae_parallelepiped._simp_1_4 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) | null | false |
StrictAnti.not_bddBelow_range_of_isPredArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [Nonempty α] [inst_2 : Preorder β] {f : α → β} [NoMaxOrder α]
[inst_4 : PredOrder β] [IsPredArchimedean β], StrictAnti f → ¬BddBelow (Set.range f) | null | true |
Units.eq_inv_of_mul_eq_one_right | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, a * ↑u = 1 → a = ↑u⁻¹ | null | true |
Std.ExtTreeMap.maxKeyD_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
SchwartzMap.instAddCommGroup | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | {E : Type u_5} →
{F : Type u_6} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] → [inst_3 : NormedSpace ℝ F] → AddCommGroup (SchwartzMap E F) | null | true |
Mathlib.Tactic.ClickSuggestions.GrwPos.relName | Mathlib.Tactic.ClickSuggestions.GRewrite | Mathlib.Tactic.ClickSuggestions.GrwPos → Lean.Name | The name of the relation. | true |
PFun.prodLift_fst_comp_snd_comp | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α →. γ) (g : β →. δ),
(f.comp ↑Prod.fst).prodLift (g.comp ↑Prod.snd) = f.prodMap g | null | true |
Complex.cos_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℕ), Complex.cos (x + ↑n * (2 * ↑Real.pi)) = Complex.cos x | null | true |
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_2 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (a b : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }),
((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2).1 * ((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2).2 = 0 | null | false |
Aesop.instEmptyCollectionLocalRuleSet | Aesop.RuleSet | EmptyCollection Aesop.LocalRuleSet | null | true |
Lean.Lsp.InlayHintLabel.ctorElimType | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintLabel → Sort u} → ℕ → Sort (max 1 u) | null | false |
PositiveLinearMap.toLinearMap_nsmul | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] [inst_7 : IsOrderedAddMonoid E₂] (f : E₁ →ₚ[R] E₂) (n : ℕ),
(n • f).toLinearMap = n • f.t... | null | true |
MeasureTheory.lpTrimToLpMeasSubgroup_ae_eq | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {F : Type u_2} {p : ENNReal} [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (hm : m ≤ m0) (f : ↥(MeasureTheory.Lp F p (μ.trim hm))),
↑↑↑(MeasureTheory.lpTrimToLpMeasSubgroup F p μ hm f) =ᵐ[μ] ↑↑f | null | true |
Lean.Omega.Constraint.instToString._private_1 | Init.Omega.Constraint | Lean.Omega.Constraint → String | null | false |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_7 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (0 ≤ a - b) = (b ≤ a) | null | false |
Std.TreeMap.maxKey! | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited α] → Std.TreeMap α β cmp → α | Tries to retrieve the largest key in the tree map, panicking if the map is empty.
| true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | Lean.Syntax | null | false |
Lean.Elab.Tactic.Conv.PatternMatchState.all.inj | Lean.Elab.Tactic.Conv.Pattern | ∀ {subgoals subgoals_1 : Array Lean.MVarId},
Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals = Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals_1 →
subgoals = subgoals_1 | null | true |
CategoryTheory.MorphismProperty.instCopyDiscardCategoryWideSubcategoryOfIsStableUnderComonoid._proof_8 | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.CopyDiscardCategory C]
[inst_3 : P.IsStableUnderBraiding] [inst_4 : ∀ (c : C), P.IsStableUnderComonoid c],
CategoryTheory.ComonObj.counit =
... | null | false |
List.mapAsyncChunked | Mathlib.Data.List.Defs | {α : Type u_7} → {β : Type u_8} → (α → β) → List α → optParam ℕ 1024 → List β | Asynchronous version of `List.map`.
| true |
CategoryTheory.Functor.comp_mapGrp_mul | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{E : Type u₃} [inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.Car... | null | true |
Perfection.coeff | Mathlib.RingTheory.Perfection | (R : Type u_1) →
[inst : CommSemiring R] → (p : ℕ) → [hp : Fact (Nat.Prime p)] → [inst_1 : CharP R p] → ℕ → Perfection R p →+* R | The `n`-th coefficient of an element of the perfection. | true |
BddDistLat.delabOf | Mathlib.Order.Category.BddDistLat | Lean.PrettyPrinter.Delaborator.Delab | This prints `BddDistLat.of X` as `↧X`. | true |
Subgroup.div_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x y : G}, x ∈ H → y ∈ H → x / y ∈ H | A subgroup is closed under division. | true |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?.match_8 | Lean.Meta.Tactic.Grind.PropagateInj | (motive : Option Lean.Meta.Grind.InjectiveInfo → Sort u_1) →
(x : Option Lean.Meta.Grind.InjectiveInfo) →
((info : Lean.Meta.Grind.InjectiveInfo) → motive (some info)) →
((x : Option Lean.Meta.Grind.InjectiveInfo) → motive x) → motive x | null | false |
existsUnique_eq' | Mathlib.Basic.ExistsUnique | ∀ {α : Sort u_1} {a' : α}, ∃! a, a' = a | The difference with `existsUnique_eq` is that the equality is reversed. | true |
FirstOrder.Language.Relations.transitive._proof_1 | Mathlib.ModelTheory.Syntax | NeZero (0 + 1 + 1 + 1) | null | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | SizeOf Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Cycle.formPerm_subsingleton._simp_1_5 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (a ≤ 0) = (a = 0) | null | false |
Nat.toInt8 | Init.Data.SInt.Basic | ℕ → Int8 | Converts a natural number to an 8-bit signed integer, wrapping around to negative numbers on
overflow.
Examples:
* `Nat.toInt8 53 = 53`
* `Nat.toInt8 127 = 127`
* `Nat.toInt8 128 = -128`
* `Nat.toInt8 255 = -1`
| true |
_private.Mathlib.FieldTheory.Isaacs.0.Field.nonempty_algEquiv_of_aeval_eq_zero_eq.match_1_1 | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_3} {E : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] (motive : Nonempty (K →ₐ[F] E) → Prop) (x : Nonempty (K →ₐ[F] E)),
(∀ (τ : K →ₐ[F] E), motive ⋯) → motive x | null | false |
hasProd_eulerFunction | Mathlib.Combinatorics.Enumerative.Pentagonal.EulerFunction | ∀ {R : Type u_1} [inst : NormedCommRing R] [NormOneClass R] [CompleteSpace R] {x : R},
‖x‖ < 1 → HasProd (fun n => 1 - x ^ (n + 1)) (eulerFunction x) | **Pentagonal number theorem** for Euler function, expressed as an infinite product.
See `hasSum_eulerFunction_pentagonal` that expresses `eulerFunction` as an infinite sum. | true |
CategoryTheory.Comma.mapLeft.eq_1 | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ : CategoryTheory.Functor A T} (l : L₁ ⟶ L₂),
CategoryTheory.Comma.mapLeft R l =
{
ob... | null | true |
AddSubmonoid.mem_multiples_iff | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] (x z : M), x ∈ AddSubmonoid.multiples z ↔ ∃ n, n • z = x | null | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.IsFractional.mapEquiv._simp_1_4 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Lean.IR.NormalizeIds.normJP | Lean.Compiler.IR.NormIds | Lean.IR.JoinPointId → Lean.IR.NormalizeIds.M Lean.IR.JoinPointId | null | true |
Lean.Compiler.LCNF.ExtractClosed.shouldExtractFVar | Lean.Compiler.LCNF.ExtractClosed | Lean.FVarId → Lean.Compiler.LCNF.ExtractClosed.M Bool | null | true |
Nat.length_toList_rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {b : ℕ}, (*...b).toList.length = b | null | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.instIteratorId.match_1.eq_5 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type} {pat : ρ} [inst : String.Slice.Pattern.ToForwardSearcher pat σ]
{s : String.Slice}
(motive : Std.IterM Id String.Slice → Std.IterStep (Std.IterM Id String.Slice) String.Slice → Sort u_1)
(currPos : s.Pos) (s_1 : Std.Iter (String.Slice.Pattern.SearchStep s))
(h_1 :
(cur... | null | true |
Diffeomorph.prodComm_symm | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_7} [inst_6 : TopologicalSpace G] (I : ModelWithCorners ... | null | true |
_private.Init.Data.String.Termination.0.String.Pos.remainingBytes_inj._simp_1_1 | Init.Data.String.Termination | ∀ {s : String} {p : s.Pos}, p.remainingBytes = p.toSlice.remainingBytes | null | false |
Lean.Meta.LibrarySearch.DeclMod.mp | Lean.Meta.Tactic.LibrarySearch | Lean.Meta.LibrarySearch.DeclMod | the forward direction of an `iff` | true |
Lean.Widget.MsgEmbed.rec_2 | Lean.Widget.InteractiveDiagnostic | {motive_1 : Lean.Widget.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u} →
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u} →
{motive... | null | false |
stdSimplex.map | Mathlib.Analysis.Convex.StdSimplex | {S : Type u_1} →
[inst : Semiring S] →
[inst_1 : PartialOrder S] →
{X : Type u_2} →
{Y : Type u_3} →
[inst_2 : Fintype X] →
[inst_3 : Fintype Y] → [IsOrderedRing S] → (X → Y) → ↑(stdSimplex S X) → ↑(stdSimplex S Y) | The map `stdSimplex S X → stdSimplex S Y` that is induced by a map `f : X → Y`. | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_rightShift._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n : ℤ} (a n' m' : ℤ), n' + a = n → ∀ (m : ℤ), m' + a = m → n + 1 = m → ∀ (p q : ℤ), p + m' = q → p + n' = q - 1 | null | false |
ENat.iInf_natCast_ne_top | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} {f : ι → ℕ}, ⨅ i, ↑(f i) ≠ ⊤ ↔ Nonempty ι | null | true |
TopCat.continuousFunctions.pullback._proof_4 | Mathlib.Topology.Sheaves.CommRingCat | ∀ {X Y : TopCatᵒᵖ} (f : X ⟶ Y) (R : TopCommRingCat),
CategoryTheory.CategoryStruct.comp f.unop 0 = CategoryTheory.CategoryStruct.comp f.unop 0 | null | false |
Equiv.optionSubtypeNe_symm_apply | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α),
(Equiv.optionSubtypeNe a).symm b = if h : b = a then none else some ⟨b, h⟩ | null | true |
Real.two_pi_pos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | 0 < 2 * Real.pi | null | true |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.MemεClosure.below.base | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u} {σ : Type v} {M : εNFA α σ} {S : Set σ} {motive : (a : σ) → εNFA.MemεClosure✝ M S a → Prop} (s : σ)
(a : s ∈ S), εNFA.MemεClosure.below✝ ⋯ | null | true |
Nat.sub_lt_right_of_lt_add | Init.Data.Nat.Basic | ∀ {n k m : ℕ}, n ≤ k → k < m + n → k - n < m | null | true |
DirectSum.IsInternal.coeAlgEquiv | Mathlib.RingTheory.GradedAlgebra.Basic | {R : Type u_5} →
[inst : CommSemiring R] →
{A : Type u_6} →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
{ι : Type u_7} →
[inst_3 : DecidableEq ι] →
[inst_4 : AddMonoid ι] →
{M : ι → Submodule R A} →
[inst_5 : SetLike.GradedMo... | The canonical isomorphism of an internal direct sum with the ambient algebra | true |
CochainComplex.homotopyUnop._proof_9 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {f g : K ⟶ L}
(h : Homotopy ((CochainComplex.opEquivalence C).functor.map f.op) ((CochainComplex.opEquivalence C).functor.map g.op))
(n : ℤ),
f.f n =
(((dNext n) fun p q =>
... | null | false |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescopeAux.match_11 | Lean.Meta.HaveTelescope | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
Std.ExtDHashMap.get_insertMany_list_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k : α} (contains_eq_false : (List.map Sigma.fst l).contains k = false)
{h : k ∈ m.insertMany l}, (m.insertMany l).get k h = m.get k ⋯ | null | true |
Real.instAddRightCancelSemigroup | Mathlib.Basic.Real.Basic | AddRightCancelSemigroup ℝ | null | true |
Ideal.exists_coeff_ne_zero_mem_comap_of_non_zero_divisor_root_mem | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S} {I : Ideal S} {r : S},
(∀ {x : S}, x * r = 0 → x = 0) →
r ∈ I → ∀ {p : Polynomial R}, p ≠ 0 → Polynomial.eval₂ f r p = 0 → ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I | null | true |
groupCohomology.d₀₁._proof_2 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{max u_1 u_2, u_1, u_1} k G) (r : k) (x : ↑A)
(g : G), (A.ρ g) (r • x) - r • x = ((RingHom.id k) r • fun g => (A.ρ g) x - x) g | null | false |
Fintype.univ_ofIsEmpty | Mathlib.Data.Fintype.OfMap | ∀ {α : Type u_1} [inst : IsEmpty α], Finset.univ = ∅ | Note: this lemma is specifically about `Fintype.ofIsEmpty`. For a statement about
arbitrary `Fintype` instances, use `Finset.univ_eq_empty`. | true |
UInt8.shiftLeft_add_of_toNat_lt | Init.Data.UInt.Bitwise | ∀ {a b c : UInt8}, b.toNat + c.toNat < 8 → a <<< (b + c) = a <<< b <<< c | null | true |
_private.Init.Data.ByteArray.Bootstrap.0.List.toByteArray.match_1.splitter | Init.Data.ByteArray.Bootstrap | (motive : List UInt8 → ByteArray → Sort u_1) →
(x : List UInt8) →
(x_1 : ByteArray) →
((r : ByteArray) → motive [] r) →
((b : UInt8) → (bs : List UInt8) → (r : ByteArray) → motive (b :: bs) r) → motive x x_1 | null | true |
isGCDMonoid_iff_exists_lcm | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_2} [inst : CommMonoidWithZero α],
IsGCDMonoid α ↔ IsCancelMulZero α ∧ ∀ (a b : α), ∃ c, ∀ (d : α), a ∣ d ∧ b ∣ d ↔ c ∣ d | null | true |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.counitIso._proof_4 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.AddMon C),
CategoryTheory.CategoryStruct.comp CategoryTheory.AddMonObj.add
(CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.counitIsoAux C F).hom =
CategoryTheory.CategoryStru... | null | false |
Lake.SemVerCore.major._default | Lake.Util.Version | ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.