name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Quaternion.instGroupWithZero._proof_4 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (n : ℕ) (a : Quaternion R), a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹ | null | false |
MulEquiv.subgroupCongr.congr_simp | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} (h : H = K), MulEquiv.subgroupCongr h = MulEquiv.subgroupCongr h | null | true |
Lean.Meta.Grind.Arith.Linear.EqCnstr._sizeOf_5 | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.DiseqCnstr → ℕ | null | false |
WeierstrassCurve.variableChange_b₈ | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R),
(C • W).b₈ = ↑C.u⁻¹ ^ 8 * (W.b₈ + 3 * C.r * W.b₆ + 3 * C.r ^ 2 * W.b₄ + C.r ^ 3 * W.b₂ + 3 * C.r ^ 4) | null | true |
Turing.TM2.stmts.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (M : Λ → Turing.TM2.Stmt Γ Λ σ) (S : Finset Λ),
Turing.TM2.stmts M S = Finset.insertNone (S.biUnion fun q => Turing.TM2.stmts₁ (M q)) | null | true |
Unitary.smul_mem | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : Monoid A] [inst_2 : MulAction R A] [SMulCommClass R A A]
[IsScalarTower R A A] [inst_5 : StarMul R] [inst_6 : StarMul A] [StarModule R A] (r : ↥(unitary R)) {a : A},
a ∈ unitary A → r • a ∈ unitary A | null | true |
Lat.ext_iff | Mathlib.Order.Category.Lat | ∀ {X Y : Lat} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x | null | true |
_private.Mathlib.RingTheory.Ideal.IsPrincipal.0.Ideal.associatesEquivIsPrincipal._simp_3 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | null | false |
Tactic.ComputeAsymptotics.Monomial.isLittleO_of_lt_exps_right | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {left right : Tactic.ComputeAsymptotics.Basis} {t1 t2 : Tactic.ComputeAsymptotics.Monomial},
Tactic.ComputeAsymptotics.WellFormedBasis (left ++ right) →
List.length t1.unit = List.length left + List.length right →
List.length t2.unit = List.length right →
t1.coef ≠ 0 →
List.replicate (Li... | null | true |
Std.DHashMap.Internal.Raw₀.getKey!_eq_of_contains | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
[inst_3 : Inhabited α], (↑m).WF → ∀ {k : α}, m.contains k = true → m.getKey! k = k | null | true |
SequentiallyComplete.setSeqAux._proof_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} [uniformSpace : UniformSpace α] {f : Filter α},
Cauchy f → ∀ {U : ℕ → SetRel α α}, (∀ (n : ℕ), U n ∈ uniformity α) → ∀ (n : ℕ), ∃ t ∈ f, t ×ˢ t ⊆ U n | null | false |
_private.Mathlib.AlgebraicGeometry.Sites.SheafQuasiCompact.0.AlgebraicGeometry.isSheaf_propQCTopology_iff._proof_1_1 | Mathlib.AlgebraicGeometry.Sites.SheafQuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.IsStableUnderBaseChange] {A : Type u_3}
[inst : CategoryTheory.Category.{u_2, u_3} A] [P.IsMultiplicative]
(F : CategoryTheory.Functor AlgebraicGeometry.Schemeᵒᵖ A) [AlgebraicGeometry.IsZariskiLocalAtSource P],
CategoryTheory.Presheaf.IsSheaf
... | null | false |
_private.Mathlib.Data.Fin.Basic.0.Fin.coe_int_add_eq_ite._proof_1_2 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (u v : Fin n), 0 ≤ ↑(↑u + ↑v) | null | false |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_indicator_const_apply_iff_eventually'._simp_1_2 | Mathlib.Topology.IndicatorConstPointwise | ∀ {α : Type u_1} {a : α} {s : Set α}, (s ∈ pure a) = (a ∈ s) | null | false |
QuadraticForm.comp_tensorRId_eq | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
[inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁),
QuadraticMap.comp Q₁ ↑(TensorProduct.rid R M₁) = Q₁.tmul QuadraticMap.sq | null | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.Context | Lean.Meta.Tactic.Grind.ProveEq | Type | Context for the `AbstractM` monad used to implement `abstractGroundMismatches?` | true |
Std.HashMap.Raw.keysArray | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → Std.HashMap.Raw α β → Array α | Returns an array of all keys present in the hash map in some order. | true |
Std.Time.DateFormat.rec | Std.Time.Format.DateFormat | {motive : Std.Time.DateFormat → Sort u} →
((firstDayOfWeek : Std.Time.Weekday) →
(minimalDaysInFirstWeek : Std.Time.Internal.Bounded.LE 0 6) →
(symbols : Std.Time.DateFormatSymbols) →
motive
{ firstDayOfWeek := firstDayOfWeek, minimalDaysInFirstWeek := minimalDaysInFirstWeek,
... | null | false |
Mathlib.Meta.Positivity.evalProjMulHeight | Mathlib.NumberTheory.Height.Projectivization | Mathlib.Meta.Positivity.PositivityExt | Extension for the `positivity` tactic: `Projectivization.mulHeight` is always positive. | true |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ico_filter_modEq_eq._simp_1_3 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
Set.Icc.coe_eq_zero | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Zero R] [inst_1 : One R] [inst_2 : Preorder R] [inst_3 : ZeroLEOneClass R]
{x : ↑(Set.Icc 0 1)}, ↑x = 0 ↔ x = 0 | null | true |
Set.embeddingOfSubset._proof_5 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (s t : Set α) (h : s ⊆ t) (x : α) (hx : x ∈ s) (y : α) (hy : y ∈ s),
(fun x => ⟨↑x, ⋯⟩) ⟨x, hx⟩ = (fun x => ⟨↑x, ⋯⟩) ⟨y, hy⟩ → ⟨x, hx⟩ = ⟨y, hy⟩ | null | false |
List.dProdIndex_eq_map_sum._f | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddMonoid ι] (fι : α → ι) (l : List α) (f : List.below l),
l.dProdIndex fι = (List.map fι l).sum | null | false |
CategoryTheory.Subgroupoid.disconnect_objs | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C), S.disconnect.objs = S.objs | null | true |
AffineSubspace.dim_eq_finDim_unbot._proof_1 | Mathlib.LinearAlgebra.AffineSpace.Dimension | ∀ {R : Type u_1} {V : Type u_2} {A : Type u_3} [inst : AddCommGroup V] [inst_1 : AddTorsor V A] [inst_2 : Ring R]
[inst_3 : Module R V] {s : AffineSubspace R A}, s ≠ ⊥ → s.finDim ≠ ⊥ | null | false |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_3 | Mathlib.Analysis.Complex.Conformal | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
FractionalIdeal.extendedHom'.congr_simp | Mathlib.RingTheory.ClassGroup.ExtendedHom | ∀ {A : Type u_1} [inst : CommRing A] {B : Type u_2} [inst_1 : CommRing B] {f f_1 : A →+* B} (e_f : f = f_1)
{K : Type u_3} {M : Submonoid A} [inst_2 : CommRing K] [inst_3 : Algebra A K] [inst_4 : IsLocalization M K]
(L : Type u_4) {N : Submonoid B} [inst_5 : CommRing L] [inst_6 : Algebra B L] [inst_7 : IsLocalizati... | null | true |
Std.DTreeMap.Internal.Impl.Const.get_eq_get! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {a : α} {h : Std.DTreeMap.Internal.Impl.contains a t = true},
Std.DTreeMap.Internal.Impl.Const.get t a h = Std.DTreeMap.Internal.Impl.Const.get! t a | null | true |
Function.RightInverse.surjective | Init.Data.Function | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.RightInverse g f → Function.Surjective f | null | true |
Std.DHashMap.Internal.Raw₀.get!_diff_of_contains_eq_false_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α} [inst_3 : Inhabited (β k)], m₂.contains k = false → (m₁.diff m₂).get! k = m₁.get! k | null | true |
Cubic | Mathlib.Algebra.CubicDiscriminant | Type u_1 → Type u_1 | The structure representing a cubic polynomial. | true |
Finset.intervalGapsWithin_snd_of_lt | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} [inst : LinearOrder α] (F : Finset (α × α)) {k : ℕ} (h : F.card = k) (a b : α) (j : ℕ) (hj : j < k),
(F.intervalGapsWithin h a b ↑j).2 = ((F.orderEmbOfFin h) ⟨j, hj⟩).1 | null | true |
Std.ExtTreeMap.getElem!_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α}
[hi : Inhabited β] {f : β → β},
(t.modify k f)[k']! = if cmp k k' = Ordering.eq then (Option.map f t[k]?).get! else t[k']! | null | true |
CategoryTheory.Limits.combineCocones._proof_7 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {K : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} K]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C))
(c : (k : K) → CategoryTheory.Limits.ColimitCocone (F.flip.obj k)... | null | false |
Lean.Meta.Sym.Config.mk.injEq | Lean.Meta.Sym.SymM | ∀ (verbose enforceUnfoldReducible enforceFoldProjs verbose_1 enforceUnfoldReducible_1 enforceFoldProjs_1 : Bool),
({ verbose := verbose, enforceUnfoldReducible := enforceUnfoldReducible, enforceFoldProjs := enforceFoldProjs } =
{ verbose := verbose_1, enforceUnfoldReducible := enforceUnfoldReducible_1,
... | null | true |
RingCon.quotientKerEquivOfSurjective._proof_2 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring P] (f : M →+* P)
(hf : Function.Surjective ⇑f), Function.RightInverse (Exists.choose ⋯) ⇑f | null | false |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Mon (CategoryTheory.Functor C D)) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor... | null | false |
Multiset.sum_eq_zero | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} [inst : AddCommMonoid M] {s : Multiset M}, (∀ x ∈ s, x = 0) → s.sum = 0 | null | true |
IsLocalizedModule.isInteger_smul | Mathlib.Algebra.Module.LocalizedModule.Int | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_3}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') {a : R} {x : M'},
IsLocalizedModule.IsInteger f x → IsLocalizedModule.IsInteger f (a • x) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.range_vecMulLinear._simp_1_2 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {α : Type u} [inst : Semiring α], ⊤ = Ideal.span {1} | null | false |
PartitionOfUnity.mem_fintsupport_iff | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (ρ : PartitionOfUnity ι X s) (x₀ : X) (i : ι),
i ∈ ρ.fintsupport x₀ ↔ x₀ ∈ tsupport ⇑(ρ i) | null | true |
Lean.Server.GoToKind.recOn | Lean.Server.GoTo | {motive : Lean.Server.GoToKind → Sort u} →
(t : Lean.Server.GoToKind) →
motive Lean.Server.GoToKind.declaration →
motive Lean.Server.GoToKind.definition → motive Lean.Server.GoToKind.type → motive t | null | false |
Std.ExtDTreeMap.getKey!_modify | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] [inst_2 : Inhabited α] {k k' : α} {f : β k → β k},
(t.modify k f).getKey! k' = if cmp k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k' | null | true |
PowerSeries.C_injective | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R], Function.Injective ⇑PowerSeries.C | null | true |
Function.Injective.ne_iff' | Init.Data.Function | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Injective f → ∀ {x y : α} {z : β}, f y = z → (f x ≠ z ↔ x ≠ y) | null | true |
Lean.Meta.declFromEqLikeName | Lean.Meta.Eqns | Lean.Environment → Lean.Name → Option (Lean.Name × String) | The equational theorem for a definition can be private even if the definition itself is not.
So un-private the name here when looking for a declaration
| true |
instCommGroupClassGroup._proof_10 | Mathlib.RingTheory.ClassGroup.Basic | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R],
autoParam (∀ (x : ClassGroup R), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
posPart_negPart_inj | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] {a b : α} [AddLeftMono α], a⁺ = b⁺ ∧ a⁻ = b⁻ ↔ a = b | null | true |
isClosed_eq | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space X] {f g : Y → X},
Continuous f → Continuous g → IsClosed {y | f y = g y} | null | true |
List.foldr_unattach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} {xs : List (Subtype P)} {f : α → β → β} {x : β},
List.foldr f x xs.unattach =
List.foldr
(fun x s =>
match x with
| ⟨x, h⟩ => binderNameHint x f (binderNameHint s (f x) (binderNameHint h () (f (wfParam x) s))))
x xs | null | true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_7 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
MonomialOrder.degree_zero | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R], m.degree 0 = 0 | null | true |
Homeomorph.sumComm._proof_2 | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Continuous (Equiv.sumComm X Y).invFun | null | false |
max_top_left | Mathlib.Order.BoundedOrder.Lattice | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : OrderTop α] (a : α), max ⊤ a = ⊤ | null | true |
Module.End.HasEigenvalue.exists_hasEigenvector | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, f.HasEigenvalue μ → ∃ v, f.HasEigenvector μ v | null | true |
TrivSqZeroExt.monoid._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M]
[inst_3 : DistribMulAction Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x y z : TrivSqZeroExt R M), x * y * z = x * (y * z) | null | false |
Lean.Elab.Term.Quotation.HeadCheck.ctorIdx | Lean.Elab.Quotation | Lean.Elab.Term.Quotation.HeadCheck → ℕ | null | false |
CategoryTheory.Square.map_f₁₃ | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D), (sq.map F).f₁₃ = F.map sq.f₁₃ | null | true |
ENat.toENNReal_eq_top | Mathlib.Basic.Real.ENatENNReal | ∀ {n : ℕ∞}, ↑n = ⊤ ↔ n = ⊤ | null | true |
FirstOrder.Language.orderRel.casesOn | Mathlib.ModelTheory.Order | {motive : (a : ℕ) → FirstOrder.Language.orderRel a → Sort u} →
{a : ℕ} → (t : FirstOrder.Language.orderRel a) → motive 2 FirstOrder.Language.orderRel.le → motive a t | null | false |
Lex.instMulOneClass._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : MulOneClass α] (a : Lex α), 1 * a = a | null | false |
HomologicalComplex.liftCycles_comp_homologyπ_eq_iff_up_to_refinements | Mathlib.Algebra.Homology.Refinements | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (K : HomologicalComplex C c) (i j k : ι),
c.prev j = i →
∀ (hk : c.next j = k) {A : C} (x₂ x₂' : A ⟶ K.X j) (hx₂ : CategoryTheory.CategoryStruct.comp x₂ (K.d j k) = 0)
(hx... | null | true |
Lean.PersistentArray.mapMAux._unsafe_rec | Lean.Data.PersistentArray | {α : Type u} →
{m : Type u → Type v} →
[Monad m] → {β : Type u} → (α → m β) → Lean.PersistentArrayNode α → m (Lean.PersistentArrayNode β) | null | false |
String.isEmpty_toSlice_iff | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s.toSlice.isEmpty = true ↔ s = "" | null | true |
PiTensorProduct.instOne | Mathlib.RingTheory.PiTensorProduct | {ι : Type u_1} →
{R : Type u_3} →
{A : ι → Type u_4} →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → AddCommMonoidWithOne (A i)] →
[inst_2 : (i : ι) → Module R (A i)] → One (PiTensorProduct R fun i => A i) | null | true |
WeierstrassCurve.Projective.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R) (P : Fin 3 → R),
W'.Equation P = ((MvPolynomial.eval P) W'.polynomial = 0) | null | true |
Lean.Elab.Command.Linter.rec | Lean.Elab.Command | {motive : Lean.Linter → Sort u} →
((run : Lean.Syntax → Lean.Elab.Command.CommandElabM Unit) →
(name : Lean.Name) → motive { run := run, name := name }) →
(t : Lean.Linter) → motive t | null | false |
ArithmeticFunction.sigma_eq_one_iff._simp_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (k n : ℕ), ((ArithmeticFunction.sigma k) n = 1) = (n = 1) | null | false |
Real.toNNReal_le_toNNReal_iff | Mathlib.Basic.NNReal.Defs | ∀ {r p : ℝ}, 0 ≤ p → (r.toNNReal ≤ p.toNNReal ↔ r ≤ p) | null | true |
Std.Time.TimeZone.TZif.Header.mk.noConfusion | Std.Time.Zoned.Database.TzIf | {P : Sort u} →
{version : UInt8} →
{isutcnt isstdcnt leapcnt timecnt typecnt charcnt : UInt32} →
{version' : UInt8} →
{isutcnt' isstdcnt' leapcnt' timecnt' typecnt' charcnt' : UInt32} →
{ version := version, isutcnt := isutcnt, isstdcnt := isstdcnt, leapcnt := leapcnt, timecnt := timecnt,
... | null | false |
Set.mem_image2_of_mem | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
a ∈ s → b ∈ t → f a b ∈ Set.image2 f s t | null | true |
Option.get_attach._proof_1 | Init.Data.Option.Attach | ∀ {α : Type u_1} {o : Option α}, o.attach.isSome = true → o.isSome = true | null | false |
SpectralMap.comp._proof_1 | Mathlib.Topology.Spectral.Hom | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : SpectralMap β γ) (g : SpectralMap α β),
IsSpectralMap (f.toFun ∘ ⇑g.toContinuousMap) | null | false |
cfcₙHomSuperset.congr_simp | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {R : Type u_1} {A : Type u_2} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Mo... | null | true |
eulerFunction_eq_tprod | Mathlib.Combinatorics.Enumerative.Pentagonal.EulerFunction | ∀ {R : Type u_1} [inst : NormedCommRing R] [NormOneClass R] [CompleteSpace R] {x : R},
‖x‖ < 1 → eulerFunction x = ∏' (n : ℕ), (1 - x ^ (n + 1)) | **Pentagonal number theorem** for Euler function, expressed as an infinite product.
See `eulerFunction_eq_tsum_pentagonal` that expresses `eulerFunction` as an infinite sum. | true |
ImportGraph.Lake.instBEqBaseLibrary | ImportGraph.WorkspaceModel.Base | BEq ImportGraph.Lake.BaseLibrary | null | true |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.Style.elabShow | Mathlib.Tactic.Linter.Style | Lean.Term → Lean.Elab.Tactic.TacticM Unit | Run the `show` tactic, with a linter warning when one should use `change` instead. | true |
Lean.PrettyPrinter.Delaborator.AppImplicitArg.canUnexpand | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.AppImplicitArg → Bool | Whether unexpanding is allowed with this argument. | true |
Finpartition.pairwiseDisjoint_apply | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a) {β : Type u_2} {f : α → β}
[inst_2 : SemilatticeInf β] [inst_3 : OrderBot β],
(∀ (x y : α), f (x ⊓ y) = f x ⊓ f y) → f ⊥ = ⊥ → (↑P.parts).PairwiseDisjoint f | Parts of a `Finpartition` are pairwise disjoint under an inf-bot-preserving map. | true |
isCancelSMul_iff_eq_one_of_smul_eq | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : MulAction α β],
IsCancelSMul α β ↔ ∀ (g : α) (x : β), g • x = x → g = 1 | null | true |
MonomialOrder.C_mul_leadingCoeff_monomial_degree | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] (p : MvPolynomial σ R),
MvPolynomial.C (m.leadingCoeff p) * (MvPolynomial.monomial (m.degree p)) 1 = m.leadingTerm p | null | true |
Finset.offDiag_inter | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} (s t : Finset α) [inst : DecidableEq α], (s ∩ t).offDiag = s.offDiag ∩ t.offDiag | null | true |
Std.instToStreamList | Init.Data.Stream | {α : Type u_1} → Std.ToStream (List α) (List α) | null | true |
NonemptyFinLinOrd.instLargeCategory._proof_8 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(∀ {X Y : NonemptyFinLinOrd} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
CategoryTheory.Triangulated.TStructure.from_truncGE_obj_ext | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} 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 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
isOpen_Iio | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {a : α}, IsOpen (Set.Iio a) | null | true |
WellFounded.fixC | Init.WFComputable | {α : Sort u} →
{C : α → Sort v} → {r : α → α → Prop} → WellFounded r → ((x : α) → ((y : α) → r y x → C y) → C x) → (x : α) → C x | A computable version of `fix`. | true |
Lean.Elab.Term.Do.ToCodeBlock.Catch.mk.inj | Lean.Elab.Do.Legacy | ∀ {x optType : Lean.Syntax} {codeBlock : Lean.Elab.Term.Do.CodeBlock} {x_1 optType_1 : Lean.Syntax}
{codeBlock_1 : Lean.Elab.Term.Do.CodeBlock},
{ x := x, optType := optType, codeBlock := codeBlock } =
{ x := x_1, optType := optType_1, codeBlock := codeBlock_1 } →
x = x_1 ∧ optType = optType_1 ∧ codeBlock... | null | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take_drop._proof_1_2 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {s : Stream'.Seq α} {n m : ℕ} (i : ℕ),
i + 1 ≤ (List.drop m (Stream'.Seq.take n s)).length → i < (List.drop m (Stream'.Seq.take n s)).length | null | false |
Lean.Meta.SynthInstance.Waiter.ctorIdx | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Waiter → ℕ | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.WithDensityVec.0.MeasureTheory.VectorMeasure.variation_withDensity'._simp_1_21 | Mathlib.MeasureTheory.VectorMeasure.WithDensityVec | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ) [inst_2 : n.AtLeastTwo], (OfNat.ofNat n = 0) = False | null | false |
BitVec.or_eq | Init.Data.BitVec.Basic | ∀ {w : ℕ} (x y : BitVec w), x.or y = x ||| y | null | true |
FirstOrder.ringFunc.one.sizeOf_spec | Mathlib.ModelTheory.Algebra.Ring.Basic | sizeOf FirstOrder.ringFunc.one = 1 | null | true |
_private.Lean.Elab.Tactic.Grind.Annotated.0.Lean.Elab.Tactic.Grind.initFn._@.Lean.Elab.Tactic.Grind.Annotated.476932661._hygCtx._hyg.2 | Lean.Elab.Tactic.Grind.Annotated | IO (Lean.SimplePersistentEnvExtension Lean.Name Lean.NameSet) | null | false |
not_irrational_zero | Mathlib.NumberTheory.Real.Irrational | ¬Irrational 0 | null | true |
CategoryTheory.Over.tensorHom_left_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X S U : C} {R T : CategoryTheory.Over X} (fS : S ⟶ X) (fU : U ⟶ X) (f : R ⟶ CategoryTheory.Over.mk fS)
(g : T ⟶ CategoryTheory.Over.mk fU) {Z : C} (h : U ⟶ Z),
CategoryTheory.CategoryStruct.comp
(... | null | true |
Std.DHashMap.Internal.AssocList.instIteratorLoopAssocListIteratorIdSigmaOfMonad | Std.Data.DHashMap.Internal.AssocList.Iterator | {α : Type u} →
{β : α → Type v} →
{m : Type (max u v) → Type w''} →
[Monad m] → Std.IteratorLoop (Std.DHashMap.Internal.AssocList.AssocListIterator α β) Id m | null | true |
Polynomial.Chebyshev.one_le_abs_eval_T_real | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ (n : ℤ) {x : ℝ}, 1 ≤ |x| → 1 ≤ |Polynomial.eval x (Polynomial.Chebyshev.T ℝ n)| | null | true |
CategoryTheory.CommGrp.fullyFaithfulForget₂CommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.CommGrp C} (f : X ⟶ Y),
CategoryTheory.InducedCategory.homMk
(CategoryTheory.Grp.homMk' ((CategoryTheory.CommGrp.forget₂CommMon... | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_7.eq_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β)
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size r.size → Sort u_3)
(hrb : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond l... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.