name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.NatTrans.shift_app | 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₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5}
[inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A]
[inst_5 : F₁.CommShif... | true |
_private.Mathlib.Logic.Denumerable.0.nonempty_denumerable_iff.match_1_1 | Mathlib.Logic.Denumerable | ∀ {α : Type u_1} (motive : Nonempty (Denumerable α) → Prop) (x : Nonempty (Denumerable α)),
(∀ (val : Denumerable α), motive ⋯) → motive x | false |
List.TProd.elim'.congr_simp | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} {l : List ι} {inst : DecidableEq ι} [inst_1 : DecidableEq ι] (h : ∀ (i : ι), i ∈ l)
(v v_1 : List.TProd α l), v = v_1 → ∀ (i : ι), List.TProd.elim' h v i = List.TProd.elim' h v_1 i | true |
CategoryTheory.MonoidalCategory.tensorHom_def'_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X₁ Y₁ X₂ Y₂ : C}
(f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ Y₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) h =
... | true |
TopologicalSpace.NonemptyCompacts.continuous_singleton | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α], Continuous fun x => {x} | true |
Subarray.array.eq_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} (xs : Subarray α), xs.array = xs.internalRepresentation.array | true |
stalkSkyscraperSheafAdjunction._proof_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] (𝓐 𝓑 : TopCat.Sheaf C X) (f : 𝓐 ⟶ 𝓑),
(CategoryTheory.CategoryStru... | false |
Std.DTreeMap.minKey?_eq_some_iff_getKey?_eq_self_and_forall | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {km : α},
t.minKey? = some km ↔ t.getKey? km = some km ∧ ∀ k ∈ t, (cmp km k).isLE = true | true |
Nat.ceil_add_le | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
(a b : R), ⌈a + b⌉₊ ≤ ⌈a⌉₊ + ⌈b⌉₊ | true |
_private.Mathlib.CategoryTheory.Monoidal.Category.0.CategoryTheory.MonoidalCategory.whisker_exchange._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{A : Type u'} →
[inst_2 : CategoryTheory.Category.{v', u'} A] →
{X : C} →
(data : F.Pre... | true |
unitary.coe_star | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : ↥(unitary R)}, ↑(star U) = star ↑U | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterM.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {β : Type u_1} {n : Type u_1 → Type u_2} {f : β → n (ULift.{u_1, 0} Bool)} [inst : MonadAttach n] (out : β)
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) (hf : MonadAttach.CanReturn (f out) { down := true })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false },... | true |
FormalMultilinearSeries.compChangeOfVariables_blocksFun | Mathlib.Analysis.Analytic.Composition | ∀ (m M N : ℕ) {i : (n : ℕ) × (Fin n → ℕ)} (hi : i ∈ FormalMultilinearSeries.compPartialSumSource m M N) (j : Fin i.fst),
(FormalMultilinearSeries.compChangeOfVariables m M N i hi).snd.blocksFun ⟨↑j, ⋯⟩ = i.snd j | true |
Set.infinite_of_finite_compl | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} [Infinite α] {s : Set α}, sᶜ.Finite → s.Infinite | true |
WeierstrassCurve.Δ._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | (7 + 1).AtLeastTwo | false |
Real.deriv_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.InverseDeriv | deriv Real.arccos = fun x => -(1 / √(1 - x ^ 2)) | true |
Algebra.TensorProduct.instNonUnitalRing | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalRing A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalSemiring B] →
[inst_6 : Module R B] ... | true |
QuadraticModuleCat.Hom.mk.injEq | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {V W : QuadraticModuleCat R} (toIsometry' toIsometry'_1 : V.form →qᵢ W.form),
({ toIsometry' := toIsometry' } = { toIsometry' := toIsometry'_1 }) = (toIsometry' = toIsometry'_1) | true |
Std.ExtDHashMap.mem_inter_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (k ∈ m₁ ∩ m₂) = (k ∈ m₁ ∧ k ∈ m₂) | false |
CategoryTheory.Pi.closedUnit._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.MonoidalClosed (C i)]
(X : (i : I) → C i) ⦃X_1 Y : (i : I) → C i⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((Categ... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.equiv_iff_toList_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | false |
CategoryTheory.Limits.filtered_colim_preservesFiniteLimits_of_types | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {K : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} K] [inst_1 : Small.{v, u₂} K] [CategoryTheory.IsFiltered K],
CategoryTheory.Limits.PreservesFiniteLimits CategoryTheory.Limits.colim | true |
_private.Mathlib.Analysis.Convex.PathConnected.0.Path.range_segment._simp_1_1 | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [inst_3 : ContinuousAdd E]
[inst_4 : ContinuousSMul ℝ E] (a b : E) (t : ↑unitInterval), (AffineMap.lineMap a b) ↑t = (Path.segment a b) t | false |
LinearMap.coe_restrictScalars | Mathlib.Algebra.Module.LinearMap.Defs | ∀ (R : Type u_1) {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module S M] [inst_7 : Module S M₂] [inst_8 : LinearMap.CompatibleSMul M M₂ R S] (f : M →ₗ[S] M₂),
... | true |
Option.decidableForallMem._proof_1 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop}, ∀ a ∈ none, p a | false |
HomologicalComplex.mapBifunctor₁₂.D₁.congr_simp | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | true |
Lean.MessageSeverity.recOn | Lean.Message | {motive : Lean.MessageSeverity → Sort u} →
(t : Lean.MessageSeverity) →
motive Lean.MessageSeverity.information →
motive Lean.MessageSeverity.warning → motive Lean.MessageSeverity.error → motive t | false |
Lean.Meta.Grind.Arith.Cutsat.VarInfo.maxDvdCoeff._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | ℕ | false |
AlgebraicTopology.DoldKan.Γ₀.splitting._proof_3 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) (Δ : SimplexCategoryᵒᵖ),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Discrete.functor (SimplicialObject.Splitting.summand (fun n => K.X... | false |
CategoryTheory.FreeBicategory.homCategory' | Mathlib.CategoryTheory.Bicategory.Coherence | {B : Type u} →
[inst : Quiver B] → (a b : B) → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.FreeBicategory.Hom a b) | true |
UInt32.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), a * b = { toBitVec := a.toBitVec * b.toBitVec } | true |
List.findIdx_map | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} (xs : List α) (f : α → β) (p : β → Bool),
List.findIdx p (List.map f xs) = List.findIdx (p ∘ f) xs | true |
Lean.Meta.LazyDiscrTree.InitEntry._sizeOf_1 | Lean.Meta.LazyDiscrTree | {α : Type} → [SizeOf α] → Lean.Meta.LazyDiscrTree.InitEntry α → ℕ | false |
Lean.MonadStateCacheT | Lean.Util.MonadCache | (α : Type) → Type → (Type → Type) → [BEq α] → [Hashable α] → Type → Type | true |
MulHom.coe_ofDense | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Semigroup M] [inst_1 : Semigroup N] {s : Set M} (f : M → N)
(hs : Subsemigroup.closure s = ⊤) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y), ⇑(MulHom.ofDense f hs hmul) = f | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.data_extract._proof_1_4 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {b e : ℕ}, ¬b ≤ e → ¬min e a.data.size ≤ b → False | false |
Submonoid.mem_divPairs | Mathlib.GroupTheory.MonoidLocalization.DivPairs | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {f : ⊤.LocalizationMap G} {s : Submonoid G}
{x : M × M}, x ∈ Submonoid.divPairs f s ↔ f x.1 / f x.2 ∈ s | true |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_free_of_surjective._simp_1_7 | Mathlib.Algebra.Module.FinitePresentation | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{M' : Type u_8} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (v : α → M) (l : α →₀ R),
(Finsupp.linearCombination R (⇑f ∘ v)) l = f ((Finsupp.linearCombination R v) l) | false |
_private.Lean.Level.0.Lean.Level.normLtAux._unary._proof_3 | Lean.Level | ∀ (l₁ : Lean.Level) (k₁ : ℕ) (l₂ : Lean.Level) (k₂ : ℕ),
(invImage
(fun x =>
PSigma.casesOn x fun a a_1 => PSigma.casesOn a_1 fun a_2 a_3 => PSigma.casesOn a_3 fun a_4 a_5 => (a, a_4))
Prod.instWellFoundedRelation).1
⟨l₁, ⟨k₁, ⟨l₂, k₂ + 1⟩⟩⟩ ⟨l₁, ⟨k₁, ⟨l₂.succ, k₂⟩⟩⟩ | false |
MeasureTheory.FiniteMeasure.coeFn_def | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω), ⇑μ = fun s => (↑μ s).toNNReal | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.exists_presentation_of_basis_cotangent._simp_1_3 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | false |
Quotient.finChoice._proof_2 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (x x_1 : { l // ∀ (i : ι), i ∈ l }),
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 ↔
(Subtype.instSetoid_mathlib fun l => ∀ (i : ι), i ∈ l) x x_1 | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobian._simp_1_2 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m n : ℕ), (f.sylvester g m n).det = f.resultant g m n | false |
GrpWithZero.carrier | Mathlib.Algebra.Category.GrpWithZero | GrpWithZero → Type u_1 | true |
Std.Do.SPred.exists.match_1 | Std.Do.SPred.SPred | {α : Sort u_3} →
(motive : (σs : List (Type u_1)) → (α → Std.Do.SPred σs) → Sort u_2) →
(σs : List (Type u_1)) →
(P : α → Std.Do.SPred σs) →
((P : α → Std.Do.SPred []) → motive [] P) →
((σ : Type u_1) → (tail : List (Type u_1)) → (P : α → Std.Do.SPred (σ :: tail)) → motive (σ :: tail) P) →... | false |
IsPrimitiveRoot.toRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | {M : Type u_1} → [inst : CommMonoid M] → {μ : M} → {n : ℕ} → [NeZero n] → IsPrimitiveRoot μ n → ↥(rootsOfUnity n M) | true |
Mathlib.Meta.NormNum.not_isSquare_of_isNNRat_rat_of_num | Mathlib.Tactic.NormNum.IsSquare | ∀ (a : ℚ) (n d : ℕ), ¬IsSquare n → n.Coprime d → Mathlib.Meta.NormNum.IsNNRat a n d → ¬IsSquare a | true |
DFinsupp.lsum_single | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} (S : Type u_4) {M : ι → Type u_5} {N : Type u_6} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : AddCommMonoid N]
[inst_4 : Module R N] [inst_5 : DecidableEq ι] [inst_6 : Semiring S] [inst_7 : Module S N]
[inst_8 : SMulComm... | true |
Lean.Meta.Grind.AC.MonadGetStruct.noConfusionType | Lean.Meta.Tactic.Grind.AC.Util | Sort u →
{m : Type → Type} →
Lean.Meta.Grind.AC.MonadGetStruct m → {m' : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m' → Sort u | false |
_private.Init.Meta.Defs.0.Lean.Name.replacePrefix.match_1 | Init.Meta.Defs | (motive : Lean.Name → Lean.Name → Lean.Name → Sort u_1) →
(x x_1 x_2 : Lean.Name) →
((newP : Lean.Name) → motive Lean.Name.anonymous Lean.Name.anonymous newP) →
((x x_3 : Lean.Name) → motive Lean.Name.anonymous x x_3) →
((n p : Lean.Name) →
(s : String) →
(h : n = p.str s) ... | false |
Lean.Expr.replace | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr | true |
Lean.instToJsonPrintImportResult.toJson | Lean.Elab.ParseImportsFast | Lean.PrintImportResult → Lean.Json | true |
SemiNormedGrp.of.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (carrier : Type u) [str : SeminormedAddCommGroup carrier] (carrier_1 : Type u)
(str_1 : SeminormedAddCommGroup carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) | true |
Finset.Ioo_subset_Ioi_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ioo a b ⊆ Finset.Ioi a | true |
Lean.Elab.Attribute.name | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Name | true |
Std.DHashMap.Internal.Raw₀.Const.any_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β) {p : α → β → Bool},
((Std.DHashMap.Raw.Const.toList ↑m).any fun x => p x.1 x.2) = (↑m).any p | true |
Std.Time.Timestamp.ofPlainDateTimeAssumingUTC | Std.Time.DateTime | Std.Time.PlainDateTime → Std.Time.Timestamp | true |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
CuspFormClass.rec | Mathlib.NumberTheory.ModularForms.Basic | {F : Type u_2} →
{Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
[inst : FunLike F UpperHalfPlane ℂ] →
{motive : CuspFormClass F Γ k → Sort u} →
([toSlashInvariantFormClass : SlashInvariantFormClass F Γ k] →
(holo : ∀ (f : F), MDiff ⇑f) →
(zero_at_cusps : ∀ (f : F) ... | false |
Turing.TM1to1.trCfg.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} {n : ℕ} (enc : Γ → List.Vector Bool n) [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (l : Option Λ) (v : σ) (T : Turing.Tape Γ),
Turing.TM1to1.trCfg enc enc0 { l := l, var := v, Tape := T } =
{ l := Option.map Turing.TM1to1.Λ'.normal l, ... | true |
GroupExtension.Splitting.conjAct | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → S.Splitting → G →* MulAut N | true |
Std.HashMap.Raw.getElem_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h : m.WF) {a b : α} (hab : (a == b) = true) {h' : a ∈ m}, m[a] = m[b] | true |
RatFunc.irreducible_minpolyX | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] (f : RatFunc K), (¬∃ c, f = RatFunc.C c) → Irreducible (f.minpolyX ↥K⟮f⟯) | true |
WeakSpace.instModule' | Mathlib.Topology.Algebra.Module.WeakDual | {𝕜 : Type u_2} →
{𝕝 : Type u_3} →
{E : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] →
... | true |
CategoryTheory.Subfunctor.range | Mathlib.CategoryTheory.Subfunctor.Image | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F F' : CategoryTheory.Functor C (Type w)} → (F' ⟶ F) → CategoryTheory.Subfunctor F | true |
QuaternionAlgebra.equivProd | Mathlib.Algebra.Quaternion | {R : Type u_1} → (c₁ c₂ c₃ : R) → QuaternionAlgebra R c₁ c₂ c₃ ≃ R × R × R × R | true |
Vector.set_mk._proof_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n) {i : ℕ} {x : α} (w : i < n), (xs.set i x ⋯).size = n | false |
ContDiffOn.pow | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {f : E → 𝔸}, ContDiffOn 𝕜 n f s → ∀ (m : ℕ), ContDiffOn 𝕜 n (fun y => f y ^ m) s | true |
Std.Internal.IO.Async.UDP.Socket.getPeerName | Std.Internal.Async.UDP | Std.Internal.IO.Async.UDP.Socket → IO Std.Net.SocketAddress | true |
Aesop.GoalOrigin | Aesop.Tree.Data | Type | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.complexMGF_id_gaussianReal._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
Submodule.span_smul | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {α : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Monoid α] [inst_4 : DistribMulAction α M] [inst_5 : SMulCommClass α R M] (a : α) (s : Set M),
Submodule.span R (a • s) = a • Submodule.span R s | true |
Lean.Meta.Grind.InjectiveInfo.inv? | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.InjectiveInfo → Option (Lean.Expr × Lean.Expr) | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._proof_3 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), autoParam (n + m = 0) CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._auto_1 → m + n = 0 | false |
_private.Mathlib.GroupTheory.Descent.0.Group.fg_of_descent._simp_1_4 | Mathlib.GroupTheory.Descent | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
Valuation.val_le_one_or_val_inv_lt_one | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation K Γ₀) (x : K), v x ≤ 1 ∨ v x⁻¹ < 1 | true |
Lean.Grind.IntInterval.lo?.eq_4 | Init.Grind.ToIntLemmas | Lean.Grind.IntInterval.ii.lo? = none | true |
AddAction.stabilizer.eq_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (a : α),
AddAction.stabilizer G a = { toAddSubmonoid := AddAction.stabilizerAddSubmonoid G a, neg_mem' := ⋯ } | true |
ContinuousMultilinearMap.nnnorm_constOfIsEmpty | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (E : ι → Type wE) {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] [inst_6 : IsEmpty ι] (x : G),
‖Continuou... | true |
groupCohomology.Hilbert90.aux.eq_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : FiniteDimensional K L] (f : Gal(L/K) → Lˣ),
groupCohomology.Hilbert90.aux f =
(Finsupp.linearCombination L fun φ => ⇑φ) (Finsupp.equivFunOnFinite.symm fun φ => ↑(f φ)) | true |
Polynomial.Monic.degree_pos | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : CommSemiring R] {p : Polynomial R}, p.Monic → (0 < p.degree ↔ p ≠ 1) | true |
SeparationQuotient.instDistrib._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Distrib R] [inst_2 : ContinuousMul R] [inst_3 : ContinuousAdd R]
(a b c : SeparationQuotient R), a * (b + c) = a * b + a * c | false |
_private.Mathlib.Data.List.TakeDrop.0.List.takeD_eq_take.match_1_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : (x : ℕ) → (x_1 : List α) → α → x ≤ x_1.length → Prop) (x : ℕ) (x_1 : List α) (x_2 : α)
(x_3 : x ≤ x_1.length),
(∀ (x : List α) (x_4 : α) (x_5 : 0 ≤ x.length), motive 0 x x_4 x_5) →
(∀ (n : ℕ) (head : α) (tail : List α) (a : α) (h : n + 1 ≤ (head :: tail).length),
motive n.succ... | false |
Lean.instInhabitedTheoremVal | Lean.Declaration | Inhabited Lean.TheoremVal | true |
t1Space_iff_specializes_imp_eq | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y | true |
Submodule.IsOrtho.le | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E}, U ⟂ V → U ≤ Vᗮ | true |
AdicCompletion.of_injective | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsHausdorff I M], Function.Injective ⇑(AdicCompletion.of I M) | true |
MeasureTheory.Measure.pi | Mathlib.MeasureTheory.Constructions.Pi | {ι : Type u_4} →
{α : ι → Type u_5} →
[Fintype ι] →
[inst : (i : ι) → MeasurableSpace (α i)] →
((i : ι) → MeasureTheory.Measure (α i)) → MeasureTheory.Measure ((i : ι) → α i) | true |
Std.Internal.IO.Async.Signal.sigxfsz.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 17 → motive Std.Internal.IO.Async.Signal.sigxfsz → motive t | false |
MonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Hom | (α : Type u_7) → (β : Type u_8) → [MulZeroOneClass α] → [MulZeroOneClass β] → Type (max u_7 u_8) | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise.0.SubMulAction.instMulOneClass._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : Mul M]
[inst_3 : IsScalarTower R M M] {p q : SubMulAction R M} {x : M}, (x ∈ p * q) = ∃ y ∈ p, ∃ z ∈ q, y * z = x | false |
Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insertIfNew! k v t) a =
if compare k a = Ordering.eq ∧ k ∉ t then v else ... | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.mkBVConst | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr | {w : ℕ} → BitVec w → Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr | true |
ContDiffOn.continuousOn_fderivWithin_apply | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {f : E → F}
{n : WithTop ℕ∞},
ContDiffOn 𝕜 n f s → UniqueDiffOn 𝕜 s → 1 ≤ n → ContinuousOn (fun ... | true |
MultiplierAlgebra.«_aux_Mathlib_Analysis_CStarAlgebra_Multiplier___macroRules_MultiplierAlgebra_term𝓜(_,_)_1» | Mathlib.Analysis.CStarAlgebra.Multiplier | Lean.Macro | false |
iteratedFDerivWithin_insert | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : 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} {n : ℕ} {y : E}, iteratedFDerivWithin 𝕜 n f (insert x s) y = iteratedFDerivWithin �... | true |
Finite.ciInf_le_of_le | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α} (c : ι),
f c ≤ a → iInf f ≤ a | true |
AddActionHom.inverse._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_1} [inst : VAdd M X] {Y₁ : Type u_3} [inst_1 : VAdd M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X)
(m : M) (x : Y₁), g (m +ᵥ f (g x)) = g (f (m +ᵥ g x)) | false |
Lean.Meta.Simp.debug.simp.check.have | Lean.Meta.Tactic.Simp.Main | Lean.Option Bool | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.