algebra.lie.basic - mathlib docs

source

@[class]

structure lie_ring (L : Type v) :

Type v

to_add_comm_group : add_comm_group L
to_has_bracket : has_bracket L L
add_lie : ∀ (x y z : L), ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
lie_add : ∀ (x y z : L), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
lie_self : ∀ (x : L), ⁅x, x⁆ = 0
leibniz_lie : ∀ (x y z : L), ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆

A Lie ring is an additive group with compatible product, known as the bracket, satisfying the Jacobi identity.

Instances of this typeclass

Instances of other typeclasses for lie_ring

lie_ring.has_sizeof_inst

source

@[class]

structure lie_algebra (R : Type u) (L : Type v) [comm_ring R] [lie_ring L] :

Type (max u v)

to_module : module R L
lie_smul : ∀ (t : R) (x y : L), ⁅x, t • y⁆ = t • ⁅x, y⁆

A Lie algebra is a module with compatible product, known as the bracket, satisfying the Jacobi identity. Forgetting the scalar multiplication, every Lie algebra is a Lie ring.

Instances of this typeclass

Instances of other typeclasses for lie_algebra

lie_algebra.has_sizeof_inst

source

@[class]

structure lie_ring_module (L : Type v) (M : Type w) [lie_ring L] [add_comm_group M] :

Type (max v w)

to_has_bracket : has_bracket L M
add_lie : ∀ (x y : L) (m : M), ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆
lie_add : ∀ (x : L) (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆
leibniz_lie : ∀ (x y : L) (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆

A Lie ring module is an additive group, together with an additive action of a Lie ring on this group, such that the Lie bracket acts as the commutator of endomorphisms. (For representations of Lie algebras see lie_module.)

Instances of this typeclass

Instances of other typeclasses for lie_ring_module

lie_ring_module.has_sizeof_inst

source

@[class]

structure lie_module (R : Type u) (L : Type v) (M : Type w) [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] :

Type

smul_lie : ∀ (t : R) (x : L) (m : M), ⁅t • x, m⁆ = t • ⁅x, m⁆
lie_smul : ∀ (t : R) (x : L) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆

A Lie module is a module over a commutative ring, together with a linear action of a Lie algebra on this module, such that the Lie bracket acts as the commutator of endomorphisms.

Instances of this typeclass

Instances of other typeclasses for lie_module

lie_module.has_sizeof_inst

source

@[simp]

theorem add_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x y : L) (m : M) :

⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆

source

@[simp]

theorem lie_add {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m n : M) :

⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆

source

@[simp]

theorem smul_lie {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] (t : R) (x : L) (m : M) :

⁅t • x, m⁆ = t • ⁅x, m⁆

source

@[simp]

theorem lie_smul {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] (t : R) (x : L) (m : M) :

⁅x, t • m⁆ = t • ⁅x, m⁆

source

theorem leibniz_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x y : L) (m : M) :

⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆

source

@[simp]

theorem lie_zero {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) :

⁅x, 0⁆ = 0

source

@[simp]

theorem zero_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (m : M) :

⁅0, m⁆ = 0

source

@[simp]

theorem lie_self {L : Type v} [lie_ring L] (x : L) :

⁅x, x⁆ = 0

source

@[protected, instance]

def lie_ring_self_module {L : Type v} [lie_ring L] :

lie_ring_module L L

Equations

lie_ring_self_module = {to_has_bracket := lie_ring.to_has_bracket infer_instance, add_lie := _, lie_add := _, leibniz_lie := _}

source

@[simp]

theorem lie_skew {L : Type v} [lie_ring L] (x y : L) :

-⁅y, x⁆ = ⁅x, y⁆

source

@[protected, instance]

def lie_algebra_self_module {R : Type u} {L : Type v} [comm_ring R] [lie_ring L] [lie_algebra R L] :

lie_module R L L

Every Lie algebra is a module over itself.

Equations

lie_algebra_self_module = {smul_lie := _, lie_smul := _}

source

@[simp]

theorem neg_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m : M) :

⁅-x, m⁆ = -⁅x, m⁆

source

@[simp]

theorem lie_neg {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m : M) :

⁅x, -m⁆ = -⁅x, m⁆

source

@[simp]

theorem sub_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x y : L) (m : M) :

⁅x - y, m⁆ = ⁅x, m⁆ - ⁅y, m⁆

source

@[simp]

theorem lie_sub {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m n : M) :

⁅x, m - n⁆ = ⁅x, m⁆ - ⁅x, n⁆

source

@[simp]

theorem nsmul_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m : M) (n : ℕ) :

⁅n • x, m⁆ = n • ⁅x, m⁆

source

@[simp]

theorem lie_nsmul {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m : M) (n : ℕ) :

⁅x, n • m⁆ = n • ⁅x, m⁆

source

@[simp]

theorem zsmul_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m : M) (a : ℤ) :

⁅a • x, m⁆ = a • ⁅x, m⁆

source

@[simp]

theorem lie_zsmul {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x : L) (m : M) (a : ℤ) :

⁅x, a • m⁆ = a • ⁅x, m⁆

source

@[simp]

theorem lie_lie {L : Type v} {M : Type w} [lie_ring L] [add_comm_group M] [lie_ring_module L M] (x y : L) (m : M) :

⁅⁅x, y⁆, m⁆ = ⁅x, ⁅y, m⁆⁆ - ⁅y, ⁅x, m⁆⁆

source

theorem lie_jacobi {L : Type v} [lie_ring L] (x y z : L) :

⁅x, ⁅y, z⁆⁆ + ⁅y, ⁅z, x⁆⁆ + ⁅z, ⁅x, y⁆⁆ = 0

source

@[protected, instance]

def lie_ring.int_lie_algebra {L : Type v} [lie_ring L] :

lie_algebra ℤ L

Equations

lie_ring.int_lie_algebra = {to_module := add_comm_group.int_module L lie_ring.to_add_comm_group, lie_smul := _}

source

@[protected, instance]

def linear_map.lie_ring_module {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] [add_comm_group N] [module R N] [lie_ring_module L N] [lie_module R L N] :

lie_ring_module L (M →ₗ[R] N)

Equations

linear_map.lie_ring_module = {to_has_bracket := {bracket := λ (x : L) (f : M →ₗ[R] N), {to_fun := λ (m : M), ⁅x, ⇑f m⁆ - ⇑f ⁅x, m⁆, map_add' := _, map_smul' := _}}, add_lie := _, lie_add := _, leibniz_lie := _}

source

@[simp]

theorem lie_hom.lie_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] [add_comm_group N] [module R N] [lie_ring_module L N] [lie_module R L N] (f : M →ₗ[R] N) (x : L) (m : M) :

⇑⁅x, f⁆ m = ⁅x, ⇑f m⁆ - ⇑f ⁅x, m⁆

source

@[protected, instance]

def linear_map.lie_module {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] [add_comm_group N] [module R N] [lie_ring_module L N] [lie_module R L N] :

lie_module R L (M →ₗ[R] N)

Equations

linear_map.lie_module = {smul_lie := _, lie_smul := _}

source

structure lie_hom (R : Type u) (L : Type v) (L' : Type w) [comm_ring R] [lie_ring L] [lie_algebra R L] [lie_ring L'] [lie_algebra R L'] :

Type (max v w)

to_linear_map : L →ₗ[R] L'
map_lie' : ∀ {x y : L}, self.to_linear_map.to_fun ⁅x, y⁆ = ⁅self.to_linear_map.to_fun x, self.to_linear_map.to_fun y⁆

A morphism of Lie algebras is a linear map respecting the bracket operations.

Instances for lie_hom

source

@[protected, instance]

def lie_hom.linear_map.has_coe {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] :

has_coe (L₁ →ₗ⁅R⁆ L₂) (L₁ →ₗ[R] L₂)

Equations

lie_hom.linear_map.has_coe = {coe := lie_hom.to_linear_map _inst_5}

source

@[protected, instance]

def lie_hom.has_coe_to_fun {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] :

has_coe_to_fun (L₁ →ₗ⁅R⁆ L₂) (λ (_x : L₁ →ₗ⁅R⁆ L₂), L₁ → L₂)

see Note [function coercion]

Equations

lie_hom.has_coe_to_fun = {coe := λ (f : L₁ →ₗ⁅R⁆ L₂), f.to_linear_map.to_fun}

source

def lie_hom.simps.apply {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (h : L₁ →ₗ⁅R⁆ L₂) :

L₁ → L₂

See Note [custom simps projection]. We need to specify this projection explicitly in this case, because it is a composition of multiple projections.

Equations

lie_hom.simps.apply h = ⇑h

source

@[simp, norm_cast]

theorem lie_hom.coe_to_linear_map {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) :

⇑↑f = ⇑f

source

@[simp]

theorem lie_hom.to_fun_eq_coe {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) :

f.to_linear_map.to_fun = ⇑f

source

@[simp]

theorem lie_hom.map_smul {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (c : R) (x : L₁) :

⇑f (c • x) = c • ⇑f x

source

@[simp]

theorem lie_hom.map_add {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) :

⇑f (x + y) = ⇑f x + ⇑f y

source

@[simp]

theorem lie_hom.map_sub {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) :

⇑f (x - y) = ⇑f x - ⇑f y

source

@[simp]

theorem lie_hom.map_neg {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (x : L₁) :

⇑f (-x) = -⇑f x

source

@[simp]

theorem lie_hom.map_lie {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) :

⇑f ⁅x, y⁆ = ⁅⇑f x, ⇑f y⁆

source

@[simp]

theorem lie_hom.map_zero {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) :

⇑f 0 = 0

source

def lie_hom.id {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

L₁ →ₗ⁅R⁆ L₁

The identity map is a morphism of Lie algebras.

Equations

lie_hom.id = {to_linear_map := {to_fun := linear_map.id.to_fun, map_add' := _, map_smul' := _}, map_lie' := _}

source

@[simp]

theorem lie_hom.coe_id {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

⇑lie_hom.id = id

source

theorem lie_hom.id_apply {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] (x : L₁) :

⇑lie_hom.id x = x

source

@[protected, instance]

def lie_hom.has_zero {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] :

has_zero (L₁ →ₗ⁅R⁆ L₂)

The constant 0 map is a Lie algebra morphism.

Equations

lie_hom.has_zero = {zero := {to_linear_map := {to_fun := 0.to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[simp, norm_cast]

theorem lie_hom.coe_zero {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] :

⇑0 = 0

source

theorem lie_hom.zero_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (x : L₁) :

⇑0 x = 0

source

@[protected, instance]

def lie_hom.has_one {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

has_one (L₁ →ₗ⁅R⁆ L₁)

The identity map is a Lie algebra morphism.

Equations

lie_hom.has_one = {one := lie_hom.id _inst_3}

source

@[simp]

theorem lie_hom.coe_one {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

⇑1 = id

source

theorem lie_hom.one_apply {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] (x : L₁) :

⇑1 x = x

source

@[protected, instance]

def lie_hom.inhabited {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] :

inhabited (L₁ →ₗ⁅R⁆ L₂)

Equations

lie_hom.inhabited = {default := 0}

source

theorem lie_hom.coe_injective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] :

function.injective coe_fn

source

@[ext]

theorem lie_hom.ext {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] {f g : L₁ →ₗ⁅R⁆ L₂} (h : ∀ (x : L₁), ⇑f x = ⇑g x) :

f = g

source

theorem lie_hom.ext_iff {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] {f g : L₁ →ₗ⁅R⁆ L₂} :

f = g ↔ ∀ (x : L₁), ⇑f x = ⇑g x

source

theorem lie_hom.congr_fun {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] {f g : L₁ →ₗ⁅R⁆ L₂} (h : f = g) (x : L₁) :

⇑f x = ⇑g x

source

@[simp]

theorem lie_hom.mk_coe {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (h₁ : ∀ (x y : L₁), ⇑f (x + y) = ⇑f x + ⇑f y) (h₂ : ∀ (r : R) (x : L₁), ⇑f (r • x) = ⇑(ring_hom.id R) r • ⇑f x) (h₃ : ∀ {x y : L₁}, {to_fun := ⇑f, map_add' := h₁, map_smul' := h₂}.to_fun ⁅x, y⁆ = ⁅{to_fun := ⇑f, map_add' := h₁, map_smul' := h₂}.to_fun x, {to_fun := ⇑f, map_add' := h₁, map_smul' := h₂}.to_fun y⁆) :

{to_linear_map := {to_fun := ⇑f, map_add' := h₁, map_smul' := h₂}, map_lie' := h₃} = f

source

@[simp]

theorem lie_hom.coe_mk {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ → L₂) (h₁ : ∀ (x y : L₁), f (x + y) = f x + f y) (h₂ : ∀ (r : R) (x : L₁), f (r • x) = ⇑(ring_hom.id R) r • f x) (h₃ : ∀ {x y : L₁}, {to_fun := f, map_add' := h₁, map_smul' := h₂}.to_fun ⁅x, y⁆ = ⁅{to_fun := f, map_add' := h₁, map_smul' := h₂}.to_fun x, {to_fun := f, map_add' := h₁, map_smul' := h₂}.to_fun y⁆) :

⇑{to_linear_map := {to_fun := f, map_add' := h₁, map_smul' := h₂}, map_lie' := h₃} = f

source

def lie_hom.comp {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [lie_ring L₃] [lie_algebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) :

L₁ →ₗ⁅R⁆ L₃

The composition of morphisms is a morphism.

Equations

f.comp g = {to_linear_map := {to_fun := (f.to_linear_map.comp g.to_linear_map).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}

source

theorem lie_hom.comp_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [lie_ring L₃] [lie_algebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) (x : L₁) :

⇑(f.comp g) x = ⇑f (⇑g x)

source

@[simp, norm_cast]

theorem lie_hom.coe_comp {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [lie_ring L₃] [lie_algebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) :

⇑(f.comp g) = ⇑f ∘ ⇑g

source

@[simp, norm_cast]

theorem lie_hom.coe_linear_map_comp {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [lie_ring L₃] [lie_algebra R L₃] (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) :

↑(f.comp g) = ↑f.comp ↑g

source

@[simp]

theorem lie_hom.comp_id {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) :

f.comp lie_hom.id = f

source

@[simp]

theorem lie_hom.id_comp {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) :

lie_hom.id.comp f = f

source

def lie_hom.inverse {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (g : L₂ → L₁) (h₁ : function.left_inverse g ⇑f) (h₂ : function.right_inverse g ⇑f) :

L₂ →ₗ⁅R⁆ L₁

The inverse of a bijective morphism is a morphism.

Equations

f.inverse g h₁ h₂ = {to_linear_map := {to_fun := (f.to_linear_map.inverse g h₁ h₂).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}

source

@[reducible]

def lie_ring_module.comp_lie_hom {R : Type u} {L₁ : Type v} {L₂ : Type w} (M : Type w₁) [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [add_comm_group M] [lie_ring_module L₂ M] (f : L₁ →ₗ⁅R⁆ L₂) :

lie_ring_module L₁ M

A Lie ring module may be pulled back along a morphism of Lie algebras.

See note [reducible non-instances].

Equations

lie_ring_module.comp_lie_hom M f = {to_has_bracket := {bracket := λ (x : L₁) (m : M), ⁅⇑f x, m⁆}, add_lie := _, lie_add := _, leibniz_lie := _}

source

theorem lie_ring_module.comp_lie_hom_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} (M : Type w₁) [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [add_comm_group M] [lie_ring_module L₂ M] (f : L₁ →ₗ⁅R⁆ L₂) (x : L₁) (m : M) :

⁅x, m⁆ = ⁅⇑f x, m⁆

source

@[reducible]

def lie_module.comp_lie_hom {R : Type u} {L₁ : Type v} {L₂ : Type w} (M : Type w₁) [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] [lie_ring L₂] [lie_algebra R L₂] [add_comm_group M] [lie_ring_module L₂ M] (f : L₁ →ₗ⁅R⁆ L₂) [module R M] [lie_module R L₂ M] :

lie_module R L₁ M

A Lie module may be pulled back along a morphism of Lie algebras.

See note [reducible non-instances].

Equations

lie_module.comp_lie_hom M f = {smul_lie := _, lie_smul := _}

source

structure lie_equiv (R : Type u) (L : Type v) (L' : Type w) [comm_ring R] [lie_ring L] [lie_algebra R L] [lie_ring L'] [lie_algebra R L'] :

Type (max v w)

to_lie_hom : L →ₗ⁅R⁆ L'
inv_fun : L' → L
left_inv : function.left_inverse self.inv_fun self.to_lie_hom.to_linear_map.to_fun
right_inv : function.right_inverse self.inv_fun self.to_lie_hom.to_linear_map.to_fun

An equivalence of Lie algebras is a morphism which is also a linear equivalence. We could instead define an equivalence to be a morphism which is also a (plain) equivalence. However it is more convenient to define via linear equivalence to get .to_linear_equiv for free.

Instances for lie_equiv

source

def lie_equiv.to_linear_equiv {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (f : L₁ ≃ₗ⁅R⁆ L₂) :

L₁ ≃ₗ[R] L₂

Consider an equivalence of Lie algebras as a linear equivalence.

Equations

f.to_linear_equiv = {to_fun := f.to_lie_hom.to_linear_map.to_fun, map_add' := _, map_smul' := _, inv_fun := f.inv_fun, left_inv := _, right_inv := _}

source

@[protected, instance]

def lie_equiv.has_coe_to_lie_hom {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] :

has_coe (L₁ ≃ₗ⁅R⁆ L₂) (L₁ →ₗ⁅R⁆ L₂)

Equations

lie_equiv.has_coe_to_lie_hom = {coe := lie_equiv.to_lie_hom _inst_6}

source

@[protected, instance]

def lie_equiv.has_coe_to_linear_equiv {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] :

has_coe (L₁ ≃ₗ⁅R⁆ L₂) (L₁ ≃ₗ[R] L₂)

Equations

lie_equiv.has_coe_to_linear_equiv = {coe := lie_equiv.to_linear_equiv _inst_6}

source

@[protected, instance]

def lie_equiv.has_coe_to_fun {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] :

has_coe_to_fun (L₁ ≃ₗ⁅R⁆ L₂) (λ (_x : L₁ ≃ₗ⁅R⁆ L₂), L₁ → L₂)

see Note [function coercion]

Equations

lie_equiv.has_coe_to_fun = {coe := λ (e : L₁ ≃ₗ⁅R⁆ L₂), e.to_lie_hom.to_linear_map.to_fun}

source

@[simp, norm_cast]

theorem lie_equiv.coe_to_lie_hom {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

⇑↑e = ⇑e

source

@[simp, norm_cast]

theorem lie_equiv.coe_to_linear_equiv {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

⇑↑e = ⇑e

source

@[simp]

theorem lie_equiv.to_linear_equiv_mk {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (g : L₂ → L₁) (h₁ : function.left_inverse g f.to_linear_map.to_fun) (h₂ : function.right_inverse g f.to_linear_map.to_fun) :

↑{to_lie_hom := f, inv_fun := g, left_inv := h₁, right_inv := h₂} = {to_fun := f.to_linear_map.to_fun, map_add' := _, map_smul' := _, inv_fun := g, left_inv := h₁, right_inv := h₂}

source

theorem lie_equiv.coe_linear_equiv_injective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] :

function.injective coe

source

theorem lie_equiv.coe_injective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] :

function.injective coe_fn

source

@[ext]

theorem lie_equiv.ext {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] {f g : L₁ ≃ₗ⁅R⁆ L₂} (h : ∀ (x : L₁), ⇑f x = ⇑g x) :

f = g

source

@[protected, instance]

def lie_equiv.has_one {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

has_one (L₁ ≃ₗ⁅R⁆ L₁)

Equations

lie_equiv.has_one = {one := {to_lie_hom := {to_linear_map := {to_fun := 1.to_fun, map_add' := _, map_smul' := _}, map_lie' := _}, inv_fun := 1.inv_fun, left_inv := _, right_inv := _}}

source

@[simp]

theorem lie_equiv.one_apply {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] (x : L₁) :

⇑1 x = x

source

@[protected, instance]

def lie_equiv.inhabited {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

inhabited (L₁ ≃ₗ⁅R⁆ L₁)

Equations

lie_equiv.inhabited = {default := 1}

source

@[refl]

def lie_equiv.refl {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

L₁ ≃ₗ⁅R⁆ L₁

Lie algebra equivalences are reflexive.

Equations

lie_equiv.refl = 1

source

@[simp]

theorem lie_equiv.refl_apply {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] (x : L₁) :

⇑lie_equiv.refl x = x

source

@[symm]

def lie_equiv.symm {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

L₂ ≃ₗ⁅R⁆ L₁

Lie algebra equivalences are symmetric.

Equations

e.symm = {to_lie_hom := {to_linear_map := (e.to_lie_hom.inverse e.inv_fun _ _).to_linear_map, map_lie' := _}, inv_fun := e.to_linear_equiv.symm.inv_fun, left_inv := _, right_inv := _}

source

@[simp]

theorem lie_equiv.symm_symm {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

e.symm.symm = e

source

@[simp]

theorem lie_equiv.apply_symm_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) (x : L₂) :

⇑e (⇑(e.symm) x) = x

source

@[simp]

theorem lie_equiv.symm_apply_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) (x : L₁) :

⇑(e.symm) (⇑e x) = x

source

@[simp]

theorem lie_equiv.refl_symm {R : Type u} {L₁ : Type v} [comm_ring R] [lie_ring L₁] [lie_algebra R L₁] :

lie_equiv.refl.symm = lie_equiv.refl

source

@[trans]

def lie_equiv.trans {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_ring L₃] [lie_algebra R L₁] [lie_algebra R L₂] [lie_algebra R L₃] (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) :

L₁ ≃ₗ⁅R⁆ L₃

Lie algebra equivalences are transitive.

Equations

e₁.trans e₂ = {to_lie_hom := {to_linear_map := (e₂.to_lie_hom.comp e₁.to_lie_hom).to_linear_map, map_lie' := _}, inv_fun := (e₁.to_linear_equiv.trans e₂.to_linear_equiv).inv_fun, left_inv := _, right_inv := _}

source

@[simp]

theorem lie_equiv.self_trans_symm {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

e.trans e.symm = lie_equiv.refl

source

@[simp]

theorem lie_equiv.symm_trans_self {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

e.symm.trans e = lie_equiv.refl

source

@[simp]

theorem lie_equiv.trans_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_ring L₃] [lie_algebra R L₁] [lie_algebra R L₂] [lie_algebra R L₃] (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) (x : L₁) :

⇑(e₁.trans e₂) x = ⇑e₂ (⇑e₁ x)

source

@[simp]

theorem lie_equiv.symm_trans {R : Type u} {L₁ : Type v} {L₂ : Type w} {L₃ : Type w₁} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_ring L₃] [lie_algebra R L₁] [lie_algebra R L₂] [lie_algebra R L₃] (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) :

(e₁.trans e₂).symm = e₂.symm.trans e₁.symm

source

@[protected]

theorem lie_equiv.bijective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

function.bijective ⇑↑e

source

@[protected]

theorem lie_equiv.injective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

function.injective ⇑↑e

source

@[protected]

theorem lie_equiv.surjective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :

function.surjective ⇑↑e

source

noncomputable def lie_equiv.of_bijective {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (h₁ : function.injective ⇑f) (h₂ : function.surjective ⇑f) :

L₁ ≃ₗ⁅R⁆ L₂

A bijective morphism of Lie algebras yields an equivalence of Lie algebras.

Equations

lie_equiv.of_bijective f h₁ h₂ = {to_lie_hom := {to_linear_map := {to_fun := ⇑f, map_add' := _, map_smul' := _}, map_lie' := _}, inv_fun := (linear_equiv.of_bijective ↑f h₁ h₂).inv_fun, left_inv := _, right_inv := _}

source

@[simp]

theorem lie_equiv.of_bijective_to_lie_hom_to_linear_map_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (h₁ : function.injective ⇑f) (h₂ : function.surjective ⇑f) (ᾰ : L₁) :

⇑((lie_equiv.of_bijective f h₁ h₂).to_lie_hom.to_linear_map) ᾰ = ⇑f ᾰ

source

@[simp]

theorem lie_equiv.of_bijective_inv_fun {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (h₁ : function.injective ⇑f) (h₂ : function.surjective ⇑f) (ᾰ : L₂) :

(lie_equiv.of_bijective f h₁ h₂).inv_fun ᾰ = (linear_equiv.of_bijective ↑f h₁ h₂).inv_fun ᾰ

source

@[simp]

theorem lie_equiv.of_bijective_to_lie_hom_apply {R : Type u} {L₁ : Type v} {L₂ : Type w} [comm_ring R] [lie_ring L₁] [lie_ring L₂] [lie_algebra R L₁] [lie_algebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂) (h₁ : function.injective ⇑f) (h₂ : function.surjective ⇑f) (ᾰ : L₁) :

⇑((lie_equiv.of_bijective f h₁ h₂).to_lie_hom) ᾰ = ⇑f ᾰ

source

structure lie_module_hom (R : Type u) (L : Type v) (M : Type w) (N : Type w₁) [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

Type (max w w₁)

to_linear_map : M →ₗ[R] N
map_lie' : ∀ {x : L} {m : M}, self.to_linear_map.to_fun ⁅x, m⁆ = ⁅x, self.to_linear_map.to_fun m⁆

A morphism of Lie algebra modules is a linear map which commutes with the action of the Lie algebra.

Instances for lie_module_hom

source

@[protected, instance]

def lie_module_hom.linear_map.has_coe {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_coe (M →ₗ⁅R,L⁆ N) (M →ₗ[R] N)

Equations

lie_module_hom.linear_map.has_coe = {coe := lie_module_hom.to_linear_map _inst_14}

source

@[protected, instance]

def lie_module_hom.has_coe_to_fun {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_coe_to_fun (M →ₗ⁅R,L⁆ N) (λ (_x : M →ₗ⁅R,L⁆ N), M → N)

see Note [function coercion]

Equations

lie_module_hom.has_coe_to_fun = {coe := λ (f : M →ₗ⁅R,L⁆ N), f.to_linear_map.to_fun}

source

@[simp, norm_cast]

theorem lie_module_hom.coe_to_linear_map {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) :

⇑↑f = ⇑f

source

@[simp]

theorem lie_module_hom.map_smul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (c : R) (x : M) :

⇑f (c • x) = c • ⇑f x

source

@[simp]

theorem lie_module_hom.map_add {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (x y : M) :

⇑f (x + y) = ⇑f x + ⇑f y

source

@[simp]

theorem lie_module_hom.map_sub {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (x y : M) :

⇑f (x - y) = ⇑f x - ⇑f y

source

@[simp]

theorem lie_module_hom.map_neg {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (x : M) :

⇑f (-x) = -⇑f x

source

@[simp]

theorem lie_module_hom.map_lie {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (x : L) (m : M) :

⇑f ⁅x, m⁆ = ⁅x, ⇑f m⁆

source

theorem lie_module_hom.map_lie₂ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (f : M →ₗ⁅R,L⁆ N →ₗ[R] P) (x : L) (m : M) (n : N) :

⁅x, ⇑(⇑f m) n⁆ = ⇑(⇑f ⁅x, m⁆) n + ⇑(⇑f m) ⁅x, n⁆

source

@[simp]

theorem lie_module_hom.map_zero {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) :

⇑f 0 = 0

source

def lie_module_hom.id {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] :

M →ₗ⁅R,L⁆ M

The identity map is a morphism of Lie modules.

Equations

lie_module_hom.id = {to_linear_map := {to_fun := linear_map.id.to_fun, map_add' := _, map_smul' := _}, map_lie' := _}

source

@[simp]

theorem lie_module_hom.coe_id {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] :

⇑lie_module_hom.id = id

source

theorem lie_module_hom.id_apply {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] (x : M) :

⇑lie_module_hom.id x = x

source

@[protected, instance]

def lie_module_hom.has_zero {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_zero (M →ₗ⁅R,L⁆ N)

The constant 0 map is a Lie module morphism.

Equations

lie_module_hom.has_zero = {zero := {to_linear_map := {to_fun := 0.to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[simp, norm_cast]

theorem lie_module_hom.coe_zero {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

⇑0 = 0

source

theorem lie_module_hom.zero_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (m : M) :

⇑0 m = 0

source

@[protected, instance]

def lie_module_hom.has_one {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] :

has_one (M →ₗ⁅R,L⁆ M)

The identity map is a Lie module morphism.

Equations

lie_module_hom.has_one = {one := lie_module_hom.id _inst_13}

source

@[protected, instance]

def lie_module_hom.inhabited {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

inhabited (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.inhabited = {default := 0}

source

theorem lie_module_hom.coe_injective {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

function.injective coe_fn

source

@[ext]

theorem lie_module_hom.ext {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] {f g : M →ₗ⁅R,L⁆ N} (h : ∀ (m : M), ⇑f m = ⇑g m) :

f = g

source

theorem lie_module_hom.ext_iff {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] {f g : M →ₗ⁅R,L⁆ N} :

f = g ↔ ∀ (m : M), ⇑f m = ⇑g m

source

theorem lie_module_hom.congr_fun {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] {f g : M →ₗ⁅R,L⁆ N} (h : f = g) (x : M) :

⇑f x = ⇑g x

source

@[simp]

theorem lie_module_hom.mk_coe {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (h : ∀ {x : L} {m : M}, ↑f.to_fun ⁅x, m⁆ = ⁅x, ↑f.to_fun m⁆) :

{to_linear_map := ↑f, map_lie' := h} = f

source

@[simp]

theorem lie_module_hom.coe_mk {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ[R] N) (h : ∀ {x : L} {m : M}, f.to_fun ⁅x, m⁆ = ⁅x, f.to_fun m⁆) :

⇑{to_linear_map := f, map_lie' := h} = ⇑f

source

@[simp, norm_cast]

theorem lie_module_hom.coe_linear_mk {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ[R] N) (h : ∀ {x : L} {m : M}, f.to_fun ⁅x, m⁆ = ⁅x, f.to_fun m⁆) :

↑{to_linear_map := f, map_lie' := h} = f

source

def lie_module_hom.comp {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) :

M →ₗ⁅R,L⁆ P

The composition of Lie module morphisms is a morphism.

Equations

f.comp g = {to_linear_map := {to_fun := (f.to_linear_map.comp g.to_linear_map).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}

source

theorem lie_module_hom.comp_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) (m : M) :

⇑(f.comp g) m = ⇑f (⇑g m)

source

@[simp, norm_cast]

theorem lie_module_hom.coe_comp {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) :

⇑(f.comp g) = ⇑f ∘ ⇑g

source

@[simp, norm_cast]

theorem lie_module_hom.coe_linear_map_comp {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) :

↑(f.comp g) = ↑f.comp ↑g

source

def lie_module_hom.inverse {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (g : N → M) (h₁ : function.left_inverse g ⇑f) (h₂ : function.right_inverse g ⇑f) :

N →ₗ⁅R,L⁆ M

The inverse of a bijective morphism of Lie modules is a morphism of Lie modules.

Equations

f.inverse g h₁ h₂ = {to_linear_map := {to_fun := (f.to_linear_map.inverse g h₁ h₂).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}

source

@[protected, instance]

def lie_module_hom.has_add {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_add (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.has_add = {add := λ (f g : M →ₗ⁅R,L⁆ N), {to_linear_map := {to_fun := (↑f + ↑g).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[protected, instance]

def lie_module_hom.has_sub {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_sub (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.has_sub = {sub := λ (f g : M →ₗ⁅R,L⁆ N), {to_linear_map := {to_fun := (↑f - ↑g).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[protected, instance]

def lie_module_hom.has_neg {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_neg (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.has_neg = {neg := λ (f : M →ₗ⁅R,L⁆ N), {to_linear_map := {to_fun := (-↑f).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[simp, norm_cast]

theorem lie_module_hom.coe_add {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f g : M →ₗ⁅R,L⁆ N) :

⇑(f + g) = ⇑f + ⇑g

source

theorem lie_module_hom.add_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f g : M →ₗ⁅R,L⁆ N) (m : M) :

⇑(f + g) m = ⇑f m + ⇑g m

source

@[simp, norm_cast]

theorem lie_module_hom.coe_sub {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f g : M →ₗ⁅R,L⁆ N) :

⇑(f - g) = ⇑f - ⇑g

source

theorem lie_module_hom.sub_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f g : M →ₗ⁅R,L⁆ N) (m : M) :

⇑(f - g) m = ⇑f m - ⇑g m

source

@[simp, norm_cast]

theorem lie_module_hom.coe_neg {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) :

⇑-f = -⇑f

source

theorem lie_module_hom.neg_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (m : M) :

(⇑-f) m = -⇑f m

source

@[protected, instance]

def lie_module_hom.has_nsmul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_smul ℕ (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.has_nsmul = {smul := λ (n : ℕ) (f : M →ₗ⁅R,L⁆ N), {to_linear_map := {to_fun := (n • ↑f).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[simp, norm_cast]

theorem lie_module_hom.coe_nsmul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (n : ℕ) (f : M →ₗ⁅R,L⁆ N) :

⇑(n • f) = n • ⇑f

source

theorem lie_module_hom.nsmul_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (n : ℕ) (f : M →ₗ⁅R,L⁆ N) (m : M) :

⇑(n • f) m = n • ⇑f m

source

@[protected, instance]

def lie_module_hom.has_zsmul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_smul ℤ (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.has_zsmul = {smul := λ (z : ℤ) (f : M →ₗ⁅R,L⁆ N), {to_linear_map := {to_fun := (z • ↑f).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[simp, norm_cast]

theorem lie_module_hom.coe_zsmul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (z : ℤ) (f : M →ₗ⁅R,L⁆ N) :

⇑(z • f) = z • ⇑f

source

theorem lie_module_hom.zsmul_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (z : ℤ) (f : M →ₗ⁅R,L⁆ N) (m : M) :

⇑(z • f) m = z • ⇑f m

source

@[protected, instance]

def lie_module_hom.add_comm_group {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

add_comm_group (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.add_comm_group = function.injective.add_comm_group coe_fn lie_module_hom.coe_injective lie_module_hom.coe_zero lie_module_hom.coe_add lie_module_hom.coe_neg lie_module_hom.coe_sub lie_module_hom.add_comm_group._proof_1 lie_module_hom.add_comm_group._proof_2

source

@[protected, instance]

def lie_module_hom.has_smul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_smul R (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.has_smul = {smul := λ (t : R) (f : M →ₗ⁅R,L⁆ N), {to_linear_map := {to_fun := (t • ↑f).to_fun, map_add' := _, map_smul' := _}, map_lie' := _}}

source

@[simp, norm_cast]

theorem lie_module_hom.coe_smul {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (t : R) (f : M →ₗ⁅R,L⁆ N) :

⇑(t • f) = t • ⇑f

source

theorem lie_module_hom.smul_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (t : R) (f : M →ₗ⁅R,L⁆ N) (m : M) :

⇑(t • f) m = t • ⇑f m

source

@[protected, instance]

def lie_module_hom.module {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

module R (M →ₗ⁅R,L⁆ N)

Equations

lie_module_hom.module = function.injective.module R {to_fun := λ (f : M →ₗ⁅R,L⁆ N), f.to_linear_map.to_fun, map_zero' := _, map_add' := _} lie_module_hom.coe_injective lie_module_hom.coe_smul

source

structure lie_module_equiv (R : Type u) (L : Type v) (M : Type w) (N : Type w₁) [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

Type (max w w₁)

to_lie_module_hom : M →ₗ⁅R,L⁆ N
inv_fun : N → M
left_inv : function.left_inverse self.inv_fun self.to_lie_module_hom.to_linear_map.to_fun
right_inv : function.right_inverse self.inv_fun self.to_lie_module_hom.to_linear_map.to_fun

An equivalence of Lie algebra modules is a linear equivalence which is also a morphism of Lie algebra modules.

Instances for lie_module_equiv

lie_module_equiv.has_sizeof_inst
lie_module_equiv.has_coe_to_equiv
lie_module_equiv.has_coe_to_lie_module_hom
lie_module_equiv.has_coe_to_linear_equiv
lie_module_equiv.has_coe_to_fun
lie_module_equiv.has_one
lie_module_equiv.inhabited

source

def lie_module_equiv.to_linear_equiv {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

M ≃ₗ[R] N

View an equivalence of Lie modules as a linear equivalence.

Equations

e.to_linear_equiv = {to_fun := e.to_lie_module_hom.to_linear_map.to_fun, map_add' := _, map_smul' := _, inv_fun := e.inv_fun, left_inv := _, right_inv := _}

source

def lie_module_equiv.to_equiv {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

M ≃ N

View an equivalence of Lie modules as a type level equivalence.

Equations

e.to_equiv = {to_fun := e.to_lie_module_hom.to_linear_map.to_fun, inv_fun := e.inv_fun, left_inv := _, right_inv := _}

source

@[protected, instance]

def lie_module_equiv.has_coe_to_equiv {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_coe (M ≃ₗ⁅R,L⁆ N) (M ≃ N)

Equations

lie_module_equiv.has_coe_to_equiv = {coe := lie_module_equiv.to_equiv _inst_14}

source

@[protected, instance]

def lie_module_equiv.has_coe_to_lie_module_hom {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_coe (M ≃ₗ⁅R,L⁆ N) (M →ₗ⁅R,L⁆ N)

Equations

lie_module_equiv.has_coe_to_lie_module_hom = {coe := lie_module_equiv.to_lie_module_hom _inst_14}

source

@[protected, instance]

def lie_module_equiv.has_coe_to_linear_equiv {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_coe (M ≃ₗ⁅R,L⁆ N) (M ≃ₗ[R] N)

Equations

lie_module_equiv.has_coe_to_linear_equiv = {coe := lie_module_equiv.to_linear_equiv _inst_14}

source

@[protected, instance]

def lie_module_equiv.has_coe_to_fun {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

has_coe_to_fun (M ≃ₗ⁅R,L⁆ N) (λ (_x : M ≃ₗ⁅R,L⁆ N), M → N)

see Note [function coercion]

Equations

lie_module_equiv.has_coe_to_fun = {coe := λ (e : M ≃ₗ⁅R,L⁆ N), e.to_lie_module_hom.to_linear_map.to_fun}

source

theorem lie_module_equiv.injective {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

function.injective ⇑e

source

@[simp]

theorem lie_module_equiv.coe_mk {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (f : M →ₗ⁅R,L⁆ N) (inv_fun : N → M) (h₁ : function.left_inverse inv_fun f.to_linear_map.to_fun) (h₂ : function.right_inverse inv_fun f.to_linear_map.to_fun) :

⇑{to_lie_module_hom := f, inv_fun := inv_fun, left_inv := h₁, right_inv := h₂} = ⇑f

source

@[simp, norm_cast]

theorem lie_module_equiv.coe_to_lie_module_hom {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

⇑↑e = ⇑e

source

@[simp, norm_cast]

theorem lie_module_equiv.coe_to_linear_equiv {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

⇑↑e = ⇑e

source

theorem lie_module_equiv.to_equiv_injective {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] :

function.injective lie_module_equiv.to_equiv

source

@[ext]

theorem lie_module_equiv.ext {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e₁ e₂ : M ≃ₗ⁅R,L⁆ N) (h : ∀ (m : M), ⇑e₁ m = ⇑e₂ m) :

e₁ = e₂

source

@[protected, instance]

def lie_module_equiv.has_one {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] :

has_one (M ≃ₗ⁅R,L⁆ M)

Equations

lie_module_equiv.has_one = {one := {to_lie_module_hom := {to_linear_map := {to_fun := 1.to_fun, map_add' := _, map_smul' := _}, map_lie' := _}, inv_fun := 1.inv_fun, left_inv := _, right_inv := _}}

source

@[simp]

theorem lie_module_equiv.one_apply {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] (m : M) :

⇑1 m = m

source

@[protected, instance]

def lie_module_equiv.inhabited {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] :

inhabited (M ≃ₗ⁅R,L⁆ M)

Equations

lie_module_equiv.inhabited = {default := 1}

source

@[refl]

def lie_module_equiv.refl {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] :

M ≃ₗ⁅R,L⁆ M

Lie module equivalences are reflexive.

Equations

lie_module_equiv.refl = 1

source

@[simp]

theorem lie_module_equiv.refl_apply {R : Type u} {L : Type v} {M : Type w} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [module R M] [lie_ring_module L M] [lie_module R L M] (m : M) :

⇑lie_module_equiv.refl m = m

source

@[symm]

def lie_module_equiv.symm {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

N ≃ₗ⁅R,L⁆ M

Lie module equivalences are syemmtric.

Equations

e.symm = {to_lie_module_hom := {to_linear_map := (e.to_lie_module_hom.inverse e.inv_fun _ _).to_linear_map, map_lie' := _}, inv_fun := ↑e.symm.inv_fun, left_inv := _, right_inv := _}

source

@[simp]

theorem lie_module_equiv.apply_symm_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) (x : N) :

⇑e (⇑(e.symm) x) = x

source

@[simp]

theorem lie_module_equiv.symm_apply_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) (x : M) :

⇑(e.symm) (⇑e x) = x

source

@[simp]

theorem lie_module_equiv.symm_symm {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

e.symm.symm = e

source

@[trans]

def lie_module_equiv.trans {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (e₁ : M ≃ₗ⁅R,L⁆ N) (e₂ : N ≃ₗ⁅R,L⁆ P) :

M ≃ₗ⁅R,L⁆ P

Lie module equivalences are transitive.

Equations

e₁.trans e₂ = {to_lie_module_hom := {to_linear_map := (e₂.to_lie_module_hom.comp e₁.to_lie_module_hom).to_linear_map, map_lie' := _}, inv_fun := (e₁.to_linear_equiv.trans e₂.to_linear_equiv).inv_fun, left_inv := _, right_inv := _}

source

@[simp]

theorem lie_module_equiv.trans_apply {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (e₁ : M ≃ₗ⁅R,L⁆ N) (e₂ : N ≃ₗ⁅R,L⁆ P) (m : M) :

⇑(e₁.trans e₂) m = ⇑e₂ (⇑e₁ m)

source

@[simp]

theorem lie_module_equiv.symm_trans {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [add_comm_group P] [module R M] [module R N] [module R P] [lie_ring_module L M] [lie_ring_module L N] [lie_ring_module L P] [lie_module R L M] [lie_module R L N] [lie_module R L P] (e₁ : M ≃ₗ⁅R,L⁆ N) (e₂ : N ≃ₗ⁅R,L⁆ P) :

(e₁.trans e₂).symm = e₂.symm.trans e₁.symm

source

@[simp]

theorem lie_module_equiv.self_trans_symm {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

e.trans e.symm = lie_module_equiv.refl

source

@[simp]

theorem lie_module_equiv.symm_trans_self {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [comm_ring R] [lie_ring L] [lie_algebra R L] [add_comm_group M] [add_comm_group N] [module R M] [module R N] [lie_ring_module L M] [lie_ring_module L N] [lie_module R L M] [lie_module R L N] (e : M ≃ₗ⁅R,L⁆ N) :

e.symm.trans e = lie_module_equiv.refl

mathlib documentation

Lie algebras #

Main definitions #

Notation #

Implementation notes #

References #

Tags #