name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Server.Test.Runner.Client.NormalizeState.mk.noConfusion | Lean.Server.Test.Runner | {P : Sort u} →
{freshPtr : USize} →
{knownPtrs : Std.TreeMap USize USize compare} →
{freshPtr' : USize} →
{knownPtrs' : Std.TreeMap USize USize compare} →
{ freshPtr := freshPtr, knownPtrs := knownPtrs } = { freshPtr := freshPtr', knownPtrs := knownPtrs' } →
(freshPtr = freshPtr' → knownPtrs = knownPtrs' → P) → P |
subset_interior_add_left | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : AddGroup α] [ContinuousConstVAdd αᵃᵒᵖ α] {s t : Set α},
interior s + t ⊆ interior (s + t) |
Lean.Parser.Term.doIfCond.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer |
MeasureTheory.SimpleFunc.range_const | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {β : Type u_2} (α : Type u_5) [inst : MeasurableSpace α] [Nonempty α] (b : β),
(MeasureTheory.SimpleFunc.const α b).range = {b} |
Lean.Quote.mk._flat_ctor | Init.Meta.Defs | {α : Type} → {k : optParam Lean.SyntaxNodeKind `term} → (α → Lean.TSyntax k) → Lean.Quote α k |
addMonoidAlgebraAlgEquivDirectSum._proof_4 | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_2} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : (m : A) → Decidable (m ≠ 0)] (x y : AddMonoidAlgebra A ι),
addMonoidAlgebraRingEquivDirectSum.toFun (x + y) =
addMonoidAlgebraRingEquivDirectSum.toFun x + addMonoidAlgebraRingEquivDirectSum.toFun y |
LinearOrderedCommGroupWithZero.zpow | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → ℤ → α → α |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.instIsCancelMulZeroOfIsCancelAdd._simp_15 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsRightCancelMulZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) |
ContinuousLinearMap.hasDerivWithinAt_of_bilinear | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {G : Type u_1}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : 𝕜} {s : Set 𝕜} {B : E →L[𝕜] F →L[𝕜] G} {u : 𝕜 → E}
{v : 𝕜 → F} {u' : E} {v' : F},
HasDerivWithinAt u u' s x →
HasDerivWithinAt v v' s x → HasDerivWithinAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) s x |
OmegaCompletePartialOrder.ContinuousHom.ωSup._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_1} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(c : OmegaCompletePartialOrder.Chain (α →𝒄 β)) (c' : OmegaCompletePartialOrder.Chain α) (a : β),
(OmegaCompletePartialOrder.ωSup (c.map OmegaCompletePartialOrder.ContinuousHom.toMono)).toFun
(OmegaCompletePartialOrder.ωSup c') ≤
a ↔
OmegaCompletePartialOrder.ωSup
(c'.map (OmegaCompletePartialOrder.ωSup (c.map OmegaCompletePartialOrder.ContinuousHom.toMono))) ≤
a |
MulEquiv.funUnique._proof_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ (α : Type u_2) (M : Type u_1) [inst : Mul M] [inst_1 : Unique α] (x y : α → M),
(Equiv.funUnique α M).toFun (x * y) = (Equiv.funUnique α M).toFun x * (Equiv.funUnique α M).toFun y |
HasFDerivAt.multiset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_5} {𝔸' : Type u_7} [inst_3 : NormedCommRing 𝔸'] [inst_4 : NormedAlgebra 𝕜 𝔸']
{g : ι → E → 𝔸'} {g' : ι → E →L[𝕜] 𝔸'} [inst_5 : DecidableEq ι] {u : Multiset ι} {x : E},
(∀ i ∈ u, HasFDerivAt (fun x => g i x) (g' i) x) →
HasFDerivAt (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod)
(Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • g' i) u).sum x |
_private.Mathlib.Algebra.Module.SpanRank.0.Submodule.spanRank_toENat_eq_iInf_finset_card._simp_1_1 | Mathlib.Algebra.Module.SpanRank | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iInf s = ⊤) = ∀ (i : ι), s i = ⊤ |
FinTopCat.instHasForget₂ContinuousMapCarrierToTopFintypeCatHomObjFinite._proof_3 | Mathlib.Topology.Category.FinTopCat | ∀ {X Y : FinTopCat} {f : X ⟶ Y},
(CategoryTheory.forget FintypeCat).map (FintypeCat.homMk ⇑(CategoryTheory.ConcreteCategory.hom f)) ≍
(CategoryTheory.forget FintypeCat).map (FintypeCat.homMk ⇑(CategoryTheory.ConcreteCategory.hom f)) |
Std.ExtHashSet.size_diff_add_size_inter_eq_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size + (m₁ ∩ m₂).size = m₁.size |
Ideal.connectedComponentOfZero._proof_2 | Mathlib.Topology.Algebra.Ring.Ideal | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (c x : R),
x ∈ (AddSubgroup.connectedComponentOfZero R).carrier → c • x ∈ connectedComponent 0 |
_private.Mathlib.MeasureTheory.Measure.OpenPos.0.IsMeagre.of_isSigmaCompact_null.match_1_1 | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} (K : ℕ → Set X) (t : Set X) (motive : t ∈ Set.range K → Prop) (x : t ∈ Set.range K),
(∀ (n : ℕ) (hn : K n = t), motive ⋯) → motive x |
Matrix.mulVecLin_reindex | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {k : Type u_2} {l : Type u_3} {m : Type u_4} {n : Type u_5}
[inst_1 : Fintype n] [inst_2 : Fintype l] (e₁ : k ≃ m) (e₂ : l ≃ n) (M : Matrix k l R),
((Matrix.reindex e₁ e₂) M).mulVecLin =
↑(LinearEquiv.funCongrLeft R R e₁.symm) ∘ₗ M.mulVecLin ∘ₗ ↑(LinearEquiv.funCongrLeft R R e₂) |
Ordinal.CNF.snd_lt | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {b o : Ordinal.{u}}, 1 < b → ∀ {x : Ordinal.{u} × Ordinal.{u}}, x ∈ Ordinal.CNF b o → x.2 < b |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff._simp_1_3 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α}, (f ≠ ⊥) = f.NeBot |
Std.Do.Spec.Iter.forIn_map | Std.Do.Triple.SpecLemmas | ∀ {α β β₂ γ : Type w} [inst : Std.Iterator α Id β] {ps : Std.Do.PostShape} {n : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Std.Do.WPMonad n ps] [Std.Iterators.Finite α Id] [inst_5 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id n] {it : Std.Iter β} {f : β → β₂} {init : γ} {g : β₂ → γ → n (ForInStep γ)}
{P : Std.Do.Assertion ps} {Q : Std.Do.PostCond γ ps},
⦃P⦄ forIn it init fun out acc => g (f out) acc ⦃Q⦄ → ⦃P⦄ forIn (Std.Iter.map f it) init g ⦃Q⦄ |
Vector.mk_isPrefixOf_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs ys : Array α} (h : xs.size = n) (h' : ys.size = n),
(Vector.mk xs h).isPrefixOf (Vector.mk ys h') = xs.isPrefixOf ys |
AddSubgroup.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : AddGroup M]
[inst_3 : AddAction M X] [ContinuousVAdd M X] {S : AddSubgroup M}, ContinuousVAdd (↥S) X |
Real.Angle.toReal_neg_iff_sign_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, θ.toReal < 0 ↔ θ.sign = -1 |
CategoryTheory.Limits.CompleteLattice.finiteColimitCocone._proof_2 | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u_2} {J : Type u_1} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeSup α] [inst_3 : OrderBot α] (F : CategoryTheory.Functor J α)
(s : CategoryTheory.Limits.Cocone F) (j : J),
CategoryTheory.CategoryStruct.comp
({ pt := Finset.univ.sup F.obj, ι := { app := fun x => CategoryTheory.homOfLE ⋯, naturality := ⋯ } }.ι.app j)
(CategoryTheory.homOfLE ⋯) =
s.ι.app j |
Array.extract.loop.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (i j : ℕ) (bs : Array α),
Array.extract.loop as i j bs =
if hlt : j < as.size then
match i with
| 0 => bs
| i'.succ => Array.extract.loop as i' (j + 1) (bs.push (as.getInternal j hlt))
else bs |
NonUnitalRingHom.srange_eq_top_iff_surjective | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] {F : Type u_1} [inst_1 : FunLike F R S]
[inst_2 : NonUnitalNonAssocSemiring S] [inst_3 : NonUnitalRingHomClass F R S] {f : F},
NonUnitalRingHom.srange f = ⊤ ↔ Function.Surjective ⇑f |
Std.DHashMap.get?_insert_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, (m.insert k v).get? k = some v |
Std.Time.PlainTime.toHours | Std.Time.Time.PlainTime | Std.Time.PlainTime → Std.Time.Hour.Offset |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go._unsafe_rec | Lean.Util.Diff | {α : Type u_1} → [BEq α] → Subarray α → Subarray α → ℕ → Subarray α × Subarray α × Array α |
FormalMultilinearSeries.iteratedFDerivSeries._proof_1 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E |
_private.Mathlib.Analysis.Normed.Group.Ultra.0.IsUltrametricDist.exists_norm_finset_sum_le_of_nonempty.match_1_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_2} {ι : Type u_1} [inst : SeminormedAddCommGroup M] {t : Finset ι} (ht : t.Nonempty) (f : ι → M)
(motive : (∃ i ∈ t, (t.sup' ht fun x => ‖f x‖) = ‖f i‖) → Prop) (x : ∃ i ∈ t, (t.sup' ht fun x => ‖f x‖) = ‖f i‖),
(∀ (j : ι) (hj : j ∈ t) (hj' : (t.sup' ht fun x => ‖f x‖) = ‖f j‖), motive ⋯) → motive x |
AddValuation.map_eq_of_lt_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R}, v x < v (y - x) → v y = v x |
instShiftLeftUSize | Init.Data.UInt.Basic | ShiftLeft USize |
_private.Mathlib.Order.Filter.Pi.0.Filter.tendsto_pi._simp_1_2 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : α → β} {x : Filter α} {y : ι → Filter β},
Filter.Tendsto f x (⨅ i, y i) = ∀ (i : ι), Filter.Tendsto f x (y i) |
CategoryTheory.Pseudofunctor.CoGrothendieck.mapCompIso._proof_2 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F G H : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} (α : F ⟶ G) (β : G ⟶ H)
{X Y : F.CoGrothendieck} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pseudofunctor.CoGrothendieck.map (CategoryTheory.CategoryStruct.comp α β)).map f)
((fun x => CategoryTheory.eqToIso ⋯) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun x => CategoryTheory.eqToIso ⋯) X).hom
(((CategoryTheory.Pseudofunctor.CoGrothendieck.map α).comp
(CategoryTheory.Pseudofunctor.CoGrothendieck.map β)).map
f) |
LieAlgebra.maxNilpotentIdeal_le_radical | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.maxNilpotentIdeal R L ≤ LieAlgebra.radical R L |
Lean.Doc.builtinDocDirectives | Lean.Elab.DocString | IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocDirectiveExpander))) |
toAdd_div | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} [inst : Sub α] (x y : Multiplicative α),
Multiplicative.toAdd (x / y) = Multiplicative.toAdd x - Multiplicative.toAdd y |
powMonoidWithZeroHom_apply | Mathlib.Algebra.GroupWithZero.Hom | ∀ {M₀ : Type u_6} [inst : CommMonoidWithZero M₀] {n : ℕ} (hn : n ≠ 0) (a : M₀), (powMonoidWithZeroHom hn) a = a ^ n |
_private.Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo.0.CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_hom._simp_1_2 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(f = CategoryTheory.CategoryStruct.comp g α) = (CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) |
MonomialOrder.coeff_degree_ne_zero_iff | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R},
MvPolynomial.coeff (m.degree f) f ≠ 0 ↔ f ≠ 0 |
SchwartzMap._aux_Mathlib_Analysis_Distribution_TemperedDistribution___unexpand_TemperedDistribution_1 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.PrettyPrinter.Unexpander |
Submodule.Quotient.restrictScalarsEquiv_symm_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : Ring S] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M] (P : Submodule R M)
(x : M), (Submodule.Quotient.restrictScalarsEquiv S P).symm (Submodule.Quotient.mk x) = Submodule.Quotient.mk x |
ValueDistribution.characteristic | Mathlib.Analysis.Complex.ValueDistribution.CharacteristicFunction | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℂ E] → (ℂ → E) → WithTop E → ℝ → ℝ |
IsMulTorsionFree.zpow_eq_one_iff | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : Group G] [IsMulTorsionFree G] {n : ℤ} {a : G}, a ^ n = 1 ↔ a = 1 ∨ n = 0 |
Multiset.Icc_eq_zero_iff._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, (Multiset.Icc a b = 0) = ¬a ≤ b |
StructureGroupoid.noConfusion | Mathlib.Geometry.Manifold.StructureGroupoid | {P : Sort u} →
{H : Type u_2} →
{inst : TopologicalSpace H} →
{t : StructureGroupoid H} →
{H' : Type u_2} →
{inst' : TopologicalSpace H'} →
{t' : StructureGroupoid H'} → H = H' → inst ≍ inst' → t ≍ t' → StructureGroupoid.noConfusionType P t t' |
_private.Mathlib.Data.Part.0.Part.mem_unique.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (motive : (x x_1 : α) → (x_2 : Part α) → x ∈ x_2 → x_1 ∈ x_2 → Prop) (x x_1 : α) (x_2 : Part α)
(x_3 : x ∈ x_2) (x_4 : x_1 ∈ x_2),
(∀ (Dom : Prop) (get : Dom → α) (w w_1 : { Dom := Dom, get := get }.Dom),
motive ({ Dom := Dom, get := get }.get w) ({ Dom := Dom, get := get }.get w_1) { Dom := Dom, get := get } ⋯ ⋯) →
motive x x_1 x_2 x_3 x_4 |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj_hom_ext.match_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀
(motive :
(x y z : AugmentedSimplexCategory) →
(f g : CategoryTheory.MonoidalCategoryStruct.tensorObj x y ⟶ z) →
CategoryTheory.CategoryStruct.comp (x.inl y) f = CategoryTheory.CategoryStruct.comp (x.inl y) g →
CategoryTheory.CategoryStruct.comp (x.inr y) f = CategoryTheory.CategoryStruct.comp (x.inr y) g → Prop)
(x y z : AugmentedSimplexCategory) (f g : CategoryTheory.MonoidalCategoryStruct.tensorObj x y ⟶ z)
(h₁ : CategoryTheory.CategoryStruct.comp (x.inl y) f = CategoryTheory.CategoryStruct.comp (x.inl y) g)
(h₂ : CategoryTheory.CategoryStruct.comp (x.inr y) f = CategoryTheory.CategoryStruct.comp (x.inr y) g),
(∀ (x y z : SimplexCategory)
(f g :
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.WithInitial.of x)
(CategoryTheory.WithInitial.of y) ⟶
CategoryTheory.WithInitial.of z)
(h₁ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl (CategoryTheory.WithInitial.of x) (CategoryTheory.WithInitial.of y)) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl (CategoryTheory.WithInitial.of x) (CategoryTheory.WithInitial.of y)) g)
(h₂ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr (CategoryTheory.WithInitial.of x) (CategoryTheory.WithInitial.of y)) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr (CategoryTheory.WithInitial.of x) (CategoryTheory.WithInitial.of y)) g),
motive (CategoryTheory.WithInitial.of x) (CategoryTheory.WithInitial.of y) (CategoryTheory.WithInitial.of z) f g
h₁ h₂) →
(∀ (x z : SimplexCategory)
(f g :
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.WithInitial.of x)
CategoryTheory.WithInitial.star ⟶
CategoryTheory.WithInitial.of z)
(h₁ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl (CategoryTheory.WithInitial.of x) CategoryTheory.WithInitial.star) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl (CategoryTheory.WithInitial.of x) CategoryTheory.WithInitial.star) g)
(h₂ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr (CategoryTheory.WithInitial.of x) CategoryTheory.WithInitial.star) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr (CategoryTheory.WithInitial.of x) CategoryTheory.WithInitial.star) g),
motive (CategoryTheory.WithInitial.of x) CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of z) f g
h₁ h₂) →
(∀ (y z : SimplexCategory)
(f g :
CategoryTheory.MonoidalCategoryStruct.tensorObj CategoryTheory.WithInitial.star
(CategoryTheory.WithInitial.of y) ⟶
CategoryTheory.WithInitial.of z)
(h₁ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of y)) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of y)) g)
(h₂ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of y)) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of y)) g),
motive CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of y) (CategoryTheory.WithInitial.of z) f g
h₁ h₂) →
(∀ (z : SimplexCategory)
(f g :
CategoryTheory.MonoidalCategoryStruct.tensorObj CategoryTheory.WithInitial.star
CategoryTheory.WithInitial.star ⟶
CategoryTheory.WithInitial.of z)
(h₁ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) g)
(h₂ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) g),
motive CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star (CategoryTheory.WithInitial.of z) f g
h₁ h₂) →
(∀
(f g :
CategoryTheory.MonoidalCategoryStruct.tensorObj CategoryTheory.WithInitial.star
CategoryTheory.WithInitial.star ⟶
CategoryTheory.WithInitial.star)
(h₁ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inl CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) g)
(h₂ :
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) f =
CategoryTheory.CategoryStruct.comp
(AugmentedSimplexCategory.inr CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star) g),
motive CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star f g
h₁ h₂) →
motive x y z f g h₁ h₂ |
Setoid.piQuotientEquiv._proof_4 | Mathlib.Data.Setoid.Basic | ∀ {ι : Sort u_1} {α : ι → Sort u_2} (r : (i : ι) → Setoid (α i)) (q : Quotient piSetoid),
(fun x => Quotient.mk'' fun i => (x i).out) ((fun q => q.liftOn' (fun x i => Quotient.mk'' (x i)) ⋯) q) = q |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Functor_Oplax___unexpand_CategoryTheory_OplaxFunctor_1 | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | Lean.PrettyPrinter.Unexpander |
convex_iff_pairwise_pos | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {s : Set E},
Convex 𝕜 s ↔ s.Pairwise fun x y => ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 → a • x + b • y ∈ s |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.continuous_map_iff._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_3} [inst_1 : TopologicalSpace Y] (f : OnePoint X → Y),
Continuous f =
(Filter.Tendsto (fun x => f ↑x) (Filter.coclosedCompact X) (nhds (f OnePoint.infty)) ∧ Continuous fun x => f ↑x) |
CategoryTheory.Idempotents.split_imp_of_iso | Mathlib.CategoryTheory.Idempotents.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X X' : C} (φ : X ≅ X') (p : X ⟶ X) (p' : X' ⟶ X'),
CategoryTheory.CategoryStruct.comp p φ.hom = CategoryTheory.CategoryStruct.comp φ.hom p' →
(∃ Y i e,
CategoryTheory.CategoryStruct.comp i e = CategoryTheory.CategoryStruct.id Y ∧
CategoryTheory.CategoryStruct.comp e i = p) →
∃ Y' i' e',
CategoryTheory.CategoryStruct.comp i' e' = CategoryTheory.CategoryStruct.id Y' ∧
CategoryTheory.CategoryStruct.comp e' i' = p' |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.IterM.step_filterM.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.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 := false })
(h_1 : (hf : MonadAttach.CanReturn (f out) { down := false }) → motive ⟨{ down := false }, hf⟩)
(h_2 : (hf : MonadAttach.CanReturn (f out) { down := true }) → motive ⟨{ down := true }, hf⟩),
(match ⟨{ down := false }, hf⟩ with
| ⟨{ down := false }, hf⟩ => h_1 hf
| ⟨{ down := true }, hf⟩ => h_2 hf) =
h_1 hf |
Interval.lattice._proof_2 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DecidableLE α] (s t : Interval α),
(match s, t with
| none, x => ⊥
| x, none => ⊥
| some s, some t =>
if h : s.toProd.1 ≤ t.toProd.2 ∧ t.toProd.1 ≤ s.toProd.2 then
↑{ fst := s.toProd.1 ⊔ t.toProd.1, snd := s.toProd.2 ⊓ t.toProd.2, fst_le_snd := ⋯ }
else ⊥) ≤
s |
Algebra.IsAlgebraic.algHomEmbeddingOfSplits._proof_3 | Mathlib.FieldTheory.Normal.Closure | ∀ {F : Type u_1} [inst : Field F] (L' : Type u_2) [inst_1 : Field L'] [inst_2 : Algebra F L'], IsScalarTower F F L' |
isCyclic_tfae | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_1) (L : Type u_2) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L],
(primitiveRoots (Module.finrank K L) K).Nonempty →
[IsGalois K L ∧ IsCyclic Gal(L/K),
∃ a,
Irreducible (Polynomial.X ^ Module.finrank K L - Polynomial.C a) ∧
Polynomial.IsSplittingField K L (Polynomial.X ^ Module.finrank K L - Polynomial.C a),
∃ α, α ^ Module.finrank K L ∈ Set.range ⇑(algebraMap K L) ∧ K⟮α⟯ = ⊤].TFAE |
DivisibleHull.instSMulRat._proof_1 | Mathlib.GroupTheory.DivisibleHull | ∀ (a : ℚ), 0 ≤ |a| |
Lean.HeadIndex.sort.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.sort = 1 |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_Ico_le_integral_of_le._simp_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) |
_private.Init.PropLemmas.0.and_or_left.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : a ∧ (b ∨ c) → Prop) (x : a ∧ (b ∨ c)), (∀ (ha : a) (hbc : b ∨ c), motive ⋯) → motive x |
Array.map_set | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α} {i : ℕ} {h : i < xs.size} {a : α},
Array.map f (xs.set i a h) = (Array.map f xs).set i (f a) ⋯ |
Cardinal.commSemiring._proof_10 | Mathlib.SetTheory.Cardinal.Order | ∀ (a : Cardinal.{u_1}), 0 * a = 0 |
StateTransition.EvalsToInTime.noConfusion | Mathlib.Computability.StateTransition | {P : Sort u} →
{σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} →
{b : Option σ} →
{m : ℕ} →
{t : StateTransition.EvalsToInTime f a b m} →
{σ' : Type u_1} →
{f' : σ' → Option σ'} →
{a' : σ'} →
{b' : Option σ'} →
{m' : ℕ} →
{t' : StateTransition.EvalsToInTime f' a' b' m'} →
σ = σ' →
f ≍ f' →
a ≍ a' → b ≍ b' → m = m' → t ≍ t' → StateTransition.EvalsToInTime.noConfusionType P t t' |
DilationEquivClass.mk | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {F : Type u_1} {X : outParam (Type u_2)} {Y : outParam (Type u_3)} [inst : PseudoEMetricSpace X]
[inst_1 : PseudoEMetricSpace Y] [inst_2 : EquivLike F X Y],
(∀ (f : F), ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (f x) (f y) = ↑r * edist x y) → DilationEquivClass F X Y |
Lean.Elab.Tactic.initFn._@.Lean.Elab.Tactic.Induction.3151586715._hygCtx._hyg.4 | Lean.Elab.Tactic.Induction | IO (Lean.Option Bool) |
_private.Lean.Meta.Tactic.Grind.Arith.EvalNum.0.Lean.Meta.Grind.Arith.evalNatCore | Lean.Meta.Tactic.Grind.Arith.EvalNum | Lean.Expr → OptionT Lean.Meta.Grind.GrindM ℕ |
Ring.DimensionLEOne.localization | Mathlib.RingTheory.DedekindDomain.Dvr | ∀ {R : Type u_2} (Rₘ : Type u_3) [inst : CommRing R] [IsDomain R] [inst_2 : CommRing Rₘ] [inst_3 : Algebra R Rₘ]
{M : Submonoid R} [IsLocalization M Rₘ], M ≤ nonZeroDivisors R → ∀ [h : Ring.DimensionLEOne R], Ring.DimensionLEOne Rₘ |
Lean.CodeAction.CommandCodeActions.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActions} → t = t' → Lean.CodeAction.CommandCodeActions.noConfusionType P t t' |
NNReal.coe_sub_of_lt._simp_1 | Mathlib.Data.NNReal.Basic | ∀ {a b : NNReal}, a < b → ↑b - ↑a = ↑(b - a) |
UniformSpace.Completion.coe_vadd._simp_1 | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : VAdd M X] [UniformContinuousConstVAdd M X] (c : M)
(x : X), c +ᵥ ↑x = ↑(c +ᵥ x) |
MeasureTheory.Measure.MutuallySingular.zero_left._simp_1 | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.Measure.MutuallySingular 0 μ = True |
ContMDiffWithinAt.prodMap' | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_8}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_9} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_10} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{F' : Type u_11} [inst_16 : NormedAddCommGroup F'] [inst_17 : NormedSpace 𝕜 F'] {G' : Type u_12}
[inst_18 : TopologicalSpace G'] {J' : ModelWithCorners 𝕜 F' G'} {N' : Type u_13} [inst_19 : TopologicalSpace N']
[inst_20 : ChartedSpace G' N'] {f : M → M'} {s : Set M} {n : WithTop ℕ∞} {g : N → N'} {r : Set N} {p : M × N},
ContMDiffWithinAt I I' n f s p.1 →
ContMDiffWithinAt J J' n g r p.2 → ContMDiffWithinAt (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) p |
ComplexShape.Embedding.πTruncGENatTrans | Mathlib.Algebra.Homology.Embedding.TruncGE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
(e : c.Embedding c') →
[inst : e.IsTruncGE] →
(C : Type u_4) →
[inst_1 : CategoryTheory.Category.{v_2, u_4} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
[inst_4 : CategoryTheory.CategoryWithHomology C] →
CategoryTheory.Functor.id (HomologicalComplex C c') ⟶ e.truncGEFunctor C |
AddMonoid.addOrderOf_le_exponent | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddMonoid G], AddMonoid.ExponentExists G → ∀ (g : G), addOrderOf g ≤ AddMonoid.exponent G |
Std.ExtTreeSet.min!_eq_iff_mem_and_forall | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
[inst_2 : Inhabited α], t ≠ ∅ → ∀ {km : α}, t.min! = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true |
TensorProduct.dualDistribEquivOfBasis_apply_apply | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} {κ : Type u_6} [inst : DecidableEq ι]
[inst_1 : DecidableEq κ] [inst_2 : Fintype ι] [inst_3 : Fintype κ] [inst_4 : CommSemiring R]
[inst_5 : AddCommMonoid M] [inst_6 : AddCommMonoid N] [inst_7 : Module R M] [inst_8 : Module R N]
(b : Module.Basis ι R M) (c : Module.Basis κ R N) (a : TensorProduct R (Module.Dual R M) (Module.Dual R N))
(a_1 : TensorProduct R M N),
((TensorProduct.dualDistribEquivOfBasis b c) a) a_1 =
(TensorProduct.lid R R) (((TensorProduct.homTensorHomMap (RingHom.id R) M N R R) a) a_1) |
NNReal.sqrt_le_sqrt | Mathlib.Data.Real.Sqrt | ∀ {x y : NNReal}, NNReal.sqrt x ≤ NNReal.sqrt y ↔ x ≤ y |
Batteries.CodeAction.matchExpand.match_6 | Batteries.CodeAction.Match | (motive : Option Lean.Elab.TermInfo → Sort u_1) →
(x : Option Lean.Elab.TermInfo) →
((info : Lean.Elab.TermInfo) → motive (some info)) → ((x : Option Lean.Elab.TermInfo) → motive x) → motive x |
SimpleGraph.Walk.take_spec | Mathlib.Combinatorics.SimpleGraph.Connectivity.WalkDecomp | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v w : V} (p : G.Walk v w) (h : u ∈ p.support),
(p.takeUntil u h).append (p.dropUntil u h) = p |
finSuccEquiv'_below | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i : Fin (n + 1)} {m : Fin n}, m.castSucc < i → (finSuccEquiv' i) m.castSucc = some m |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal.Impl.Const.get t k ⋯)).isSome = true |
Lean.Compiler.LCNF.ConfigOptions.recOn | Lean.Compiler.LCNF.ConfigOptions | {motive : Lean.Compiler.LCNF.ConfigOptions → Sort u} →
(t : Lean.Compiler.LCNF.ConfigOptions) →
((smallThreshold maxRecInline maxRecInlineIfReduce : ℕ) →
(checkTypes extractClosed : Bool) →
(maxRecSpecialize : ℕ) →
(resetReuse : Bool) →
motive
{ smallThreshold := smallThreshold, maxRecInline := maxRecInline,
maxRecInlineIfReduce := maxRecInlineIfReduce, checkTypes := checkTypes,
extractClosed := extractClosed, maxRecSpecialize := maxRecSpecialize, resetReuse := resetReuse }) →
motive t |
CategoryTheory.StructuredArrow.isoMk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S : D} →
{T : CategoryTheory.Functor C D} →
{f f' : CategoryTheory.StructuredArrow S T} →
(g : f.right ≅ f'.right) →
autoParam (CategoryTheory.CategoryStruct.comp f.hom (T.map g.hom) = f'.hom)
CategoryTheory.StructuredArrow.isoMk._auto_1 →
(f ≅ f') |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.truncate.go.match_1 | Lean.Server.Completion.CompletionCollectors | (motive : Lean.Name × ℕ → Sort u_1) → (x : Lean.Name × ℕ) → ((p' : Lean.Name) → (len : ℕ) → motive (p', len)) → motive x |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.ListBlank.append.match_1.eq_2 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : List Γ → Turing.ListBlank Γ → Sort u_2) (a : Γ) (l : List Γ)
(L : Turing.ListBlank Γ) (h_1 : (L : Turing.ListBlank Γ) → motive [] L)
(h_2 : (a : Γ) → (l : List Γ) → (L : Turing.ListBlank Γ) → motive (a :: l) L),
(match a :: l, L with
| [], L => h_1 L
| a :: l, L => h_2 a l L) =
h_2 a l L |
MeasureTheory.MemLp.aemeasurable | Mathlib.MeasureTheory.Function.LpSeminorm.Defs | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} [inst : ENorm ε] {μ : MeasureTheory.Measure α}
[inst_1 : MeasurableSpace ε] [inst_2 : TopologicalSpace ε] [TopologicalSpace.PseudoMetrizableSpace ε] [BorelSpace ε]
{f : α → ε} {p : ENNReal}, MeasureTheory.MemLp f p μ → AEMeasurable f μ |
Lean.Lsp.FileEvent.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileEvent → Sort u} →
(t : Lean.Lsp.FileEvent) →
((uri : Lean.Lsp.DocumentUri) → (type : Lean.Lsp.FileChangeType) → motive { uri := uri, type := type }) → motive t |
EuclideanGeometry.inversion_eq_center'._simp_1 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c x : P} {R : ℝ}, (EuclideanGeometry.inversion c R x = c) = (x = c ∨ R = 0) |
AddMonoidHom.coeToZeroHom | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_4} → {N : Type u_5} → [inst : AddZero M] → [inst_1 : AddZero N] → Coe (M →+ N) (ZeroHom M N) |
CategoryTheory.Functor.homologySequence_mono_shift_map_mor₂_iff | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A)
[inst_3 : CategoryTheory.Limits.HasZeroObject C] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_6 : CategoryTheory.Pretriangulated C]
[inst_7 : CategoryTheory.Abelian A] [F.IsHomological] [inst_9 : F.ShiftSequence ℤ],
∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
∀ (n₀ : ℤ), CategoryTheory.Mono ((F.shift n₀).map T.mor₂) ↔ (F.shift n₀).map T.mor₁ = 0 |
CategoryTheory.GradedObject.isColimitCofan₃MapBifunctorBifunctor₂₃MapObj._proof_6 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_12} {C₂ : Type u_10} {C₃ : Type u_8} {C₄ : Type u_6} {C₂₃ : Type u_14}
[inst : CategoryTheory.Category.{u_11, u_12} C₁] [inst_1 : CategoryTheory.Category.{u_9, u_10} C₂]
[inst_2 : CategoryTheory.Category.{u_7, u_8} C₃] [inst_3 : CategoryTheory.Category.{u_5, u_6} C₄]
[inst_4 : CategoryTheory.Category.{u_13, u_14} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄))
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3}
{J : Type u_4} {r : I₁ × I₂ × I₃ → J} (ρ₂₃ : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r)
(X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂)
(X₃ : CategoryTheory.GradedObject I₃ C₃)
[inst_5 : (((CategoryTheory.GradedObject.mapBifunctor G₂₃ I₂ I₃).obj X₂).obj X₃).HasMap ρ₂₃.p]
[inst_6 :
(((CategoryTheory.GradedObject.mapBifunctor F I₁ ρ₂₃.I₂₃).obj X₁).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)).HasMap
ρ₂₃.q]
(j : J) (x : CategoryTheory.Discrete ↑(r ⁻¹' {j})),
CategoryTheory.CategoryStruct.comp
((((((CategoryTheory.GradedObject.mapTrifunctor (CategoryTheory.bifunctorComp₂₃ F G₂₃) I₁ I₂ I₃).obj X₁).obj
X₂).obj
X₃).cofanMapObjComp
(fun x =>
match x with
| (i₁, i₂, i₃) => (i₁, ρ₂₃.p (i₂, i₃)))
ρ₂₃.q r ⋯ j
(fun x h =>
match x, h with
| (i₁, i₂₃), h =>
(fun x =>
match x with
| ⟨(i₁, i₂₃), hi⟩ =>
(CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.Discrete.natIso fun x =>
match x with
| { as := ⟨(i₁', i₂, i₃), hi_1⟩ } => CategoryTheory.eqToIso ⋯).hom).obj
((CategoryTheory.Limits.Cocone.whiskeringEquivalence
(CategoryTheory.Discrete.equivalence
((fun i₁ i₂₃ =>
{
toFun := fun x =>
match x with
| ⟨(i₁', i₂, i₃), hi⟩ => ⟨(i₂, i₃), ⋯⟩,
invFun := fun x =>
match x with
| ⟨(i₂, i₃), hi⟩ => ⟨(i₁, i₂, i₃), ⋯⟩,
left_inv := ⋯, right_inv := ⋯ })
i₁ i₂₃))).functor.obj
((fun i =>
(F.obj (X₁ (↑i).1)).mapCocone
((fun i₂₃ =>
(((CategoryTheory.GradedObject.mapBifunctor G₂₃ I₂ I₃).obj X₂).obj X₃).cofanMapObj
ρ₂₃.p i₂₃)
(↑i).2))
⟨(i₁, i₂₃), hi⟩)))
⟨(i₁, i₂₃), h⟩)
((((CategoryTheory.GradedObject.mapBifunctor F I₁ ρ₂₃.I₂₃).obj X₁).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)).cofanMapObj
ρ₂₃.q j)).ι.app
x)
(CategoryTheory.Iso.refl
(((((CategoryTheory.GradedObject.mapTrifunctor (CategoryTheory.bifunctorComp₂₃ F G₂₃) I₁ I₂ I₃).obj X₁).obj
X₂).obj
X₃).cofanMapObjComp
(fun x =>
match x with
| (i₁, i₂, i₃) => (i₁, ρ₂₃.p (i₂, i₃)))
ρ₂₃.q r ⋯ j
(fun x h =>
match x, h with
| (i₁, i₂₃), h =>
(fun x =>
match x with
| ⟨(i₁, i₂₃), hi⟩ =>
(CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.Discrete.natIso fun x =>
match x with
| { as := ⟨(i₁', i₂, i₃), hi_1⟩ } => CategoryTheory.eqToIso ⋯).hom).obj
((CategoryTheory.Limits.Cocone.whiskeringEquivalence
(CategoryTheory.Discrete.equivalence
((fun i₁ i₂₃ =>
{
toFun := fun x =>
match x with
| ⟨(i₁', i₂, i₃), hi⟩ => ⟨(i₂, i₃), ⋯⟩,
invFun := fun x =>
match x with
| ⟨(i₂, i₃), hi⟩ => ⟨(i₁, i₂, i₃), ⋯⟩,
left_inv := ⋯, right_inv := ⋯ })
i₁ i₂₃))).functor.obj
((fun i =>
(F.obj (X₁ (↑i).1)).mapCocone
((fun i₂₃ =>
(((CategoryTheory.GradedObject.mapBifunctor G₂₃ I₂ I₃).obj X₂).obj X₃).cofanMapObj
ρ₂₃.p i₂₃)
(↑i).2))
⟨(i₁, i₂₃), hi⟩)))
⟨(i₁, i₂₃), h⟩)
((((CategoryTheory.GradedObject.mapBifunctor F I₁ ρ₂₃.I₂₃).obj X₁).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)).cofanMapObj
ρ₂₃.q j)).pt).hom =
(CategoryTheory.GradedObject.cofan₃MapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ j).ι.app x |
MeasureTheory.IntegrableOn.comp_neg_Iio | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_4} {F : Type u_6} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.Measure G}
[inst_2 : PartialOrder G] [inst_3 : AddCommGroup G] [IsOrderedAddMonoid G] [MeasurableNeg G] [μ.IsNegInvariant]
{c : G} {f : G → F},
MeasureTheory.IntegrableOn f (Set.Ioi (-c)) μ → MeasureTheory.IntegrableOn (fun x => f (-x)) (Set.Iio c) μ |
Ne.irrefl | Init.Core | ∀ {α : Sort u} {a : α}, a ≠ a → False |
List.zipWith_rotate_distrib | Mathlib.Data.List.Rotate | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β) (n : ℕ),
l.length = l'.length → (List.zipWith f l l').rotate n = List.zipWith f (l.rotate n) (l'.rotate n) |
differentIdeal.eq_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (B : Type u_3) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[inst_4 : IsDedekindDomain B] [inst_5 : Module.IsTorsionFree A B],
differentIdeal A B =
Submodule.comap (Algebra.linearMap B (FractionRing B)) (1 / Submodule.traceDual A (FractionRing A) 1) |
CategoryTheory.Triangulated.TStructure.descTruncGT.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.Triangulated.TStructure C) {X Y : C} (f f_1 : X ⟶ Y),
f = f_1 →
∀ (n₀ n₁ n₁_1 : ℤ) (e_n₁ : n₁ = n₁_1) (h : n₀ + 1 = n₁) [inst_6 : t.IsGE Y n₁],
t.descTruncGT f n₀ n₁ h = t.descTruncGT f_1 n₀ n₁_1 ⋯ |
Std.ExtTreeMap.getKey!_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α} {f : β → β},
(t.modify k f).getKey! k' = if cmp k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.