name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
List.sum_toFinset | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_5} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] (f : ι → M) {l : List ι},
l.Nodup → l.toFinset.sum f = (List.map f l).sum | true |
decidable_of_decidable_of_eq | Init.Core | {p q : Prop} → [Decidable p] → p = q → Decidable q | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local.inj | Lean.Elab.Tactic.Do.Attr | ∀ {fvarId fvarId_1 : Lean.FVarId},
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId = Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId_1 →
fvarId = fvarId_1 | true |
YoungDiagram.exists_notMem_col | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram) (j : ℕ), ∃ i, (i, j) ∉ μ.cells | true |
ModuleCat.instModuleCarrierMkOfSMul'._proof_2 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] {A : AddCommGrpCat} (φ : R →+* CategoryTheory.End A) (b : ↑(ModuleCat.mkOfSMul' φ)),
1 • b = b | false |
Int.gcd_eq_zero_iff | Init.Data.Int.Gcd | ∀ {a b : ℤ}, a.gcd b = 0 ↔ a = 0 ∧ b = 0 | true |
IO.Promise.isResolved | Init.System.Promise | {α : Type} → IO.Promise α → BaseIO Bool | true |
Std.CancellationToken.Consumer.normal.injEq | Std.Sync.CancellationToken | ∀ (promise promise_1 : IO.Promise Unit),
(Std.CancellationToken.Consumer.normal promise = Std.CancellationToken.Consumer.normal promise_1) =
(promise = promise_1) | true |
_private.Mathlib.Data.List.Permutation.0.List.nodup_permutations'Aux_iff._proof_1_19 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {s : List α} (n : ℕ), n - 1 + 1 ≤ s.length → n - 1 < s.length | false |
Std.ExtTreeSet.isSome_max?_of_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true → t.max?.isSome = true | true |
Aesop.SimpResult.solved | Aesop.Search.Expansion.Simp | Lean.Meta.Simp.UsedSimps → Aesop.SimpResult | true |
_private.Lean.Elab.DocString.Builtin.Postponed.0.Lean.Doc.getHandlerUnsafe | Lean.Elab.DocString.Builtin.Postponed | Lean.Name → Lean.Elab.TermElabM Lean.Doc.PostponedCheckHandler | true |
Vector.push_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {size : xs.size = n} (x : α), (xs.push x).size = n + 1 | false |
StrictAntiOn.add_const | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α} {s : Set β}
[AddRightStrictMono α], StrictAntiOn f s → ∀ (c : α), StrictAntiOn (fun x => f x + c) s | true |
ULift.isAddRegular_up._simp_1 | Mathlib.Algebra.Regular.ULift | ∀ {R : Type v} [inst : Add R] {a : R}, IsAddRegular { down := a } = IsAddRegular a | false |
_private.Init.Data.String.Iterate.0.String.Slice.RevPosIterator.finitenessRelation._simp_2 | Init.Data.String.Iterate | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | false |
lpInftySubalgebra | Mathlib.Analysis.Normed.Lp.lpSpace | (𝕜 : Type u_1) →
{I : Type u_5} →
(B : I → Type u_6) →
[inst : NormedField 𝕜] →
[inst_1 : (i : I) → NormedRing (B i)] →
[inst_2 : (i : I) → NormedAlgebra 𝕜 (B i)] → [∀ (i : I), NormOneClass (B i)] → Subalgebra 𝕜 (PreLp B) | true |
Std.ExtTreeSet.getLED | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → α → α → α | true |
AddSubgroup.isAddQuotientCoveringMap | Mathlib.Topology.Covering.Quotient | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] (S : AddSubgroup G),
IsDiscrete ↑S → IsAddQuotientCoveringMap QuotientAddGroup.mk ↥S.op | true |
MeasureTheory.integrable_neg_iff | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β}, MeasureTheory.Integrable (-f) μ ↔ MeasureTheory.Integrable f μ | true |
AlgebraicGeometry.Scheme.height_of_isClosed | Mathlib.AlgebraicGeometry.Scheme | ∀ {X : AlgebraicGeometry.Scheme} {x : ↥X}, IsClosed {x} → Order.height x = 0 | true |
Std.DHashMap.Internal.Raw₀.forall_mem_keys_iff_forall_contains_getKey | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {p : α → Prop}, (∀ k ∈ (↑m).keys, p k) ↔ ∀ (k : α) (h : m.contains k = true), p (m.getKey k h) | true |
Fin.Icc_sub_one_eq_Ico | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} {a b : Fin n}, 0 < b → Finset.Icc a (b - 1) = Finset.Ico a b | true |
ZFSet.mem_prod._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {x y z : ZFSet.{u}}, (z ∈ x.prod y) = ∃ a ∈ x, ∃ b ∈ y, z = a.pair b | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeImpl | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → optParam (Option Lean.Expr) none → Lean.Meta.Grind.GoalM Unit | true |
Set.div_empty | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Div α] {s : Set α}, s / ∅ = ∅ | true |
Int.sub_max_sub_left | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), max (a - b) (a - c) = a - min b c | true |
finsum_mem_image' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α → M} {s : Set β} {g : β → α},
Set.InjOn g (s ∩ Function.support (f ∘ g)) → ∑ᶠ (i : α) (_ : i ∈ g '' s), f i = ∑ᶠ (j : β) (_ : j ∈ s), f (g j) | true |
ContinuousMultilinearMap.ofSubsingleton._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ (R : Type u_4) {ι : Type u_3} (M₂ : Type u_1) (M₃ : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : TopologicalSpace M₂]
[inst_6 : TopologicalSpace M₃] (f : ContinuousMultilinearMap R (fun x => M₂) M₃), Continuous (⇑f ∘ fun x x_1 => x) | false |
_private.Mathlib.Algebra.CharZero.Defs.0.charZero_of_inj_zero._simp_1_1 | Mathlib.Algebra.CharZero.Defs | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] {a b c : G}, (b + a = c + a) = (b = c) | false |
OrderDual.instNonAssocSemiring._proof_4 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [h : NonAssocSemiring R] (n : ℕ), ↑(n + 1) = ↑n + 1 | false |
ContinuousAddEquiv.trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | {M : Type u_1} →
{N : Type u_2} →
[inst : TopologicalSpace M] →
[inst_1 : TopologicalSpace N] →
[inst_2 : Add M] →
[inst_3 : Add N] →
{L : Type u_3} → [inst_4 : Add L] → [inst_5 : TopologicalSpace L] → M ≃ₜ+ N → N ≃ₜ+ L → M ≃ₜ+ L | true |
GroupTopology.casesOn | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} →
[inst : Group α] →
{motive : GroupTopology α → Sort u_1} →
(t : GroupTopology α) →
((toTopologicalSpace : TopologicalSpace α) →
(toIsTopologicalGroup : IsTopologicalGroup α) →
motive { toTopologicalSpace := toTopologicalSpace, toIsTopologicalGroup := toIsTopologicalGroup }) →
motive t | false |
Dynamics.mem_ball_dynEntourage_comp | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} (T : X → X) (n : ℕ) {U : SetRel X X} [U.IsSymm] (x y : X),
(UniformSpace.ball x (Dynamics.dynEntourage T U n) ∩ UniformSpace.ball y (Dynamics.dynEntourage T U n)).Nonempty →
x ∈ UniformSpace.ball y (Dynamics.dynEntourage T (U.comp U) n) | true |
MeasureTheory.lintegral_mul_left_eq_self | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : Group G] [MeasurableMul G]
[μ.IsMulLeftInvariant] (f : G → ENNReal) (g : G), ∫⁻ (x : G), f (g * x) ∂μ = ∫⁻ (x : G), f x ∂μ | true |
ValuationSubring.ofPrime_idealOfLE | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R S : ValuationSubring K) (h : R ≤ S), R.ofPrime (R.idealOfLE S h) = S | true |
Nat.coprime_factorial_iff | Mathlib.Data.Nat.Prime.Factorial | ∀ {m n : ℕ}, m ≠ 1 → (m.Coprime n.factorial ↔ n < m.minFac) | true |
Subsemigroup.topEquiv_symm_apply_coe | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (x : M), ↑(Subsemigroup.topEquiv.symm x) = x | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_addNatEmb_Ioi._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
_private.Aesop.Tree.Check.0.Aesop.MVarClusterRef.checkMVars.checkNormMVars.match_1 | Aesop.Tree.Check | (motive : Aesop.NormalizationState → Sort u_1) →
(x : Aesop.NormalizationState) →
(Unit → motive Aesop.NormalizationState.notNormal) →
((postMetaState : Lean.Meta.SavedState) →
(script : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))) →
motive (Aesop.NormalizationState.provenByNormalization postMetaState script)) →
((postGoal : Lean.MVarId) →
(postMetaState : Lean.Meta.SavedState) →
(script : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))) →
motive (Aesop.NormalizationState.normal postGoal postMetaState script)) →
motive x | false |
IncidenceAlgebra.instAddCommGroup._proof_5 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑(f - g) = ⇑f - ⇑g | false |
_private.Mathlib.Analysis.BoxIntegral.Box.SubboxInduction.0.BoxIntegral.Box.mem_splitCenterBox._simp_1_4 | Mathlib.Analysis.BoxIntegral.Box.SubboxInduction | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
CommRingCat.Under.equalizerFork'._proof_2 | Mathlib.Algebra.Category.Ring.Under.Limits | ∀ {R : CommRingCat} {A B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra (↑R) A]
[inst_3 : Algebra (↑R) B], AlgHomClass (A →ₐ[↑R] B) (↑R) A B | false |
CategoryTheory.Limits.hasBinaryProduct_zero_right | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[CategoryTheory.Limits.HasZeroMorphisms C] (X : C), CategoryTheory.Limits.HasBinaryProduct X 0 | true |
Mathlib.Tactic.DepRewrite.Conv.depRewriteTarget | Mathlib.Tactic.DepRewrite | Lean.Syntax → Bool → optParam Mathlib.Tactic.DepRewrite.Config { } → Lean.Elab.Tactic.TacticM Unit | true |
CategoryTheory.Limits.PullbackCone.combine._proof_6 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {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] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (x : D) (j : CategoryTheory.Limits.WalkingCospan),
CategoryTheory.CategoryStruct.comp
((hc x).lift
{ pt := (c x).pt,
π :=
CategoryTheory.CategoryStruct.comp (c x).π
(CategoryTheory.Limits.cospanHomMk (H.map (CategoryTheory.CategoryStruct.id x))
(F.map (CategoryTheory.CategoryStruct.id x)) (G.map (CategoryTheory.CategoryStruct.id x)) ⋯ ⋯) })
((c x).π.app j) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (c x).pt) ((c x).π.app j) | false |
Array.findIdx?_eq_some_iff_findIdx_eq | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool} {i : ℕ},
Array.findIdx? p xs = some i ↔ i < xs.size ∧ Array.findIdx p xs = i | true |
Std.toList_roo_eq_toList_rco_of_isSome_succ? | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {lo hi : α} (h : (Std.PRange.succ? lo).isSome = true),
(lo<...hi).toList = (((Std.PRange.succ? lo).get h)...hi).toList | true |
CategoryTheory.Equivalence.congrFullSubcategory_inverse | Mathlib.CategoryTheory.ObjectProperty.Equivalence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{P : CategoryTheory.ObjectProperty C} {Q : CategoryTheory.ObjectProperty D} (e : C ≌ D)
[inst_2 : Q.IsClosedUnderIsomorphisms] (h : Q.inverseImage e.functor = P),
(e.congrFullSubcategory h).inverse = P.lift (Q.ι.comp e.inverse) ⋯ | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.List.getValue_filter_containsKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | false |
ModuleCat.smulShortComplex_g | Mathlib.RingTheory.Regular.Category | ∀ {R : Type u} [inst : CommRing R] (M : ModuleCat R) (r : R), (M.smulShortComplex r).g = ModuleCat.ofHom (r • ⊤).mkQ | true |
Submodule.coe_mapIic_apply | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
(q : Submodule R ↥p), ↑(p.mapIic q) = Submodule.map p.subtype q | true |
Lean.Meta.SimpCongrTheorems.noConfusionType | Lean.Meta.Tactic.Simp.SimpCongrTheorems | Sort u → Lean.Meta.SimpCongrTheorems → Lean.Meta.SimpCongrTheorems → Sort u | false |
Finset.map_disjSum | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Finset α} {t : Finset β} (f : α ⊕ β ↪ γ),
Finset.map f (s.disjSum t) =
(Finset.map (Function.Embedding.inl.trans f) s).disjUnion (Finset.map (Function.Embedding.inr.trans f) t) ⋯ | true |
CategoryTheory.CartesianMonoidalCategory.lift_snd_comp_fst_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {W X Y Z : C} (g : W ⟶ X) (g' : Y ⟶ Z),
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.snd W Y) g')
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.fst W Y) g) =
CategoryTheory.CategoryStruct.comp (β_ W Y).hom (CategoryTheory.MonoidalCategoryStruct.tensorHom g' g) | true |
RootPairing.Equiv.weightEquiv_inv | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (g : P.Aut),
RootPairing.Equiv.weightEquiv P P g⁻¹ = (RootPairing.Equiv.weightEquiv P P g)⁻¹ | true |
Polynomial.prod_multiset_X_sub_C_dvd | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
(Multiset.map (fun a => Polynomial.X - Polynomial.C a) p.roots).prod ∣ p | true |
CategoryTheory.IsCofiltered.SmallCofilteredIntermediate._proof_1 | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor D C),
CategoryTheory.EssentiallySmall.{max u_1 u_2, u_1, u_3}
(CategoryTheory.IsCofiltered.cofilteredClosure F.obj).FullSubcategory | false |
HNNExtension.NormalWord.ReducedWord.ctorIdx | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} → {inst : Group G} → {A B : Subgroup G} → HNNExtension.NormalWord.ReducedWord G A B → ℕ | false |
BoxIntegral.TaggedPrepartition.distortion | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} → {I : BoxIntegral.Box ι} → BoxIntegral.TaggedPrepartition I → [Fintype ι] → NNReal | true |
UInt64.toUSize_sub | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), (a - b).toUSize = a.toUSize - b.toUSize | true |
IntermediateField.adjoin_algebraic_toSubalgebra | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {S : Set E},
(∀ x ∈ S, IsAlgebraic F x) → (IntermediateField.adjoin F S).toSubalgebra = Algebra.adjoin F S | true |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_of_sign_eq._simp_1_1 | Mathlib.Analysis.Convex.Side | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i | false |
RootPairing.coroot_reflectionPerm | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (i j : ι),
P.coroot ((P.reflectionPerm i) j) = (P.coreflection i) (P.coroot j) | true |
CategoryTheory.PreZeroHypercover.sumInr | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} → (E : CategoryTheory.PreZeroHypercover S) → (F : CategoryTheory.PreZeroHypercover S) → F.Hom (E.sum F) | true |
PosMulStrictMono.toPosMulMono | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] [inst_1 : PartialOrder α] [PosMulStrictMono α], PosMulMono α | true |
Lean.Meta.getPropHyps | Lean.Meta.Tactic.Util | Lean.MetaM (Array Lean.FVarId) | true |
Matrix.module | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} →
{n : Type u_3} →
{R : Type u_7} →
{α : Type v} → [inst : Semiring R] → [inst_1 : AddCommMonoid α] → [Module R α] → Module R (Matrix m n α) | true |
CategoryTheory.Limits.Pi.whiskerEquiv | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type u_1} →
{K : Type u_2} →
{f : J → C} →
{g : K → C} →
(e : J ≃ K) →
((j : J) → g (e j) ≅ f j) →
[inst_1 : CategoryTheory.Limits.HasProduct f] →
[inst_2 : CategoryTheory.Limits.HasProduct g] → ∏ᶜ f ≅ ∏ᶜ g | true |
FP.Float.Zero.valid | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.ValidFinite FP.emin 0 | true |
CliffordAlgebra.equivExterior._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | false |
Lean.Parser.nameLit | Lean.Parser.Extra | Lean.Parser.Parser | true |
WeierstrassCurve.Affine.Point.instInvolutiveNeg | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} → [inst : CommRing R] → {W' : WeierstrassCurve.Affine R} → InvolutiveNeg W'.Point | true |
BoundedContinuousFunction.instRing | Mathlib.Topology.ContinuousMap.Bounded.Normed | {α : Type u} →
[inst : TopologicalSpace α] → {R : Type u_1} → [inst_1 : SeminormedRing R] → Ring (BoundedContinuousFunction α R) | true |
CategoryTheory.InjectiveResolution.ofCocomplex._proof_2 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X₀ X₁ : C}
(f : X₀ ⟶ X₁), CategoryTheory.Limits.HasCokernel f | false |
Std.Sat.CNF.Mem | Std.Sat.CNF.Basic | {α : Type u_1} → Std.Sat.CNF α → Std.Sat.CNF.Clause α → Prop | true |
Filter.Tendsto.compCM | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [LocallyCompactPair Y Z] {α : Type u_6} {l : Filter α} {g : α → C(Y, Z)} {g₀ : C(Y, Z)}
{f : α → C(X, Y)} {f₀ : C(X, Y)},
Filter.Tendsto g l (nhds g₀) →
Filter.Tendsto f l (nhds f₀) → Filter.Tendsto (fun a => (g a).comp (f a)) l (nhds (g₀.comp f₀)) | true |
zpow_lt_zpow_right | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] {m n : ℤ} {a : α},
1 < a → m < n → a ^ m < a ^ n | true |
MeasureTheory.StronglyMeasurable.approxBounded | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | {α : Type u_1} →
{β : Type u_2} →
{f : α → β} →
[inst : TopologicalSpace β] →
{x : MeasurableSpace α} →
[Norm β] → [SMul ℝ β] → MeasureTheory.StronglyMeasurable f → ℝ → ℕ → MeasureTheory.SimpleFunc α β | true |
_private.Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors.0.MvPowerSeries.instNoZeroDivisors._simp_2 | Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors | ∀ {α : Type u} [inst : Add α] {x y : WithTop α}, (x + y = ⊤) = (x = ⊤ ∨ y = ⊤) | false |
AlgEquivClass.casesOn | Mathlib.Algebra.Algebra.Equiv | {F : Type u_1} →
{R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
[inst_5 : EquivLike F A B] →
{motive : AlgEquivClass F R A B → Sort u} →
(t : AlgEquivClass F R A B) →
([toRingEquivClass : RingEquivClass F A B] →
(commutes : ∀ (f : F) (r : R), f ((algebraMap R A) r) = (algebraMap R B) r) → motive ⋯) →
motive t | false |
Lean.Parser.numLitNoAntiquot | Lean.Parser.Basic | Lean.Parser.Parser | true |
_private.Mathlib.FieldTheory.Separable.0.Associated.separable._proof_1_1 | Mathlib.FieldTheory.Separable | ∀ {R : Type u_1} [inst : CommSemiring R] {f g : Polynomial R}, Associated f g → f.Separable → g.Separable | false |
Subalgebra.unop_op | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A), S.op.unop = S | true |
Valuation.RankOne.restrict_RankOne._proof_3 | Mathlib.RingTheory.Valuation.RankOne | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] (K : Type u_1) [inst_1 : Field K] (v : Valuation K Γ₀),
MonoidWithZeroHomClass (Valuation K (MonoidWithZeroHom.ValueGroup₀ ↑v)) K (MonoidWithZeroHom.ValueGroup₀ ↑v) | false |
QuotSMulTop.equivQuotTensor._proof_3 | Mathlib.RingTheory.QuotSMulTop | ∀ {R : Type u_2} [inst : CommRing R] (r : R) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
r • ⊤ = Ideal.span {r} • ⊤ | false |
Array.foldrM.fold._unsafe_rec | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (α → β → m β) → (as : Array α) → ℕ → (i : ℕ) → i ≤ as.size → β → m β | false |
IsPredArchimedean.mk | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : PredOrder α],
(∀ {a b : α}, a ≤ b → ∃ n, Order.pred^[n] b = a) → IsPredArchimedean α | true |
Lean.Expr.ProdTree._sizeOf_1 | Mathlib.Tactic.ProdAssoc | Lean.Expr.ProdTree → ℕ | false |
Polynomial.toFinsupp_C_mul_X | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : R), (Polynomial.C a * Polynomial.X).toFinsupp = AddMonoidAlgebra.single 1 a | true |
Set.Finite.toFinset_nontrivial._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α} (h : s.Finite), h.toFinset.Nontrivial = s.Nontrivial | false |
Prod.instMonoidWithZero | Mathlib.Algebra.GroupWithZero.Prod | {M₀ : Type u_1} → {N₀ : Type u_2} → [MonoidWithZero M₀] → [MonoidWithZero N₀] → MonoidWithZero (M₀ × N₀) | true |
Batteries.UnionFind.parent_push | Batteries.Data.UnionFind.Lemmas | ∀ {a : ℕ} {m : Batteries.UnionFind}, m.push.parent a = m.parent a | true |
Lean.Parser.Term.valueOf | Lean.Parser.Term | Lean.Parser.Parser | true |
Std.DTreeMap.Internal.Impl.maxKey!_eq_maxKey! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : Inhabited α] [inst_3 : BEq α]
[Std.LawfulBEqOrd α] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.maxKey! = Std.Internal.List.maxKey! t.toListModel | true |
Ideal.span_iUnion | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Sort u_1} (s : ι → Set α), Ideal.span (⋃ i, s i) = ⨆ i, Ideal.span (s i) | true |
CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C),
(CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).right = X.right.obj (SimplexCategory.mk 0) | true |
Lean.Parser.Command.recommended_spelling._regBuiltin.Lean.Parser.Command.recommended_spelling.docString_3 | Lean.Parser.Command | IO Unit | false |
ContinuousMap.coeFnAlgHom | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
[inst : TopologicalSpace α] →
(R : Type u_2) →
[inst_1 : CommSemiring R] →
{A : Type u_3} →
[inst_2 : TopologicalSpace A] →
[inst_3 : Semiring A] → [inst_4 : Algebra R A] → [inst_5 : IsTopologicalSemiring A] → C(α, A) →ₐ[R] α → A | true |
op_smul_eq_mul | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_9} [inst : Mul α] (a b : α), MulOpposite.op a • b = b * a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.