File: Mathlib/Algebra/Symmetrized.lean

full_name: SymAlg
code: /-- The symmetrized algebra has the same underlying space as the original algebra.
-/
def SymAlg (α : Type*) : Type _ 
goal: Type u_1

full_name: «_aux_Mathlib_Algebra_Symmetrized___macroRules_term_ˢʸᵐ_1»
code: postfix:max "ˢʸᵐ" => SymAlg
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Symmetrized___unexpand_SymAlg_1
code: postfix:max "ˢʸᵐ" => SymAlg
goal: Lean.PrettyPrinter.Unexpander

full_name: SymAlg.sym
code: /-- The element of `SymAlg α` that represents `a : α`. -/
@[match_pattern]
def sym : α ≃ αˢʸᵐ 
goal: α ≃ αˢʸᵐ

full_name: SymAlg.unsym
code: /-- The element of `α` represented by `x : αˢʸᵐ`. -/
-- Porting note (kmill): `pp_nodot` has no affect here
-- unless RFC lean4#1910 leads to dot notation for CoeFun
@[pp_nodot]
def unsym : αˢʸᵐ ≃ α 
goal: αˢʸᵐ ≃ α

full_name: SymAlg.unsym_sym
code: @[simp]
theorem unsym_sym (a : α) : unsym (sym a) = a 
goal: SymAlg.unsym (SymAlg.sym a) = a

full_name: SymAlg.sym_unsym
code: @[simp]
theorem sym_unsym (a : α) : sym (unsym a) = a 
goal: SymAlg.sym (SymAlg.unsym a) = a

full_name: SymAlg.sym_comp_unsym
code: @[simp]
theorem sym_comp_unsym : (sym : α → αˢʸᵐ) ∘ unsym = id 
goal: ⇑SymAlg.sym ∘ ⇑SymAlg.unsym = id

full_name: SymAlg.unsym_comp_sym
code: @[simp]
theorem unsym_comp_sym : (unsym : αˢʸᵐ → α) ∘ sym = id 
goal: ⇑SymAlg.unsym ∘ ⇑SymAlg.sym = id

full_name: SymAlg.sym_symm
code: @[simp]
theorem sym_symm : (@sym α).symm = unsym 
goal: SymAlg.sym.symm = SymAlg.unsym

full_name: SymAlg.unsym_symm
code: @[simp]
theorem unsym_symm : (@unsym α).symm = sym 
goal: SymAlg.unsym.symm = SymAlg.sym

full_name: SymAlg.sym_bijective
code: theorem sym_bijective : Bijective (sym : α → αˢʸᵐ) 
goal: Function.Bijective ⇑SymAlg.sym

full_name: SymAlg.unsym_bijective
code: theorem unsym_bijective : Bijective (unsym : αˢʸᵐ → α) 
goal: Function.Bijective ⇑SymAlg.unsym

full_name: SymAlg.sym_injective
code: theorem sym_injective : Injective (sym : α → αˢʸᵐ) 
goal: Function.Injective ⇑SymAlg.sym

full_name: SymAlg.sym_surjective
code: theorem sym_surjective : Surjective (sym : α → αˢʸᵐ) 
goal: Function.Surjective ⇑SymAlg.sym

full_name: SymAlg.unsym_injective
code: theorem unsym_injective : Injective (unsym : αˢʸᵐ → α) 
goal: Function.Injective ⇑SymAlg.unsym

full_name: SymAlg.unsym_surjective
code: theorem unsym_surjective : Surjective (unsym : αˢʸᵐ → α) 
goal: Function.Surjective ⇑SymAlg.unsym

full_name: SymAlg.sym_inj
code: theorem sym_inj {a b : α} : sym a = sym b ↔ a = b 
goal: SymAlg.sym a = SymAlg.sym b ↔ a = b

full_name: SymAlg.unsym_inj
code: theorem unsym_inj {a b : αˢʸᵐ} : unsym a = unsym b ↔ a = b 
goal: SymAlg.unsym a = SymAlg.unsym b ↔ a = b

full_name: SymAlg.instNontrivial
code: instance [Nontrivial α] : Nontrivial αˢʸᵐ 
goal: Nontrivial αˢʸᵐ

full_name: SymAlg.instInhabited
code: instance [Inhabited α] : Inhabited αˢʸᵐ 
goal: Inhabited αˢʸᵐ

full_name: SymAlg.instSubsingleton
code: instance [Subsingleton α] : Subsingleton αˢʸᵐ 
goal: Subsingleton αˢʸᵐ

full_name: SymAlg.instUnique
code: instance [Unique α] : Unique αˢʸᵐ 
goal: Unique αˢʸᵐ

full_name: SymAlg.instIsEmpty
code: instance [IsEmpty α] : IsEmpty αˢʸᵐ 
goal: IsEmpty αˢʸᵐ

full_name: SymAlg.instOne
code: @[to_additive]
instance [One α] : One αˢʸᵐ 
goal: One αˢʸᵐ

full_name: SymAlg.instZero
code: @[to_additive]
instance [One α] : One αˢʸᵐ 
goal: Zero αˢʸᵐ

full_name: SymAlg.instAdd
code: instance [Add α] : Add αˢʸᵐ 
goal: Add αˢʸᵐ

full_name: SymAlg.instSub
code: instance [Sub α] : Sub αˢʸᵐ 
goal: Sub αˢʸᵐ

full_name: SymAlg.instNeg
code: instance [Neg α] : Neg αˢʸᵐ 
goal: Neg αˢʸᵐ

full_name: SymAlg.instMulOfAddOfInvertibleOfNat
code: instance [Add α] [Mul α] [One α] [OfNat α 2] [Invertible (2 : α)] : Mul αˢʸᵐ 
goal: Mul αˢʸᵐ

full_name: SymAlg.instInv
code: @[to_additive existing]
instance [Inv α] : Inv αˢʸᵐ 
goal: Inv αˢʸᵐ

full_name: SymAlg.instSMul
code: instance (R : Type*) [SMul R α] : SMul R αˢʸᵐ 
goal: SMul R αˢʸᵐ

full_name: SymAlg.sym_one
code: @[to_additive (attr := simp)]
theorem sym_one [One α] : sym (1 : α) = 1 
goal: SymAlg.sym 1 = 1

full_name: SymAlg.sym_zero
code: @[to_additive (attr := simp)]
theorem sym_one [One α] : sym (1 : α) = 1 
goal: SymAlg.sym 0 = 0

full_name: SymAlg.unsym_zero
code: @[to_additive (attr := simp)]
theorem unsym_one [One α] : unsym (1 : αˢʸᵐ) = 1 
goal: SymAlg.unsym 0 = 0

full_name: SymAlg.unsym_one
code: @[to_additive (attr := simp)]
theorem unsym_one [One α] : unsym (1 : αˢʸᵐ) = 1 
goal: SymAlg.unsym 1 = 1

full_name: SymAlg.sym_add
code: @[simp]
theorem sym_add [Add α] (a b : α) : sym (a + b) = sym a + sym b 
goal: SymAlg.sym (a + b) = SymAlg.sym a + SymAlg.sym b

full_name: SymAlg.unsym_add
code: @[simp]
theorem unsym_add [Add α] (a b : αˢʸᵐ) : unsym (a + b) = unsym a + unsym b 
goal: SymAlg.unsym (a + b) = SymAlg.unsym a + SymAlg.unsym b

full_name: SymAlg.sym_sub
code: @[simp]
theorem sym_sub [Sub α] (a b : α) : sym (a - b) = sym a - sym b 
goal: SymAlg.sym (a - b) = SymAlg.sym a - SymAlg.sym b

full_name: SymAlg.unsym_sub
code: @[simp]
theorem unsym_sub [Sub α] (a b : αˢʸᵐ) : unsym (a - b) = unsym a - unsym b 
goal: SymAlg.unsym (a - b) = SymAlg.unsym a - SymAlg.unsym b

full_name: SymAlg.sym_neg
code: @[simp]
theorem sym_neg [Neg α] (a : α) : sym (-a) = -sym a 
goal: SymAlg.sym (-a) = -SymAlg.sym a

full_name: SymAlg.unsym_neg
code: @[simp]
theorem unsym_neg [Neg α] (a : αˢʸᵐ) : unsym (-a) = -unsym a 
goal: SymAlg.unsym (-a) = -SymAlg.unsym a

full_name: SymAlg.mul_def
code: theorem mul_def [Add α] [Mul α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : αˢʸᵐ) :
    a * b = sym (⅟ 2 * (unsym a * unsym b + unsym b * unsym a)) 
goal: a * b = SymAlg.sym (⅟2 * (SymAlg.unsym a * SymAlg.unsym b + SymAlg.unsym b * SymAlg.unsym a))

full_name: SymAlg.unsym_mul
code: theorem unsym_mul [Mul α] [Add α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : αˢʸᵐ) :
    unsym (a * b) = ⅟ 2 * (unsym a * unsym b + unsym b * unsym a) 
goal: SymAlg.unsym (a * b) = ⅟2 * (SymAlg.unsym a * SymAlg.unsym b + SymAlg.unsym b * SymAlg.unsym a)

full_name: SymAlg.sym_mul_sym
code: theorem sym_mul_sym [Mul α] [Add α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : α) :
    sym a * sym b = sym (⅟ 2 * (a * b + b * a)) 
goal: SymAlg.sym a * SymAlg.sym b = SymAlg.sym (⅟2 * (a * b + b * a))

full_name: SymAlg.sym_inv
code: @[simp, to_additive existing]
theorem sym_inv [Inv α] (a : α) : sym a⁻¹ = (sym a)⁻¹ 
goal: SymAlg.sym a⁻¹ = (SymAlg.sym a)⁻¹

full_name: SymAlg.unsym_inv
code: @[simp, to_additive existing]
theorem unsym_inv [Inv α] (a : αˢʸᵐ) : unsym a⁻¹ = (unsym a)⁻¹ 
goal: SymAlg.unsym a⁻¹ = (SymAlg.unsym a)⁻¹

full_name: SymAlg.sym_smul
code: @[simp]
theorem sym_smul {R : Type*} [SMul R α] (c : R) (a : α) : sym (c • a) = c • sym a 
goal: SymAlg.sym (c • a) = c • SymAlg.sym a

full_name: SymAlg.unsym_smul
code: @[simp]
theorem unsym_smul {R : Type*} [SMul R α] (c : R) (a : αˢʸᵐ) : unsym (c • a) = c • unsym a 
goal: SymAlg.unsym (c • a) = c • SymAlg.unsym a

full_name: SymAlg.unsym_eq_one_iff
code: @[to_additive (attr := simp)]
theorem unsym_eq_one_iff [One α] (a : αˢʸᵐ) : unsym a = 1 ↔ a = 1 
goal: SymAlg.unsym a = 1 ↔ a = 1

full_name: SymAlg.unsym_eq_zero_iff
code: @[to_additive (attr := simp)]
theorem unsym_eq_one_iff [One α] (a : αˢʸᵐ) : unsym a = 1 ↔ a = 1 
goal: SymAlg.unsym a = 0 ↔ a = 0

full_name: SymAlg.sym_eq_zero_iff
code: @[to_additive (attr := simp)]
theorem sym_eq_one_iff [One α] (a : α) : sym a = 1 ↔ a = 1 
goal: SymAlg.sym a = 0 ↔ a = 0

full_name: SymAlg.sym_eq_one_iff
code: @[to_additive (attr := simp)]
theorem sym_eq_one_iff [One α] (a : α) : sym a = 1 ↔ a = 1 
goal: SymAlg.sym a = 1 ↔ a = 1

full_name: SymAlg.unsym_ne_one_iff
code: @[to_additive]
theorem unsym_ne_one_iff [One α] (a : αˢʸᵐ) : unsym a ≠ (1 : α) ↔ a ≠ (1 : αˢʸᵐ) 
goal: SymAlg.unsym a ≠ 1 ↔ a ≠ 1

full_name: SymAlg.unsym_ne_zero_iff
code: @[to_additive]
theorem unsym_ne_one_iff [One α] (a : αˢʸᵐ) : unsym a ≠ (1 : α) ↔ a ≠ (1 : αˢʸᵐ) 
goal: SymAlg.unsym a ≠ 0 ↔ a ≠ 0

full_name: SymAlg.sym_ne_one_iff
code: @[to_additive]
theorem sym_ne_one_iff [One α] (a : α) : sym a ≠ (1 : αˢʸᵐ) ↔ a ≠ (1 : α) 
goal: SymAlg.sym a ≠ 1 ↔ a ≠ 1

full_name: SymAlg.sym_ne_zero_iff
code: @[to_additive]
theorem sym_ne_one_iff [One α] (a : α) : sym a ≠ (1 : αˢʸᵐ) ↔ a ≠ (1 : α) 
goal: SymAlg.sym a ≠ 0 ↔ a ≠ 0

full_name: SymAlg.addCommSemigroup
code: instance addCommSemigroup [AddCommSemigroup α] : AddCommSemigroup αˢʸᵐ 
goal: AddCommSemigroup αˢʸᵐ

full_name: SymAlg.addMonoid
code: instance addMonoid [AddMonoid α] : AddMonoid αˢʸᵐ 
goal: AddMonoid αˢʸᵐ

full_name: SymAlg.addGroup
code: instance addGroup [AddGroup α] : AddGroup αˢʸᵐ 
goal: AddGroup αˢʸᵐ

full_name: SymAlg.addCommMonoid
code: instance addCommMonoid [AddCommMonoid α] : AddCommMonoid αˢʸᵐ 
goal: AddCommMonoid αˢʸᵐ

full_name: SymAlg.addCommGroup
code: instance addCommGroup [AddCommGroup α] : AddCommGroup αˢʸᵐ 
goal: AddCommGroup αˢʸᵐ

full_name: SymAlg.instModule
code: instance {R : Type*} [Semiring R] [AddCommMonoid α] [Module R α] : Module R αˢʸᵐ 
goal: Module R αˢʸᵐ

full_name: SymAlg.instInvertibleCoeEquivSym
code: instance [Mul α] [AddMonoidWithOne α] [Invertible (2 : α)] (a : α) [Invertible a] :
    Invertible (sym a) 
goal: Invertible (SymAlg.sym a)

full_name: SymAlg.invOf_sym
code: @[simp]
theorem invOf_sym [Mul α] [AddMonoidWithOne α] [Invertible (2 : α)] (a : α) [Invertible a] :
    ⅟ (sym a) = sym (⅟ a) 
goal: ⅟(SymAlg.sym a) = SymAlg.sym ⅟a

full_name: SymAlg.nonAssocSemiring
code: instance nonAssocSemiring [Semiring α] [Invertible (2 : α)] : NonAssocSemiring αˢʸᵐ 
goal: NonAssocSemiring αˢʸᵐ

full_name: SymAlg.instNonAssocRingOfInvertibleOfNat
code: /-- The symmetrization of a real (unital, associative) algebra is a non-associative ring. -/
instance [Ring α] [Invertible (2 : α)] : NonAssocRing αˢʸᵐ 
goal: NonAssocRing αˢʸᵐ

full_name: SymAlg.unsym_mul_self
code: theorem unsym_mul_self [Semiring α] [Invertible (2 : α)] (a : αˢʸᵐ) :
    unsym (a * a) = unsym a * unsym a 
goal: SymAlg.unsym (a * a) = SymAlg.unsym a * SymAlg.unsym a

full_name: SymAlg.sym_mul_self
code: theorem sym_mul_self [Semiring α] [Invertible (2 : α)] (a : α) : sym (a * a) = sym a * sym a 
goal: SymAlg.sym (a * a) = SymAlg.sym a * SymAlg.sym a

full_name: SymAlg.mul_comm
code: theorem mul_comm [Mul α] [AddCommSemigroup α] [One α] [OfNat α 2] [Invertible (2 : α)]
    (a b : αˢʸᵐ) :
    a * b = b * a 
goal: a * b = b * a

full_name: SymAlg.instCommMagmaOfInvertibleOfNat
code: instance [Ring α] [Invertible (2 : α)] : CommMagma αˢʸᵐ 
goal: CommMagma αˢʸᵐ

full_name: SymAlg.instIsCommJordan
code: instance [Ring α] [Invertible (2 : α)] : IsCommJordan αˢʸᵐ 
goal: IsCommJordan αˢʸᵐ