name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
WithZeroTopology.tendsto_of_ne_zero | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {l : Filter α} {f : α → Γ₀} {γ : Γ₀},
γ ≠ 0 → (Filter.Tendsto f l (nhds γ) ↔ ∀ᶠ (x : α) in l, f x = γ) |
NumberField.mixedEmbedding.norm_le_convexBodySumFun | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.mixedSpace K),
‖x‖ ≤ NumberField.mixedEmbedding.convexBodySumFun x |
CategoryTheory.Functor.PreOneHypercoverDenseData.X | 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} → {S : C} → (self : F.PreOneHypercoverDenseData S) → self.I₀ → C₀ |
Std.HashSet.any_eq_true_iff_exists_mem_get | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [LawfulHashable α] [EquivBEq α] {p : α → Bool},
m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p (m.get a h) = true |
Pointed.coe_of | Mathlib.CategoryTheory.Category.Pointed | ∀ {X : Type u_1} (point : X), (Pointed.of point).X = X |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup'._simp_1_2 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {p : α ×' β → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ |
CategoryTheory.Limits.instDecidableEqWalkingReflexivePair | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | DecidableEq CategoryTheory.Limits.WalkingReflexivePair |
SubMulAction.mem_carrier | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] {p : SubMulAction R M} {x : M}, x ∈ p.carrier ↔ x ∈ ↑p |
Lean.Parser.ParserAliasInfo.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAliasInfo → Sort u} →
(t : Lean.Parser.ParserAliasInfo) →
((declName : Lean.Name) →
(stackSz? : Option ℕ) →
(autoGroupArgs : Bool) →
motive { declName := declName, stackSz? := stackSz?, autoGroupArgs := autoGroupArgs }) →
motive t |
LocallyConstant.congrRightₗ._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] {Z : Type u_3} (R : Type u_4) [inst_1 : Semiring R]
[inst_2 : AddCommMonoid Y] [inst_3 : Module R Y] [inst_4 : AddCommMonoid Z] [inst_5 : Module R Z] (e : Y ≃ₗ[R] Z),
Function.RightInverse (LocallyConstant.congrRight e.toEquiv).invFun (LocallyConstant.congrRight e.toEquiv).toFun |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.exists_lt_of_lt_ciSup.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_2} [inst : ConditionallyCompleteLinearOrder α] {b : α} {f : ι → α}
(motive : (∃ a ∈ Set.range f, b < a) → Prop) (x : ∃ a ∈ Set.range f, b < a),
(∀ (i : ι) (h : b < f i), motive ⋯) → motive x |
Lean.Firefox.FrameTable.Entry.noConfusionType | Lean.Util.Profiler | Sort u → Lean.Firefox.FrameTable.Entry → Lean.Firefox.FrameTable.Entry → Sort u |
MulLECancellable.le_mul_iff_one_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : MulOneClass α] [MulLeftMono α] {a b : α},
MulLECancellable a → (a ≤ a * b ↔ 1 ≤ b) |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_1 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α}, (Set.range f ⊆ s) = ∀ (y : ι), f y ∈ s |
Nat.add_sub_cancel | Init.Data.Nat.Basic | ∀ (n m : ℕ), n + m - m = n |
«term_⁻ᵐ» | Mathlib.Algebra.Notation | Lean.TrailingParserDescr |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt._simp_1_2 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b : α}, (0 < a - b) = (b < a) |
FirstOrder.Language.Embedding.map_rel | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Embedding M N) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x) ↔ FirstOrder.Language.Structure.RelMap r x |
AddSubgroup.map._proof_3 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_2} [inst : AddGroup G] {N : Type u_1} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
0 ∈ (AddSubmonoid.map f H.toAddSubmonoid).carrier |
CategoryTheory.Hopf.instCategory | Mathlib.CategoryTheory.Monoidal.Hopf_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.Hopf C) |
ProbabilityTheory.Kernel.IndepSets.union_iff._simp_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α},
ProbabilityTheory.Kernel.IndepSets (s₁ ∪ s₂) s' κ μ =
(ProbabilityTheory.Kernel.IndepSets s₁ s' κ μ ∧ ProbabilityTheory.Kernel.IndepSets s₂ s' κ μ) |
instSliceableSubarrayNat_8 | Init.Data.Slice.Array.Basic | {α : Type u} → Std.Rii.Sliceable (Subarray α) ℕ (Subarray α) |
ISize.toUSize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.toUSize (OfNat.ofNat n) = OfNat.ofNat n |
CategoryTheory.ShortComplex.FunctorEquivalence.unitIso._proof_10 | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_3) [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.ShortComplex (CategoryTheory.Functor J C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).map f)
((fun x =>
CategoryTheory.ShortComplex.isoMk
(CategoryTheory.NatIso.ofComponents
(fun x_1 =>
CategoryTheory.Iso.refl
(((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).obj
x).X₁.obj
x_1))
⋯)
(CategoryTheory.NatIso.ofComponents
(fun x_1 =>
CategoryTheory.Iso.refl
(((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).obj
x).X₂.obj
x_1))
⋯)
(CategoryTheory.NatIso.ofComponents
(fun x_1 =>
CategoryTheory.Iso.refl
(((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).obj
x).X₃.obj
x_1))
⋯)
⋯ ⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.ShortComplex.isoMk
(CategoryTheory.NatIso.ofComponents
(fun x_1 =>
CategoryTheory.Iso.refl
(((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).obj
x).X₁.obj
x_1))
⋯)
(CategoryTheory.NatIso.ofComponents
(fun x_1 =>
CategoryTheory.Iso.refl
(((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).obj
x).X₂.obj
x_1))
⋯)
(CategoryTheory.NatIso.ofComponents
(fun x_1 =>
CategoryTheory.Iso.refl
(((CategoryTheory.Functor.id (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))).obj
x).X₃.obj
x_1))
⋯)
⋯ ⋯)
X).hom
(((CategoryTheory.ShortComplex.FunctorEquivalence.functor J C).comp
(CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C)).map
f) |
UpperSet.instMax._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s t : UpperSet α), IsUpperSet (↑s ∩ ↑t) |
AlgebraNorm.recOn | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{motive : AlgebraNorm R S → Sort u} →
(t : AlgebraNorm R S) →
((toRingNorm : RingNorm S) →
(smul' : ∀ (a : R) (x : S), toRingNorm.toFun (a • x) = ‖a‖ * toRingNorm.toFun x) →
motive { toRingNorm := toRingNorm, smul' := smul' }) →
motive t |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.Step.length.match_1_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (motive : (x x_1 : List (α × Bool)) → FreeGroup.Red.Step x x_1 → Prop) (x x_1 : List (α × Bool))
(x_2 : FreeGroup.Red.Step x x_1),
(∀ (L1 L2 : List (α × Bool)) (x : α) (b : Bool), motive (L1 ++ (x, b) :: (x, !b) :: L2) (L1 ++ L2) ⋯) →
motive x x_1 x_2 |
Similar.index_map | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂],
Similar v₁ v₂ → ∀ (f : ι' → ι), Similar (v₁ ∘ f) (v₂ ∘ f) |
AddMonoidAlgebra.domCongr._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (A : Type u_1) {M : Type u_2} {N : Type u_3} [inst : Semiring A] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N) (x y : AddMonoidAlgebra A M),
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun (x + y) =
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun x + (AddMonoidAlgebra.mapDomainRingEquiv A e).toFun y |
Finset.neg_smul_finset | Mathlib.Algebra.Ring.Action.Pointwise.Finset | ∀ {R : Type u_1} {G : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup G] [inst_2 : Module R G] [inst_3 : DecidableEq G]
{t : Finset G} {a : R}, -a • t = -(a • t) |
NonarchimedeanAddGroup | Mathlib.Topology.Algebra.Nonarchimedean.Basic | (G : Type u_1) → [AddGroup G] → [TopologicalSpace G] → Prop |
HomogeneousLocalization.AtPrime | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} → [inst : CommRing A] → [SetLike σ A] → (ι → σ) → (𝔭 : Ideal A) → [𝔭.IsPrime] → Type (max u_1 u_2) |
LinearPMap.sSup_le | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (fun x1 x2 => x1 ≤ x2) c)
{g : E →ₗ.[R] F}, (∀ f ∈ c, f ≤ g) → LinearPMap.sSup c hc ≤ g |
Mathlib.Linter.TextBased.ErrorFormat.rec | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorFormat → Sort u} →
motive Mathlib.Linter.TextBased.ErrorFormat.humanReadable →
motive Mathlib.Linter.TextBased.ErrorFormat.exceptionsFile →
motive Mathlib.Linter.TextBased.ErrorFormat.github → (t : Mathlib.Linter.TextBased.ErrorFormat) → motive t |
Std.IterM.mapM.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β] [inst_1 : Monad n]
[inst_2 : MonadAttach n] [inst_3 : MonadLiftT m n] (f : β → n γ) (it : Std.IterM m β),
Std.IterM.mapM f it = Std.IterM.mapWithPostcondition (fun b => Std.Iterators.PostconditionT.attachLift (f b)) it |
unitInterval.symm_lt_comm | Mathlib.Topology.UnitInterval | ∀ {i j : ↑unitInterval}, unitInterval.symm i < j ↔ unitInterval.symm j < i |
RelSeries.mem_toList._simp_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r} {x : α}, (x ∈ s.toList) = (x ∈ s) |
Set.mem_image_equiv._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) |
AddCommGroup.toDivisionAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G],
AddCommGroup.toDivisionAddCommMonoid =
{ toSubNegMonoid := inst.toSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯, add_comm := ⋯ } |
MonoidAlgebra.lift | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
(A : Type u_4) →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → [inst_3 : Monoid M] → (M →* A) ≃ (MonoidAlgebra R M →ₐ[R] A) |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_inv | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (α : F ⟶ G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
(α.naturality (CategoryTheory.CategoryStruct.comp f g)).inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (α.app a) (G.mapComp f g).hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (α.app a) (G.map f) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (α.naturality f).inv (G.map g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (α.app b) (G.map g)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (α.naturality g).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (F.map g) (α.app c)).inv
(CategoryTheory.Bicategory.whiskerRight (F.mapComp f g).inv (α.app c))))))) |
MeasureTheory.stoppedValue_stoppedProcess | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] [inst_1 : LinearOrder ι] {u : ι → Ω → β}
{τ σ : Ω → WithTop ι},
MeasureTheory.stoppedValue (MeasureTheory.stoppedProcess u τ) σ = fun ω =>
if σ ω ≠ ⊤ then MeasureTheory.stoppedValue u (fun ω => min (σ ω) (τ ω)) ω
else MeasureTheory.stoppedValue u (fun ω => min (↑(Classical.arbitrary ι)) (τ ω)) ω |
Set.nonempty_image_addRight_neg_inter_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {s t : Set α} {a : α},
((fun x => x + -a) '' s ∩ t).Nonempty ↔ ((fun x => a + x) '' (-s) ∩ -t).Nonempty |
Std.Slice.foldlM_toArray | Init.Data.Slice.Lemmas | ∀ {γ : Type u} {α β : Type v} {m : Type u_1 → Type u_2} {δ : Type u_1} [inst : Monad m]
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
[Std.LawfulIteratorLoop α Id m] [Std.Iterators.Finite α Id] [LawfulMonad m] {s : Std.Slice γ} {init : δ}
{f : δ → β → m δ}, Array.foldlM f init s.toArray = Std.Slice.foldlM f init s |
_private.Mathlib.Topology.Closure.0.exists_isClosed_iff.match_1_1 | Mathlib.Topology.Closure | ∀ {X : Type u_1} [inst : TopologicalSpace X] {p : Set X → Prop} (motive : (∃ t, IsClosed t ∧ p t) → Prop)
(x : ∃ t, IsClosed t ∧ p t), (∀ (w : Set X) (h : IsClosed w ∧ p w), motive ⋯) → motive x |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.ctorElimType | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | {motive : Lean.Elab.Tactic.Do.ClassifyInvariantUseResult✝ → Sort u} → ℕ → Sort (max 1 u) |
CategoryTheory.Pretriangulated.Triangle.functorIsoMk._proof_4 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
[inst_2 : CategoryTheory.Category.{u_3, u_1} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(iso₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ≅ B.comp CategoryTheory.Pretriangulated.Triangle.π₁)
(iso₃ : A.comp CategoryTheory.Pretriangulated.Triangle.π₃ ≅ B.comp CategoryTheory.Pretriangulated.Triangle.π₃),
CategoryTheory.CategoryStruct.comp (A.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₃Toπ₁)
(CategoryTheory.Functor.whiskerRight iso₁.hom (CategoryTheory.shiftFunctor C 1)) =
CategoryTheory.CategoryStruct.comp iso₃.hom (B.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₃Toπ₁) →
CategoryTheory.CategoryStruct.comp (B.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₃Toπ₁)
(CategoryTheory.Functor.whiskerRight iso₁.inv (CategoryTheory.shiftFunctor C 1)) =
CategoryTheory.CategoryStruct.comp iso₃.inv (A.whiskerLeft CategoryTheory.Pretriangulated.Triangle.π₃Toπ₁) |
CategoryTheory.Subobject.isoOfEq._proof_4 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} (X Y : CategoryTheory.Subobject B) (h : X = Y),
CategoryTheory.CategoryStruct.comp (Y.ofLE X ⋯) (X.ofLE Y ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Subobject.underlying.obj Y) |
ValuativeRel.srel_of_srel_of_rel | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : ValuativeRel R] {a b c : R}, a <ᵥ b → b ≤ᵥ c → a <ᵥ c |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_3 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_4} {R' : Type u_5} {M : Type u_3} {M' : Type u_2} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_1} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommClass R S' M] (x : S'ᵈᵐᵃ),
x • 0 = 0 |
Matrix.blockDiagonal'_zero | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [inst : DecidableEq o] [inst_1 : Zero α],
Matrix.blockDiagonal' 0 = 0 |
selfAdjoint.submodule | Mathlib.Algebra.Star.Module | (R : Type u_1) →
(A : Type u_2) →
[inst : Semiring R] →
[inst_1 : StarMul R] →
[TrivialStar R] →
[inst_3 : AddCommGroup A] →
[inst_4 : Module R A] → [inst_5 : StarAddMonoid A] → [StarModule R A] → Submodule R A |
LieEquiv.coe_toLieHom | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), ⇑e.toLieHom = ⇑e |
CategoryTheory.MorphismProperty.LeftFraction₃.recOn | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.LeftFraction₃ X Y → Sort u} →
(t : W.LeftFraction₃ X Y) →
({Y' : C} →
(f f' f'' : X ⟶ Y') →
(s : Y ⟶ Y') → (hs : W s) → motive { Y' := Y', f := f, f' := f', f'' := f'', s := s, hs := hs }) →
motive t |
List.subset_replicate | Init.Data.List.Sublist | ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, n ≠ 0 → (l ⊆ List.replicate n a ↔ ∀ x ∈ l, x = a) |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.ModuleDocstringState✝ |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)) {Z : ↑(F.obj b)}
(h : (F.map f).toFunctor.obj ((CategoryTheory.CategoryStruct.id (F.obj a)).toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.map f).toFunctor.map ((F.mapId a).hom.toNatTrans.app X)) h =
CategoryTheory.CategoryStruct.comp ((F.mapComp (CategoryTheory.CategoryStruct.id a) f).inv.toNatTrans.app X)
(CategoryTheory.CategoryStruct.comp ((F.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom).toNatTrans.app X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) h)) |
Lean.Meta.Simp.Result.mk._flat_ctor | Lean.Meta.Tactic.Simp.Types | Lean.Expr → Option Lean.Expr → Bool → Lean.Meta.Simp.Result |
Lean.Elab.Deriving.FromToJson.mkToJsonBodyForStruct | Lean.Elab.Deriving.FromToJson | Lean.Elab.Deriving.Header → Lean.Name → Lean.Elab.TermElabM Lean.Term |
AdjoinRoot.algHomOfDvd._proof_1 | Mathlib.RingTheory.AdjoinRoot | ∀ (R : Type u_2) {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S),
g ∣ f → g ∣ Polynomial.map (↑(AlgHom.id R S)) f |
Rep.quotientToCoinvariantsFunctor_map_hom | Mathlib.RepresentationTheory.Coinvariants | ∀ (k : Type u) {G : Type u} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal] {X Y : Rep k G}
(f : X ⟶ Y),
((Rep.quotientToCoinvariantsFunctor k S).map f).hom =
(Rep.coinvariantsFunctor k ↥S).map ((Action.res (ModuleCat k) S.subtype).map f) |
Substring.Raw.noConfusion | Init.Prelude | {P : Sort u} → {t t' : Substring.Raw} → t = t' → Substring.Raw.noConfusionType P t t' |
Finset.symmDiff_nonempty | Mathlib.Data.Finset.SymmDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (symmDiff s t).Nonempty ↔ s ≠ t |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj.0.CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheory.Arrow C₃} (sq₁₃ : G.PullbackObjObj f₁.hom f₃.hom) (sq : f₃ ⟶ f₃'),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp sq₁₃.fst ((G.obj (Opposite.op f₁.left)).map sq.left))
((G.obj (Opposite.op ((CategoryTheory.Functor.id C₁).obj f₁.left))).map f₃'.hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp sq₁₃.snd ((G.obj (Opposite.op f₁.right)).map sq.right))
((G.map f₁.hom.op).app ((CategoryTheory.Functor.id C₃).obj f₃'.right)) |
MonotoneOn.image_lowerBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
MonotoneOn f t → s ⊆ t → f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s) |
CategoryTheory.Limits.pullbackConeEquivBinaryFan._proof_15 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ X}
(X_1 : CategoryTheory.Limits.BinaryFan (CategoryTheory.Over.mk f) (CategoryTheory.Over.mk g)),
(({ obj := fun c => CategoryTheory.Limits.PullbackCone.mk c.fst.left c.snd.left ⋯,
map := fun {c₁ c₂} a => { hom := a.hom.left, w := ⋯ }, map_id := ⋯, map_comp := ⋯ }.comp
{
obj := fun c =>
CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.Over.homMk c.fst ⋯)
(CategoryTheory.Over.homMk c.snd ⋯),
map := fun {c₁ c₂} a => { hom := CategoryTheory.Over.homMk a.hom ⋯, w := ⋯ }, map_id := ⋯,
map_comp := ⋯ }).obj
X_1).fst =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.isoMk
(CategoryTheory.Iso.refl
(({ obj := fun c => CategoryTheory.Limits.PullbackCone.mk c.fst.left c.snd.left ⋯,
map := fun {c₁ c₂} a => { hom := a.hom.left, w := ⋯ }, map_id := ⋯, map_comp := ⋯ }.comp
{
obj := fun c =>
CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.Over.homMk c.fst ⋯)
(CategoryTheory.Over.homMk c.snd ⋯),
map := fun {c₁ c₂} a => { hom := CategoryTheory.Over.homMk a.hom ⋯, w := ⋯ }, map_id := ⋯,
map_comp := ⋯ }).obj
X_1).pt.left)
⋯).hom
((CategoryTheory.Functor.id
(CategoryTheory.Limits.BinaryFan (CategoryTheory.Over.mk f) (CategoryTheory.Over.mk g))).obj
X_1).fst |
Mathlib.Tactic.modifyLocalContext | Mathlib.Util.Tactic | {m : Type → Type} → [Lean.MonadMCtx m] → Lean.MVarId → (Lean.LocalContext → Lean.LocalContext) → m Unit |
Metric.infDist_le_hausdorffDist_of_mem | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α} {x : α},
x ∈ s → Metric.hausdorffEDist s t ≠ ⊤ → Metric.infDist x t ≤ Metric.hausdorffDist s t |
inv_mul' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a * b)⁻¹ = a⁻¹ / b |
Array.reverse_eq_append_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys zs : Array α}, (xs.reverse = ys ++ zs) = (xs = zs.reverse ++ ys.reverse) |
ContinuousOn.cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax |
Prod.instGeneralizedBooleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : GeneralizedBooleanAlgebra β]
(x x_1 : α × β), x ⊓ x_1 ⊔ x \ x_1 = x |
CategoryTheory.IsPullback.rec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{P X Y Z : C} →
{fst : P ⟶ X} →
{snd : P ⟶ Y} →
{f : X ⟶ Z} →
{g : Y ⟶ Z} →
{motive : CategoryTheory.IsPullback fst snd f g → Sort u} →
((toCommSq : CategoryTheory.CommSq fst snd f g) →
(isLimit' :
Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk fst snd ⋯))) →
motive ⋯) →
(t : CategoryTheory.IsPullback fst snd f g) → motive t |
StrongDual.toLpₗ.eq_1 | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {𝕜 : Type u_2}
[inst_1 : NontriviallyNormedField 𝕜] [inst_2 : NormedSpace 𝕜 E] (μ : MeasureTheory.Measure E) (p : ENNReal),
StrongDual.toLpₗ μ p =
if h_Lp : MeasureTheory.MemLp id p μ then
{ toFun := fun L => MeasureTheory.MemLp.toLp ⇑L ⋯, map_add' := ⋯, map_smul' := ⋯ }
else 0 |
CategoryTheory.GradedObject.mapTrifunctor._proof_8 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_2} {C₂ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_9} [inst : CategoryTheory.Category.{u_3, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_10, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_11, u_5} C₃]
[inst_3 : CategoryTheory.Category.{u_8, u_9} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) (I₁ : Type u_1)
(I₂ : Type u_6) (I₃ : Type u_7) {X Y Z : CategoryTheory.GradedObject I₁ C₁} (f : X ⟶ Y) (g : Y ⟶ Z),
{
app := fun X₂ =>
{ app := fun X₃ x => ((F.map (CategoryTheory.CategoryStruct.comp f g x.1)).app (X₂ x.2.1)).app (X₃ x.2.2),
naturality := ⋯ },
naturality := ⋯ } =
CategoryTheory.CategoryStruct.comp
{ app := fun X₂ => { app := fun X₃ x => ((F.map (f x.1)).app (X₂ x.2.1)).app (X₃ x.2.2), naturality := ⋯ },
naturality := ⋯ }
{ app := fun X₂ => { app := fun X₃ x => ((F.map (g x.1)).app (X₂ x.2.1)).app (X₃ x.2.2), naturality := ⋯ },
naturality := ⋯ } |
Multiset.foldl_add | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β) (s t : Multiset α),
Multiset.foldl f b (s + t) = Multiset.foldl f (Multiset.foldl f b s) t |
CategoryTheory.Limits.FormalCoproduct.evalCompInclIsoId._proof_2 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (A : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] [inst_2 : CategoryTheory.Limits.HasCoproducts A]
(F : CategoryTheory.Functor C A) (x : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.desc fun x_1 =>
CategoryTheory.CategoryStruct.id (F.obj (((CategoryTheory.Limits.FormalCoproduct.incl C).obj x).obj x_1)))
(CategoryTheory.Limits.Sigma.ι (fun x_1 => F.obj x) PUnit.unit) =
CategoryTheory.CategoryStruct.id
((((CategoryTheory.Limits.FormalCoproduct.eval C A).comp
((CategoryTheory.Functor.whiskeringLeft C (CategoryTheory.Limits.FormalCoproduct C) A).obj
(CategoryTheory.Limits.FormalCoproduct.incl C))).obj
F).obj
x) |
FreeMagma.of.elim | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeMagma α → Sort u_1} → (t : FreeMagma α) → t.ctorIdx = 0 → ((a : α) → motive (FreeMagma.of a)) → motive t |
Std.ExtTreeSet.get_union_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
(not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ |
Int.toList_rco_eq_singleton_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, ((m...n).toList = [k]) = (n = m + 1 ∧ m = k) |
CategoryTheory.WithTerminal.homFrom | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : C) → CategoryTheory.WithTerminal.incl.obj X ⟶ CategoryTheory.WithTerminal.star |
Prop.instDistribLattice | Mathlib.Order.PropInstances | DistribLattice Prop |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.of_isCompact_of_forall_exists_isCompactOpenCovered._proof_1_3 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {f : (i : ι) → X i → S} [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : TopologicalSpace S] {U : Set S} (Us : (x : S) → x ∈ U → Set S),
(∀ (x : S) (a : x ∈ U), IsCompactOpenCovered f (Us x a)) →
∀ t ∈ {x | ∃ x_1, ∃ (h : x_1 ∈ U), Us x_1 h = ↑x}, IsCompactOpenCovered f ↑t |
SimplicialObject.Splitting.IndexSet.e.eq_1 | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {Δ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ), A.e = ↑A.snd |
_private.Mathlib.Algebra.Category.MonCat.FilteredColimits.0.MonCat.FilteredColimits.colimit_mul_mk_eq._simp_1_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type w)}
{inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))} [self : CategoryTheory.ConcreteCategory C FC]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (x : CC X),
(CategoryTheory.ConcreteCategory.hom g) ((CategoryTheory.ConcreteCategory.hom f) x) =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.head?_keys._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 |
comap_prime | Mathlib.Algebra.Prime.Lemmas | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoidWithZero M] [inst_1 : CommMonoidWithZero N] {F : Type u_3}
{G : Type u_4} [inst_2 : FunLike F M N] [MonoidWithZeroHomClass F M N] [inst_4 : FunLike G N M] [MulHomClass G N M]
(f : F) (g : G) {p : M}, (∀ (a : M), g (f a) = a) → Prime (f p) → Prime p |
isUnit_unop | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_2} [inst : Monoid M] {m : Mᵐᵒᵖ}, IsUnit (MulOpposite.unop m) ↔ IsUnit m |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp.0.Real.differentiable_iteratedDeriv_sinh.match_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (motive : ℕ → Prop) (n : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive n |
HomotopicalAlgebra.PrepathObject.trans_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P P' : HomotopicalAlgebra.PrepathObject A)
[inst_1 : CategoryTheory.Limits.HasPullback P.p₁ P'.p₀],
(P.trans P').ι = CategoryTheory.Limits.pullback.lift P.ι P'.ι ⋯ |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.Reachable.mem_subgraphVerts.aux | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {v : V} {H : G.Subgraph},
(∀ v ∈ H.verts, ∀ (w : V), G.Adj v w → H.Adj v w) → ∀ {v' : V}, v' ∈ H.verts → ∀ (p : G.Walk v' v), v ∈ H.verts |
CompleteLinearOrder.toDecidableLE | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} → [self : CompleteLinearOrder α] → DecidableLE α |
FiberBundleCore.mem_localTrivAt_source._simp_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (p : Z.TotalSpace) (b : B),
(p ∈ (Z.localTrivAt b).source) = (p.proj ∈ (Z.localTrivAt b).baseSet) |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_216 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α)
(h :
List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length] <
[g a, g (g a)].length |
complEDS₂_two | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), complEDS₂ b c d 2 = d |
Std.ExtDHashMap.get_filter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool} {k : α} {h' : k ∈ Std.ExtDHashMap.filter f m},
(Std.ExtDHashMap.filter f m).get k h' = m.get k ⋯ |
MulEquiv.coprodCongr._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHomClass (N ≃* M) N M |
_private.Batteries.Data.List.Lemmas.0.List.getElem_getElem_idxsOf._proof_4 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} [inst : BEq α] (h : i < (List.idxsOf x xs).length),
(List.idxsOf x xs)[i] < xs.length |
NNReal.rpow_sub_natCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x : NNReal}, x ≠ 0 → ∀ (y : ℝ) (n : ℕ), x ^ (y - ↑n) = x ^ y / x ^ n |
Quaternion.coe_ofComplex | Mathlib.Analysis.Quaternion | ⇑Quaternion.ofComplex = Quaternion.coeComplex |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.