File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

full_name: MulAction.fixedBy_inv
code: /-- In a multiplicative group action, the points fixed by `g` are also fixed by `g⁻¹` -/
@[to_additive (attr := simp)
  "In an additive group action, the points fixed by `g` are also fixed by `g⁻¹`"]
theorem fixedBy_inv (g : G) : fixedBy α g⁻¹ = fixedBy α g 
goal: MulAction.fixedBy α g⁻¹ = MulAction.fixedBy α g

full_name: AddAction.fixedBy_neg
code: /-- In a multiplicative group action, the points fixed by `g` are also fixed by `g⁻¹` -/
@[to_additive (attr := simp)
  "In an additive group action, the points fixed by `g` are also fixed by `g⁻¹`"]
theorem fixedBy_inv (g : G) : fixedBy α g⁻¹ = fixedBy α g 
goal: AddAction.fixedBy α (-g) = AddAction.fixedBy α g

full_name: MulAction.smul_mem_fixedBy_iff_mem_fixedBy
code: @[to_additive]
theorem smul_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
goal: g • a ∈ MulAction.fixedBy α g ↔ a ∈ MulAction.fixedBy α g

full_name: AddAction.vadd_mem_fixedBy_iff_mem_fixedBy
code: @[to_additive]
theorem smul_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
goal: g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g

full_name: AddAction.vadd_neg_mem_fixedBy_iff_mem_fixedBy
code: @[to_additive]
theorem smul_inv_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g⁻¹ • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
goal: -g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g

full_name: MulAction.smul_inv_mem_fixedBy_iff_mem_fixedBy
code: @[to_additive]
theorem smul_inv_mem_fixedBy_iff_mem_fixedBy {a : α} {g : G} :
    g⁻¹ • a ∈ fixedBy α g ↔ a ∈ fixedBy α g 
goal: g⁻¹ • a ∈ MulAction.fixedBy α g ↔ a ∈ MulAction.fixedBy α g

full_name: MulAction.minimalPeriod_eq_one_iff_fixedBy
code: @[to_additive minimalPeriod_eq_one_iff_fixedBy]
theorem minimalPeriod_eq_one_iff_fixedBy {a : α} {g : G} :
    Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ fixedBy α g 
goal: Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ MulAction.fixedBy α g

full_name: AddAction.minimalPeriod_eq_one_iff_fixedBy
code: @[to_additive minimalPeriod_eq_one_iff_fixedBy]
theorem minimalPeriod_eq_one_iff_fixedBy {a : α} {g : G} :
    Function.minimalPeriod (fun x => g • x) a = 1 ↔ a ∈ fixedBy α g 
goal: Function.minimalPeriod (fun x => g +ᵥ x) a = 1 ↔ a ∈ AddAction.fixedBy α g

full_name: AddAction.fixedBy_subset_fixedBy_zsmul
code: @[to_additive]
theorem fixedBy_subset_fixedBy_zpow (g : G) (j : ℤ) :
    fixedBy α g ⊆ fixedBy α (g ^ j) 
goal: AddAction.fixedBy α g ⊆ AddAction.fixedBy α (j • g)

full_name: MulAction.fixedBy_subset_fixedBy_zpow
code: @[to_additive]
theorem fixedBy_subset_fixedBy_zpow (g : G) (j : ℤ) :
    fixedBy α g ⊆ fixedBy α (g ^ j) 
goal: MulAction.fixedBy α g ⊆ MulAction.fixedBy α (g ^ j)

full_name: AddAction.fixedBy_zero_eq_univ
code: @[to_additive (attr := simp)]
theorem fixedBy_one_eq_univ : fixedBy α (1 : M) = Set.univ 
goal: AddAction.fixedBy α 0 = Set.univ

full_name: MulAction.fixedBy_one_eq_univ
code: @[to_additive (attr := simp)]
theorem fixedBy_one_eq_univ : fixedBy α (1 : M) = Set.univ 
goal: MulAction.fixedBy α 1 = Set.univ

full_name: MulAction.fixedBy_mul
code: @[to_additive]
theorem fixedBy_mul (m₁ m₂ : M) : fixedBy α m₁ ∩ fixedBy α m₂ ⊆ fixedBy α (m₁ * m₂) 
goal: MulAction.fixedBy α m₁ ∩ MulAction.fixedBy α m₂ ⊆ MulAction.fixedBy α (m₁ * m₂)

full_name: AddAction.fixedBy_add
code: @[to_additive]
theorem fixedBy_mul (m₁ m₂ : M) : fixedBy α m₁ ∩ fixedBy α m₂ ⊆ fixedBy α (m₁ * m₂) 
goal: AddAction.fixedBy α m₁ ∩ AddAction.fixedBy α m₂ ⊆ AddAction.fixedBy α (m₁ + m₂)

full_name: AddAction.vadd_fixedBy
code: @[to_additive]
theorem smul_fixedBy (g h : G) :
    h • fixedBy α g = fixedBy α (h * g * h⁻¹) 
goal: h +ᵥ AddAction.fixedBy α g = AddAction.fixedBy α (h + g + -h)

full_name: MulAction.smul_fixedBy
code: @[to_additive]
theorem smul_fixedBy (g h : G) :
    h • fixedBy α g = fixedBy α (h * g * h⁻¹) 
goal: h • MulAction.fixedBy α g = MulAction.fixedBy α (h * g * h⁻¹)

full_name: AddAction.set_mem_fixedBy_iff
code: /--
If a set `s : Set α` is in `fixedBy (Set α) g`, then all points of `s` will stay in `s` after being
moved by `g`.
-/
@[to_additive "If a set `s : Set α` is in `fixedBy (Set α) g`, then all points of `s` will stay in
`s` after being moved by `g`."]
theorem set_mem_fixedBy_iff (s : Set α) (g : G) :
    s ∈ fixedBy (Set α) g ↔ ∀ x, g • x ∈ s ↔ x ∈ s 
goal: s ∈ AddAction.fixedBy (Set α) g ↔ ∀ (x : α), g +ᵥ x ∈ s ↔ x ∈ s

full_name: MulAction.set_mem_fixedBy_iff
code: /--
If a set `s : Set α` is in `fixedBy (Set α) g`, then all points of `s` will stay in `s` after being
moved by `g`.
-/
@[to_additive "If a set `s : Set α` is in `fixedBy (Set α) g`, then all points of `s` will stay in
`s` after being moved by `g`."]
theorem set_mem_fixedBy_iff (s : Set α) (g : G) :
    s ∈ fixedBy (Set α) g ↔ ∀ x, g • x ∈ s ↔ x ∈ s 
goal: s ∈ MulAction.fixedBy (Set α) g ↔ ∀ (x : α), g • x ∈ s ↔ x ∈ s

full_name: MulAction.smul_mem_of_set_mem_fixedBy
code: theorem smul_mem_of_set_mem_fixedBy {s : Set α} {g : G} (s_in_fixedBy : s ∈ fixedBy (Set α) g)
    {x : α} : g • x ∈ s ↔ x ∈ s 
goal: g • x ∈ s ↔ x ∈ s

full_name: MulAction.set_mem_fixedBy_of_subset_fixedBy
code: /--
If `s ⊆ fixedBy α g`, then `g • s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g • x ≠ x` and `g • x ∈ s`).
-/
@[to_additive "If `s ⊆ fixedBy α g`, then `g +ᵥ s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g +ᵥ x ≠ x` and `g +ᵥ x ∈ s`)."]
theorem set_mem_fixedBy_of_subset_fixedBy {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ fixedBy α g) :
    s ∈ fixedBy (Set α) g 
goal: s ∈ MulAction.fixedBy (Set α) g

full_name: AddAction.set_mem_fixedBy_of_subset_fixedBy
code: /--
If `s ⊆ fixedBy α g`, then `g • s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g • x ≠ x` and `g • x ∈ s`).
-/
@[to_additive "If `s ⊆ fixedBy α g`, then `g +ᵥ s = s`, which means that `s ∈ fixedBy (Set α) g`.

Note that the reverse implication is in general not true, as `s ∈ fixedBy (Set α) g` is a
weaker statement (it allows for points `x ∈ s` for which `g +ᵥ x ≠ x` and `g +ᵥ x ∈ s`)."]
theorem set_mem_fixedBy_of_subset_fixedBy {s : Set α} {g : G} (s_ss_fixedBy : s ⊆ fixedBy α g) :
    s ∈ fixedBy (Set α) g 
goal: s ∈ AddAction.fixedBy (Set α) g

full_name: MulAction.smul_subset_of_set_mem_fixedBy
code: theorem smul_subset_of_set_mem_fixedBy {s t : Set α} {g : G} (t_ss_s : t ⊆ s)
    (s_in_fixedBy : s ∈ fixedBy (Set α) g) : g • t ⊆ s 
goal: g • t ⊆ s

full_name: MulAction.set_mem_fixedBy_of_movedBy_subset
code: /-- If `(fixedBy α g)ᶜ ⊆ s`, then `g` cannot move a point of `s` outside of `s`. -/
@[to_additive "If `(fixedBy α g)ᶜ ⊆ s`, then `g` cannot move a point of `s` outside of `s`."]
theorem set_mem_fixedBy_of_movedBy_subset {s : Set α} {g : G} (s_subset : (fixedBy α g)ᶜ ⊆ s) :
    s ∈ fixedBy (Set α) g 
goal: s ∈ MulAction.fixedBy (Set α) g

full_name: AddAction.set_mem_fixedBy_of_movedBy_subset
code: /-- If `(fixedBy α g)ᶜ ⊆ s`, then `g` cannot move a point of `s` outside of `s`. -/
@[to_additive "If `(fixedBy α g)ᶜ ⊆ s`, then `g` cannot move a point of `s` outside of `s`."]
theorem set_mem_fixedBy_of_movedBy_subset {s : Set α} {g : G} (s_subset : (fixedBy α g)ᶜ ⊆ s) :
    s ∈ fixedBy (Set α) g 
goal: s ∈ AddAction.fixedBy (Set α) g

full_name: AddAction.fixedBy_mem_fixedBy_of_addCommute
code: /--
If `g` and `h` commute, then `g` fixes `h • x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
-/
@[to_additive "If `g` and `h` commute, then `g` fixes `h +ᵥ x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
"]
theorem fixedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g) ∈ fixedBy (Set α) h 
goal: AddAction.fixedBy α g ∈ AddAction.fixedBy (Set α) h

full_name: MulAction.fixedBy_mem_fixedBy_of_commute
code: /--
If `g` and `h` commute, then `g` fixes `h • x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
-/
@[to_additive "If `g` and `h` commute, then `g` fixes `h +ᵥ x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
"]
theorem fixedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g) ∈ fixedBy (Set α) h 
goal: MulAction.fixedBy α g ∈ MulAction.fixedBy (Set α) h

full_name: AddAction.vadd_zsmul_fixedBy_eq_of_addCommute
code: /--
If `g` and `h` commute, then `g` fixes `(h ^ j) • x` iff `g` fixes `x`.
-/
@[to_additive "If `g` and `h` commute, then `g` fixes `(j • h) +ᵥ x` iff `g` fixes `x`."]
theorem smul_zpow_fixedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • fixedBy α g = fixedBy α g 
goal: j • h +ᵥ AddAction.fixedBy α g = AddAction.fixedBy α g

full_name: MulAction.smul_zpow_fixedBy_eq_of_commute
code: /--
If `g` and `h` commute, then `g` fixes `(h ^ j) • x` iff `g` fixes `x`.
-/
@[to_additive "If `g` and `h` commute, then `g` fixes `(j • h) +ᵥ x` iff `g` fixes `x`."]
theorem smul_zpow_fixedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • fixedBy α g = fixedBy α g 
goal: h ^ j • MulAction.fixedBy α g = MulAction.fixedBy α g

full_name: AddAction.movedBy_mem_fixedBy_of_addCommute
code: /--
If `g` and `h` commute, then `g` moves `h • x` iff `g` moves `x`.
This is equivalent to say that the set `(fixedBy α g)ᶜ` is fixed by `h`.
-/
@[to_additive "If `g` and `h` commute, then `g` moves `h +ᵥ x` iff `g` moves `x`.
This is equivalent to say that the set `(fixedBy α g)ᶜ` is fixed by `h`."]
theorem movedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g)ᶜ ∈ fixedBy (Set α) h 
goal: (AddAction.fixedBy α g)ᶜ ∈ AddAction.fixedBy (Set α) h

full_name: MulAction.movedBy_mem_fixedBy_of_commute
code: /--
If `g` and `h` commute, then `g` moves `h • x` iff `g` moves `x`.
This is equivalent to say that the set `(fixedBy α g)ᶜ` is fixed by `h`.
-/
@[to_additive "If `g` and `h` commute, then `g` moves `h +ᵥ x` iff `g` moves `x`.
This is equivalent to say that the set `(fixedBy α g)ᶜ` is fixed by `h`."]
theorem movedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g)ᶜ ∈ fixedBy (Set α) h 
goal: (MulAction.fixedBy α g)ᶜ ∈ MulAction.fixedBy (Set α) h

full_name: MulAction.smul_zpow_movedBy_eq_of_commute
code: /--
If `g` and `h` commute, then `g` moves `h ^ j • x` iff `g` moves `x`.
-/
@[to_additive "If `g` and `h` commute, then `g` moves `(j • h) +ᵥ x` iff `g` moves `x`."]
theorem smul_zpow_movedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • (fixedBy α g)ᶜ = (fixedBy α g)ᶜ 
goal: h ^ j • (MulAction.fixedBy α g)ᶜ = (MulAction.fixedBy α g)ᶜ

full_name: AddAction.vadd_zsmul_movedBy_eq_of_addCommute
code: /--
If `g` and `h` commute, then `g` moves `h ^ j • x` iff `g` moves `x`.
-/
@[to_additive "If `g` and `h` commute, then `g` moves `(j • h) +ᵥ x` iff `g` moves `x`."]
theorem smul_zpow_movedBy_eq_of_commute {g h : G} (comm : Commute g h) (j : ℤ) :
    h ^ j • (fixedBy α g)ᶜ = (fixedBy α g)ᶜ 
goal: j • h +ᵥ (AddAction.fixedBy α g)ᶜ = (AddAction.fixedBy α g)ᶜ

full_name: AddAction.fixedBy_eq_univ_iff_eq_zero
code: /-- If the multiplicative action of `M` on `α` is faithful,
then `fixedBy α m = Set.univ` implies that `m = 1`. -/
@[to_additive "If the additive action of `M` on `α` is faithful,
then `fixedBy α m = Set.univ` implies that `m = 1`."]
theorem fixedBy_eq_univ_iff_eq_one {m : M} : fixedBy α m = Set.univ ↔ m = 1 
goal: AddAction.fixedBy α m = Set.univ ↔ m = 0

full_name: MulAction.fixedBy_eq_univ_iff_eq_one
code: /-- If the multiplicative action of `M` on `α` is faithful,
then `fixedBy α m = Set.univ` implies that `m = 1`. -/
@[to_additive "If the additive action of `M` on `α` is faithful,
then `fixedBy α m = Set.univ` implies that `m = 1`."]
theorem fixedBy_eq_univ_iff_eq_one {m : M} : fixedBy α m = Set.univ ↔ m = 1 
goal: MulAction.fixedBy α m = Set.univ ↔ m = 1

full_name: MulAction.not_commute_of_disjoint_movedBy_preimage
code: /--
If the image of the `(fixedBy α g)ᶜ` set by the pointwise action of `h: G`
is disjoint from `(fixedBy α g)ᶜ`, then `g` and `h` cannot commute.
-/
@[to_additive "If the image of the `(fixedBy α g)ᶜ` set by the pointwise action of `h: G`
is disjoint from `(fixedBy α g)ᶜ`, then `g` and `h` cannot commute."]
theorem not_commute_of_disjoint_movedBy_preimage {g h : G} (ne_one : g ≠ 1)
    (disjoint : Disjoint (fixedBy α g)ᶜ (h • (fixedBy α g)ᶜ)) : ¬Commute g h 
goal: ¬Commute g h

full_name: AddAction.not_addCommute_of_disjoint_movedBy_preimage
code: /--
If the image of the `(fixedBy α g)ᶜ` set by the pointwise action of `h: G`
is disjoint from `(fixedBy α g)ᶜ`, then `g` and `h` cannot commute.
-/
@[to_additive "If the image of the `(fixedBy α g)ᶜ` set by the pointwise action of `h: G`
is disjoint from `(fixedBy α g)ᶜ`, then `g` and `h` cannot commute."]
theorem not_commute_of_disjoint_movedBy_preimage {g h : G} (ne_one : g ≠ 1)
    (disjoint : Disjoint (fixedBy α g)ᶜ (h • (fixedBy α g)ᶜ)) : ¬Commute g h 
goal: ¬AddCommute g h