name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
List.Perm.flatMap_left | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {β : Type u_2} (l : List α) {f g : α → List β},
(∀ a ∈ l, (f a).Perm (g a)) → (List.flatMap f l).Perm (List.flatMap g l) | true |
CategoryTheory.Limits.isSplitMonoEqualizes | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.IsSplitMono f] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfIsSplitMono f) | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry?._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (Std.DTreeMap.Internal.Impl α fun x => β) → Option (α × β) | false |
instNonAssocRingWithConvMatrix._proof_6 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : NonAssocRing α] (n_1 : ℕ), ↑(n_1 + 1) = ↑n_1 + 1 | false |
Sublocale.toNucleus._proof_2 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : X), ↑(S.restrict ↑(S.restrict x)) ≤ ↑(S.restrict x) | false |
OrderHom.diag | Mathlib.Order.Hom.Basic | {α : Type u_2} → [inst : Preorder α] → α →o α × α | true |
FreeGroup.invRev_cons | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {a : α × Bool},
FreeGroup.invRev (a :: L) = FreeGroup.invRev L ++ FreeGroup.invRev [a] | true |
Ring.DirectLimit.lift._proof_1 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P),
(∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) →
∀
a ∈
Ideal.span
{a |
(∃ i j, ∃ (H : i ≤ j), ∃ x, FreeCommRing.of ⟨j, f i j H x⟩ - FreeCommRing.of ⟨i, x⟩ = a) ∨
(∃ i, FreeCommRing.of ⟨i, 1⟩ - 1 = a) ∨
(∃ i x y, FreeCommRing.of ⟨i, x + y⟩ - (FreeCommRing.of ⟨i, x⟩ + FreeCommRing.of ⟨i, y⟩) = a) ∨
∃ i x y, FreeCommRing.of ⟨i, x * y⟩ - FreeCommRing.of ⟨i, x⟩ * FreeCommRing.of ⟨i, y⟩ = a},
(FreeCommRing.lift fun x => (g x.fst) x.snd) a = 0 | false |
CategoryTheory.CosimplicialObject.Augmented.const_obj_left | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.CosimplicialObject.Augmented.const.obj X).left = X | true |
Lean.Meta.Grind.Order.Cnstr.kind | Lean.Meta.Tactic.Grind.Order.Types | {α : Type} → Lean.Meta.Grind.Order.Cnstr α → Lean.Meta.Grind.Order.CnstrKind | true |
PerfectRing.lift_comp_lift | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing K] [inst_1 : CommRing L]
[inst_2 : CommRing M] [inst_3 : CommRing N] (i : K →+* L) (j : K →+* M) (k : K →+* N) (p : ℕ) [inst_4 : ExpChar M p]
[inst_5 : ExpChar K p] [inst_6 : PerfectRing M p] [inst_7 : IsPRadical i p] [inst_8 : ExpChar L p]
[inst_9 : ExpChar N p] [inst_10 : PerfectRing N p] [inst_11 : IsPRadical j p],
(PerfectRing.lift j k p).comp (PerfectRing.lift i j p) = PerfectRing.lift i k p | true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.smoothingSeminorm._simp_6 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | false |
NonUnitalNonAssocCommSemiring.casesOn | Mathlib.Algebra.Ring.Defs | {α : Type u} →
{motive : NonUnitalNonAssocCommSemiring α → Sort u_1} →
(t : NonUnitalNonAssocCommSemiring α) →
([toNonUnitalNonAssocSemiring : NonUnitalNonAssocSemiring α] →
(mul_comm : ∀ (a b : α), a * b = b * a) →
motive { toNonUnitalNonAssocSemiring := toNonUnitalNonAssocSemiring, mul_comm := mul_comm }) →
motive t | false |
Lean.Lsp.TextDocumentSyncKind.none.elim | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentSyncKind → Sort u} →
(t : Lean.Lsp.TextDocumentSyncKind) → t.ctorIdx = 0 → motive Lean.Lsp.TextDocumentSyncKind.none → motive t | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Basic.0.Mathlib.Meta.Positivity.evalUpperHalfPlaneCoe._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Complex.instZero)), «$_zα» =Q Complex.instZero | false |
WithZero.instDivisionMonoid._proof_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : DivisionMonoid α] (x : WithZero α), x⁻¹⁻¹ = x | false |
CategoryTheory.ShortComplex.rightHomologyMapIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasRightHomology] [inst_3 : S₂.HasRightHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap e.hom)
(CategoryTheory.ShortComplex.rightHomologyMap e.inv) =
CategoryTheory.CategoryStruct.id S₁.rightHomology | false |
Finsupp.sumFinsuppLEquivProdFinsupp._proof_1 | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ {M : Type u_3} (R : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_2}
{β : Type u_1} (m : R) (x : α ⊕ β →₀ M),
Finsupp.sumFinsuppAddEquivProdFinsupp.toFun (m • x) = (RingHom.id R) m • Finsupp.sumFinsuppAddEquivProdFinsupp.toFun x | false |
Computation.IsBisimulation | Mathlib.Data.Seq.Computation | {α : Type u} → (Computation α → Computation α → Prop) → Prop | true |
LaurentSeries.«_aux_Mathlib_RingTheory_LaurentSeries___macroRules_LaurentSeries_term_⸨X⸩_1» | Mathlib.RingTheory.LaurentSeries | Lean.Macro | false |
LinearMap.toContinuousBilinearMap | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
[CompleteSpace 𝕜] →
{E : Type u_2} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module 𝕜 E] →
[inst_4 : TopologicalSpace E] →
[IsTopologicalAddGroup E] →
[ContinuousSMul 𝕜 E] →
[FiniteDimensional 𝕜 E] →
[T2Space E] →
{F : Type u_3} →
[inst_9 : AddCommGroup F] →
[inst_10 : Module 𝕜 F] →
[inst_11 : TopologicalSpace F] →
[IsTopologicalAddGroup F] →
[ContinuousSMul 𝕜 F] →
[FiniteDimensional 𝕜 F] →
[T2Space F] →
{G : Type u_4} →
[inst_16 : AddCommGroup G] →
[inst_17 : Module 𝕜 G] →
[inst_18 : TopologicalSpace G] →
[inst_19 : IsTopologicalAddGroup G] →
[inst_20 : ContinuousSMul 𝕜 G] → (E →ₗ[𝕜] F →ₗ[𝕜] G) → E →L[𝕜] F →L[𝕜] G | true |
Fin.predAbove_last_of_ne_last | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {i : Fin (n + 2)} (hi : i ≠ Fin.last (n + 1)), (Fin.last n).predAbove i = i.castPred hi | true |
Subspace.quotEquivAnnihilator._proof_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} [inst : Field K], RingHomInvPair (RingHom.id K) (RingHom.id K) | false |
RingConeClass.toAddGroupConeClass | Mathlib.Algebra.Order.Ring.Cone | ∀ {S : Type u_1} {R : outParam (Type u_2)} {inst : Ring R} {inst_1 : SetLike S R} [self : RingConeClass S R],
AddGroupConeClass S R | true |
CategoryTheory.instInhabitedSkeleton._aux_1 | Mathlib.CategoryTheory.Skeletal | (C : Type u_2) → [inst : CategoryTheory.Category.{u_1, u_2} C] → [Inhabited C] → CategoryTheory.Skeleton C | false |
CategoryTheory.instIsIsoAppFromLeftDerivedZeroOfProjective | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive] (X : C)
[CategoryTheory.Projective X], CategoryTheory.IsIso (F.fromLeftDerivedZero.app X) | true |
CategoryTheory.Limits.cokernel.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {Z : C} (h : CategoryTheory.Limits.cokernel f ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.π f) h) =
CategoryTheory.CategoryStruct.comp 0 h | true |
Std.DTreeMap.Raw.Const.get?_insertMany_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp],
t.WF →
∀ {l : List (α × β)} {k : α},
Std.DTreeMap.Raw.Const.get? (Std.DTreeMap.Raw.Const.insertMany t l) k =
(List.findSomeRev?
(fun x =>
match x with
| (a, b) => if cmp a k = Ordering.eq then some b else none)
l).or
(Std.DTreeMap.Raw.Const.get? t k) | true |
Set.bijOn_iUnion_of_directed | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} {s : ι → Set α},
Directed (fun x1 x2 => x1 ⊆ x2) s →
∀ {t : ι → Set β} {f : α → β}, (∀ (i : ι), Set.BijOn f (s i) (t i)) → Set.BijOn f (⋃ i, s i) (⋃ i, t i) | true |
IsLocalization.Away.mk | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (r : R),
IsUnit ((algebraMap R S) r) →
(∀ (s : S), ∃ n a, s * (algebraMap R S) r ^ n = (algebraMap R S) a) →
(∀ (a b : R), (algebraMap R S) a = (algebraMap R S) b → ∃ n, r ^ n * a = r ^ n * b) → IsLocalization.Away r S | true |
AlgebraicGeometry.IsImmersion.of_comp | Mathlib.AlgebraicGeometry.Morphisms.Immersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.IsImmersion (CategoryTheory.CategoryStruct.comp f g)], AlgebraicGeometry.IsImmersion f | true |
Vector.instLawfulEqCmpCompareLex | Init.Data.Ord.Vector | ∀ {α : Type u_1} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp] {n : ℕ}, Std.LawfulEqCmp (Vector.compareLex cmp) | true |
Polynomial.natTrailingDegree_X_le | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R], Polynomial.X.natTrailingDegree ≤ 1 | true |
Nat.set_induction | Mathlib.Data.Nat.Basic | ∀ {S : Set ℕ}, 0 ∈ S → (∀ k ∈ S, k + 1 ∈ S) → ∀ (n : ℕ), n ∈ S | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getNatLit._sparseCasesOn_3 | Lean.Compiler.LCNF.Simp.ConstantFold | {motive : Lean.Compiler.LCNF.LitValue → Sort u} →
(t : Lean.Compiler.LCNF.LitValue) →
((val : ℕ) → motive (Lean.Compiler.LCNF.LitValue.nat val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Lean.PrettyPrinter.Delaborator.declSigWithId._regBuiltin.Lean.PrettyPrinter.Delaborator.declSigWithId.parenthesizer_7 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | false |
List.sublist_orderedInsert | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] (x : α) (xs : List α),
xs.Sublist (List.orderedInsert r x xs) | true |
CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : CategoryTheory.Functor Cᵒᵖ (Type u_2)}
{F G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type u_2)} (η : F ⟶ G)
⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A F).map f)
(CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.OverPresheafAux.YonedaCollection.map₁ η)
((CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A G).map f) | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon_obj | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{w + 1}) C),
(CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon C).obj F =
F.mapAddMon.obj (CategoryTheory.AddMon.trivial (CategoryTheory.Discrete PUnit.{w + 1})) | true |
Lean.Parser.Term.borrowed.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
ContinuousLinearMap.IsIdempotentElem.ker_eq_range | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {S : Type u_5} [inst : Semiring S] {E : Type u_7} [inst_1 : AddCommGroup E] [inst_2 : Module S E] {p : E →ₗ[S] E},
IsIdempotentElem p → p.ker = (LinearMap.id - p).range | true |
_private.Mathlib.Algebra.Group.Subgroup.Ker.0.Subgroup.map_eq_map_iff._simp_1_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G →* N} {H K : Subgroup G},
(Subgroup.map f H ≤ Subgroup.map f K) = (H ⊔ f.ker ≤ K ⊔ f.ker) | false |
intervalIntegral.continuousAt_of_dominated_interval | Mathlib.MeasureTheory.Integral.DominatedConvergence | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {μ : MeasureTheory.Measure ℝ} {X : Type u_3}
[inst_2 : TopologicalSpace X] [FirstCountableTopology X] {F : X → ℝ → E} {x₀ : X} {bound : ℝ → ℝ} {a b : ℝ},
(∀ᶠ (x : X) in nhds x₀, MeasureTheory.AEStronglyMeasurable (F x) (μ.restrict (Set.uIoc a b))) →
(∀ᶠ (x : X) in nhds x₀, ∀ᵐ (t : ℝ) ∂μ, t ∈ Set.uIoc a b → ‖F x t‖ ≤ bound t) →
IntervalIntegrable bound μ a b →
(∀ᵐ (t : ℝ) ∂μ, t ∈ Set.uIoc a b → ContinuousAt (fun x => F x t) x₀) →
ContinuousAt (fun x => ∫ (t : ℝ) in a..b, F x t ∂μ) x₀ | true |
CategoryTheory.Adjunction.whiskerRight | Mathlib.CategoryTheory.Adjunction.Whiskering | (C : Type u_1) →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor D E} →
{G : CategoryTheory.Functor E D} →
(F ⊣ G) →
((CategoryTheory.Functor.whiskeringRight C D E).obj F ⊣
(CategoryTheory.Functor.whiskeringRight C E D).obj G) | true |
_private.Lean.Elab.Tactic.Do.VCGen.0.Lean.Elab.Tactic.Do.VCGen.genVCs.onJumpSite._sparseCasesOn_5 | Lean.Elab.Tactic.Do.VCGen | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
ZFSet.not_nonempty_empty._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∅.Nonempty = False | false |
ContMDiffAddMonoidMorphism.contMDiff_toFun | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {H' : Type u_5} [inst_4 : TopologicalSpace H']
{E' : Type u_6} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E'] {I : ModelWithCorners 𝕜 E H}
{I' : ModelWithCorners 𝕜 E' H'} {n : WithTop ℕ∞} {G : Type u_8} [inst_7 : TopologicalSpace G]
[inst_8 : ChartedSpace H G] [inst_9 : AddMonoid G] {G' : Type u_9} [inst_10 : TopologicalSpace G']
[inst_11 : ChartedSpace H' G'] [inst_12 : AddMonoid G'] (self : ContMDiffAddMonoidMorphism I I' n G G'),
ContMDiff I I' n (↑self.toAddMonoidHom).toFun | true |
Aesop.instBEqForwardRuleMatch.beq | Aesop.Forward.Match.Types | Aesop.ForwardRuleMatch → Aesop.ForwardRuleMatch → Bool | true |
Nat.divisors_ofNat | Mathlib.Tactic.Simproc.Divisors | Lean.Meta.Simp.DSimproc | true |
CategoryTheory.Comma.mapLeftIso_inverse_map_right | 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} (i : L₁ ≅ L₂) {X Y : CategoryTheory.Comma L₂ R} (f : X ⟶ Y),
((CategoryTheory.Comma.mapLeftIso R i).inverse.map f).right = f.right | true |
HomotopyEquiv.toHomologyIso | Mathlib.Algebra.Homology.Homotopy | {C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{ι : Type u_3} →
{c : ComplexShape ι} →
{K L : HomologicalComplex C c} →
HomotopyEquiv K L →
(i : ι) → [inst_2 : K.HasHomology i] → [inst_3 : L.HasHomology i] → K.homology i ≅ L.homology i | true |
FirstOrder.Language.realize_denselyOrdered_iff | Mathlib.ModelTheory.Order | ∀ {L : FirstOrder.Language} {M : Type w'} [inst : L.IsOrdered] [inst_1 : L.Structure M] [inst_2 : Preorder M]
[L.OrderedStructure M], M ⊨ L.denselyOrderedSentence ↔ DenselyOrdered M | true |
CommRingCat.Under.instPreservesLimitUnderDiscreteFunctorTensorProdOfFinite | Mathlib.Algebra.Category.Ring.Under.Limits | ∀ {R S : CommRingCat} [inst : Algebra ↑R ↑S] (J : Type u) [Finite J] (f : J → CategoryTheory.Under R),
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Discrete.functor f) (R.tensorProd S) | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_3 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (a - b ≤ 0) = (a ≤ b) | false |
Part.none_ne_some | Mathlib.Data.Part | ∀ {α : Type u_1} (x : α), Part.none ≠ Part.some x | true |
Std.TreeMap.Raw.maxKey?_le | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {k : α},
t.WF → ((∀ (k' : α), t.maxKey? = some k' → (cmp k' k).isLE = true) ↔ ∀ k' ∈ t, (cmp k' k).isLE = true) | true |
FirstOrder.Language.BoundedFormula.IsUniversal.below | Mathlib.ModelTheory.Complexity | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : {n : ℕ} → (a : L.BoundedFormula α n) → a.IsUniversal → Prop} →
{n : ℕ} → {a : L.BoundedFormula α n} → a.IsUniversal → Prop | true |
PrimeSpectrum.localization_comap_isInducing | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} (S : Type v) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (M : Submonoid R)
[IsLocalization M S], Topology.IsInducing (PrimeSpectrum.comap (algebraMap R S)) | true |
Multiset.sections_cons | Mathlib.Data.Multiset.Sections | ∀ {α : Type u_1} (s : Multiset (Multiset α)) (m : Multiset α),
(m ::ₘ s).Sections = m.bind fun a => Multiset.map (Multiset.cons a) s.Sections | true |
Equiv.Perm.viaEmbeddingHom | Mathlib.GroupTheory.Perm.ViaEmbedding | {α : Type u_1} → {β : Type u_2} → (α ↪ β) → Equiv.Perm α →* Equiv.Perm β | true |
MeasureTheory.integrable_of_forall_fin_meas_le' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {ε : Type u_9} [inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε]
{μ : MeasureTheory.Measure α} (hm : m ≤ m0) [MeasureTheory.SigmaFinite (μ.trim hm)],
∀ C < ⊤,
∀ {f : α → ε},
MeasureTheory.AEStronglyMeasurable f μ →
(∀ (s : Set α), MeasurableSet s → μ s ≠ ⊤ → ∫⁻ (x : α) in s, ‖f x‖ₑ ∂μ ≤ C) → MeasureTheory.Integrable f μ | true |
Function.const_zero | Mathlib.Algebra.Notation.Pi.Defs | ∀ {α : Type u_2} {M : Type u_7} [inst : Zero M], Function.const α 0 = 0 | true |
ENNReal.rpow_mul_natCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : ENNReal) (y : ℝ) (n : ℕ), x ^ (y * ↑n) = (x ^ y) ^ n | true |
MeasureTheory.VectorMeasure.instZero._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_2} [inst : AddCommMonoid M] (x : Set α),
¬MeasurableSet x → 0 x = 0 x | false |
CondensedMod.LocallyConstant.functorIsoDiscreteAux₁ | Mathlib.Condensed.Discrete.Module | (R : Type (u + 1)) →
[inst : Ring R] → (M : ModuleCat R) → M ≅ ModuleCat.of R (LocallyConstant ↑(CompHaus.of PUnit.{u + 1}).toTop ↑M) | true |
CategoryTheory.nerveAdjunction.isIso_counit | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.IsIso CategoryTheory.nerveAdjunction.counit | true |
Lean.AttributeExtensionState._sizeOf_inst | Lean.Attributes | SizeOf Lean.AttributeExtensionState | false |
Std.HashMap.Raw.modify.congr_simp | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : EquivBEq α] [inst_2 : Hashable α] (m m_1 : Std.HashMap.Raw α β),
m = m_1 → ∀ (a a_1 : α), a = a_1 → ∀ (f f_1 : β → β), f = f_1 → m.modify a f = m_1.modify a_1 f_1 | true |
CategoryTheory.Functor.prod'_μ_fst | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor C E) [inst_6 : F.LaxMonoidal] [inst_7 : G.LaxMonoidal]
(X Y : C), (CategoryTheory.Functor.LaxMonoidal.μ (F.prod' G) X Y).1 = CategoryTheory.Functor.LaxMonoidal.μ F X Y | true |
Substring.Raw.ValidFor.drop | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw},
Substring.Raw.ValidFor l m r s → ∀ (n : ℕ), Substring.Raw.ValidFor (l ++ List.take n m) (List.drop n m) r (s.drop n) | true |
Std.Sat.AIG._sizeOf_inst | Std.Sat.AIG.Basic | (α : Type) → {inst : DecidableEq α} → {inst_1 : Hashable α} → [SizeOf α] → SizeOf (Std.Sat.AIG α) | false |
instWellFoundedLTShrink | Mathlib.Order.Shrink | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] [inst_1 : Preorder α] [WellFoundedLT α], WellFoundedLT (Shrink.{u, u_1} α) | true |
Subfield.relfinrank | Mathlib.FieldTheory.Relrank | {E : Type v} → [inst : Field E] → Subfield E → Subfield E → ℕ | true |
_private.Mathlib.Algebra.Group.Basic.0.neg_nsmul.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
_private.Mathlib.Algebra.Order.Nonneg.Ring.0.Nonneg.instNontrivialSubtypeLeOfNatOfAddLeftMono.match_1 | Mathlib.Algebra.Order.Nonneg.Ring | ∀ {α : Type u_1} [inst : AddGroup α] (motive : (∃ y, y ≠ 0) → Prop) (x : ∃ y, y ≠ 0),
(∀ (a : α) (ha : a ≠ 0), motive ⋯) → motive x | false |
AddCon.addGroup._proof_5 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddGroup M] (c : AddCon M) (a : c.Quotient), -a + a = 0 | false |
slope_pos_iff_gt | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {𝕜 : Type u_4} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {f : 𝕜 → 𝕜} {x₀ b : 𝕜},
b < x₀ → (0 < slope f x₀ b ↔ f b < f x₀) | true |
_private.Lean.Server.References.0.Lean.Server.References.definitionsMatching.match_1 | Lean.Server.References | {α : Type} →
(motive :
Option IO.CancelToken →
MProd (Option (Array (Lean.Server.References.MatchedDefinition α)))
(Array (Lean.Server.References.MatchedDefinition α)) →
Sort u_1) →
(cancelTk? : Option IO.CancelToken) →
(r :
MProd (Option (Array (Lean.Server.References.MatchedDefinition α)))
(Array (Lean.Server.References.MatchedDefinition α))) →
((cancelTk : IO.CancelToken) →
(r :
MProd (Option (Array (Lean.Server.References.MatchedDefinition α)))
(Array (Lean.Server.References.MatchedDefinition α))) →
motive (some cancelTk) r) →
((x : Option IO.CancelToken) →
(r :
MProd (Option (Array (Lean.Server.References.MatchedDefinition α)))
(Array (Lean.Server.References.MatchedDefinition α))) →
motive x r) →
motive cancelTk? r | false |
MonoidAlgebra.module | Mathlib.Algebra.MonoidAlgebra.Module | {k : Type u₁} →
{G : Type u₂} →
{R : Type u_2} → [inst : Semiring R] → [inst_1 : Semiring k] → [Module R k] → Module R (MonoidAlgebra k G) | true |
Int16.toNatClampNeg_toInt64 | Init.Data.SInt.Lemmas | ∀ (x : Int16), x.toInt64.toNatClampNeg = x.toNatClampNeg | true |
Lean.Server.FileWorker.RpcSession.recOn | Lean.Server.FileWorker.Utils | {motive : Lean.Server.FileWorker.RpcSession → Sort u} →
(t : Lean.Server.FileWorker.RpcSession) →
((objects : Lean.Server.RpcObjectStore) →
(expireTime : ℕ) → motive { objects := objects, expireTime := expireTime }) →
motive t | false |
_private.Init.Data.Int.Gcd.0.Int.lcm_eq_one_iff._simp_1_3 | Init.Data.Int.Gcd | ∀ {a b : ℤ}, (a ∣ b) = (a.natAbs ∣ b.natAbs) | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_span_eq_top._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) | false |
Euclidean.ball_subset_closedBall | Mathlib.Analysis.InnerProductSpace.EuclideanDist | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : TopologicalSpace E] [inst_2 : IsTopologicalAddGroup E]
[inst_3 : T2Space E] [inst_4 : Module ℝ E] [inst_5 : ContinuousSMul ℝ E] [inst_6 : FiniteDimensional ℝ E] {x : E}
{r : ℝ}, Euclidean.ball x r ⊆ Euclidean.closedBall x r | true |
unitsCentralizerEquiv._proof_11 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (M : Type u_1) [inst : Monoid M] (x : Mˣ) (x_1 y : ↥(MulAction.stabilizer (ConjAct Mˣ) x)),
{ toFun := fun u => ⟨↑(ConjAct.ofConjAct ↑u), ⋯⟩, map_one' := ⋯, map_mul' := ⋯ }.toHomUnits (x_1 * y) =
{ toFun := fun u => ⟨↑(ConjAct.ofConjAct ↑u), ⋯⟩, map_one' := ⋯, map_mul' := ⋯ }.toHomUnits x_1 *
{ toFun := fun u => ⟨↑(ConjAct.ofConjAct ↑u), ⋯⟩, map_one' := ⋯, map_mul' := ⋯ }.toHomUnits y | false |
NonUnitalStarSubalgebra.coe_eq_zero | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) {x : ↥S}, ↑x = 0 ↔ x = 0 | true |
Rat.mul_assoc | Init.Data.Rat.Lemmas | ∀ (a b c : ℚ), a * b * c = a * (b * c) | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.isEqnThmHypothesis.go._unsafe_rec | Lean.Meta.Tactic.Simp.Rewrite | Lean.Expr → Bool | false |
CategoryTheory.Functor.limitIsoOfIsRightKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Basic | {C : Type u_1} →
{H : Type u_3} →
{D : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D] →
(F' : CategoryTheory.Functor D H) →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor C H} →
(α : L.comp F' ⟶ F) →
[F'.IsRightKanExtension α] →
[inst_4 : CategoryTheory.Limits.HasLimit F] →
[inst_5 : CategoryTheory.Limits.HasLimit F'] →
CategoryTheory.Limits.limit F' ≅ CategoryTheory.Limits.limit F | true |
IsUltrametricDist.nnnorm_tsum_le | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedAddCommGroup M] [IsUltrametricDist M] (f : ι → M),
‖∑' (i : ι), f i‖₊ ≤ ⨆ i, ‖f i‖₊ | true |
_private.Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn.0.ApproximatesLinearOn.surjOn_closedBall_of_nonlinearRightInverse._simp_1_2 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
IntermediateField.algebraicIndependent_adjoin_iff | Mathlib.RingTheory.AlgebraicIndependent.AlgebraicClosure | ∀ {ι : Type u_1} {F : Type u_2} {E : Type u_3} {S : Type u_5} {s : Set E} [inst : Field F] [inst_1 : Field E]
[inst_2 : Algebra F E] [inst_3 : CommRing S] [inst_4 : Algebra E S] {x : ι → S},
AlgebraicIndependent (↥(IntermediateField.adjoin F s)) x ↔ AlgebraicIndependent (↥(Algebra.adjoin F s)) x | true |
CauSeq.instMaxAbs.match_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs) (x : α)
(x_1 : ℕ) (motive : ((∀ k ≥ x_1, |↑f k - ↑f x_1| < x) ∧ ∀ k ≥ x_1, |↑g k - ↑g x_1| < x) → Prop)
(x_2 : (∀ k ≥ x_1, |↑f k - ↑f x_1| < x) ∧ ∀ k ≥ x_1, |↑g k - ↑g x_1| < x),
(∀ (H₁ : ∀ k ≥ x_1, |↑f k - ↑f x_1| < x) (H₂ : ∀ k ≥ x_1, |↑g k - ↑g x_1| < x), motive ⋯) → motive x_2 | false |
MonoidHom.mem_mgraph._simp_2 | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} [inst : Monoid G] [inst_1 : Monoid H] {f : G →* H} {x : G × H},
(x ∈ f.mgraph) = (f x.1 = x.2) | false |
Nat.add_modEq_right_iff | Mathlib.Data.Nat.ModEq | ∀ {n a b : ℕ}, a + b ≡ b [MOD n] ↔ n ∣ a | true |
CategoryTheory.DifferentialObject.mk.noConfusion | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
{inst : AddMonoidWithOne S} →
{C : Type u} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{inst_3 : CategoryTheory.HasShift C S} →
{P : Sort u_2} →
{obj : C} →
{d : obj ⟶ (CategoryTheory.shiftFunctor C 1).obj obj} →
{d_squared :
autoParam (CategoryTheory.CategoryStruct.comp d ((CategoryTheory.shiftFunctor C 1).map d) = 0)
CategoryTheory.DifferentialObject.d_squared._autoParam} →
{obj' : C} →
{d' : obj' ⟶ (CategoryTheory.shiftFunctor C 1).obj obj'} →
{d_squared' :
autoParam
(CategoryTheory.CategoryStruct.comp d' ((CategoryTheory.shiftFunctor C 1).map d') = 0)
CategoryTheory.DifferentialObject.d_squared._autoParam} →
{ obj := obj, d := d, d_squared := d_squared } =
{ obj := obj', d := d', d_squared := d_squared' } →
(obj ≍ obj' → d ≍ d' → P) → P | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.toOpens | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | {X : AlgebraicGeometry.Scheme} → X.AffineZariskiSite → X.Opens | true |
Valuation.mk.sizeOf_spec | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : LinearOrderedCommMonoidWithZero Γ₀] [inst_1 : Ring R] [inst_2 : SizeOf R]
[inst_3 : SizeOf Γ₀] (toMonoidWithZeroHom : R →*₀ Γ₀)
(map_add_le_max' :
∀ (x y : R),
(↑toMonoidWithZeroHom).toFun (x + y) ≤ max ((↑toMonoidWithZeroHom).toFun x) ((↑toMonoidWithZeroHom).toFun y)),
sizeOf { toMonoidWithZeroHom := toMonoidWithZeroHom, map_add_le_max' := map_add_le_max' } =
1 + sizeOf toMonoidWithZeroHom | true |
_private.Lean.Meta.Tactic.Grind.Order.Internalize.0.Lean.Meta.Grind.Order.OffsetTermResult.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Order.Internalize | ∀ (a : Lean.Expr) (k : ℤ) (h : Lean.Expr), sizeOf { a := a, k := k, h := h } = 1 + sizeOf a + sizeOf k + sizeOf h | true |
CategoryTheory.Grp.forget₂Mon | Mathlib.CategoryTheory.Monoidal.Grp_ | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
CategoryTheory.Functor (CategoryTheory.Grp C) (CategoryTheory.Mon C) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.