Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | num_lines int64 1 150 | complexity_score float64 2.72 139,370,958,066,637,970,000,000,000,000,000,000,000,000,000,000,000,000,000B | diff_level int64 0 2 | file_diff_level float64 0 2 | theorem_same_file int64 1 32 | rank_file int64 0 2.51k |
|---|---|---|---|---|---|---|---|---|---|---|---|
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Linear.Basic
#align_import category_theory.linear.linear_functor from "leanprover-community/mathlib"@"829895f162a1f29d0133f4b3538f4cd1fb5bffd3"
namespace CategoryTheory
variable (R : Type*) [Semiring R]
class Functor.Linear {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
[Linear R C] [Linear R D] (F : C β₯€ D) [F.Additive] : Prop where
map_smul : β {X Y : C} (f : X βΆ Y) (r : R), F.map (r β’ f) = r β’ F.map f := by aesop_cat
#align category_theory.functor.linear CategoryTheory.Functor.Linear
section Linear
namespace Functor
section
variable {R}
variable {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
[CategoryTheory.Linear R C] [CategoryTheory.Linear R D] (F : C β₯€ D) [Additive F] [Linear R F]
@[simp]
theorem map_smul {X Y : C} (r : R) (f : X βΆ Y) : F.map (r β’ f) = r β’ F.map f :=
Functor.Linear.map_smul _ _
#align category_theory.functor.map_smul CategoryTheory.Functor.map_smul
@[simp]
| Mathlib/CategoryTheory/Linear/LinearFunctor.lean | 53 | 54 | theorem map_units_smul {X Y : C} (r : RΛ£) (f : X βΆ Y) : F.map (r β’ f) = r β’ F.map f := by |
apply map_smul
| 1 | 2.718282 | 0 | 0 | 1 | 0 |
import Mathlib.CategoryTheory.Products.Basic
#align_import category_theory.products.bifunctor from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open CategoryTheory
namespace CategoryTheory.Bifunctor
universe vβ vβ vβ uβ uβ uβ
variable {C : Type uβ} {D : Type uβ} {E : Type uβ}
variable [Category.{vβ} C] [Category.{vβ} D] [Category.{vβ} E]
@[simp]
theorem map_id (F : C Γ D β₯€ E) (X : C) (Y : D) :
F.map ((π X, π Y) : (X, Y) βΆ (X, Y)) = π (F.obj (X, Y)) :=
F.map_id (X, Y)
#align category_theory.bifunctor.map_id CategoryTheory.Bifunctor.map_id
@[simp]
| Mathlib/CategoryTheory/Products/Bifunctor.lean | 31 | 34 | theorem map_id_comp (F : C Γ D β₯€ E) (W : C) {X Y Z : D} (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((π W, f β« g) : (W, X) βΆ (W, Z)) =
F.map ((π W, f) : (W, X) βΆ (W, Y)) β« F.map ((π W, g) : (W, Y) βΆ (W, Z)) := by |
rw [β Functor.map_comp, prod_comp, Category.comp_id]
| 1 | 2.718282 | 0 | 0 | 4 | 1 |
import Mathlib.CategoryTheory.Products.Basic
#align_import category_theory.products.bifunctor from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open CategoryTheory
namespace CategoryTheory.Bifunctor
universe vβ vβ vβ uβ uβ uβ
variable {C : Type uβ} {D : Type uβ} {E : Type uβ}
variable [Category.{vβ} C] [Category.{vβ} D] [Category.{vβ} E]
@[simp]
theorem map_id (F : C Γ D β₯€ E) (X : C) (Y : D) :
F.map ((π X, π Y) : (X, Y) βΆ (X, Y)) = π (F.obj (X, Y)) :=
F.map_id (X, Y)
#align category_theory.bifunctor.map_id CategoryTheory.Bifunctor.map_id
@[simp]
theorem map_id_comp (F : C Γ D β₯€ E) (W : C) {X Y Z : D} (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((π W, f β« g) : (W, X) βΆ (W, Z)) =
F.map ((π W, f) : (W, X) βΆ (W, Y)) β« F.map ((π W, g) : (W, Y) βΆ (W, Z)) := by
rw [β Functor.map_comp, prod_comp, Category.comp_id]
#align category_theory.bifunctor.map_id_comp CategoryTheory.Bifunctor.map_id_comp
@[simp]
| Mathlib/CategoryTheory/Products/Bifunctor.lean | 38 | 41 | theorem map_comp_id (F : C Γ D β₯€ E) (X Y Z : C) (W : D) (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((f β« g, π W) : (X, W) βΆ (Z, W)) =
F.map ((f, π W) : (X, W) βΆ (Y, W)) β« F.map ((g, π W) : (Y, W) βΆ (Z, W)) := by |
rw [β Functor.map_comp, prod_comp, Category.comp_id]
| 1 | 2.718282 | 0 | 0 | 4 | 1 |
import Mathlib.CategoryTheory.Products.Basic
#align_import category_theory.products.bifunctor from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open CategoryTheory
namespace CategoryTheory.Bifunctor
universe vβ vβ vβ uβ uβ uβ
variable {C : Type uβ} {D : Type uβ} {E : Type uβ}
variable [Category.{vβ} C] [Category.{vβ} D] [Category.{vβ} E]
@[simp]
theorem map_id (F : C Γ D β₯€ E) (X : C) (Y : D) :
F.map ((π X, π Y) : (X, Y) βΆ (X, Y)) = π (F.obj (X, Y)) :=
F.map_id (X, Y)
#align category_theory.bifunctor.map_id CategoryTheory.Bifunctor.map_id
@[simp]
theorem map_id_comp (F : C Γ D β₯€ E) (W : C) {X Y Z : D} (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((π W, f β« g) : (W, X) βΆ (W, Z)) =
F.map ((π W, f) : (W, X) βΆ (W, Y)) β« F.map ((π W, g) : (W, Y) βΆ (W, Z)) := by
rw [β Functor.map_comp, prod_comp, Category.comp_id]
#align category_theory.bifunctor.map_id_comp CategoryTheory.Bifunctor.map_id_comp
@[simp]
theorem map_comp_id (F : C Γ D β₯€ E) (X Y Z : C) (W : D) (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((f β« g, π W) : (X, W) βΆ (Z, W)) =
F.map ((f, π W) : (X, W) βΆ (Y, W)) β« F.map ((g, π W) : (Y, W) βΆ (Z, W)) := by
rw [β Functor.map_comp, prod_comp, Category.comp_id]
#align category_theory.bifunctor.map_comp_id CategoryTheory.Bifunctor.map_comp_id
@[simp]
| Mathlib/CategoryTheory/Products/Bifunctor.lean | 45 | 48 | theorem diagonal (F : C Γ D β₯€ E) (X X' : C) (f : X βΆ X') (Y Y' : D) (g : Y βΆ Y') :
F.map ((π X, g) : (X, Y) βΆ (X, Y')) β« F.map ((f, π Y') : (X, Y') βΆ (X', Y')) =
F.map ((f, g) : (X, Y) βΆ (X', Y')) := by |
rw [β Functor.map_comp, prod_comp, Category.id_comp, Category.comp_id]
| 1 | 2.718282 | 0 | 0 | 4 | 1 |
import Mathlib.CategoryTheory.Products.Basic
#align_import category_theory.products.bifunctor from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open CategoryTheory
namespace CategoryTheory.Bifunctor
universe vβ vβ vβ uβ uβ uβ
variable {C : Type uβ} {D : Type uβ} {E : Type uβ}
variable [Category.{vβ} C] [Category.{vβ} D] [Category.{vβ} E]
@[simp]
theorem map_id (F : C Γ D β₯€ E) (X : C) (Y : D) :
F.map ((π X, π Y) : (X, Y) βΆ (X, Y)) = π (F.obj (X, Y)) :=
F.map_id (X, Y)
#align category_theory.bifunctor.map_id CategoryTheory.Bifunctor.map_id
@[simp]
theorem map_id_comp (F : C Γ D β₯€ E) (W : C) {X Y Z : D} (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((π W, f β« g) : (W, X) βΆ (W, Z)) =
F.map ((π W, f) : (W, X) βΆ (W, Y)) β« F.map ((π W, g) : (W, Y) βΆ (W, Z)) := by
rw [β Functor.map_comp, prod_comp, Category.comp_id]
#align category_theory.bifunctor.map_id_comp CategoryTheory.Bifunctor.map_id_comp
@[simp]
theorem map_comp_id (F : C Γ D β₯€ E) (X Y Z : C) (W : D) (f : X βΆ Y) (g : Y βΆ Z) :
F.map ((f β« g, π W) : (X, W) βΆ (Z, W)) =
F.map ((f, π W) : (X, W) βΆ (Y, W)) β« F.map ((g, π W) : (Y, W) βΆ (Z, W)) := by
rw [β Functor.map_comp, prod_comp, Category.comp_id]
#align category_theory.bifunctor.map_comp_id CategoryTheory.Bifunctor.map_comp_id
@[simp]
theorem diagonal (F : C Γ D β₯€ E) (X X' : C) (f : X βΆ X') (Y Y' : D) (g : Y βΆ Y') :
F.map ((π X, g) : (X, Y) βΆ (X, Y')) β« F.map ((f, π Y') : (X, Y') βΆ (X', Y')) =
F.map ((f, g) : (X, Y) βΆ (X', Y')) := by
rw [β Functor.map_comp, prod_comp, Category.id_comp, Category.comp_id]
#align category_theory.bifunctor.diagonal CategoryTheory.Bifunctor.diagonal
@[simp]
| Mathlib/CategoryTheory/Products/Bifunctor.lean | 52 | 55 | theorem diagonal' (F : C Γ D β₯€ E) (X X' : C) (f : X βΆ X') (Y Y' : D) (g : Y βΆ Y') :
F.map ((f, π Y) : (X, Y) βΆ (X', Y)) β« F.map ((π X', g) : (X', Y) βΆ (X', Y')) =
F.map ((f, g) : (X, Y) βΆ (X', Y')) := by |
rw [β Functor.map_comp, prod_comp, Category.id_comp, Category.comp_id]
| 1 | 2.718282 | 0 | 0 | 4 | 1 |
import Mathlib.Data.Complex.Basic
import Mathlib.Data.Real.Sqrt
#align_import data.complex.basic from "leanprover-community/mathlib"@"31c24aa72e7b3e5ed97a8412470e904f82b81004"
open Set ComplexConjugate
namespace Complex
namespace AbsTheory
-- We develop enough theory to bundle `abs` into an `AbsoluteValue` before making things public;
-- this is so there's not two versions of it hanging around.
local notation "abs" z => Real.sqrt (normSq z)
private theorem mul_self_abs (z : β) : ((abs z) * abs z) = normSq z :=
Real.mul_self_sqrt (normSq_nonneg _)
private theorem abs_nonneg' (z : β) : 0 β€ abs z :=
Real.sqrt_nonneg _
| Mathlib/Data/Complex/Abs.lean | 34 | 34 | theorem abs_conj (z : β) : (abs conj z) = abs z := by | simp
| 1 | 2.718282 | 0 | 0 | 1 | 2 |
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Algebra.Order.Monoid.WithTop
#align_import algebra.order.sub.with_top from "leanprover-community/mathlib"@"afdb4fa3b32d41106a4a09b371ce549ad7958abd"
variable {Ξ± Ξ² : Type*}
namespace WithTop
section
variable [Sub Ξ±] [Bot Ξ±]
protected def sub : β _ _ : WithTop Ξ±, WithTop Ξ±
| _, β€ => (β₯ : Ξ±)
| β€, (x : Ξ±) => β€
| (x : Ξ±), (y : Ξ±) => (x - y : Ξ±)
#align with_top.sub WithTop.sub
instance : Sub (WithTop Ξ±) :=
β¨WithTop.subβ©
@[simp, norm_cast]
theorem coe_sub {a b : Ξ±} : (β(a - b) : WithTop Ξ±) = βa - βb :=
rfl
#align with_top.coe_sub WithTop.coe_sub
@[simp]
theorem top_sub_coe {a : Ξ±} : (β€ : WithTop Ξ±) - a = β€ :=
rfl
#align with_top.top_sub_coe WithTop.top_sub_coe
@[simp]
| Mathlib/Algebra/Order/Sub/WithTop.lean | 55 | 55 | theorem sub_top {a : WithTop Ξ±} : a - β€ = (β₯ : Ξ±) := by | cases a <;> rfl
| 1 | 2.718282 | 0 | 0 | 1 | 3 |
import Mathlib.CategoryTheory.Preadditive.Injective
import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
import Mathlib.Algebra.Homology.QuasiIso
#align_import category_theory.preadditive.injective_resolution from "leanprover-community/mathlib"@"14b69e9f3c16630440a2cbd46f1ddad0d561dee7"
noncomputable section
universe v u
namespace CategoryTheory
open Limits HomologicalComplex CochainComplex
variable {C : Type u} [Category.{v} C] [HasZeroObject C] [HasZeroMorphisms C]
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure InjectiveResolution (Z : C) where
cocomplex : CochainComplex C β
injective : β n, Injective (cocomplex.X n) := by infer_instance
[hasHomology : β i, cocomplex.HasHomology i]
ΞΉ : (singleβ C).obj Z βΆ cocomplex
quasiIso : QuasiIso ΞΉ := by infer_instance
set_option linter.uppercaseLean3 false in
#align category_theory.InjectiveResolution CategoryTheory.InjectiveResolution
open InjectiveResolution in
attribute [instance] injective hasHomology InjectiveResolution.quasiIso
class HasInjectiveResolution (Z : C) : Prop where
out : Nonempty (InjectiveResolution Z)
#align category_theory.has_injective_resolution CategoryTheory.HasInjectiveResolution
attribute [inherit_doc HasInjectiveResolution] HasInjectiveResolution.out
section
variable (C)
class HasInjectiveResolutions : Prop where
out : β Z : C, HasInjectiveResolution Z
#align category_theory.has_injective_resolutions CategoryTheory.HasInjectiveResolutions
attribute [instance 100] HasInjectiveResolutions.out
end
namespace InjectiveResolution
variable {Z : C} (I : InjectiveResolution Z)
lemma cocomplex_exactAt_succ (n : β) :
I.cocomplex.ExactAt (n + 1) := by
rw [β quasiIsoAt_iff_exactAt I.ΞΉ (n + 1) (exactAt_succ_single_obj _ _)]
infer_instance
lemma exact_succ (n : β):
(ShortComplex.mk _ _ (I.cocomplex.d_comp_d n (n + 1) (n + 2))).Exact :=
(HomologicalComplex.exactAt_iff' _ n (n + 1) (n + 2) (by simp)
(by simp only [CochainComplex.next]; rfl)).1 (I.cocomplex_exactAt_succ n)
@[simp]
theorem ΞΉ_f_succ (n : β) : I.ΞΉ.f (n + 1) = 0 :=
(isZero_single_obj_X _ _ _ _ (by simp)).eq_of_src _ _
set_option linter.uppercaseLean3 false in
#align category_theory.InjectiveResolution.ΞΉ_f_succ CategoryTheory.InjectiveResolution.ΞΉ_f_succ
-- Porting note (#10618): removed @[simp] simp can prove this
@[reassoc]
| Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean | 104 | 106 | theorem ΞΉ_f_zero_comp_complex_d :
I.ΞΉ.f 0 β« I.cocomplex.d 0 1 = 0 := by |
simp
| 1 | 2.718282 | 0 | 0 | 2 | 4 |
import Mathlib.CategoryTheory.Preadditive.Injective
import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
import Mathlib.Algebra.Homology.QuasiIso
#align_import category_theory.preadditive.injective_resolution from "leanprover-community/mathlib"@"14b69e9f3c16630440a2cbd46f1ddad0d561dee7"
noncomputable section
universe v u
namespace CategoryTheory
open Limits HomologicalComplex CochainComplex
variable {C : Type u} [Category.{v} C] [HasZeroObject C] [HasZeroMorphisms C]
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure InjectiveResolution (Z : C) where
cocomplex : CochainComplex C β
injective : β n, Injective (cocomplex.X n) := by infer_instance
[hasHomology : β i, cocomplex.HasHomology i]
ΞΉ : (singleβ C).obj Z βΆ cocomplex
quasiIso : QuasiIso ΞΉ := by infer_instance
set_option linter.uppercaseLean3 false in
#align category_theory.InjectiveResolution CategoryTheory.InjectiveResolution
open InjectiveResolution in
attribute [instance] injective hasHomology InjectiveResolution.quasiIso
class HasInjectiveResolution (Z : C) : Prop where
out : Nonempty (InjectiveResolution Z)
#align category_theory.has_injective_resolution CategoryTheory.HasInjectiveResolution
attribute [inherit_doc HasInjectiveResolution] HasInjectiveResolution.out
section
variable (C)
class HasInjectiveResolutions : Prop where
out : β Z : C, HasInjectiveResolution Z
#align category_theory.has_injective_resolutions CategoryTheory.HasInjectiveResolutions
attribute [instance 100] HasInjectiveResolutions.out
end
namespace InjectiveResolution
variable {Z : C} (I : InjectiveResolution Z)
lemma cocomplex_exactAt_succ (n : β) :
I.cocomplex.ExactAt (n + 1) := by
rw [β quasiIsoAt_iff_exactAt I.ΞΉ (n + 1) (exactAt_succ_single_obj _ _)]
infer_instance
lemma exact_succ (n : β):
(ShortComplex.mk _ _ (I.cocomplex.d_comp_d n (n + 1) (n + 2))).Exact :=
(HomologicalComplex.exactAt_iff' _ n (n + 1) (n + 2) (by simp)
(by simp only [CochainComplex.next]; rfl)).1 (I.cocomplex_exactAt_succ n)
@[simp]
theorem ΞΉ_f_succ (n : β) : I.ΞΉ.f (n + 1) = 0 :=
(isZero_single_obj_X _ _ _ _ (by simp)).eq_of_src _ _
set_option linter.uppercaseLean3 false in
#align category_theory.InjectiveResolution.ΞΉ_f_succ CategoryTheory.InjectiveResolution.ΞΉ_f_succ
-- Porting note (#10618): removed @[simp] simp can prove this
@[reassoc]
theorem ΞΉ_f_zero_comp_complex_d :
I.ΞΉ.f 0 β« I.cocomplex.d 0 1 = 0 := by
simp
set_option linter.uppercaseLean3 false in
#align category_theory.InjectiveResolution.ΞΉ_f_zero_comp_complex_d CategoryTheory.InjectiveResolution.ΞΉ_f_zero_comp_complex_d
-- Porting note (#10618): removed @[simp] simp can prove this
| Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean | 111 | 113 | theorem complex_d_comp (n : β) :
I.cocomplex.d n (n + 1) β« I.cocomplex.d (n + 1) (n + 2) = 0 := by |
simp
| 1 | 2.718282 | 0 | 0 | 2 | 4 |
import Mathlib.Data.Set.Lattice
import Mathlib.Order.Hom.Lattice
#align_import order.hom.complete_lattice from "leanprover-community/mathlib"@"9d684a893c52e1d6692a504a118bfccbae04feeb"
open Function OrderDual Set
variable {F Ξ± Ξ² Ξ³ Ξ΄ : Type*} {ΞΉ : Sort*} {ΞΊ : ΞΉ β Sort*}
-- Porting note: mathport made this & sInfHom into "SupHomCat" and "InfHomCat".
structure sSupHom (Ξ± Ξ² : Type*) [SupSet Ξ±] [SupSet Ξ²] where
toFun : Ξ± β Ξ²
map_sSup' (s : Set Ξ±) : toFun (sSup s) = sSup (toFun '' s)
#align Sup_hom sSupHom
structure sInfHom (Ξ± Ξ² : Type*) [InfSet Ξ±] [InfSet Ξ²] where
toFun : Ξ± β Ξ²
map_sInf' (s : Set Ξ±) : toFun (sInf s) = sInf (toFun '' s)
#align Inf_hom sInfHom
structure FrameHom (Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²] extends
InfTopHom Ξ± Ξ² where
map_sSup' (s : Set Ξ±) : toFun (sSup s) = sSup (toFun '' s)
#align frame_hom FrameHom
structure CompleteLatticeHom (Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²] extends
sInfHom Ξ± Ξ² where
map_sSup' (s : Set Ξ±) : toFun (sSup s) = sSup (toFun '' s)
#align complete_lattice_hom CompleteLatticeHom
section
-- Porting note: mathport made this & InfHomClass into "SupHomClassCat" and "InfHomClassCat".
class sSupHomClass (F Ξ± Ξ² : Type*) [SupSet Ξ±] [SupSet Ξ²] [FunLike F Ξ± Ξ²] : Prop where
map_sSup (f : F) (s : Set Ξ±) : f (sSup s) = sSup (f '' s)
#align Sup_hom_class sSupHomClass
class sInfHomClass (F Ξ± Ξ² : Type*) [InfSet Ξ±] [InfSet Ξ²] [FunLike F Ξ± Ξ²] : Prop where
map_sInf (f : F) (s : Set Ξ±) : f (sInf s) = sInf (f '' s)
#align Inf_hom_class sInfHomClass
class FrameHomClass (F Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²] [FunLike F Ξ± Ξ²]
extends InfTopHomClass F Ξ± Ξ² : Prop where
map_sSup (f : F) (s : Set Ξ±) : f (sSup s) = sSup (f '' s)
#align frame_hom_class FrameHomClass
class CompleteLatticeHomClass (F Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²]
[FunLike F Ξ± Ξ²] extends sInfHomClass F Ξ± Ξ² : Prop where
map_sSup (f : F) (s : Set Ξ±) : f (sSup s) = sSup (f '' s)
#align complete_lattice_hom_class CompleteLatticeHomClass
end
export sSupHomClass (map_sSup)
export sInfHomClass (map_sInf)
attribute [simp] map_sSup map_sInf
section Hom
variable [FunLike F Ξ± Ξ²]
@[simp] theorem map_iSup [SupSet Ξ±] [SupSet Ξ²] [sSupHomClass F Ξ± Ξ²] (f : F) (g : ΞΉ β Ξ±) :
f (β¨ i, g i) = β¨ i, f (g i) := by simp [iSup, β Set.range_comp, Function.comp]
#align map_supr map_iSup
| Mathlib/Order/Hom/CompleteLattice.lean | 134 | 135 | theorem map_iSupβ [SupSet Ξ±] [SupSet Ξ²] [sSupHomClass F Ξ± Ξ²] (f : F) (g : β i, ΞΊ i β Ξ±) :
f (β¨ (i) (j), g i j) = β¨ (i) (j), f (g i j) := by | simp_rw [map_iSup]
| 1 | 2.718282 | 0 | 0 | 2 | 5 |
import Mathlib.Data.Set.Lattice
import Mathlib.Order.Hom.Lattice
#align_import order.hom.complete_lattice from "leanprover-community/mathlib"@"9d684a893c52e1d6692a504a118bfccbae04feeb"
open Function OrderDual Set
variable {F Ξ± Ξ² Ξ³ Ξ΄ : Type*} {ΞΉ : Sort*} {ΞΊ : ΞΉ β Sort*}
-- Porting note: mathport made this & sInfHom into "SupHomCat" and "InfHomCat".
structure sSupHom (Ξ± Ξ² : Type*) [SupSet Ξ±] [SupSet Ξ²] where
toFun : Ξ± β Ξ²
map_sSup' (s : Set Ξ±) : toFun (sSup s) = sSup (toFun '' s)
#align Sup_hom sSupHom
structure sInfHom (Ξ± Ξ² : Type*) [InfSet Ξ±] [InfSet Ξ²] where
toFun : Ξ± β Ξ²
map_sInf' (s : Set Ξ±) : toFun (sInf s) = sInf (toFun '' s)
#align Inf_hom sInfHom
structure FrameHom (Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²] extends
InfTopHom Ξ± Ξ² where
map_sSup' (s : Set Ξ±) : toFun (sSup s) = sSup (toFun '' s)
#align frame_hom FrameHom
structure CompleteLatticeHom (Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²] extends
sInfHom Ξ± Ξ² where
map_sSup' (s : Set Ξ±) : toFun (sSup s) = sSup (toFun '' s)
#align complete_lattice_hom CompleteLatticeHom
section
-- Porting note: mathport made this & InfHomClass into "SupHomClassCat" and "InfHomClassCat".
class sSupHomClass (F Ξ± Ξ² : Type*) [SupSet Ξ±] [SupSet Ξ²] [FunLike F Ξ± Ξ²] : Prop where
map_sSup (f : F) (s : Set Ξ±) : f (sSup s) = sSup (f '' s)
#align Sup_hom_class sSupHomClass
class sInfHomClass (F Ξ± Ξ² : Type*) [InfSet Ξ±] [InfSet Ξ²] [FunLike F Ξ± Ξ²] : Prop where
map_sInf (f : F) (s : Set Ξ±) : f (sInf s) = sInf (f '' s)
#align Inf_hom_class sInfHomClass
class FrameHomClass (F Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²] [FunLike F Ξ± Ξ²]
extends InfTopHomClass F Ξ± Ξ² : Prop where
map_sSup (f : F) (s : Set Ξ±) : f (sSup s) = sSup (f '' s)
#align frame_hom_class FrameHomClass
class CompleteLatticeHomClass (F Ξ± Ξ² : Type*) [CompleteLattice Ξ±] [CompleteLattice Ξ²]
[FunLike F Ξ± Ξ²] extends sInfHomClass F Ξ± Ξ² : Prop where
map_sSup (f : F) (s : Set Ξ±) : f (sSup s) = sSup (f '' s)
#align complete_lattice_hom_class CompleteLatticeHomClass
end
export sSupHomClass (map_sSup)
export sInfHomClass (map_sInf)
attribute [simp] map_sSup map_sInf
section Hom
variable [FunLike F Ξ± Ξ²]
@[simp] theorem map_iSup [SupSet Ξ±] [SupSet Ξ²] [sSupHomClass F Ξ± Ξ²] (f : F) (g : ΞΉ β Ξ±) :
f (β¨ i, g i) = β¨ i, f (g i) := by simp [iSup, β Set.range_comp, Function.comp]
#align map_supr map_iSup
theorem map_iSupβ [SupSet Ξ±] [SupSet Ξ²] [sSupHomClass F Ξ± Ξ²] (f : F) (g : β i, ΞΊ i β Ξ±) :
f (β¨ (i) (j), g i j) = β¨ (i) (j), f (g i j) := by simp_rw [map_iSup]
#align map_suprβ map_iSupβ
@[simp] theorem map_iInf [InfSet Ξ±] [InfSet Ξ²] [sInfHomClass F Ξ± Ξ²] (f : F) (g : ΞΉ β Ξ±) :
f (β¨
i, g i) = β¨
i, f (g i) := by simp [iInf, β Set.range_comp, Function.comp]
#align map_infi map_iInf
| Mathlib/Order/Hom/CompleteLattice.lean | 142 | 143 | theorem map_iInfβ [InfSet Ξ±] [InfSet Ξ²] [sInfHomClass F Ξ± Ξ²] (f : F) (g : β i, ΞΊ i β Ξ±) :
f (β¨
(i) (j), g i j) = β¨
(i) (j), f (g i j) := by | simp_rw [map_iInf]
| 1 | 2.718282 | 0 | 0 | 2 | 5 |
import Mathlib.Topology.Metrizable.Basic
import Mathlib.Topology.Algebra.GroupWithZero
import Mathlib.Topology.Instances.Real
def preCantorSet : β β Set β
| 0 => Set.Icc 0 1
| n + 1 => (Β· / 3) '' preCantorSet n βͺ (fun x β¦ (2 + x) / 3) '' preCantorSet n
@[simp] lemma preCantorSet_zero : preCantorSet 0 = Set.Icc 0 1 := rfl
@[simp] lemma preCantorSet_succ (n : β) :
preCantorSet (n + 1) = (Β· / 3) '' preCantorSet n βͺ (fun x β¦ (2 + x) / 3) '' preCantorSet n :=
rfl
def cantorSet : Set β := β n, preCantorSet n
lemma quarters_mem_preCantorSet (n : β) : 1/4 β preCantorSet n β§ 3/4 β preCantorSet n := by
induction n with
| zero =>
simp only [preCantorSet_zero, inv_nonneg]
refine β¨β¨ ?_, ?_β©, ?_, ?_β© <;> norm_num
| succ n ih =>
apply And.intro
Β· -- goal: 1 / 4 β preCantorSet (n + 1)
-- follows by the inductive hyphothesis, since 3 / 4 β preCantorSet n
exact Or.inl β¨3 / 4, ih.2, by norm_numβ©
Β· -- goal: 3 / 4 β preCantorSet (n + 1)
-- follows by the inductive hyphothesis, since 1 / 4 β preCantorSet n
exact Or.inr β¨1 / 4, ih.1, by norm_numβ©
lemma quarter_mem_preCantorSet (n : β) : 1/4 β preCantorSet n := (quarters_mem_preCantorSet n).1
theorem quarter_mem_cantorSet : 1/4 β cantorSet :=
Set.mem_iInter.mpr quarter_mem_preCantorSet
lemma zero_mem_preCantorSet (n : β) : 0 β preCantorSet n := by
induction n with
| zero =>
simp [preCantorSet]
| succ n ih =>
exact Or.inl β¨0, ih, by simp only [zero_div]β©
| Mathlib/Topology/Instances/CantorSet.lean | 75 | 75 | theorem zero_mem_cantorSet : 0 β cantorSet := by | simp [cantorSet, zero_mem_preCantorSet]
| 1 | 2.718282 | 0 | 0 | 1 | 6 |
import Mathlib.FieldTheory.RatFunc.Basic
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
noncomputable section
universe u
variable {K : Type u}
namespace RatFunc
section Eval
open scoped Classical
open scoped nonZeroDivisors Polynomial
open RatFunc
section Domain
variable [CommRing K] [IsDomain K]
def C : K β+* RatFunc K := algebraMap _ _
set_option linter.uppercaseLean3 false in #align ratfunc.C RatFunc.C
@[simp]
theorem algebraMap_eq_C : algebraMap K (RatFunc K) = C :=
rfl
set_option linter.uppercaseLean3 false in #align ratfunc.algebra_map_eq_C RatFunc.algebraMap_eq_C
@[simp]
theorem algebraMap_C (a : K) : algebraMap K[X] (RatFunc K) (Polynomial.C a) = C a :=
rfl
set_option linter.uppercaseLean3 false in #align ratfunc.algebra_map_C RatFunc.algebraMap_C
@[simp]
theorem algebraMap_comp_C : (algebraMap K[X] (RatFunc K)).comp Polynomial.C = C :=
rfl
set_option linter.uppercaseLean3 false in #align ratfunc.algebra_map_comp_C RatFunc.algebraMap_comp_C
| Mathlib/FieldTheory/RatFunc/AsPolynomial.lean | 61 | 62 | theorem smul_eq_C_mul (r : K) (x : RatFunc K) : r β’ x = C r * x := by |
rw [Algebra.smul_def, algebraMap_eq_C]
| 1 | 2.718282 | 0 | 0 | 1 | 7 |
import Mathlib.Mathport.Rename
import Mathlib.Tactic.Lemma
import Mathlib.Tactic.TypeStar
#align_import data.option.defs from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
namespace Option
#align option.lift_or_get Option.liftOrGet
protected def traverse.{u, v}
{F : Type u β Type v} [Applicative F] {Ξ± : Type*} {Ξ² : Type u} (f : Ξ± β F Ξ²) :
Option Ξ± β F (Option Ξ²)
| none => pure none
| some x => some <$> f x
#align option.traverse Option.traverse
#align option.maybe Option.sequence
#align option.mmap Option.mapM
#align option.melim Option.elimM
#align option.mget_or_else Option.getDM
variable {Ξ± : Type*} {Ξ² : Type*}
-- Porting note: Would need to add the attribute directly in `Init.Prelude`.
-- attribute [inline] Option.isSome Option.isNone
protected def elim' (b : Ξ²) (f : Ξ± β Ξ²) : Option Ξ± β Ξ²
| some a => f a
| none => b
#align option.elim Option.elim'
@[simp]
theorem elim'_none (b : Ξ²) (f : Ξ± β Ξ²) : Option.elim' b f none = b := rfl
@[simp]
theorem elim'_some {a : Ξ±} (b : Ξ²) (f : Ξ± β Ξ²) : Option.elim' b f (some a) = f a := rfl
-- Porting note: this lemma was introduced because it is necessary
-- in `CategoryTheory.Category.PartialFun`
lemma elim'_eq_elim {Ξ± Ξ² : Type*} (b : Ξ²) (f : Ξ± β Ξ²) (a : Option Ξ±) :
Option.elim' b f a = Option.elim a b f := by
cases a <;> rfl
| Mathlib/Data/Option/Defs.lean | 61 | 61 | theorem mem_some_iff {Ξ± : Type*} {a b : Ξ±} : a β some b β b = a := by | simp
| 1 | 2.718282 | 0 | 0 | 2 | 8 |
import Mathlib.Mathport.Rename
import Mathlib.Tactic.Lemma
import Mathlib.Tactic.TypeStar
#align_import data.option.defs from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
namespace Option
#align option.lift_or_get Option.liftOrGet
protected def traverse.{u, v}
{F : Type u β Type v} [Applicative F] {Ξ± : Type*} {Ξ² : Type u} (f : Ξ± β F Ξ²) :
Option Ξ± β F (Option Ξ²)
| none => pure none
| some x => some <$> f x
#align option.traverse Option.traverse
#align option.maybe Option.sequence
#align option.mmap Option.mapM
#align option.melim Option.elimM
#align option.mget_or_else Option.getDM
variable {Ξ± : Type*} {Ξ² : Type*}
-- Porting note: Would need to add the attribute directly in `Init.Prelude`.
-- attribute [inline] Option.isSome Option.isNone
protected def elim' (b : Ξ²) (f : Ξ± β Ξ²) : Option Ξ± β Ξ²
| some a => f a
| none => b
#align option.elim Option.elim'
@[simp]
theorem elim'_none (b : Ξ²) (f : Ξ± β Ξ²) : Option.elim' b f none = b := rfl
@[simp]
theorem elim'_some {a : Ξ±} (b : Ξ²) (f : Ξ± β Ξ²) : Option.elim' b f (some a) = f a := rfl
-- Porting note: this lemma was introduced because it is necessary
-- in `CategoryTheory.Category.PartialFun`
lemma elim'_eq_elim {Ξ± Ξ² : Type*} (b : Ξ²) (f : Ξ± β Ξ²) (a : Option Ξ±) :
Option.elim' b f a = Option.elim a b f := by
cases a <;> rfl
theorem mem_some_iff {Ξ± : Type*} {a b : Ξ±} : a β some b β b = a := by simp
#align option.mem_some_iff Option.mem_some_iff
@[inline]
def decidableEqNone {o : Option Ξ±} : Decidable (o = none) :=
decidable_of_decidable_of_iff isNone_iff_eq_none
#align option.decidable_eq_none Option.decidableEqNone
instance decidableForallMem {p : Ξ± β Prop} [DecidablePred p] :
β o : Option Ξ±, Decidable (β a β o, p a)
| none => isTrue (by simp [false_imp_iff])
| some a =>
if h : p a then isTrue fun o e β¦ some_inj.1 e βΈ h
else isFalse <| mt (fun H β¦ H _ rfl) h
instance decidableExistsMem {p : Ξ± β Prop} [DecidablePred p] :
β o : Option Ξ±, Decidable (β a β o, p a)
| none => isFalse fun β¨a, β¨h, _β©β© β¦ by cases h
| some a => if h : p a then isTrue <| β¨_, rfl, hβ© else isFalse fun β¨_, β¨rfl, hnβ©β© β¦ h hn
abbrev iget [Inhabited Ξ±] : Option Ξ± β Ξ±
| some x => x
| none => default
#align option.iget Option.iget
theorem iget_some [Inhabited Ξ±] {a : Ξ±} : (some a).iget = a :=
rfl
#align option.iget_some Option.iget_some
@[simp]
| Mathlib/Data/Option/Defs.lean | 96 | 97 | theorem mem_toList {a : Ξ±} {o : Option Ξ±} : a β toList o β a β o := by |
cases o <;> simp [toList, eq_comm]
| 1 | 2.718282 | 0 | 0 | 2 | 8 |
import Mathlib.Algebra.Ring.Defs
import Mathlib.Data.Rat.Init
#align_import algebra.field.defs from "leanprover-community/mathlib"@"2651125b48fc5c170ab1111afd0817c903b1fc6c"
-- `NeZero` should not be needed in the basic algebraic hierarchy.
assert_not_exists NeZero
-- Check that we have not imported `Mathlib.Tactic.Common` yet.
assert_not_exists Mathlib.Tactic.LibrarySearch.librarySearch
assert_not_exists MonoidHom
open Function Set
universe u
variable {Ξ± Ξ² K : Type*}
def NNRat.castRec [NatCast K] [Div K] (q : ββ₯0) : K := q.num / q.den
def Rat.castRec [NatCast K] [IntCast K] [Div K] (q : β) : K := q.num / q.den
#align rat.cast_rec Rat.castRec
#noalign qsmul_rec
class DivisionSemiring (Ξ± : Type*) extends Semiring Ξ±, GroupWithZero Ξ±, NNRatCast Ξ± where
protected nnratCast := NNRat.castRec
protected nnratCast_def (q : ββ₯0) : (NNRat.cast q : Ξ±) = q.num / q.den := by intros; rfl
protected nnqsmul : ββ₯0 β Ξ± β Ξ±
protected nnqsmul_def (q : ββ₯0) (a : Ξ±) : nnqsmul q a = NNRat.cast q * a := by intros; rfl
#align division_semiring DivisionSemiring
class DivisionRing (Ξ± : Type*)
extends Ring Ξ±, DivInvMonoid Ξ±, Nontrivial Ξ±, NNRatCast Ξ±, RatCast Ξ± where
protected mul_inv_cancel : β (a : Ξ±), a β 0 β a * aβ»ΒΉ = 1
protected inv_zero : (0 : Ξ±)β»ΒΉ = 0
protected nnratCast := NNRat.castRec
protected nnratCast_def (q : ββ₯0) : (NNRat.cast q : Ξ±) = q.num / q.den := by intros; rfl
protected nnqsmul : ββ₯0 β Ξ± β Ξ±
protected nnqsmul_def (q : ββ₯0) (a : Ξ±) : nnqsmul q a = NNRat.cast q * a := by intros; rfl
protected ratCast := Rat.castRec
protected ratCast_def (q : β) : (Rat.cast q : Ξ±) = q.num / q.den := by intros; rfl
protected qsmul : β β Ξ± β Ξ±
protected qsmul_def (a : β) (x : Ξ±) : qsmul a x = Rat.cast a * x := by intros; rfl
#align division_ring DivisionRing
#align division_ring.rat_cast_mk DivisionRing.ratCast_def
-- see Note [lower instance priority]
instance (priority := 100) DivisionRing.toDivisionSemiring [DivisionRing Ξ±] : DivisionSemiring Ξ± :=
{ βΉDivisionRing Ξ±βΊ with }
#align division_ring.to_division_semiring DivisionRing.toDivisionSemiring
class Semifield (Ξ± : Type*) extends CommSemiring Ξ±, DivisionSemiring Ξ±, CommGroupWithZero Ξ±
#align semifield Semifield
class Field (K : Type u) extends CommRing K, DivisionRing K
#align field Field
-- see Note [lower instance priority]
instance (priority := 100) Field.toSemifield [Field Ξ±] : Semifield Ξ± := { βΉField Ξ±βΊ with }
#align field.to_semifield Field.toSemifield
namespace Rat
variable [DivisionRing K] {a b : K}
lemma cast_def (q : β) : (q : K) = q.num / q.den := DivisionRing.ratCast_def _
#align rat.cast_def Rat.cast_def
lemma cast_mk' (a b h1 h2) : ((β¨a, b, h1, h2β© : β) : K) = a / b := cast_def _
#align rat.cast_mk' Rat.cast_mk'
instance (priority := 100) smulDivisionRing : SMul β K :=
β¨DivisionRing.qsmulβ©
#align rat.smul_division_ring Rat.smulDivisionRing
theorem smul_def (a : β) (x : K) : a β’ x = βa * x := DivisionRing.qsmul_def a x
#align rat.smul_def Rat.smul_def
@[simp]
| Mathlib/Algebra/Field/Defs.lean | 226 | 227 | theorem smul_one_eq_cast (A : Type*) [DivisionRing A] (m : β) : m β’ (1 : A) = βm := by |
rw [Rat.smul_def, mul_one]
| 1 | 2.718282 | 0 | 0 | 1 | 9 |
import Mathlib.CategoryTheory.Limits.HasLimits
import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
#align_import category_theory.limits.shapes.wide_equalizers from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
namespace CategoryTheory.Limits
open CategoryTheory
universe w v u uβ
variable {J : Type w}
inductive WalkingParallelFamily (J : Type w) : Type w
| zero : WalkingParallelFamily J
| one : WalkingParallelFamily J
#align category_theory.limits.walking_parallel_family CategoryTheory.Limits.WalkingParallelFamily
open WalkingParallelFamily
instance : DecidableEq (WalkingParallelFamily J)
| zero, zero => isTrue rfl
| zero, one => isFalse fun t => WalkingParallelFamily.noConfusion t
| one, zero => isFalse fun t => WalkingParallelFamily.noConfusion t
| one, one => isTrue rfl
instance : Inhabited (WalkingParallelFamily J) :=
β¨zeroβ©
inductive WalkingParallelFamily.Hom (J : Type w) :
WalkingParallelFamily J β WalkingParallelFamily J β Type w
| id : β X : WalkingParallelFamily.{w} J, WalkingParallelFamily.Hom J X X
| line : J β WalkingParallelFamily.Hom J zero one
deriving DecidableEq
#align
category_theory.limits.walking_parallel_family.hom
CategoryTheory.Limits.WalkingParallelFamily.Hom
instance (J : Type v) : Inhabited (WalkingParallelFamily.Hom J zero zero) where default := Hom.id _
open WalkingParallelFamily.Hom
def WalkingParallelFamily.Hom.comp :
β {X Y Z : WalkingParallelFamily J} (_ : WalkingParallelFamily.Hom J X Y)
(_ : WalkingParallelFamily.Hom J Y Z), WalkingParallelFamily.Hom J X Z
| _, _, _, id _, h => h
| _, _, _, line j, id one => line j
#align
category_theory.limits.walking_parallel_family.hom.comp
CategoryTheory.Limits.WalkingParallelFamily.Hom.comp
-- attribute [local tidy] tactic.case_bash Porting note: no tidy, no local
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
Hom := WalkingParallelFamily.Hom J
id := WalkingParallelFamily.Hom.id
comp := WalkingParallelFamily.Hom.comp
assoc f g h := by cases f <;> cases g <;> cases h <;> aesop_cat
comp_id f := by cases f <;> aesop_cat
#align
category_theory.limits.walking_parallel_family.category
CategoryTheory.Limits.WalkingParallelFamily.category
@[simp]
theorem WalkingParallelFamily.hom_id (X : WalkingParallelFamily J) :
WalkingParallelFamily.Hom.id X = π X :=
rfl
#align
category_theory.limits.walking_parallel_family.hom_id
CategoryTheory.Limits.WalkingParallelFamily.hom_id
variable {C : Type u} [Category.{v} C]
variable {X Y : C} (f : J β (X βΆ Y))
def parallelFamily : WalkingParallelFamily J β₯€ C where
obj x := WalkingParallelFamily.casesOn x X Y
map {x y} h :=
match x, y, h with
| _, _, Hom.id _ => π _
| _, _, line j => f j
map_comp := by
rintro _ _ _ β¨β© β¨β© <;>
Β· aesop_cat
#align category_theory.limits.parallel_family CategoryTheory.Limits.parallelFamily
@[simp]
theorem parallelFamily_obj_zero : (parallelFamily f).obj zero = X :=
rfl
#align category_theory.limits.parallel_family_obj_zero CategoryTheory.Limits.parallelFamily_obj_zero
@[simp]
theorem parallelFamily_obj_one : (parallelFamily f).obj one = Y :=
rfl
#align category_theory.limits.parallel_family_obj_one CategoryTheory.Limits.parallelFamily_obj_one
@[simp]
theorem parallelFamily_map_left {j : J} : (parallelFamily f).map (line j) = f j :=
rfl
#align
category_theory.limits.parallel_family_map_left
CategoryTheory.Limits.parallelFamily_map_left
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J β₯€ C) :
F β
parallelFamily fun j => F.map (line j) :=
NatIso.ofComponents (fun j => eqToIso <| by cases j <;> aesop_cat) <| by
rintro _ _ (_|_) <;> aesop_cat
#align
category_theory.limits.diagram_iso_parallel_family
CategoryTheory.Limits.diagramIsoParallelFamily
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
WalkingParallelFamily.{w} (ULift Bool) β WalkingParallelPair where
functor :=
parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
rintro _ _ (_|β¨_|_β©) <;> aesop_cat)
counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
rintro _ _ (_|_|_) <;> aesop_cat)
functor_unitIso_comp := by rintro (_|_) <;> aesop_cat
#align
category_theory.limits.walking_parallel_family_equiv_walking_parallel_pair
CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair
abbrev Trident :=
Cone (parallelFamily f)
#align category_theory.limits.trident CategoryTheory.Limits.Trident
abbrev Cotrident :=
Cocone (parallelFamily f)
#align category_theory.limits.cotrident CategoryTheory.Limits.Cotrident
variable {f}
abbrev Trident.ΞΉ (t : Trident f) :=
t.Ο.app zero
#align category_theory.limits.trident.ΞΉ CategoryTheory.Limits.Trident.ΞΉ
abbrev Cotrident.Ο (t : Cotrident f) :=
t.ΞΉ.app one
#align category_theory.limits.cotrident.Ο CategoryTheory.Limits.Cotrident.Ο
@[simp]
theorem Trident.ΞΉ_eq_app_zero (t : Trident f) : t.ΞΉ = t.Ο.app zero :=
rfl
#align category_theory.limits.trident.ΞΉ_eq_app_zero CategoryTheory.Limits.Trident.ΞΉ_eq_app_zero
@[simp]
theorem Cotrident.Ο_eq_app_one (t : Cotrident f) : t.Ο = t.ΞΉ.app one :=
rfl
#align category_theory.limits.cotrident.Ο_eq_app_one CategoryTheory.Limits.Cotrident.Ο_eq_app_one
@[reassoc (attr := simp)]
| Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean | 218 | 219 | theorem Trident.app_zero (s : Trident f) (j : J) : s.Ο.app zero β« f j = s.Ο.app one := by |
rw [β s.w (line j), parallelFamily_map_left]
| 1 | 2.718282 | 0 | 0 | 2 | 10 |
import Mathlib.CategoryTheory.Limits.HasLimits
import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
#align_import category_theory.limits.shapes.wide_equalizers from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
namespace CategoryTheory.Limits
open CategoryTheory
universe w v u uβ
variable {J : Type w}
inductive WalkingParallelFamily (J : Type w) : Type w
| zero : WalkingParallelFamily J
| one : WalkingParallelFamily J
#align category_theory.limits.walking_parallel_family CategoryTheory.Limits.WalkingParallelFamily
open WalkingParallelFamily
instance : DecidableEq (WalkingParallelFamily J)
| zero, zero => isTrue rfl
| zero, one => isFalse fun t => WalkingParallelFamily.noConfusion t
| one, zero => isFalse fun t => WalkingParallelFamily.noConfusion t
| one, one => isTrue rfl
instance : Inhabited (WalkingParallelFamily J) :=
β¨zeroβ©
inductive WalkingParallelFamily.Hom (J : Type w) :
WalkingParallelFamily J β WalkingParallelFamily J β Type w
| id : β X : WalkingParallelFamily.{w} J, WalkingParallelFamily.Hom J X X
| line : J β WalkingParallelFamily.Hom J zero one
deriving DecidableEq
#align
category_theory.limits.walking_parallel_family.hom
CategoryTheory.Limits.WalkingParallelFamily.Hom
instance (J : Type v) : Inhabited (WalkingParallelFamily.Hom J zero zero) where default := Hom.id _
open WalkingParallelFamily.Hom
def WalkingParallelFamily.Hom.comp :
β {X Y Z : WalkingParallelFamily J} (_ : WalkingParallelFamily.Hom J X Y)
(_ : WalkingParallelFamily.Hom J Y Z), WalkingParallelFamily.Hom J X Z
| _, _, _, id _, h => h
| _, _, _, line j, id one => line j
#align
category_theory.limits.walking_parallel_family.hom.comp
CategoryTheory.Limits.WalkingParallelFamily.Hom.comp
-- attribute [local tidy] tactic.case_bash Porting note: no tidy, no local
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
Hom := WalkingParallelFamily.Hom J
id := WalkingParallelFamily.Hom.id
comp := WalkingParallelFamily.Hom.comp
assoc f g h := by cases f <;> cases g <;> cases h <;> aesop_cat
comp_id f := by cases f <;> aesop_cat
#align
category_theory.limits.walking_parallel_family.category
CategoryTheory.Limits.WalkingParallelFamily.category
@[simp]
theorem WalkingParallelFamily.hom_id (X : WalkingParallelFamily J) :
WalkingParallelFamily.Hom.id X = π X :=
rfl
#align
category_theory.limits.walking_parallel_family.hom_id
CategoryTheory.Limits.WalkingParallelFamily.hom_id
variable {C : Type u} [Category.{v} C]
variable {X Y : C} (f : J β (X βΆ Y))
def parallelFamily : WalkingParallelFamily J β₯€ C where
obj x := WalkingParallelFamily.casesOn x X Y
map {x y} h :=
match x, y, h with
| _, _, Hom.id _ => π _
| _, _, line j => f j
map_comp := by
rintro _ _ _ β¨β© β¨β© <;>
Β· aesop_cat
#align category_theory.limits.parallel_family CategoryTheory.Limits.parallelFamily
@[simp]
theorem parallelFamily_obj_zero : (parallelFamily f).obj zero = X :=
rfl
#align category_theory.limits.parallel_family_obj_zero CategoryTheory.Limits.parallelFamily_obj_zero
@[simp]
theorem parallelFamily_obj_one : (parallelFamily f).obj one = Y :=
rfl
#align category_theory.limits.parallel_family_obj_one CategoryTheory.Limits.parallelFamily_obj_one
@[simp]
theorem parallelFamily_map_left {j : J} : (parallelFamily f).map (line j) = f j :=
rfl
#align
category_theory.limits.parallel_family_map_left
CategoryTheory.Limits.parallelFamily_map_left
@[simps!]
def diagramIsoParallelFamily (F : WalkingParallelFamily J β₯€ C) :
F β
parallelFamily fun j => F.map (line j) :=
NatIso.ofComponents (fun j => eqToIso <| by cases j <;> aesop_cat) <| by
rintro _ _ (_|_) <;> aesop_cat
#align
category_theory.limits.diagram_iso_parallel_family
CategoryTheory.Limits.diagramIsoParallelFamily
@[simps!]
def walkingParallelFamilyEquivWalkingParallelPair :
WalkingParallelFamily.{w} (ULift Bool) β WalkingParallelPair where
functor :=
parallelFamily fun p => cond p.down WalkingParallelPairHom.left WalkingParallelPairHom.right
inverse := parallelPair (line (ULift.up true)) (line (ULift.up false))
unitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
rintro _ _ (_|β¨_|_β©) <;> aesop_cat)
counitIso := NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by
rintro _ _ (_|_|_) <;> aesop_cat)
functor_unitIso_comp := by rintro (_|_) <;> aesop_cat
#align
category_theory.limits.walking_parallel_family_equiv_walking_parallel_pair
CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair
abbrev Trident :=
Cone (parallelFamily f)
#align category_theory.limits.trident CategoryTheory.Limits.Trident
abbrev Cotrident :=
Cocone (parallelFamily f)
#align category_theory.limits.cotrident CategoryTheory.Limits.Cotrident
variable {f}
abbrev Trident.ΞΉ (t : Trident f) :=
t.Ο.app zero
#align category_theory.limits.trident.ΞΉ CategoryTheory.Limits.Trident.ΞΉ
abbrev Cotrident.Ο (t : Cotrident f) :=
t.ΞΉ.app one
#align category_theory.limits.cotrident.Ο CategoryTheory.Limits.Cotrident.Ο
@[simp]
theorem Trident.ΞΉ_eq_app_zero (t : Trident f) : t.ΞΉ = t.Ο.app zero :=
rfl
#align category_theory.limits.trident.ΞΉ_eq_app_zero CategoryTheory.Limits.Trident.ΞΉ_eq_app_zero
@[simp]
theorem Cotrident.Ο_eq_app_one (t : Cotrident f) : t.Ο = t.ΞΉ.app one :=
rfl
#align category_theory.limits.cotrident.Ο_eq_app_one CategoryTheory.Limits.Cotrident.Ο_eq_app_one
@[reassoc (attr := simp)]
theorem Trident.app_zero (s : Trident f) (j : J) : s.Ο.app zero β« f j = s.Ο.app one := by
rw [β s.w (line j), parallelFamily_map_left]
#align category_theory.limits.trident.app_zero CategoryTheory.Limits.Trident.app_zero
@[reassoc (attr := simp)]
| Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean | 223 | 224 | theorem Cotrident.app_one (s : Cotrident f) (j : J) : f j β« s.ΞΉ.app one = s.ΞΉ.app zero := by |
rw [β s.w (line j), parallelFamily_map_left]
| 1 | 2.718282 | 0 | 0 | 2 | 10 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
| Mathlib/Order/Interval/Finset/Basic.lean | 57 | 58 | theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by |
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
| Mathlib/Order/Interval/Finset/Basic.lean | 62 | 63 | theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by |
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
| Mathlib/Order/Interval/Finset/Basic.lean | 67 | 68 | theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by |
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 73 | 74 | theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by |
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 78 | 79 | theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by |
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 83 | 84 | theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by |
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
#align finset.Ico_eq_empty_iff Finset.Ico_eq_empty_iff
@[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 88 | 89 | theorem Ioc_eq_empty_iff : Ioc a b = β
β Β¬a < b := by |
rw [β coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
#align finset.Ico_eq_empty_iff Finset.Ico_eq_empty_iff
@[simp]
theorem Ioc_eq_empty_iff : Ioc a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
#align finset.Ioc_eq_empty_iff Finset.Ioc_eq_empty_iff
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 94 | 95 | theorem Ioo_eq_empty_iff [DenselyOrdered Ξ±] : Ioo a b = β
β Β¬a < b := by |
rw [β coe_eq_empty, coe_Ioo, Set.Ioo_eq_empty_iff]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
#align finset.Ico_eq_empty_iff Finset.Ico_eq_empty_iff
@[simp]
theorem Ioc_eq_empty_iff : Ioc a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
#align finset.Ioc_eq_empty_iff Finset.Ioc_eq_empty_iff
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem Ioo_eq_empty_iff [DenselyOrdered Ξ±] : Ioo a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioo, Set.Ioo_eq_empty_iff]
#align finset.Ioo_eq_empty_iff Finset.Ioo_eq_empty_iff
alias β¨_, Icc_eq_emptyβ© := Icc_eq_empty_iff
#align finset.Icc_eq_empty Finset.Icc_eq_empty
alias β¨_, Ico_eq_emptyβ© := Ico_eq_empty_iff
#align finset.Ico_eq_empty Finset.Ico_eq_empty
alias β¨_, Ioc_eq_emptyβ© := Ioc_eq_empty_iff
#align finset.Ioc_eq_empty Finset.Ioc_eq_empty
@[simp]
theorem Ioo_eq_empty (h : Β¬a < b) : Ioo a b = β
:=
eq_empty_iff_forall_not_mem.2 fun _ hx => h ((mem_Ioo.1 hx).1.trans (mem_Ioo.1 hx).2)
#align finset.Ioo_eq_empty Finset.Ioo_eq_empty
@[simp]
theorem Icc_eq_empty_of_lt (h : b < a) : Icc a b = β
:=
Icc_eq_empty h.not_le
#align finset.Icc_eq_empty_of_lt Finset.Icc_eq_empty_of_lt
@[simp]
theorem Ico_eq_empty_of_le (h : b β€ a) : Ico a b = β
:=
Ico_eq_empty h.not_lt
#align finset.Ico_eq_empty_of_le Finset.Ico_eq_empty_of_le
@[simp]
theorem Ioc_eq_empty_of_le (h : b β€ a) : Ioc a b = β
:=
Ioc_eq_empty h.not_lt
#align finset.Ioc_eq_empty_of_le Finset.Ioc_eq_empty_of_le
@[simp]
theorem Ioo_eq_empty_of_le (h : b β€ a) : Ioo a b = β
:=
Ioo_eq_empty h.not_lt
#align finset.Ioo_eq_empty_of_le Finset.Ioo_eq_empty_of_le
-- porting note (#10618): simp can prove this
-- @[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 134 | 134 | theorem left_mem_Icc : a β Icc a b β a β€ b := by | simp only [mem_Icc, true_and_iff, le_rfl]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
#align finset.Ico_eq_empty_iff Finset.Ico_eq_empty_iff
@[simp]
theorem Ioc_eq_empty_iff : Ioc a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
#align finset.Ioc_eq_empty_iff Finset.Ioc_eq_empty_iff
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem Ioo_eq_empty_iff [DenselyOrdered Ξ±] : Ioo a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioo, Set.Ioo_eq_empty_iff]
#align finset.Ioo_eq_empty_iff Finset.Ioo_eq_empty_iff
alias β¨_, Icc_eq_emptyβ© := Icc_eq_empty_iff
#align finset.Icc_eq_empty Finset.Icc_eq_empty
alias β¨_, Ico_eq_emptyβ© := Ico_eq_empty_iff
#align finset.Ico_eq_empty Finset.Ico_eq_empty
alias β¨_, Ioc_eq_emptyβ© := Ioc_eq_empty_iff
#align finset.Ioc_eq_empty Finset.Ioc_eq_empty
@[simp]
theorem Ioo_eq_empty (h : Β¬a < b) : Ioo a b = β
:=
eq_empty_iff_forall_not_mem.2 fun _ hx => h ((mem_Ioo.1 hx).1.trans (mem_Ioo.1 hx).2)
#align finset.Ioo_eq_empty Finset.Ioo_eq_empty
@[simp]
theorem Icc_eq_empty_of_lt (h : b < a) : Icc a b = β
:=
Icc_eq_empty h.not_le
#align finset.Icc_eq_empty_of_lt Finset.Icc_eq_empty_of_lt
@[simp]
theorem Ico_eq_empty_of_le (h : b β€ a) : Ico a b = β
:=
Ico_eq_empty h.not_lt
#align finset.Ico_eq_empty_of_le Finset.Ico_eq_empty_of_le
@[simp]
theorem Ioc_eq_empty_of_le (h : b β€ a) : Ioc a b = β
:=
Ioc_eq_empty h.not_lt
#align finset.Ioc_eq_empty_of_le Finset.Ioc_eq_empty_of_le
@[simp]
theorem Ioo_eq_empty_of_le (h : b β€ a) : Ioo a b = β
:=
Ioo_eq_empty h.not_lt
#align finset.Ioo_eq_empty_of_le Finset.Ioo_eq_empty_of_le
-- porting note (#10618): simp can prove this
-- @[simp]
theorem left_mem_Icc : a β Icc a b β a β€ b := by simp only [mem_Icc, true_and_iff, le_rfl]
#align finset.left_mem_Icc Finset.left_mem_Icc
-- porting note (#10618): simp can prove this
-- @[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 139 | 139 | theorem left_mem_Ico : a β Ico a b β a < b := by | simp only [mem_Ico, true_and_iff, le_refl]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
#align finset.Ico_eq_empty_iff Finset.Ico_eq_empty_iff
@[simp]
theorem Ioc_eq_empty_iff : Ioc a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
#align finset.Ioc_eq_empty_iff Finset.Ioc_eq_empty_iff
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem Ioo_eq_empty_iff [DenselyOrdered Ξ±] : Ioo a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioo, Set.Ioo_eq_empty_iff]
#align finset.Ioo_eq_empty_iff Finset.Ioo_eq_empty_iff
alias β¨_, Icc_eq_emptyβ© := Icc_eq_empty_iff
#align finset.Icc_eq_empty Finset.Icc_eq_empty
alias β¨_, Ico_eq_emptyβ© := Ico_eq_empty_iff
#align finset.Ico_eq_empty Finset.Ico_eq_empty
alias β¨_, Ioc_eq_emptyβ© := Ioc_eq_empty_iff
#align finset.Ioc_eq_empty Finset.Ioc_eq_empty
@[simp]
theorem Ioo_eq_empty (h : Β¬a < b) : Ioo a b = β
:=
eq_empty_iff_forall_not_mem.2 fun _ hx => h ((mem_Ioo.1 hx).1.trans (mem_Ioo.1 hx).2)
#align finset.Ioo_eq_empty Finset.Ioo_eq_empty
@[simp]
theorem Icc_eq_empty_of_lt (h : b < a) : Icc a b = β
:=
Icc_eq_empty h.not_le
#align finset.Icc_eq_empty_of_lt Finset.Icc_eq_empty_of_lt
@[simp]
theorem Ico_eq_empty_of_le (h : b β€ a) : Ico a b = β
:=
Ico_eq_empty h.not_lt
#align finset.Ico_eq_empty_of_le Finset.Ico_eq_empty_of_le
@[simp]
theorem Ioc_eq_empty_of_le (h : b β€ a) : Ioc a b = β
:=
Ioc_eq_empty h.not_lt
#align finset.Ioc_eq_empty_of_le Finset.Ioc_eq_empty_of_le
@[simp]
theorem Ioo_eq_empty_of_le (h : b β€ a) : Ioo a b = β
:=
Ioo_eq_empty h.not_lt
#align finset.Ioo_eq_empty_of_le Finset.Ioo_eq_empty_of_le
-- porting note (#10618): simp can prove this
-- @[simp]
theorem left_mem_Icc : a β Icc a b β a β€ b := by simp only [mem_Icc, true_and_iff, le_rfl]
#align finset.left_mem_Icc Finset.left_mem_Icc
-- porting note (#10618): simp can prove this
-- @[simp]
theorem left_mem_Ico : a β Ico a b β a < b := by simp only [mem_Ico, true_and_iff, le_refl]
#align finset.left_mem_Ico Finset.left_mem_Ico
-- porting note (#10618): simp can prove this
-- @[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 144 | 144 | theorem right_mem_Icc : b β Icc a b β a β€ b := by | simp only [mem_Icc, and_true_iff, le_rfl]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : Type*}
namespace Finset
section Preorder
variable [Preorder Ξ±]
section LocallyFiniteOrder
variable [LocallyFiniteOrder Ξ±] {a aβ aβ b bβ bβ c x : Ξ±}
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty β a β€ b := by
rw [β coe_nonempty, coe_Icc, Set.nonempty_Icc]
#align finset.nonempty_Icc Finset.nonempty_Icc
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ico, Set.nonempty_Ico]
#align finset.nonempty_Ico Finset.nonempty_Ico
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
#align finset.nonempty_Ioc Finset.nonempty_Ioc
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem nonempty_Ioo [DenselyOrdered Ξ±] : (Ioo a b).Nonempty β a < b := by
rw [β coe_nonempty, coe_Ioo, Set.nonempty_Ioo]
#align finset.nonempty_Ioo Finset.nonempty_Ioo
@[simp]
theorem Icc_eq_empty_iff : Icc a b = β
β Β¬a β€ b := by
rw [β coe_eq_empty, coe_Icc, Set.Icc_eq_empty_iff]
#align finset.Icc_eq_empty_iff Finset.Icc_eq_empty_iff
@[simp]
theorem Ico_eq_empty_iff : Ico a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ico, Set.Ico_eq_empty_iff]
#align finset.Ico_eq_empty_iff Finset.Ico_eq_empty_iff
@[simp]
theorem Ioc_eq_empty_iff : Ioc a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
#align finset.Ioc_eq_empty_iff Finset.Ioc_eq_empty_iff
-- TODO: This is nonsense. A locally finite order is never densely ordered
@[simp]
theorem Ioo_eq_empty_iff [DenselyOrdered Ξ±] : Ioo a b = β
β Β¬a < b := by
rw [β coe_eq_empty, coe_Ioo, Set.Ioo_eq_empty_iff]
#align finset.Ioo_eq_empty_iff Finset.Ioo_eq_empty_iff
alias β¨_, Icc_eq_emptyβ© := Icc_eq_empty_iff
#align finset.Icc_eq_empty Finset.Icc_eq_empty
alias β¨_, Ico_eq_emptyβ© := Ico_eq_empty_iff
#align finset.Ico_eq_empty Finset.Ico_eq_empty
alias β¨_, Ioc_eq_emptyβ© := Ioc_eq_empty_iff
#align finset.Ioc_eq_empty Finset.Ioc_eq_empty
@[simp]
theorem Ioo_eq_empty (h : Β¬a < b) : Ioo a b = β
:=
eq_empty_iff_forall_not_mem.2 fun _ hx => h ((mem_Ioo.1 hx).1.trans (mem_Ioo.1 hx).2)
#align finset.Ioo_eq_empty Finset.Ioo_eq_empty
@[simp]
theorem Icc_eq_empty_of_lt (h : b < a) : Icc a b = β
:=
Icc_eq_empty h.not_le
#align finset.Icc_eq_empty_of_lt Finset.Icc_eq_empty_of_lt
@[simp]
theorem Ico_eq_empty_of_le (h : b β€ a) : Ico a b = β
:=
Ico_eq_empty h.not_lt
#align finset.Ico_eq_empty_of_le Finset.Ico_eq_empty_of_le
@[simp]
theorem Ioc_eq_empty_of_le (h : b β€ a) : Ioc a b = β
:=
Ioc_eq_empty h.not_lt
#align finset.Ioc_eq_empty_of_le Finset.Ioc_eq_empty_of_le
@[simp]
theorem Ioo_eq_empty_of_le (h : b β€ a) : Ioo a b = β
:=
Ioo_eq_empty h.not_lt
#align finset.Ioo_eq_empty_of_le Finset.Ioo_eq_empty_of_le
-- porting note (#10618): simp can prove this
-- @[simp]
theorem left_mem_Icc : a β Icc a b β a β€ b := by simp only [mem_Icc, true_and_iff, le_rfl]
#align finset.left_mem_Icc Finset.left_mem_Icc
-- porting note (#10618): simp can prove this
-- @[simp]
theorem left_mem_Ico : a β Ico a b β a < b := by simp only [mem_Ico, true_and_iff, le_refl]
#align finset.left_mem_Ico Finset.left_mem_Ico
-- porting note (#10618): simp can prove this
-- @[simp]
theorem right_mem_Icc : b β Icc a b β a β€ b := by simp only [mem_Icc, and_true_iff, le_rfl]
#align finset.right_mem_Icc Finset.right_mem_Icc
-- porting note (#10618): simp can prove this
-- @[simp]
| Mathlib/Order/Interval/Finset/Basic.lean | 149 | 149 | theorem right_mem_Ioc : b β Ioc a b β a < b := by | simp only [mem_Ioc, and_true_iff, le_rfl]
| 1 | 2.718282 | 0 | 0 | 12 | 11 |
import Mathlib.Algebra.Lie.Subalgebra
import Mathlib.RingTheory.Noetherian
import Mathlib.RingTheory.Artinian
#align_import algebra.lie.submodule from "leanprover-community/mathlib"@"9822b65bfc4ac74537d77ae318d27df1df662471"
universe u v w wβ wβ
section LieSubmodule
variable (R : Type u) (L : Type v) (M : Type w)
variable [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M]
variable [LieRingModule L M] [LieModule R L M]
structure LieSubmodule extends Submodule R M where
lie_mem : β {x : L} {m : M}, m β carrier β β
x, mβ β carrier
#align lie_submodule LieSubmodule
attribute [nolint docBlame] LieSubmodule.toSubmodule
attribute [coe] LieSubmodule.toSubmodule
namespace LieSubmodule
variable {R L M}
variable (N N' : LieSubmodule R L M)
instance : SetLike (LieSubmodule R L M) M where
coe s := s.carrier
coe_injective' N O h := by cases N; cases O; congr; exact SetLike.coe_injective' h
instance : AddSubgroupClass (LieSubmodule R L M) M where
add_mem {N} _ _ := N.add_mem'
zero_mem N := N.zero_mem'
neg_mem {N} x hx := show -x β N.toSubmodule from neg_mem hx
instance instSMulMemClass : SMulMemClass (LieSubmodule R L M) R M where
smul_mem {s} c _ h := s.smul_mem' c h
instance : Zero (LieSubmodule R L M) :=
β¨{ (0 : Submodule R M) with
lie_mem := fun {x m} h β¦ by rw [(Submodule.mem_bot R).1 h]; apply lie_zero }β©
instance : Inhabited (LieSubmodule R L M) :=
β¨0β©
instance coeSubmodule : CoeOut (LieSubmodule R L M) (Submodule R M) :=
β¨toSubmoduleβ©
#align lie_submodule.coe_submodule LieSubmodule.coeSubmodule
-- Syntactic tautology
#noalign lie_submodule.to_submodule_eq_coe
@[norm_cast]
theorem coe_toSubmodule : ((N : Submodule R M) : Set M) = N :=
rfl
#align lie_submodule.coe_to_submodule LieSubmodule.coe_toSubmodule
-- Porting note (#10618): `simp` can prove this after `mem_coeSubmodule` is added to the simp set,
-- but `dsimp` can't.
@[simp, nolint simpNF]
theorem mem_carrier {x : M} : x β N.carrier β x β (N : Set M) :=
Iff.rfl
#align lie_submodule.mem_carrier LieSubmodule.mem_carrier
theorem mem_mk_iff (S : Set M) (hβ hβ hβ hβ) {x : M} :
x β (β¨β¨β¨β¨S, hββ©, hββ©, hββ©, hββ© : LieSubmodule R L M) β x β S :=
Iff.rfl
#align lie_submodule.mem_mk_iff LieSubmodule.mem_mk_iff
@[simp]
theorem mem_mk_iff' (p : Submodule R M) (h) {x : M} :
x β (β¨p, hβ© : LieSubmodule R L M) β x β p :=
Iff.rfl
@[simp]
theorem mem_coeSubmodule {x : M} : x β (N : Submodule R M) β x β N :=
Iff.rfl
#align lie_submodule.mem_coe_submodule LieSubmodule.mem_coeSubmodule
theorem mem_coe {x : M} : x β (N : Set M) β x β N :=
Iff.rfl
#align lie_submodule.mem_coe LieSubmodule.mem_coe
@[simp]
protected theorem zero_mem : (0 : M) β N :=
zero_mem N
#align lie_submodule.zero_mem LieSubmodule.zero_mem
-- Porting note (#10618): @[simp] can prove this
theorem mk_eq_zero {x} (h : x β N) : (β¨x, hβ© : N) = 0 β x = 0 :=
Subtype.ext_iff_val
#align lie_submodule.mk_eq_zero LieSubmodule.mk_eq_zero
@[simp]
theorem coe_toSet_mk (S : Set M) (hβ hβ hβ hβ) :
((β¨β¨β¨β¨S, hββ©, hββ©, hββ©, hββ© : LieSubmodule R L M) : Set M) = S :=
rfl
#align lie_submodule.coe_to_set_mk LieSubmodule.coe_toSet_mk
| Mathlib/Algebra/Lie/Submodule.lean | 132 | 133 | theorem coe_toSubmodule_mk (p : Submodule R M) (h) :
(({ p with lie_mem := h } : LieSubmodule R L M) : Submodule R M) = p := by | cases p; rfl
| 1 | 2.718282 | 0 | 0 | 1 | 12 |
import Mathlib.Order.RelIso.Basic
import Mathlib.Logic.Embedding.Set
import Mathlib.Logic.Equiv.Set
#align_import order.rel_iso.set from "leanprover-community/mathlib"@"ee0c179cd3c8a45aa5bffbf1b41d8dbede452865"
open Function
universe u v w
variable {Ξ± Ξ² Ξ³ Ξ΄ : Type*} {r : Ξ± β Ξ± β Prop} {s : Ξ² β Ξ² β Prop} {t : Ξ³ β Ξ³ β Prop}
{u : Ξ΄ β Ξ΄ β Prop}
def Subrel (r : Ξ± β Ξ± β Prop) (p : Set Ξ±) : p β p β Prop :=
(Subtype.val : p β Ξ±) β»ΒΉ'o r
#align subrel Subrel
@[simp]
theorem subrel_val (r : Ξ± β Ξ± β Prop) (p : Set Ξ±) {a b} : Subrel r p a b β r a.1 b.1 :=
Iff.rfl
#align subrel_val subrel_val
def RelEmbedding.codRestrict (p : Set Ξ²) (f : r βͺr s) (H : β a, f a β p) : r βͺr Subrel s p :=
β¨f.toEmbedding.codRestrict p H, f.map_rel_iff'β©
#align rel_embedding.cod_restrict RelEmbedding.codRestrict
@[simp]
theorem RelEmbedding.codRestrict_apply (p) (f : r βͺr s) (H a) :
RelEmbedding.codRestrict p f H a = β¨f a, H aβ© :=
rfl
#align rel_embedding.cod_restrict_apply RelEmbedding.codRestrict_apply
section image
variable {Ξ± Ξ² : Type*} {r : Ξ± β Ξ± β Prop} {s : Ξ² β Ξ² β Prop}
theorem RelIso.image_eq_preimage_symm (e : r βr s) (t : Set Ξ±) : e '' t = e.symm β»ΒΉ' t :=
e.toEquiv.image_eq_preimage t
| Mathlib/Order/RelIso/Set.lean | 111 | 112 | theorem RelIso.preimage_eq_image_symm (e : r βr s) (t : Set Ξ²) : e β»ΒΉ' t = e.symm '' t := by |
rw [e.symm.image_eq_preimage_symm]; rfl
| 1 | 2.718282 | 0 | 0 | 1 | 13 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 73 | 75 | theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by |
simpa using (AddConstMapClass.semiconj f).iterate_right n x
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 78 | 79 | theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by | simp [β map_add_nsmul]
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
| Mathlib/Algebra/AddConstMap/Basic.lean | 90 | 91 | theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by | simp
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 98 | 100 | theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by |
simpa using map_add_const f 0
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 107 | 109 | theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by |
simpa using map_add_nsmul f 0 n
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by
simpa using map_add_nsmul f 0 n
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 112 | 114 | theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by |
simpa using map_add_nat' f 0 n
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by
simpa using map_add_nsmul f 0 n
@[simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by
simpa using map_add_nat' f 0 n
theorem map_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + (OfNat.ofNat n : β) β’ b :=
map_nat' f n
| Mathlib/Algebra/AddConstMap/Basic.lean | 121 | 122 | theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) : f n = f 0 + n := by | simp
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by
simpa using map_add_nsmul f 0 n
@[simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by
simpa using map_add_nat' f 0 n
theorem map_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + (OfNat.ofNat n : β) β’ b :=
map_nat' f n
theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) : f n = f 0 + n := by simp
theorem map_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + OfNat.ofNat n := map_nat f n
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 129 | 131 | theorem map_const_add [AddCommSemigroup G] [Add H] [AddConstMapClass F G H a b]
(f : F) (x : G) : f (a + x) = f x + b := by |
rw [add_comm, map_add_const]
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by
simpa using map_add_nsmul f 0 n
@[simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by
simpa using map_add_nat' f 0 n
theorem map_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + (OfNat.ofNat n : β) β’ b :=
map_nat' f n
theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) : f n = f 0 + n := by simp
theorem map_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + OfNat.ofNat n := map_nat f n
@[simp]
theorem map_const_add [AddCommSemigroup G] [Add H] [AddConstMapClass F G H a b]
(f : F) (x : G) : f (a + x) = f x + b := by
rw [add_comm, map_add_const]
theorem map_one_add [AddCommMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (1 + x) = f x + b := map_const_add f x
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 137 | 139 | theorem map_nsmul_add [AddCommMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) (x : G) : f (n β’ a + x) = f x + n β’ b := by |
rw [add_comm, map_add_nsmul]
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by
simpa using map_add_nsmul f 0 n
@[simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by
simpa using map_add_nat' f 0 n
theorem map_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + (OfNat.ofNat n : β) β’ b :=
map_nat' f n
theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) : f n = f 0 + n := by simp
theorem map_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + OfNat.ofNat n := map_nat f n
@[simp]
theorem map_const_add [AddCommSemigroup G] [Add H] [AddConstMapClass F G H a b]
(f : F) (x : G) : f (a + x) = f x + b := by
rw [add_comm, map_add_const]
theorem map_one_add [AddCommMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (1 + x) = f x + b := map_const_add f x
@[simp]
theorem map_nsmul_add [AddCommMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) (x : G) : f (n β’ a + x) = f x + n β’ b := by
rw [add_comm, map_add_nsmul]
@[simp]
| Mathlib/Algebra/AddConstMap/Basic.lean | 142 | 144 | theorem map_nat_add' [AddCommMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) (x : G) : f (βn + x) = f x + n β’ b := by |
simpa using map_nsmul_add f n x
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected toFun : G β H
map_add_const' (x : G) : toFun (x + a) = toFun x + b
@[inherit_doc]
scoped [AddConstMap] notation:25 G " β+c[" a ", " b "] " H => AddConstMap G H a b
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
(a : outParam G) (b : outParam H) extends DFunLike F G fun _ β¦ H where
map_add_const (f : F) (x : G) : f (x + a) = f x + b
namespace AddConstMapClass
attribute [simp] map_add_const
variable {F G H : Type*} {a : G} {b : H}
protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
Semiconj f (Β· + a) (Β· + b) :=
map_add_const f
@[simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (x : G) (n : β) : f (x + n β’ a) = f x + n β’ b := by
simpa using (AddConstMapClass.semiconj f).iterate_right n x
@[simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) : f (x + n) = f x + n β’ b := by simp [β map_add_nsmul]
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (x + 1) = f x + b := map_add_const f x
@[simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : β) β’ b :=
map_add_nat' f x n
theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) : f (x + n) = f x + n := by simp
theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (x : G) (n : β) [n.AtLeastTwo] :
f (x + OfNat.ofNat n) = f x + OfNat.ofNat n := map_add_nat f x n
@[simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
f a = f 0 + b := by
simpa using map_add_const f 0
theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
f 1 = f 0 + b :=
map_const f
@[simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) : f (n β’ a) = f 0 + n β’ b := by
simpa using map_add_nsmul f 0 n
@[simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by
simpa using map_add_nat' f 0 n
theorem map_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + (OfNat.ofNat n : β) β’ b :=
map_nat' f n
theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) : f n = f 0 + n := by simp
theorem map_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) [n.AtLeastTwo] :
f (OfNat.ofNat n) = f 0 + OfNat.ofNat n := map_nat f n
@[simp]
theorem map_const_add [AddCommSemigroup G] [Add H] [AddConstMapClass F G H a b]
(f : F) (x : G) : f (a + x) = f x + b := by
rw [add_comm, map_add_const]
theorem map_one_add [AddCommMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
(f : F) (x : G) : f (1 + x) = f x + b := map_const_add f x
@[simp]
theorem map_nsmul_add [AddCommMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
(f : F) (n : β) (x : G) : f (n β’ a + x) = f x + n β’ b := by
rw [add_comm, map_add_nsmul]
@[simp]
theorem map_nat_add' [AddCommMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) (x : G) : f (βn + x) = f x + n β’ b := by
simpa using map_nsmul_add f n x
theorem map_ofNat_add' [AddCommMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) [n.AtLeastTwo] (x : G) :
f (OfNat.ofNat n + x) = f x + OfNat.ofNat n β’ b :=
map_nat_add' f n x
| Mathlib/Algebra/AddConstMap/Basic.lean | 151 | 152 | theorem map_nat_add [AddCommMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : β) (x : G) : f (βn + x) = f x + n := by | simp
| 1 | 2.718282 | 0 | 0 | 11 | 14 |
import Mathlib.Algebra.Group.Semiconj.Defs
import Mathlib.Algebra.Group.Basic
#align_import algebra.group.semiconj from "leanprover-community/mathlib"@"a148d797a1094ab554ad4183a4ad6f130358ef64"
assert_not_exists MonoidWithZero
assert_not_exists DenselyOrdered
namespace SemiconjBy
variable {G : Type*}
section DivisionMonoid
variable [DivisionMonoid G] {a x y : G}
@[to_additive (attr := simp)]
| Mathlib/Algebra/Group/Semiconj/Basic.lean | 26 | 27 | theorem inv_inv_symm_iff : SemiconjBy aβ»ΒΉ xβ»ΒΉ yβ»ΒΉ β SemiconjBy a y x := by |
simp_rw [SemiconjBy, β mul_inv_rev, inv_inj, eq_comm]
| 1 | 2.718282 | 0 | 0 | 1 | 15 |
import Mathlib.Algebra.Group.Defs
import Mathlib.Data.Int.Defs
import Mathlib.Data.Rat.Init
import Mathlib.Order.Basic
import Mathlib.Tactic.Common
#align_import data.rat.defs from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
-- TODO: If `Inv` was defined earlier than `Algebra.Group.Defs`, we could have
-- assert_not_exists Monoid
assert_not_exists MonoidWithZero
assert_not_exists Lattice
assert_not_exists PNat
assert_not_exists Nat.dvd_mul
open Function
namespace Rat
variable {q : β}
-- Porting note: the definition of `β` has changed; in mathlib3 this was a field.
theorem pos (a : β) : 0 < a.den := Nat.pos_of_ne_zero a.den_nz
#align rat.pos Rat.pos
#align rat.of_int Rat.ofInt
lemma mk'_num_den (q : β) : mk' q.num q.den q.den_nz q.reduced = q := rfl
@[simp]
theorem ofInt_eq_cast (n : β€) : ofInt n = Int.cast n :=
rfl
#align rat.of_int_eq_cast Rat.ofInt_eq_cast
-- TODO: Replace `Rat.ofNat_num`/`Rat.ofNat_den` in Batteries
-- See note [no_index around OfNat.ofNat]
@[simp] lemma num_ofNat (n : β) : num (no_index (OfNat.ofNat n)) = OfNat.ofNat n := rfl
@[simp] lemma den_ofNat (n : β) : den (no_index (OfNat.ofNat n)) = 1 := rfl
@[simp, norm_cast] lemma num_natCast (n : β) : num n = n := rfl
#align rat.coe_nat_num Rat.num_natCast
@[simp, norm_cast] lemma den_natCast (n : β) : den n = 1 := rfl
#align rat.coe_nat_denom Rat.den_natCast
-- TODO: Replace `intCast_num`/`intCast_den` the names in Batteries
@[simp, norm_cast] lemma num_intCast (n : β€) : (n : β).num = n := rfl
#align rat.coe_int_num Rat.num_intCast
@[simp, norm_cast] lemma den_intCast (n : β€) : (n : β).den = 1 := rfl
#align rat.coe_int_denom Rat.den_intCast
@[deprecated (since := "2024-04-29")] alias coe_int_num := num_intCast
@[deprecated (since := "2024-04-29")] alias coe_int_den := den_intCast
lemma intCast_injective : Injective (Int.cast : β€ β β) := fun _ _ β¦ congr_arg num
lemma natCast_injective : Injective (Nat.cast : β β β) :=
intCast_injective.comp fun _ _ β¦ Int.natCast_inj.1
-- We want to use these lemmas earlier than the lemmas simp can prove them with
@[simp, nolint simpNF, norm_cast] lemma natCast_inj {m n : β} : (m : β) = n β m = n :=
natCast_injective.eq_iff
@[simp, nolint simpNF, norm_cast] lemma intCast_eq_zero {n : β€} : (n : β) = 0 β n = 0 := intCast_inj
@[simp, nolint simpNF, norm_cast] lemma natCast_eq_zero {n : β} : (n : β) = 0 β n = 0 := natCast_inj
@[simp, nolint simpNF, norm_cast] lemma intCast_eq_one {n : β€} : (n : β) = 1 β n = 1 := intCast_inj
@[simp, nolint simpNF, norm_cast] lemma natCast_eq_one {n : β} : (n : β) = 1 β n = 1 := natCast_inj
#noalign rat.mk_pnat
#noalign rat.mk_pnat_eq
#noalign rat.zero_mk_pnat
-- Porting note (#11215): TODO Should this be namespaced?
#align rat.mk_nat mkRat
lemma mkRat_eq_divInt (n d) : mkRat n d = n /. d := rfl
#align rat.mk_nat_eq Rat.mkRat_eq_divInt
#align rat.mk_zero Rat.divInt_zero
#align rat.zero_mk_nat Rat.zero_mkRat
#align rat.zero_mk Rat.zero_divInt
@[simp] lemma mk'_zero (d) (h : d β 0) (w) : mk' 0 d h w = 0 := by congr; simp_all
@[simp]
lemma num_eq_zero {q : β} : q.num = 0 β q = 0 := by
induction q
constructor
Β· rintro rfl
exact mk'_zero _ _ _
Β· exact congr_arg num
lemma num_ne_zero {q : β} : q.num β 0 β q β 0 := num_eq_zero.not
#align rat.num_ne_zero_of_ne_zero Rat.num_ne_zero
@[simp] lemma den_ne_zero (q : β) : q.den β 0 := q.den_pos.ne'
#noalign rat.nonneg
@[simp] lemma num_nonneg : 0 β€ q.num β 0 β€ q := by
simp [Int.le_iff_lt_or_eq, instLE, Rat.blt, Int.not_lt]; tauto
#align rat.num_nonneg_iff_zero_le Rat.num_nonneg
@[simp]
| Mathlib/Data/Rat/Defs.lean | 127 | 128 | theorem divInt_eq_zero {a b : β€} (b0 : b β 0) : a /. b = 0 β a = 0 := by |
rw [β zero_divInt b, divInt_eq_iff b0 b0, Int.zero_mul, Int.mul_eq_zero, or_iff_left b0]
| 1 | 2.718282 | 0 | 0 | 1 | 16 |
import Mathlib.Order.Filter.Prod
#align_import order.filter.n_ary from "leanprover-community/mathlib"@"78f647f8517f021d839a7553d5dc97e79b508dea"
open Function Set
open Filter
namespace Filter
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' : Type*} {m : Ξ± β Ξ² β Ξ³} {f fβ fβ : Filter Ξ±}
{g gβ gβ : Filter Ξ²} {h hβ hβ : Filter Ξ³} {s sβ sβ : Set Ξ±} {t tβ tβ : Set Ξ²} {u : Set Ξ³}
{v : Set Ξ΄} {a : Ξ±} {b : Ξ²} {c : Ξ³}
def mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) : Filter Ξ³ :=
((f ΓΛ’ g).map (uncurry m)).copy { s | β u β f, β v β g, image2 m u v β s } fun _ β¦ by
simp only [mem_map, mem_prod_iff, image2_subset_iff, prod_subset_iff]; rfl
#align filter.mapβ Filter.mapβ
@[simp 900]
theorem mem_mapβ_iff : u β mapβ m f g β β s β f, β t β g, image2 m s t β u :=
Iff.rfl
#align filter.mem_mapβ_iff Filter.mem_mapβ_iff
theorem image2_mem_mapβ (hs : s β f) (ht : t β g) : image2 m s t β mapβ m f g :=
β¨_, hs, _, ht, Subset.rflβ©
#align filter.image2_mem_mapβ Filter.image2_mem_mapβ
| Mathlib/Order/Filter/NAry.lean | 53 | 55 | theorem map_prod_eq_mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map (fun p : Ξ± Γ Ξ² => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g := by |
rw [mapβ, copy_eq, uncurry_def]
| 1 | 2.718282 | 0 | 0 | 5 | 17 |
import Mathlib.Order.Filter.Prod
#align_import order.filter.n_ary from "leanprover-community/mathlib"@"78f647f8517f021d839a7553d5dc97e79b508dea"
open Function Set
open Filter
namespace Filter
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' : Type*} {m : Ξ± β Ξ² β Ξ³} {f fβ fβ : Filter Ξ±}
{g gβ gβ : Filter Ξ²} {h hβ hβ : Filter Ξ³} {s sβ sβ : Set Ξ±} {t tβ tβ : Set Ξ²} {u : Set Ξ³}
{v : Set Ξ΄} {a : Ξ±} {b : Ξ²} {c : Ξ³}
def mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) : Filter Ξ³ :=
((f ΓΛ’ g).map (uncurry m)).copy { s | β u β f, β v β g, image2 m u v β s } fun _ β¦ by
simp only [mem_map, mem_prod_iff, image2_subset_iff, prod_subset_iff]; rfl
#align filter.mapβ Filter.mapβ
@[simp 900]
theorem mem_mapβ_iff : u β mapβ m f g β β s β f, β t β g, image2 m s t β u :=
Iff.rfl
#align filter.mem_mapβ_iff Filter.mem_mapβ_iff
theorem image2_mem_mapβ (hs : s β f) (ht : t β g) : image2 m s t β mapβ m f g :=
β¨_, hs, _, ht, Subset.rflβ©
#align filter.image2_mem_mapβ Filter.image2_mem_mapβ
theorem map_prod_eq_mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map (fun p : Ξ± Γ Ξ² => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g := by
rw [mapβ, copy_eq, uncurry_def]
#align filter.map_prod_eq_mapβ Filter.map_prod_eq_mapβ
theorem map_prod_eq_mapβ' (m : Ξ± Γ Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map m (f ΓΛ’ g) = mapβ (fun a b => m (a, b)) f g :=
map_prod_eq_mapβ (curry m) f g
#align filter.map_prod_eq_mapβ' Filter.map_prod_eq_mapβ'
@[simp]
| Mathlib/Order/Filter/NAry.lean | 64 | 65 | theorem mapβ_mk_eq_prod (f : Filter Ξ±) (g : Filter Ξ²) : mapβ Prod.mk f g = f ΓΛ’ g := by |
simp only [β map_prod_eq_mapβ, map_id']
| 1 | 2.718282 | 0 | 0 | 5 | 17 |
import Mathlib.Order.Filter.Prod
#align_import order.filter.n_ary from "leanprover-community/mathlib"@"78f647f8517f021d839a7553d5dc97e79b508dea"
open Function Set
open Filter
namespace Filter
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' : Type*} {m : Ξ± β Ξ² β Ξ³} {f fβ fβ : Filter Ξ±}
{g gβ gβ : Filter Ξ²} {h hβ hβ : Filter Ξ³} {s sβ sβ : Set Ξ±} {t tβ tβ : Set Ξ²} {u : Set Ξ³}
{v : Set Ξ΄} {a : Ξ±} {b : Ξ²} {c : Ξ³}
def mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) : Filter Ξ³ :=
((f ΓΛ’ g).map (uncurry m)).copy { s | β u β f, β v β g, image2 m u v β s } fun _ β¦ by
simp only [mem_map, mem_prod_iff, image2_subset_iff, prod_subset_iff]; rfl
#align filter.mapβ Filter.mapβ
@[simp 900]
theorem mem_mapβ_iff : u β mapβ m f g β β s β f, β t β g, image2 m s t β u :=
Iff.rfl
#align filter.mem_mapβ_iff Filter.mem_mapβ_iff
theorem image2_mem_mapβ (hs : s β f) (ht : t β g) : image2 m s t β mapβ m f g :=
β¨_, hs, _, ht, Subset.rflβ©
#align filter.image2_mem_mapβ Filter.image2_mem_mapβ
theorem map_prod_eq_mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map (fun p : Ξ± Γ Ξ² => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g := by
rw [mapβ, copy_eq, uncurry_def]
#align filter.map_prod_eq_mapβ Filter.map_prod_eq_mapβ
theorem map_prod_eq_mapβ' (m : Ξ± Γ Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map m (f ΓΛ’ g) = mapβ (fun a b => m (a, b)) f g :=
map_prod_eq_mapβ (curry m) f g
#align filter.map_prod_eq_mapβ' Filter.map_prod_eq_mapβ'
@[simp]
theorem mapβ_mk_eq_prod (f : Filter Ξ±) (g : Filter Ξ²) : mapβ Prod.mk f g = f ΓΛ’ g := by
simp only [β map_prod_eq_mapβ, map_id']
#align filter.mapβ_mk_eq_prod Filter.mapβ_mk_eq_prod
-- lemma image2_mem_mapβ_iff (hm : injective2 m) : image2 m s t β mapβ m f g β s β f β§ t β g :=
-- β¨by { rintro β¨u, v, hu, hv, hβ©, rw image2_subset_image2_iff hm at h,
-- exact β¨mem_of_superset hu h.1, mem_of_superset hv h.2β© }, Ξ» h, image2_mem_mapβ h.1 h.2β©
theorem mapβ_mono (hf : fβ β€ fβ) (hg : gβ β€ gβ) : mapβ m fβ gβ β€ mapβ m fβ gβ :=
fun _ β¨s, hs, t, ht, hstβ© => β¨s, hf hs, t, hg ht, hstβ©
#align filter.mapβ_mono Filter.mapβ_mono
theorem mapβ_mono_left (h : gβ β€ gβ) : mapβ m f gβ β€ mapβ m f gβ :=
mapβ_mono Subset.rfl h
#align filter.mapβ_mono_left Filter.mapβ_mono_left
theorem mapβ_mono_right (h : fβ β€ fβ) : mapβ m fβ g β€ mapβ m fβ g :=
mapβ_mono h Subset.rfl
#align filter.mapβ_mono_right Filter.mapβ_mono_right
@[simp]
theorem le_mapβ_iff {h : Filter Ξ³} :
h β€ mapβ m f g β β β¦sβ¦, s β f β β β¦tβ¦, t β g β image2 m s t β h :=
β¨fun H _ hs _ ht => H <| image2_mem_mapβ hs ht, fun H _ β¨_, hs, _, ht, huβ© =>
mem_of_superset (H hs ht) huβ©
#align filter.le_mapβ_iff Filter.le_mapβ_iff
@[simp]
| Mathlib/Order/Filter/NAry.lean | 91 | 91 | theorem mapβ_eq_bot_iff : mapβ m f g = β₯ β f = β₯ β¨ g = β₯ := by | simp [β map_prod_eq_mapβ]
| 1 | 2.718282 | 0 | 0 | 5 | 17 |
import Mathlib.Order.Filter.Prod
#align_import order.filter.n_ary from "leanprover-community/mathlib"@"78f647f8517f021d839a7553d5dc97e79b508dea"
open Function Set
open Filter
namespace Filter
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' : Type*} {m : Ξ± β Ξ² β Ξ³} {f fβ fβ : Filter Ξ±}
{g gβ gβ : Filter Ξ²} {h hβ hβ : Filter Ξ³} {s sβ sβ : Set Ξ±} {t tβ tβ : Set Ξ²} {u : Set Ξ³}
{v : Set Ξ΄} {a : Ξ±} {b : Ξ²} {c : Ξ³}
def mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) : Filter Ξ³ :=
((f ΓΛ’ g).map (uncurry m)).copy { s | β u β f, β v β g, image2 m u v β s } fun _ β¦ by
simp only [mem_map, mem_prod_iff, image2_subset_iff, prod_subset_iff]; rfl
#align filter.mapβ Filter.mapβ
@[simp 900]
theorem mem_mapβ_iff : u β mapβ m f g β β s β f, β t β g, image2 m s t β u :=
Iff.rfl
#align filter.mem_mapβ_iff Filter.mem_mapβ_iff
theorem image2_mem_mapβ (hs : s β f) (ht : t β g) : image2 m s t β mapβ m f g :=
β¨_, hs, _, ht, Subset.rflβ©
#align filter.image2_mem_mapβ Filter.image2_mem_mapβ
theorem map_prod_eq_mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map (fun p : Ξ± Γ Ξ² => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g := by
rw [mapβ, copy_eq, uncurry_def]
#align filter.map_prod_eq_mapβ Filter.map_prod_eq_mapβ
theorem map_prod_eq_mapβ' (m : Ξ± Γ Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map m (f ΓΛ’ g) = mapβ (fun a b => m (a, b)) f g :=
map_prod_eq_mapβ (curry m) f g
#align filter.map_prod_eq_mapβ' Filter.map_prod_eq_mapβ'
@[simp]
theorem mapβ_mk_eq_prod (f : Filter Ξ±) (g : Filter Ξ²) : mapβ Prod.mk f g = f ΓΛ’ g := by
simp only [β map_prod_eq_mapβ, map_id']
#align filter.mapβ_mk_eq_prod Filter.mapβ_mk_eq_prod
-- lemma image2_mem_mapβ_iff (hm : injective2 m) : image2 m s t β mapβ m f g β s β f β§ t β g :=
-- β¨by { rintro β¨u, v, hu, hv, hβ©, rw image2_subset_image2_iff hm at h,
-- exact β¨mem_of_superset hu h.1, mem_of_superset hv h.2β© }, Ξ» h, image2_mem_mapβ h.1 h.2β©
theorem mapβ_mono (hf : fβ β€ fβ) (hg : gβ β€ gβ) : mapβ m fβ gβ β€ mapβ m fβ gβ :=
fun _ β¨s, hs, t, ht, hstβ© => β¨s, hf hs, t, hg ht, hstβ©
#align filter.mapβ_mono Filter.mapβ_mono
theorem mapβ_mono_left (h : gβ β€ gβ) : mapβ m f gβ β€ mapβ m f gβ :=
mapβ_mono Subset.rfl h
#align filter.mapβ_mono_left Filter.mapβ_mono_left
theorem mapβ_mono_right (h : fβ β€ fβ) : mapβ m fβ g β€ mapβ m fβ g :=
mapβ_mono h Subset.rfl
#align filter.mapβ_mono_right Filter.mapβ_mono_right
@[simp]
theorem le_mapβ_iff {h : Filter Ξ³} :
h β€ mapβ m f g β β β¦sβ¦, s β f β β β¦tβ¦, t β g β image2 m s t β h :=
β¨fun H _ hs _ ht => H <| image2_mem_mapβ hs ht, fun H _ β¨_, hs, _, ht, huβ© =>
mem_of_superset (H hs ht) huβ©
#align filter.le_mapβ_iff Filter.le_mapβ_iff
@[simp]
theorem mapβ_eq_bot_iff : mapβ m f g = β₯ β f = β₯ β¨ g = β₯ := by simp [β map_prod_eq_mapβ]
#align filter.mapβ_eq_bot_iff Filter.mapβ_eq_bot_iff
@[simp]
theorem mapβ_bot_left : mapβ m β₯ g = β₯ := mapβ_eq_bot_iff.2 <| .inl rfl
#align filter.mapβ_bot_left Filter.mapβ_bot_left
@[simp]
theorem mapβ_bot_right : mapβ m f β₯ = β₯ := mapβ_eq_bot_iff.2 <| .inr rfl
#align filter.mapβ_bot_right Filter.mapβ_bot_right
@[simp]
| Mathlib/Order/Filter/NAry.lean | 103 | 103 | theorem mapβ_neBot_iff : (mapβ m f g).NeBot β f.NeBot β§ g.NeBot := by | simp [neBot_iff, not_or]
| 1 | 2.718282 | 0 | 0 | 5 | 17 |
import Mathlib.Order.Filter.Prod
#align_import order.filter.n_ary from "leanprover-community/mathlib"@"78f647f8517f021d839a7553d5dc97e79b508dea"
open Function Set
open Filter
namespace Filter
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' : Type*} {m : Ξ± β Ξ² β Ξ³} {f fβ fβ : Filter Ξ±}
{g gβ gβ : Filter Ξ²} {h hβ hβ : Filter Ξ³} {s sβ sβ : Set Ξ±} {t tβ tβ : Set Ξ²} {u : Set Ξ³}
{v : Set Ξ΄} {a : Ξ±} {b : Ξ²} {c : Ξ³}
def mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) : Filter Ξ³ :=
((f ΓΛ’ g).map (uncurry m)).copy { s | β u β f, β v β g, image2 m u v β s } fun _ β¦ by
simp only [mem_map, mem_prod_iff, image2_subset_iff, prod_subset_iff]; rfl
#align filter.mapβ Filter.mapβ
@[simp 900]
theorem mem_mapβ_iff : u β mapβ m f g β β s β f, β t β g, image2 m s t β u :=
Iff.rfl
#align filter.mem_mapβ_iff Filter.mem_mapβ_iff
theorem image2_mem_mapβ (hs : s β f) (ht : t β g) : image2 m s t β mapβ m f g :=
β¨_, hs, _, ht, Subset.rflβ©
#align filter.image2_mem_mapβ Filter.image2_mem_mapβ
theorem map_prod_eq_mapβ (m : Ξ± β Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map (fun p : Ξ± Γ Ξ² => m p.1 p.2) (f ΓΛ’ g) = mapβ m f g := by
rw [mapβ, copy_eq, uncurry_def]
#align filter.map_prod_eq_mapβ Filter.map_prod_eq_mapβ
theorem map_prod_eq_mapβ' (m : Ξ± Γ Ξ² β Ξ³) (f : Filter Ξ±) (g : Filter Ξ²) :
Filter.map m (f ΓΛ’ g) = mapβ (fun a b => m (a, b)) f g :=
map_prod_eq_mapβ (curry m) f g
#align filter.map_prod_eq_mapβ' Filter.map_prod_eq_mapβ'
@[simp]
theorem mapβ_mk_eq_prod (f : Filter Ξ±) (g : Filter Ξ²) : mapβ Prod.mk f g = f ΓΛ’ g := by
simp only [β map_prod_eq_mapβ, map_id']
#align filter.mapβ_mk_eq_prod Filter.mapβ_mk_eq_prod
-- lemma image2_mem_mapβ_iff (hm : injective2 m) : image2 m s t β mapβ m f g β s β f β§ t β g :=
-- β¨by { rintro β¨u, v, hu, hv, hβ©, rw image2_subset_image2_iff hm at h,
-- exact β¨mem_of_superset hu h.1, mem_of_superset hv h.2β© }, Ξ» h, image2_mem_mapβ h.1 h.2β©
theorem mapβ_mono (hf : fβ β€ fβ) (hg : gβ β€ gβ) : mapβ m fβ gβ β€ mapβ m fβ gβ :=
fun _ β¨s, hs, t, ht, hstβ© => β¨s, hf hs, t, hg ht, hstβ©
#align filter.mapβ_mono Filter.mapβ_mono
theorem mapβ_mono_left (h : gβ β€ gβ) : mapβ m f gβ β€ mapβ m f gβ :=
mapβ_mono Subset.rfl h
#align filter.mapβ_mono_left Filter.mapβ_mono_left
theorem mapβ_mono_right (h : fβ β€ fβ) : mapβ m fβ g β€ mapβ m fβ g :=
mapβ_mono h Subset.rfl
#align filter.mapβ_mono_right Filter.mapβ_mono_right
@[simp]
theorem le_mapβ_iff {h : Filter Ξ³} :
h β€ mapβ m f g β β β¦sβ¦, s β f β β β¦tβ¦, t β g β image2 m s t β h :=
β¨fun H _ hs _ ht => H <| image2_mem_mapβ hs ht, fun H _ β¨_, hs, _, ht, huβ© =>
mem_of_superset (H hs ht) huβ©
#align filter.le_mapβ_iff Filter.le_mapβ_iff
@[simp]
theorem mapβ_eq_bot_iff : mapβ m f g = β₯ β f = β₯ β¨ g = β₯ := by simp [β map_prod_eq_mapβ]
#align filter.mapβ_eq_bot_iff Filter.mapβ_eq_bot_iff
@[simp]
theorem mapβ_bot_left : mapβ m β₯ g = β₯ := mapβ_eq_bot_iff.2 <| .inl rfl
#align filter.mapβ_bot_left Filter.mapβ_bot_left
@[simp]
theorem mapβ_bot_right : mapβ m f β₯ = β₯ := mapβ_eq_bot_iff.2 <| .inr rfl
#align filter.mapβ_bot_right Filter.mapβ_bot_right
@[simp]
theorem mapβ_neBot_iff : (mapβ m f g).NeBot β f.NeBot β§ g.NeBot := by simp [neBot_iff, not_or]
#align filter.mapβ_ne_bot_iff Filter.mapβ_neBot_iff
protected theorem NeBot.mapβ (hf : f.NeBot) (hg : g.NeBot) : (mapβ m f g).NeBot :=
mapβ_neBot_iff.2 β¨hf, hgβ©
#align filter.ne_bot.mapβ Filter.NeBot.mapβ
instance mapβ.neBot [NeBot f] [NeBot g] : NeBot (mapβ m f g) := .mapβ βΉ_βΊ βΉ_βΊ
theorem NeBot.of_mapβ_left (h : (mapβ m f g).NeBot) : f.NeBot :=
(mapβ_neBot_iff.1 h).1
#align filter.ne_bot.of_mapβ_left Filter.NeBot.of_mapβ_left
theorem NeBot.of_mapβ_right (h : (mapβ m f g).NeBot) : g.NeBot :=
(mapβ_neBot_iff.1 h).2
#align filter.ne_bot.of_mapβ_right Filter.NeBot.of_mapβ_right
| Mathlib/Order/Filter/NAry.lean | 120 | 121 | theorem mapβ_sup_left : mapβ m (fβ β fβ) g = mapβ m fβ g β mapβ m fβ g := by |
simp_rw [β map_prod_eq_mapβ, sup_prod, map_sup]
| 1 | 2.718282 | 0 | 0 | 5 | 17 |
import Mathlib.LinearAlgebra.Quotient
import Mathlib.Algebra.Category.ModuleCat.Basic
#align_import algebra.category.Module.epi_mono from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe v u
open CategoryTheory
namespace ModuleCat
variable {R : Type u} [Ring R] {X Y : ModuleCat.{v} R} (f : X βΆ Y)
variable {M : Type v} [AddCommGroup M] [Module R M]
theorem ker_eq_bot_of_mono [Mono f] : LinearMap.ker f = β₯ :=
LinearMap.ker_eq_bot_of_cancel fun u v => (@cancel_mono _ _ _ _ _ f _ (βu) (βv)).1
set_option linter.uppercaseLean3 false in
#align Module.ker_eq_bot_of_mono ModuleCat.ker_eq_bot_of_mono
theorem range_eq_top_of_epi [Epi f] : LinearMap.range f = β€ :=
LinearMap.range_eq_top_of_cancel fun u v => (@cancel_epi _ _ _ _ _ f _ (βu) (βv)).1
set_option linter.uppercaseLean3 false in
#align Module.range_eq_top_of_epi ModuleCat.range_eq_top_of_epi
theorem mono_iff_ker_eq_bot : Mono f β LinearMap.ker f = β₯ :=
β¨fun hf => ker_eq_bot_of_mono _, fun hf =>
ConcreteCategory.mono_of_injective _ <| by convert LinearMap.ker_eq_bot.1 hfβ©
set_option linter.uppercaseLean3 false in
#align Module.mono_iff_ker_eq_bot ModuleCat.mono_iff_ker_eq_bot
| Mathlib/Algebra/Category/ModuleCat/EpiMono.lean | 44 | 45 | theorem mono_iff_injective : Mono f β Function.Injective f := by |
rw [mono_iff_ker_eq_bot, LinearMap.ker_eq_bot]
| 1 | 2.718282 | 0 | 0 | 2 | 18 |
import Mathlib.LinearAlgebra.Quotient
import Mathlib.Algebra.Category.ModuleCat.Basic
#align_import algebra.category.Module.epi_mono from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe v u
open CategoryTheory
namespace ModuleCat
variable {R : Type u} [Ring R] {X Y : ModuleCat.{v} R} (f : X βΆ Y)
variable {M : Type v} [AddCommGroup M] [Module R M]
theorem ker_eq_bot_of_mono [Mono f] : LinearMap.ker f = β₯ :=
LinearMap.ker_eq_bot_of_cancel fun u v => (@cancel_mono _ _ _ _ _ f _ (βu) (βv)).1
set_option linter.uppercaseLean3 false in
#align Module.ker_eq_bot_of_mono ModuleCat.ker_eq_bot_of_mono
theorem range_eq_top_of_epi [Epi f] : LinearMap.range f = β€ :=
LinearMap.range_eq_top_of_cancel fun u v => (@cancel_epi _ _ _ _ _ f _ (βu) (βv)).1
set_option linter.uppercaseLean3 false in
#align Module.range_eq_top_of_epi ModuleCat.range_eq_top_of_epi
theorem mono_iff_ker_eq_bot : Mono f β LinearMap.ker f = β₯ :=
β¨fun hf => ker_eq_bot_of_mono _, fun hf =>
ConcreteCategory.mono_of_injective _ <| by convert LinearMap.ker_eq_bot.1 hfβ©
set_option linter.uppercaseLean3 false in
#align Module.mono_iff_ker_eq_bot ModuleCat.mono_iff_ker_eq_bot
theorem mono_iff_injective : Mono f β Function.Injective f := by
rw [mono_iff_ker_eq_bot, LinearMap.ker_eq_bot]
set_option linter.uppercaseLean3 false in
#align Module.mono_iff_injective ModuleCat.mono_iff_injective
theorem epi_iff_range_eq_top : Epi f β LinearMap.range f = β€ :=
β¨fun _ => range_eq_top_of_epi _, fun hf =>
ConcreteCategory.epi_of_surjective _ <| LinearMap.range_eq_top.1 hfβ©
set_option linter.uppercaseLean3 false in
#align Module.epi_iff_range_eq_top ModuleCat.epi_iff_range_eq_top
| Mathlib/Algebra/Category/ModuleCat/EpiMono.lean | 55 | 56 | theorem epi_iff_surjective : Epi f β Function.Surjective f := by |
rw [epi_iff_range_eq_top, LinearMap.range_eq_top]
| 1 | 2.718282 | 0 | 0 | 2 | 18 |
import Mathlib.CategoryTheory.Monoidal.Types.Symmetric
import Mathlib.CategoryTheory.Monoidal.Types.Coyoneda
import Mathlib.CategoryTheory.Monoidal.Center
import Mathlib.Tactic.ApplyFun
#align_import category_theory.enriched.basic from "leanprover-community/mathlib"@"95a87616d63b3cb49d3fe678d416fbe9c4217bf4"
universe w v uβ uβ uβ
noncomputable section
namespace CategoryTheory
open Opposite
open MonoidalCategory
variable (V : Type v) [Category.{w} V] [MonoidalCategory V]
class EnrichedCategory (C : Type uβ) where
Hom : C β C β V
id (X : C) : π_ V βΆ Hom X X
comp (X Y Z : C) : Hom X Y β Hom Y Z βΆ Hom X Z
id_comp (X Y : C) : (Ξ»_ (Hom X Y)).inv β« id X β· _ β« comp X X Y = π _ := by aesop_cat
comp_id (X Y : C) : (Ο_ (Hom X Y)).inv β« _ β id Y β« comp X Y Y = π _ := by aesop_cat
assoc (W X Y Z : C) : (Ξ±_ _ _ _).inv β« comp W X Y β· _ β« comp W Y Z =
_ β comp X Y Z β« comp W X Z := by aesop_cat
#align category_theory.enriched_category CategoryTheory.EnrichedCategory
notation X " βΆ[" V "] " Y:10 => (EnrichedCategory.Hom X Y : V)
variable {C : Type uβ} [EnrichedCategory V C]
def eId (X : C) : π_ V βΆ X βΆ[V] X :=
EnrichedCategory.id X
#align category_theory.e_id CategoryTheory.eId
def eComp (X Y Z : C) : ((X βΆ[V] Y) β Y βΆ[V] Z) βΆ X βΆ[V] Z :=
EnrichedCategory.comp X Y Z
#align category_theory.e_comp CategoryTheory.eComp
@[reassoc (attr := simp)]
theorem e_id_comp (X Y : C) :
(Ξ»_ (X βΆ[V] Y)).inv β« eId V X β· _ β« eComp V X X Y = π (X βΆ[V] Y) :=
EnrichedCategory.id_comp X Y
#align category_theory.e_id_comp CategoryTheory.e_id_comp
@[reassoc (attr := simp)]
theorem e_comp_id (X Y : C) :
(Ο_ (X βΆ[V] Y)).inv β« _ β eId V Y β« eComp V X Y Y = π (X βΆ[V] Y) :=
EnrichedCategory.comp_id X Y
#align category_theory.e_comp_id CategoryTheory.e_comp_id
@[reassoc (attr := simp)]
theorem e_assoc (W X Y Z : C) :
(Ξ±_ _ _ _).inv β« eComp V W X Y β· _ β« eComp V W Y Z =
_ β eComp V X Y Z β« eComp V W X Z :=
EnrichedCategory.assoc W X Y Z
#align category_theory.e_assoc CategoryTheory.e_assoc
@[reassoc]
| Mathlib/CategoryTheory/Enriched/Basic.lean | 98 | 101 | theorem e_assoc' (W X Y Z : C) :
(Ξ±_ _ _ _).hom β« _ β eComp V X Y Z β« eComp V W X Z =
eComp V W X Y β· _ β« eComp V W Y Z := by |
rw [β e_assoc V W X Y Z, Iso.hom_inv_id_assoc]
| 1 | 2.718282 | 0 | 0 | 1 | 19 |
import Mathlib.Init.Algebra.Classes
import Mathlib.Init.Data.Ordering.Basic
#align_import init.data.ordering.lemmas from "leanprover-community/lean"@"4bd314f7bd5e0c9e813fc201f1279a23f13f9f1d"
universe u
namespace Ordering
@[simp]
| Mathlib/Init/Data/Ordering/Lemmas.lean | 20 | 22 | theorem ite_eq_lt_distrib (c : Prop) [Decidable c] (a b : Ordering) :
((if c then a else b) = Ordering.lt) = if c then a = Ordering.lt else b = Ordering.lt := by |
by_cases c <;> simp [*]
| 1 | 2.718282 | 0 | 0 | 3 | 20 |
import Mathlib.Init.Algebra.Classes
import Mathlib.Init.Data.Ordering.Basic
#align_import init.data.ordering.lemmas from "leanprover-community/lean"@"4bd314f7bd5e0c9e813fc201f1279a23f13f9f1d"
universe u
namespace Ordering
@[simp]
theorem ite_eq_lt_distrib (c : Prop) [Decidable c] (a b : Ordering) :
((if c then a else b) = Ordering.lt) = if c then a = Ordering.lt else b = Ordering.lt := by
by_cases c <;> simp [*]
#align ordering.ite_eq_lt_distrib Ordering.ite_eq_lt_distrib
@[simp]
| Mathlib/Init/Data/Ordering/Lemmas.lean | 26 | 28 | theorem ite_eq_eq_distrib (c : Prop) [Decidable c] (a b : Ordering) :
((if c then a else b) = Ordering.eq) = if c then a = Ordering.eq else b = Ordering.eq := by |
by_cases c <;> simp [*]
| 1 | 2.718282 | 0 | 0 | 3 | 20 |
import Mathlib.Init.Algebra.Classes
import Mathlib.Init.Data.Ordering.Basic
#align_import init.data.ordering.lemmas from "leanprover-community/lean"@"4bd314f7bd5e0c9e813fc201f1279a23f13f9f1d"
universe u
namespace Ordering
@[simp]
theorem ite_eq_lt_distrib (c : Prop) [Decidable c] (a b : Ordering) :
((if c then a else b) = Ordering.lt) = if c then a = Ordering.lt else b = Ordering.lt := by
by_cases c <;> simp [*]
#align ordering.ite_eq_lt_distrib Ordering.ite_eq_lt_distrib
@[simp]
theorem ite_eq_eq_distrib (c : Prop) [Decidable c] (a b : Ordering) :
((if c then a else b) = Ordering.eq) = if c then a = Ordering.eq else b = Ordering.eq := by
by_cases c <;> simp [*]
#align ordering.ite_eq_eq_distrib Ordering.ite_eq_eq_distrib
@[simp]
| Mathlib/Init/Data/Ordering/Lemmas.lean | 32 | 34 | theorem ite_eq_gt_distrib (c : Prop) [Decidable c] (a b : Ordering) :
((if c then a else b) = Ordering.gt) = if c then a = Ordering.gt else b = Ordering.gt := by |
by_cases c <;> simp [*]
| 1 | 2.718282 | 0 | 0 | 3 | 20 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 30 | 32 | theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 36 | 38 | theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 42 | 43 | theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by | coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 47 | 48 | theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by
coherence
#align category_theory.monoidal_category.id_tensor_right_unitor_inv CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 52 | 53 | theorem leftUnitor_inv_tensor_id (X Y : C) : (Ξ»_ X).inv β π Y = (Ξ»_ _).inv β« (Ξ±_ _ _ _).inv := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by
coherence
#align category_theory.monoidal_category.id_tensor_right_unitor_inv CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
theorem leftUnitor_inv_tensor_id (X Y : C) : (Ξ»_ X).inv β π Y = (Ξ»_ _).inv β« (Ξ±_ _ _ _).inv := by
coherence
#align category_theory.monoidal_category.left_unitor_inv_tensor_id CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 57 | 60 | theorem pentagon_inv_inv_hom (W X Y Z : C) :
(Ξ±_ W (X β Y) Z).inv β« ((Ξ±_ W X Y).inv β π Z) β« (Ξ±_ (W β X) Y Z).hom =
(π W β (Ξ±_ X Y Z).hom) β« (Ξ±_ W X (Y β Z)).inv := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by
coherence
#align category_theory.monoidal_category.id_tensor_right_unitor_inv CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
theorem leftUnitor_inv_tensor_id (X Y : C) : (Ξ»_ X).inv β π Y = (Ξ»_ _).inv β« (Ξ±_ _ _ _).inv := by
coherence
#align category_theory.monoidal_category.left_unitor_inv_tensor_id CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
@[reassoc]
theorem pentagon_inv_inv_hom (W X Y Z : C) :
(Ξ±_ W (X β Y) Z).inv β« ((Ξ±_ W X Y).inv β π Z) β« (Ξ±_ (W β X) Y Z).hom =
(π W β (Ξ±_ X Y Z).hom) β« (Ξ±_ W X (Y β Z)).inv := by
coherence
#align category_theory.monoidal_category.pentagon_inv_inv_hom CategoryTheory.MonoidalCategory.pentagon_inv_inv_hom
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 63 | 64 | theorem unitors_equal : (Ξ»_ (π_ C)).hom = (Ο_ (π_ C)).hom := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by
coherence
#align category_theory.monoidal_category.id_tensor_right_unitor_inv CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
theorem leftUnitor_inv_tensor_id (X Y : C) : (Ξ»_ X).inv β π Y = (Ξ»_ _).inv β« (Ξ±_ _ _ _).inv := by
coherence
#align category_theory.monoidal_category.left_unitor_inv_tensor_id CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
@[reassoc]
theorem pentagon_inv_inv_hom (W X Y Z : C) :
(Ξ±_ W (X β Y) Z).inv β« ((Ξ±_ W X Y).inv β π Z) β« (Ξ±_ (W β X) Y Z).hom =
(π W β (Ξ±_ X Y Z).hom) β« (Ξ±_ W X (Y β Z)).inv := by
coherence
#align category_theory.monoidal_category.pentagon_inv_inv_hom CategoryTheory.MonoidalCategory.pentagon_inv_inv_hom
theorem unitors_equal : (Ξ»_ (π_ C)).hom = (Ο_ (π_ C)).hom := by
coherence
#align category_theory.monoidal_category.unitors_equal CategoryTheory.MonoidalCategory.unitors_equal
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 67 | 68 | theorem unitors_inv_equal : (Ξ»_ (π_ C)).inv = (Ο_ (π_ C)).inv := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by
coherence
#align category_theory.monoidal_category.id_tensor_right_unitor_inv CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
theorem leftUnitor_inv_tensor_id (X Y : C) : (Ξ»_ X).inv β π Y = (Ξ»_ _).inv β« (Ξ±_ _ _ _).inv := by
coherence
#align category_theory.monoidal_category.left_unitor_inv_tensor_id CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
@[reassoc]
theorem pentagon_inv_inv_hom (W X Y Z : C) :
(Ξ±_ W (X β Y) Z).inv β« ((Ξ±_ W X Y).inv β π Z) β« (Ξ±_ (W β X) Y Z).hom =
(π W β (Ξ±_ X Y Z).hom) β« (Ξ±_ W X (Y β Z)).inv := by
coherence
#align category_theory.monoidal_category.pentagon_inv_inv_hom CategoryTheory.MonoidalCategory.pentagon_inv_inv_hom
theorem unitors_equal : (Ξ»_ (π_ C)).hom = (Ο_ (π_ C)).hom := by
coherence
#align category_theory.monoidal_category.unitors_equal CategoryTheory.MonoidalCategory.unitors_equal
theorem unitors_inv_equal : (Ξ»_ (π_ C)).inv = (Ο_ (π_ C)).inv := by
coherence
#align category_theory.monoidal_category.unitors_inv_equal CategoryTheory.MonoidalCategory.unitors_inv_equal
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 72 | 75 | theorem pentagon_hom_inv {W X Y Z : C} :
(Ξ±_ W X (Y β Z)).hom β« (π W β (Ξ±_ X Y Z).inv) =
(Ξ±_ (W β X) Y Z).inv β« ((Ξ±_ W X Y).hom β π Z) β« (Ξ±_ W (X β Y) Z).hom := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Tactic.CategoryTheory.Coherence
import Mathlib.CategoryTheory.Monoidal.Free.Coherence
#align_import category_theory.monoidal.coherence_lemmas from "leanprover-community/mathlib"@"b8b8bf3ea0c625fa1f950034a184e07c67f7bcfe"
open CategoryTheory Category Iso
namespace CategoryTheory.MonoidalCategory
variable {C : Type*} [Category C] [MonoidalCategory C]
-- See Proposition 2.2.4 of <http://www-math.mit.edu/~etingof/egnobookfinal.pdf>
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
(Ξ±_ (π_ C) X Y).hom β« (Ξ»_ (X β Y)).hom = (Ξ»_ X).hom β π Y := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor' CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
(Ξ»_ (X β Y)).hom = (Ξ±_ (π_ C) X Y).inv β« ((Ξ»_ X).hom β π Y) := by
coherence
#align category_theory.monoidal_category.left_unitor_tensor CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
(Ξ»_ (X β Y)).inv = ((Ξ»_ X).inv β π Y) β« (Ξ±_ (π_ C) X Y).hom := by coherence
#align category_theory.monoidal_category.left_unitor_tensor_inv CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : π X β (Ο_ Y).inv = (Ο_ _).inv β« (Ξ±_ _ _ _).hom := by
coherence
#align category_theory.monoidal_category.id_tensor_right_unitor_inv CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
theorem leftUnitor_inv_tensor_id (X Y : C) : (Ξ»_ X).inv β π Y = (Ξ»_ _).inv β« (Ξ±_ _ _ _).inv := by
coherence
#align category_theory.monoidal_category.left_unitor_inv_tensor_id CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
@[reassoc]
theorem pentagon_inv_inv_hom (W X Y Z : C) :
(Ξ±_ W (X β Y) Z).inv β« ((Ξ±_ W X Y).inv β π Z) β« (Ξ±_ (W β X) Y Z).hom =
(π W β (Ξ±_ X Y Z).hom) β« (Ξ±_ W X (Y β Z)).inv := by
coherence
#align category_theory.monoidal_category.pentagon_inv_inv_hom CategoryTheory.MonoidalCategory.pentagon_inv_inv_hom
theorem unitors_equal : (Ξ»_ (π_ C)).hom = (Ο_ (π_ C)).hom := by
coherence
#align category_theory.monoidal_category.unitors_equal CategoryTheory.MonoidalCategory.unitors_equal
theorem unitors_inv_equal : (Ξ»_ (π_ C)).inv = (Ο_ (π_ C)).inv := by
coherence
#align category_theory.monoidal_category.unitors_inv_equal CategoryTheory.MonoidalCategory.unitors_inv_equal
@[reassoc]
theorem pentagon_hom_inv {W X Y Z : C} :
(Ξ±_ W X (Y β Z)).hom β« (π W β (Ξ±_ X Y Z).inv) =
(Ξ±_ (W β X) Y Z).inv β« ((Ξ±_ W X Y).hom β π Z) β« (Ξ±_ W (X β Y) Z).hom := by
coherence
#align category_theory.monoidal_category.pentagon_hom_inv CategoryTheory.MonoidalCategory.pentagon_hom_inv
@[reassoc]
| Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean | 79 | 82 | theorem pentagon_inv_hom (W X Y Z : C) :
(Ξ±_ (W β X) Y Z).inv β« ((Ξ±_ W X Y).hom β π Z) =
(Ξ±_ W X (Y β Z)).hom β« (π W β (Ξ±_ X Y Z).inv) β« (Ξ±_ W (X β Y) Z).inv := by |
coherence
| 1 | 2.718282 | 0 | 0 | 10 | 21 |
import Mathlib.Probability.ProbabilityMassFunction.Constructions
import Mathlib.Tactic.FinCases
namespace PMF
open ENNReal
noncomputable
def binomial (p : ββ₯0β) (h : p β€ 1) (n : β) : PMF (Fin (n + 1)) :=
.ofFintype (fun i => p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β)) (by
convert (add_pow p (1-p) n).symm
Β· rw [Finset.sum_fin_eq_sum_range]
apply Finset.sum_congr rfl
intro i hi
rw [Finset.mem_range] at hi
rw [dif_pos hi, Fin.last]
Β· simp [h])
theorem binomial_apply (p : ββ₯0β) (h : p β€ 1) (n : β) (i : Fin (n + 1)) :
binomial p h n i = p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β) := rfl
@[simp]
| Mathlib/Probability/ProbabilityMassFunction/Binomial.lean | 40 | 42 | theorem binomial_apply_zero (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n 0 = (1-p)^n := by |
simp [binomial_apply]
| 1 | 2.718282 | 0 | 0 | 4 | 22 |
import Mathlib.Probability.ProbabilityMassFunction.Constructions
import Mathlib.Tactic.FinCases
namespace PMF
open ENNReal
noncomputable
def binomial (p : ββ₯0β) (h : p β€ 1) (n : β) : PMF (Fin (n + 1)) :=
.ofFintype (fun i => p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β)) (by
convert (add_pow p (1-p) n).symm
Β· rw [Finset.sum_fin_eq_sum_range]
apply Finset.sum_congr rfl
intro i hi
rw [Finset.mem_range] at hi
rw [dif_pos hi, Fin.last]
Β· simp [h])
theorem binomial_apply (p : ββ₯0β) (h : p β€ 1) (n : β) (i : Fin (n + 1)) :
binomial p h n i = p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β) := rfl
@[simp]
theorem binomial_apply_zero (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n 0 = (1-p)^n := by
simp [binomial_apply]
@[simp]
| Mathlib/Probability/ProbabilityMassFunction/Binomial.lean | 45 | 47 | theorem binomial_apply_last (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n (.last n) = p^n := by |
simp [binomial_apply]
| 1 | 2.718282 | 0 | 0 | 4 | 22 |
import Mathlib.Probability.ProbabilityMassFunction.Constructions
import Mathlib.Tactic.FinCases
namespace PMF
open ENNReal
noncomputable
def binomial (p : ββ₯0β) (h : p β€ 1) (n : β) : PMF (Fin (n + 1)) :=
.ofFintype (fun i => p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β)) (by
convert (add_pow p (1-p) n).symm
Β· rw [Finset.sum_fin_eq_sum_range]
apply Finset.sum_congr rfl
intro i hi
rw [Finset.mem_range] at hi
rw [dif_pos hi, Fin.last]
Β· simp [h])
theorem binomial_apply (p : ββ₯0β) (h : p β€ 1) (n : β) (i : Fin (n + 1)) :
binomial p h n i = p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β) := rfl
@[simp]
theorem binomial_apply_zero (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n 0 = (1-p)^n := by
simp [binomial_apply]
@[simp]
theorem binomial_apply_last (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n (.last n) = p^n := by
simp [binomial_apply]
| Mathlib/Probability/ProbabilityMassFunction/Binomial.lean | 49 | 50 | theorem binomial_apply_self (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n n = p^n := by | simp
| 1 | 2.718282 | 0 | 0 | 4 | 22 |
import Mathlib.Probability.ProbabilityMassFunction.Constructions
import Mathlib.Tactic.FinCases
namespace PMF
open ENNReal
noncomputable
def binomial (p : ββ₯0β) (h : p β€ 1) (n : β) : PMF (Fin (n + 1)) :=
.ofFintype (fun i => p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β)) (by
convert (add_pow p (1-p) n).symm
Β· rw [Finset.sum_fin_eq_sum_range]
apply Finset.sum_congr rfl
intro i hi
rw [Finset.mem_range] at hi
rw [dif_pos hi, Fin.last]
Β· simp [h])
theorem binomial_apply (p : ββ₯0β) (h : p β€ 1) (n : β) (i : Fin (n + 1)) :
binomial p h n i = p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β) := rfl
@[simp]
theorem binomial_apply_zero (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n 0 = (1-p)^n := by
simp [binomial_apply]
@[simp]
theorem binomial_apply_last (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n (.last n) = p^n := by
simp [binomial_apply]
theorem binomial_apply_self (p : ββ₯0β) (h : p β€ 1) (n : β) :
binomial p h n n = p^n := by simp
| Mathlib/Probability/ProbabilityMassFunction/Binomial.lean | 53 | 55 | theorem binomial_one_eq_bernoulli (p : ββ₯0β) (h : p β€ 1) :
binomial p h 1 = (bernoulli p h).map (cond Β· 1 0) := by |
ext i; fin_cases i <;> simp [tsum_bool, binomial_apply]
| 1 | 2.718282 | 0 | 0 | 4 | 22 |
import Mathlib.Algebra.Algebra.Prod
import Mathlib.Algebra.Algebra.Subalgebra.Basic
#align_import algebra.algebra.subalgebra.basic from "leanprover-community/mathlib"@"b915e9392ecb2a861e1e766f0e1df6ac481188ca"
namespace Subalgebra
open Algebra
variable {R A B : Type*} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B]
variable (S : Subalgebra R A) (Sβ : Subalgebra R B)
def prod : Subalgebra R (A Γ B) :=
{ S.toSubsemiring.prod Sβ.toSubsemiring with
carrier := S ΓΛ’ Sβ
algebraMap_mem' := fun _ => β¨algebraMap_mem _ _, algebraMap_mem _ _β© }
#align subalgebra.prod Subalgebra.prod
@[simp]
theorem coe_prod : (prod S Sβ : Set (A Γ B)) = (S : Set A) ΓΛ’ (Sβ : Set B) :=
rfl
#align subalgebra.coe_prod Subalgebra.coe_prod
open Subalgebra in
theorem prod_toSubmodule : toSubmodule (S.prod Sβ) = (toSubmodule S).prod (toSubmodule Sβ) := rfl
#align subalgebra.prod_to_submodule Subalgebra.prod_toSubmodule
@[simp]
theorem mem_prod {S : Subalgebra R A} {Sβ : Subalgebra R B} {x : A Γ B} :
x β prod S Sβ β x.1 β S β§ x.2 β Sβ := Set.mem_prod
#align subalgebra.mem_prod Subalgebra.mem_prod
@[simp]
| Mathlib/Algebra/Algebra/Subalgebra/Prod.lean | 51 | 51 | theorem prod_top : (prod β€ β€ : Subalgebra R (A Γ B)) = β€ := by | ext; simp
| 1 | 2.718282 | 0 | 0 | 1 | 23 |
import Mathlib.Order.Filter.Cofinite
#align_import data.analysis.filter from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
open Set Filter
-- Porting note (#11215): TODO write doc strings
structure CFilter (Ξ± Ο : Type*) [PartialOrder Ξ±] where
f : Ο β Ξ±
pt : Ο
inf : Ο β Ο β Ο
inf_le_left : β a b : Ο, f (inf a b) β€ f a
inf_le_right : β a b : Ο, f (inf a b) β€ f b
#align cfilter CFilter
variable {Ξ± : Type*} {Ξ² : Type*} {Ο : Type*} {Ο : Type*}
instance [Inhabited Ξ±] [SemilatticeInf Ξ±] : Inhabited (CFilter Ξ± Ξ±) :=
β¨{ f := id
pt := default
inf := (Β· β Β·)
inf_le_left := fun _ _ β¦ inf_le_left
inf_le_right := fun _ _ β¦ inf_le_right }β©
namespace CFilter
section
variable [PartialOrder Ξ±] (F : CFilter Ξ± Ο)
instance : CoeFun (CFilter Ξ± Ο) fun _ β¦ Ο β Ξ± :=
β¨CFilter.fβ©
-- @[simp]
theorem coe_mk (f pt inf hβ hβ a) : (@CFilter.mk Ξ± Ο _ f pt inf hβ hβ) a = f a :=
rfl
#align cfilter.coe_mk CFilter.coe_mk
def ofEquiv (E : Ο β Ο) : CFilter Ξ± Ο β CFilter Ξ± Ο
| β¨f, p, g, hβ, hββ© =>
{ f := fun a β¦ f (E.symm a)
pt := E p
inf := fun a b β¦ E (g (E.symm a) (E.symm b))
inf_le_left := fun a b β¦ by simpa using hβ (E.symm a) (E.symm b)
inf_le_right := fun a b β¦ by simpa using hβ (E.symm a) (E.symm b) }
#align cfilter.of_equiv CFilter.ofEquiv
@[simp]
| Mathlib/Data/Analysis/Filter.lean | 74 | 75 | theorem ofEquiv_val (E : Ο β Ο) (F : CFilter Ξ± Ο) (a : Ο) : F.ofEquiv E a = F (E.symm a) := by |
cases F; rfl
| 1 | 2.718282 | 0 | 0 | 1 | 24 |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section PartialOrder
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [PartialOrder Ξ±] [TopologicalSpace Ξ²]
| Mathlib/Topology/Order/LeftRight.lean | 95 | 97 | theorem continuousWithinAt_Ioi_iff_Ici {a : Ξ±} {f : Ξ± β Ξ²} :
ContinuousWithinAt f (Ioi a) a β ContinuousWithinAt f (Ici a) a := by |
simp only [β Ici_diff_left, continuousWithinAt_diff_self]
| 1 | 2.718282 | 0 | 0 | 6 | 25 |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
| Mathlib/Topology/Order/LeftRight.lean | 111 | 112 | theorem nhds_left_sup_nhds_right (a : Ξ±) : π[β€] a β π[β₯] a = π a := by |
rw [β nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
| 1 | 2.718282 | 0 | 0 | 6 | 25 |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
theorem nhds_left_sup_nhds_right (a : Ξ±) : π[β€] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
#align nhds_left_sup_nhds_right nhds_left_sup_nhds_right
| Mathlib/Topology/Order/LeftRight.lean | 115 | 116 | theorem nhds_left'_sup_nhds_right (a : Ξ±) : π[<] a β π[β₯] a = π a := by |
rw [β nhdsWithin_union, Iio_union_Ici, nhdsWithin_univ]
| 1 | 2.718282 | 0 | 0 | 6 | 25 |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
theorem nhds_left_sup_nhds_right (a : Ξ±) : π[β€] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
#align nhds_left_sup_nhds_right nhds_left_sup_nhds_right
theorem nhds_left'_sup_nhds_right (a : Ξ±) : π[<] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iio_union_Ici, nhdsWithin_univ]
#align nhds_left'_sup_nhds_right nhds_left'_sup_nhds_right
| Mathlib/Topology/Order/LeftRight.lean | 119 | 120 | theorem nhds_left_sup_nhds_right' (a : Ξ±) : π[β€] a β π[>] a = π a := by |
rw [β nhdsWithin_union, Iic_union_Ioi, nhdsWithin_univ]
| 1 | 2.718282 | 0 | 0 | 6 | 25 |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
theorem nhds_left_sup_nhds_right (a : Ξ±) : π[β€] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
#align nhds_left_sup_nhds_right nhds_left_sup_nhds_right
theorem nhds_left'_sup_nhds_right (a : Ξ±) : π[<] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iio_union_Ici, nhdsWithin_univ]
#align nhds_left'_sup_nhds_right nhds_left'_sup_nhds_right
theorem nhds_left_sup_nhds_right' (a : Ξ±) : π[β€] a β π[>] a = π a := by
rw [β nhdsWithin_union, Iic_union_Ioi, nhdsWithin_univ]
#align nhds_left_sup_nhds_right' nhds_left_sup_nhds_right'
| Mathlib/Topology/Order/LeftRight.lean | 123 | 124 | theorem nhds_left'_sup_nhds_right' (a : Ξ±) : π[<] a β π[>] a = π[β ] a := by |
rw [β nhdsWithin_union, Iio_union_Ioi]
| 1 | 2.718282 | 0 | 0 | 6 | 25 |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
theorem nhds_left_sup_nhds_right (a : Ξ±) : π[β€] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
#align nhds_left_sup_nhds_right nhds_left_sup_nhds_right
theorem nhds_left'_sup_nhds_right (a : Ξ±) : π[<] a β π[β₯] a = π a := by
rw [β nhdsWithin_union, Iio_union_Ici, nhdsWithin_univ]
#align nhds_left'_sup_nhds_right nhds_left'_sup_nhds_right
theorem nhds_left_sup_nhds_right' (a : Ξ±) : π[β€] a β π[>] a = π a := by
rw [β nhdsWithin_union, Iic_union_Ioi, nhdsWithin_univ]
#align nhds_left_sup_nhds_right' nhds_left_sup_nhds_right'
theorem nhds_left'_sup_nhds_right' (a : Ξ±) : π[<] a β π[>] a = π[β ] a := by
rw [β nhdsWithin_union, Iio_union_Ioi]
#align nhds_left'_sup_nhds_right' nhds_left'_sup_nhds_right'
| Mathlib/Topology/Order/LeftRight.lean | 127 | 129 | theorem continuousAt_iff_continuous_left_right {a : Ξ±} {f : Ξ± β Ξ²} :
ContinuousAt f a β ContinuousWithinAt f (Iic a) a β§ ContinuousWithinAt f (Ici a) a := by |
simp only [ContinuousWithinAt, ContinuousAt, β tendsto_sup, nhds_left_sup_nhds_right]
| 1 | 2.718282 | 0 | 0 | 6 | 25 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.deriv.add from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L : Filter π}
section Add
nonrec theorem HasDerivAtFilter.add (hf : HasDerivAtFilter f f' x L)
(hg : HasDerivAtFilter g g' x L) : HasDerivAtFilter (fun y => f y + g y) (f' + g') x L := by
simpa using (hf.add hg).hasDerivAtFilter
#align has_deriv_at_filter.add HasDerivAtFilter.add
nonrec theorem HasStrictDerivAt.add (hf : HasStrictDerivAt f f' x) (hg : HasStrictDerivAt g g' x) :
HasStrictDerivAt (fun y => f y + g y) (f' + g') x := by simpa using (hf.add hg).hasStrictDerivAt
#align has_strict_deriv_at.add HasStrictDerivAt.add
nonrec theorem HasDerivWithinAt.add (hf : HasDerivWithinAt f f' s x)
(hg : HasDerivWithinAt g g' s x) : HasDerivWithinAt (fun y => f y + g y) (f' + g') s x :=
hf.add hg
#align has_deriv_within_at.add HasDerivWithinAt.add
nonrec theorem HasDerivAt.add (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x) :
HasDerivAt (fun x => f x + g x) (f' + g') x :=
hf.add hg
#align has_deriv_at.add HasDerivAt.add
theorem derivWithin_add (hxs : UniqueDiffWithinAt π s x) (hf : DifferentiableWithinAt π f s x)
(hg : DifferentiableWithinAt π g s x) :
derivWithin (fun y => f y + g y) s x = derivWithin f s x + derivWithin g s x :=
(hf.hasDerivWithinAt.add hg.hasDerivWithinAt).derivWithin hxs
#align deriv_within_add derivWithin_add
@[simp]
theorem deriv_add (hf : DifferentiableAt π f x) (hg : DifferentiableAt π g x) :
deriv (fun y => f y + g y) x = deriv f x + deriv g x :=
(hf.hasDerivAt.add hg.hasDerivAt).deriv
#align deriv_add deriv_add
-- Porting note (#10756): new theorem
theorem HasStrictDerivAt.add_const (c : F) (hf : HasStrictDerivAt f f' x) :
HasStrictDerivAt (fun y β¦ f y + c) f' x :=
add_zero f' βΈ hf.add (hasStrictDerivAt_const x c)
theorem HasDerivAtFilter.add_const (hf : HasDerivAtFilter f f' x L) (c : F) :
HasDerivAtFilter (fun y => f y + c) f' x L :=
add_zero f' βΈ hf.add (hasDerivAtFilter_const x L c)
#align has_deriv_at_filter.add_const HasDerivAtFilter.add_const
nonrec theorem HasDerivWithinAt.add_const (hf : HasDerivWithinAt f f' s x) (c : F) :
HasDerivWithinAt (fun y => f y + c) f' s x :=
hf.add_const c
#align has_deriv_within_at.add_const HasDerivWithinAt.add_const
nonrec theorem HasDerivAt.add_const (hf : HasDerivAt f f' x) (c : F) :
HasDerivAt (fun x => f x + c) f' x :=
hf.add_const c
#align has_deriv_at.add_const HasDerivAt.add_const
| Mathlib/Analysis/Calculus/Deriv/Add.lean | 97 | 99 | theorem derivWithin_add_const (hxs : UniqueDiffWithinAt π s x) (c : F) :
derivWithin (fun y => f y + c) s x = derivWithin f s x := by |
simp only [derivWithin, fderivWithin_add_const hxs]
| 1 | 2.718282 | 0 | 0 | 8 | 26 |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.deriv.add from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Topology Filter ENNReal
open Filter Asymptotics Set
variable {π : Type u} [NontriviallyNormedField π]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace π E]
variable {f fβ fβ g : π β F}
variable {f' fβ' fβ' g' : F}
variable {x : π}
variable {s t : Set π}
variable {L : Filter π}
section Add
nonrec theorem HasDerivAtFilter.add (hf : HasDerivAtFilter f f' x L)
(hg : HasDerivAtFilter g g' x L) : HasDerivAtFilter (fun y => f y + g y) (f' + g') x L := by
simpa using (hf.add hg).hasDerivAtFilter
#align has_deriv_at_filter.add HasDerivAtFilter.add
nonrec theorem HasStrictDerivAt.add (hf : HasStrictDerivAt f f' x) (hg : HasStrictDerivAt g g' x) :
HasStrictDerivAt (fun y => f y + g y) (f' + g') x := by simpa using (hf.add hg).hasStrictDerivAt
#align has_strict_deriv_at.add HasStrictDerivAt.add
nonrec theorem HasDerivWithinAt.add (hf : HasDerivWithinAt f f' s x)
(hg : HasDerivWithinAt g g' s x) : HasDerivWithinAt (fun y => f y + g y) (f' + g') s x :=
hf.add hg
#align has_deriv_within_at.add HasDerivWithinAt.add
nonrec theorem HasDerivAt.add (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x) :
HasDerivAt (fun x => f x + g x) (f' + g') x :=
hf.add hg
#align has_deriv_at.add HasDerivAt.add
theorem derivWithin_add (hxs : UniqueDiffWithinAt π s x) (hf : DifferentiableWithinAt π f s x)
(hg : DifferentiableWithinAt π g s x) :
derivWithin (fun y => f y + g y) s x = derivWithin f s x + derivWithin g s x :=
(hf.hasDerivWithinAt.add hg.hasDerivWithinAt).derivWithin hxs
#align deriv_within_add derivWithin_add
@[simp]
theorem deriv_add (hf : DifferentiableAt π f x) (hg : DifferentiableAt π g x) :
deriv (fun y => f y + g y) x = deriv f x + deriv g x :=
(hf.hasDerivAt.add hg.hasDerivAt).deriv
#align deriv_add deriv_add
-- Porting note (#10756): new theorem
theorem HasStrictDerivAt.add_const (c : F) (hf : HasStrictDerivAt f f' x) :
HasStrictDerivAt (fun y β¦ f y + c) f' x :=
add_zero f' βΈ hf.add (hasStrictDerivAt_const x c)
theorem HasDerivAtFilter.add_const (hf : HasDerivAtFilter f f' x L) (c : F) :
HasDerivAtFilter (fun y => f y + c) f' x L :=
add_zero f' βΈ hf.add (hasDerivAtFilter_const x L c)
#align has_deriv_at_filter.add_const HasDerivAtFilter.add_const
nonrec theorem HasDerivWithinAt.add_const (hf : HasDerivWithinAt f f' s x) (c : F) :
HasDerivWithinAt (fun y => f y + c) f' s x :=
hf.add_const c
#align has_deriv_within_at.add_const HasDerivWithinAt.add_const
nonrec theorem HasDerivAt.add_const (hf : HasDerivAt f f' x) (c : F) :
HasDerivAt (fun x => f x + c) f' x :=
hf.add_const c
#align has_deriv_at.add_const HasDerivAt.add_const
theorem derivWithin_add_const (hxs : UniqueDiffWithinAt π s x) (c : F) :
derivWithin (fun y => f y + c) s x = derivWithin f s x := by
simp only [derivWithin, fderivWithin_add_const hxs]
#align deriv_within_add_const derivWithin_add_const
| Mathlib/Analysis/Calculus/Deriv/Add.lean | 102 | 103 | theorem deriv_add_const (c : F) : deriv (fun y => f y + c) x = deriv f x := by |
simp only [deriv, fderiv_add_const]
| 1 | 2.718282 | 0 | 0 | 8 | 26 |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4