File: Mathlib/GroupTheory/Perm/Support.lean

full_name: Equiv.Perm.Disjoint
code: /-- Two permutations `f` and `g` are `Disjoint` if their supports are disjoint, i.e.,
every element is fixed either by `f`, or by `g`. -/
def Disjoint (f g : Perm α) 
goal: Prop

full_name: Equiv.Perm.Disjoint.symm
code: @[symm]
theorem Disjoint.symm : Disjoint f g → Disjoint g f 
goal: f.Disjoint g → g.Disjoint f

full_name: Equiv.Perm.Disjoint.symmetric
code: theorem Disjoint.symmetric : Symmetric (@Disjoint α) 
goal: Symmetric Equiv.Perm.Disjoint

full_name: Equiv.Perm.instIsSymmDisjoint
code: instance : IsSymm (Perm α) Disjoint 
goal: IsSymm (Equiv.Perm α) Equiv.Perm.Disjoint

full_name: Equiv.Perm.disjoint_comm
code: theorem disjoint_comm : Disjoint f g ↔ Disjoint g f 
goal: f.Disjoint g ↔ g.Disjoint f

full_name: Equiv.Perm.Disjoint.commute
code: theorem Disjoint.commute (h : Disjoint f g) : Commute f g 
goal: Commute f g

full_name: Equiv.Perm.disjoint_one_left
code: @[simp]
theorem disjoint_one_left (f : Perm α) : Disjoint 1 f 
goal: Equiv.Perm.Disjoint 1 f

full_name: Equiv.Perm.disjoint_one_right
code: @[simp]
theorem disjoint_one_right (f : Perm α) : Disjoint f 1 
goal: f.Disjoint 1

full_name: Equiv.Perm.disjoint_iff_eq_or_eq
code: theorem disjoint_iff_eq_or_eq : Disjoint f g ↔ ∀ x : α, f x = x ∨ g x = x 
goal: f.Disjoint g ↔ ∀ (x : α), f x = x ∨ g x = x

full_name: Equiv.Perm.disjoint_refl_iff
code: @[simp]
theorem disjoint_refl_iff : Disjoint f f ↔ f = 1 
goal: f.Disjoint f ↔ f = 1

full_name: Equiv.Perm.Disjoint.inv_left
code: theorem Disjoint.inv_left (h : Disjoint f g) : Disjoint f⁻¹ g 
goal: f⁻¹.Disjoint g

full_name: Equiv.Perm.Disjoint.inv_right
code: theorem Disjoint.inv_right (h : Disjoint f g) : Disjoint f g⁻¹ 
goal: f.Disjoint g⁻¹

full_name: Equiv.Perm.disjoint_inv_left_iff
code: @[simp]
theorem disjoint_inv_left_iff : Disjoint f⁻¹ g ↔ Disjoint f g 
goal: f⁻¹.Disjoint g ↔ f.Disjoint g

full_name: Equiv.Perm.disjoint_inv_right_iff
code: @[simp]
theorem disjoint_inv_right_iff : Disjoint f g⁻¹ ↔ Disjoint f g 
goal: f.Disjoint g⁻¹ ↔ f.Disjoint g

full_name: Equiv.Perm.Disjoint.mul_left
code: theorem Disjoint.mul_left (H1 : Disjoint f h) (H2 : Disjoint g h) : Disjoint (f * g) h 
goal: (f * g).Disjoint h

full_name: Equiv.Perm.Disjoint.mul_right
code: theorem Disjoint.mul_right (H1 : Disjoint f g) (H2 : Disjoint f h) : Disjoint f (g * h) 
goal: f.Disjoint (g * h)

full_name: Equiv.Perm.disjoint_conj
code: theorem disjoint_conj (h : Perm α) : Disjoint (h * f * h⁻¹) (h * g * h⁻¹) ↔ Disjoint f g 
goal: (h * f * h⁻¹).Disjoint (h * g * h⁻¹) ↔ f.Disjoint g

full_name: Equiv.Perm.Disjoint.conj
code: theorem Disjoint.conj (H : Disjoint f g) (h : Perm α) : Disjoint (h * f * h⁻¹) (h * g * h⁻¹) 
goal: (h * f * h⁻¹).Disjoint (h * g * h⁻¹)

full_name: Equiv.Perm.disjoint_prod_right
code: theorem disjoint_prod_right (l : List (Perm α)) (h : ∀ g ∈ l, Disjoint f g) :
    Disjoint f l.prod 
goal: f.Disjoint l.prod

full_name: Equiv.Perm.disjoint_prod_perm
code: theorem disjoint_prod_perm {l₁ l₂ : List (Perm α)} (hl : l₁.Pairwise Disjoint) (hp : l₁ ~ l₂) :
    l₁.prod = l₂.prod 
goal: l₁.prod = l₂.prod

full_name: Equiv.Perm.nodup_of_pairwise_disjoint
code: theorem nodup_of_pairwise_disjoint {l : List (Perm α)} (h1 : (1 : Perm α) ∉ l)
    (h2 : l.Pairwise Disjoint) : l.Nodup 
goal: l.Nodup

full_name: Equiv.Perm.pow_apply_eq_self_of_apply_eq_self
code: theorem pow_apply_eq_self_of_apply_eq_self {x : α} (hfx : f x = x) : ∀ n : ℕ, (f ^ n) x = x
  
goal: (f ^ n) x = x

full_name: Equiv.Perm.zpow_apply_eq_self_of_apply_eq_self
code: theorem zpow_apply_eq_self_of_apply_eq_self {x : α} (hfx : f x = x) : ∀ n : ℤ, (f ^ n) x = x
  
goal: (f ^ n) x = x

full_name: Equiv.Perm.pow_apply_eq_of_apply_apply_eq_self
code: theorem pow_apply_eq_of_apply_apply_eq_self {x : α} (hffx : f (f x) = x) :
    ∀ n : ℕ, (f ^ n) x = x ∨ (f ^ n) x = f x
  
goal: (f ^ n) x = x ∨ (f ^ n) x = f x

full_name: Equiv.Perm.zpow_apply_eq_of_apply_apply_eq_self
code: theorem zpow_apply_eq_of_apply_apply_eq_self {x : α} (hffx : f (f x) = x) :
    ∀ i : ℤ, (f ^ i) x = x ∨ (f ^ i) x = f x
  
goal: (f ^ i) x = x ∨ (f ^ i) x = f x

full_name: Equiv.Perm.Disjoint.mul_apply_eq_iff
code: theorem Disjoint.mul_apply_eq_iff {σ τ : Perm α} (hστ : Disjoint σ τ) {a : α} :
    (σ * τ) a = a ↔ σ a = a ∧ τ a = a 
goal: (σ * τ) a = a ↔ σ a = a ∧ τ a = a

full_name: Equiv.Perm.Disjoint.mul_eq_one_iff
code: theorem Disjoint.mul_eq_one_iff {σ τ : Perm α} (hστ : Disjoint σ τ) :
    σ * τ = 1 ↔ σ = 1 ∧ τ = 1 
goal: σ * τ = 1 ↔ σ = 1 ∧ τ = 1

full_name: Equiv.Perm.Disjoint.zpow_disjoint_zpow
code: theorem Disjoint.zpow_disjoint_zpow {σ τ : Perm α} (hστ : Disjoint σ τ) (m n : ℤ) :
    Disjoint (σ ^ m) (τ ^ n) 
goal: (σ ^ m).Disjoint (τ ^ n)

full_name: Equiv.Perm.Disjoint.pow_disjoint_pow
code: theorem Disjoint.pow_disjoint_pow {σ τ : Perm α} (hστ : Disjoint σ τ) (m n : ℕ) :
    Disjoint (σ ^ m) (τ ^ n) 
goal: (σ ^ m).Disjoint (τ ^ n)

full_name: Equiv.Perm.IsSwap
code: /-- `f.IsSwap` indicates that the permutation `f` is a transposition of two elements. -/
def IsSwap (f : Perm α) : Prop 
goal: Prop

full_name: Equiv.Perm.ofSubtype_swap_eq
code: @[simp]
theorem ofSubtype_swap_eq {p : α → Prop} [DecidablePred p] (x y : Subtype p) :
    ofSubtype (Equiv.swap x y) = Equiv.swap ↑x ↑y 
goal: Equiv.Perm.ofSubtype (Equiv.swap x y) = Equiv.swap ↑x ↑y

full_name: Equiv.Perm.IsSwap.of_subtype_isSwap
code: theorem IsSwap.of_subtype_isSwap {p : α → Prop} [DecidablePred p] {f : Perm (Subtype p)}
    (h : f.IsSwap) : (ofSubtype f).IsSwap 
goal: (Equiv.Perm.ofSubtype f).IsSwap

full_name: Equiv.Perm.ne_and_ne_of_swap_mul_apply_ne_self
code: theorem ne_and_ne_of_swap_mul_apply_ne_self {f : Perm α} {x y : α} (hy : (swap x (f x) * f) y ≠ y) :
    f y ≠ y ∧ y ≠ x 
goal: f y ≠ y ∧ y ≠ x

full_name: Equiv.Perm.set_support_inv_eq
code: theorem set_support_inv_eq : { x | p⁻¹ x ≠ x } = { x | p x ≠ x } 
goal: {x | p⁻¹ x ≠ x} = {x | p x ≠ x}

full_name: Equiv.Perm.set_support_apply_mem
code: theorem set_support_apply_mem {p : Perm α} {a : α} :
    p a ∈ { x | p x ≠ x } ↔ a ∈ { x | p x ≠ x } 
goal: p a ∈ {x | p x ≠ x} ↔ a ∈ {x | p x ≠ x}

full_name: Equiv.Perm.set_support_zpow_subset
code: theorem set_support_zpow_subset (n : ℤ) : { x | (p ^ n) x ≠ x } ⊆ { x | p x ≠ x } 
goal: {x | (p ^ n) x ≠ x} ⊆ {x | p x ≠ x}

full_name: Equiv.Perm.set_support_mul_subset
code: theorem set_support_mul_subset : { x | (p * q) x ≠ x } ⊆ { x | p x ≠ x } ∪ { x | q x ≠ x } 
goal: {x | (p * q) x ≠ x} ⊆ {x | p x ≠ x} ∪ {x | q x ≠ x}

full_name: Equiv.Perm.apply_pow_apply_eq_iff
code: @[simp]
theorem apply_pow_apply_eq_iff (f : Perm α) (n : ℕ) {x : α} :
    f ((f ^ n) x) = (f ^ n) x ↔ f x = x 
goal: f ((f ^ n) x) = (f ^ n) x ↔ f x = x

full_name: Equiv.Perm.apply_zpow_apply_eq_iff
code: @[simp]
theorem apply_zpow_apply_eq_iff (f : Perm α) (n : ℤ) {x : α} :
    f ((f ^ n) x) = (f ^ n) x ↔ f x = x 
goal: f ((f ^ n) x) = (f ^ n) x ↔ f x = x

full_name: Equiv.Perm.support
code: /-- The `Finset` of nonfixed points of a permutation. -/
def support (f : Perm α) : Finset α 
goal: Finset α

full_name: Equiv.Perm.mem_support
code: @[simp]
theorem mem_support {x : α} : x ∈ f.support ↔ f x ≠ x 
goal: x ∈ f.support ↔ f x ≠ x

full_name: Equiv.Perm.not_mem_support
code: theorem not_mem_support {x : α} : x ∉ f.support ↔ f x = x 
goal: x ∉ f.support ↔ f x = x

full_name: Equiv.Perm.coe_support_eq_set_support
code: theorem coe_support_eq_set_support (f : Perm α) : (f.support : Set α) = { x | f x ≠ x } 
goal: ↑f.support = {x | f x ≠ x}

full_name: Equiv.Perm.support_eq_empty_iff
code: @[simp]
theorem support_eq_empty_iff {σ : Perm α} : σ.support = ∅ ↔ σ = 1 
goal: σ.support = ∅ ↔ σ = 1

full_name: Equiv.Perm.support_one
code: @[simp]
theorem support_one : (1 : Perm α).support = ∅ 
goal: Equiv.Perm.support 1 = ∅

full_name: Equiv.Perm.support_refl
code: @[simp]
theorem support_refl : support (Equiv.refl α) = ∅ 
goal: Equiv.Perm.support (Equiv.refl α) = ∅

full_name: Equiv.Perm.support_congr
code: theorem support_congr (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) : f = g 
goal: f = g

full_name: Equiv.Perm.support_mul_le
code: theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support 
goal: (f * g).support ≤ f.support ⊔ g.support

full_name: Equiv.Perm.exists_mem_support_of_mem_support_prod
code: theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support 
goal: ∃ f ∈ l, x ∈ f.support

full_name: Equiv.Perm.support_pow_le
code: theorem support_pow_le (σ : Perm α) (n : ℕ) : (σ ^ n).support ≤ σ.support 
goal: (σ ^ n).support ≤ σ.support

full_name: Equiv.Perm.support_inv
code: @[simp]
theorem support_inv (σ : Perm α) : support σ⁻¹ = σ.support 
goal: σ⁻¹.support = σ.support

full_name: Equiv.Perm.apply_mem_support
code: theorem apply_mem_support {x : α} : f x ∈ f.support ↔ x ∈ f.support 
goal: f x ∈ f.support ↔ x ∈ f.support

full_name: Equiv.Perm.pow_apply_mem_support
code: theorem pow_apply_mem_support {n : ℕ} {x : α} : (f ^ n) x ∈ f.support ↔ x ∈ f.support 
goal: (f ^ n) x ∈ f.support ↔ x ∈ f.support

full_name: Equiv.Perm.zpow_apply_mem_support
code: theorem zpow_apply_mem_support {n : ℤ} {x : α} : (f ^ n) x ∈ f.support ↔ x ∈ f.support 
goal: (f ^ n) x ∈ f.support ↔ x ∈ f.support

full_name: Equiv.Perm.pow_eq_on_of_mem_support
code: theorem pow_eq_on_of_mem_support (h : ∀ x ∈ f.support ∩ g.support, f x = g x) (k : ℕ) :
    ∀ x ∈ f.support ∩ g.support, (f ^ k) x = (g ^ k) x 
goal: x ∈ f.support ∩ g.support → (f ^ k) x = (g ^ k) x

full_name: Equiv.Perm.disjoint_iff_disjoint_support
code: theorem disjoint_iff_disjoint_support : Disjoint f g ↔ _root_.Disjoint f.support g.support 
goal: f.Disjoint g ↔ Disjoint f.support g.support

full_name: Equiv.Perm.Disjoint.disjoint_support
code: theorem Disjoint.disjoint_support (h : Disjoint f g) : _root_.Disjoint f.support g.support 
goal: Disjoint f.support g.support

full_name: Equiv.Perm.Disjoint.support_mul
code: theorem Disjoint.support_mul (h : Disjoint f g) : (f * g).support = f.support ∪ g.support 
goal: (f * g).support = f.support ∪ g.support

full_name: Equiv.Perm.support_prod_of_pairwise_disjoint
code: theorem support_prod_of_pairwise_disjoint (l : List (Perm α)) (h : l.Pairwise Disjoint) :
    l.prod.support = (l.map support).foldr (· ⊔ ·) ⊥ 
goal: l.prod.support = List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map Equiv.Perm.support l)

full_name: Equiv.Perm.support_prod_le
code: theorem support_prod_le (l : List (Perm α)) : l.prod.support ≤ (l.map support).foldr (· ⊔ ·) ⊥ 
goal: l.prod.support ≤ List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map Equiv.Perm.support l)

full_name: Equiv.Perm.support_zpow_le
code: theorem support_zpow_le (σ : Perm α) (n : ℤ) : (σ ^ n).support ≤ σ.support 
goal: (σ ^ n).support ≤ σ.support

full_name: Equiv.Perm.support_swap
code: @[simp]
theorem support_swap {x y : α} (h : x ≠ y) : support (swap x y) = {x, y} 
goal: (Equiv.swap x y).support = {x, y}

full_name: Equiv.Perm.support_swap_iff
code: theorem support_swap_iff (x y : α) : support (swap x y) = {x, y} ↔ x ≠ y 
goal: (Equiv.swap x y).support = {x, y} ↔ x ≠ y

full_name: Equiv.Perm.support_swap_mul_swap
code: theorem support_swap_mul_swap {x y z : α} (h : List.Nodup [x, y, z]) :
    support (swap x y * swap y z) = {x, y, z} 
goal: (Equiv.swap x y * Equiv.swap y z).support = {x, y, z}

full_name: Equiv.Perm.support_swap_mul_ge_support_diff
code: theorem support_swap_mul_ge_support_diff (f : Perm α) (x y : α) :
    f.support \ {x, y} ≤ (swap x y * f).support 
goal: f.support \ {x, y} ≤ (Equiv.swap x y * f).support

full_name: Equiv.Perm.support_swap_mul_eq
code: theorem support_swap_mul_eq (f : Perm α) (x : α) (h : f (f x) ≠ x) :
    (swap x (f x) * f).support = f.support \ {x} 
goal: (Equiv.swap x (f x) * f).support = f.support \ {x}

full_name: Equiv.Perm.mem_support_swap_mul_imp_mem_support_ne
code: theorem mem_support_swap_mul_imp_mem_support_ne {x y : α} (hy : y ∈ support (swap x (f x) * f)) :
    y ∈ support f ∧ y ≠ x 
goal: y ∈ f.support ∧ y ≠ x

full_name: Equiv.Perm.Disjoint.mem_imp
code: theorem Disjoint.mem_imp (h : Disjoint f g) {x : α} (hx : x ∈ f.support) : x ∉ g.support 
goal: x ∉ g.support

full_name: Equiv.Perm.eq_on_support_mem_disjoint
code: theorem eq_on_support_mem_disjoint {l : List (Perm α)} (h : f ∈ l) (hl : l.Pairwise Disjoint) :
    ∀ x ∈ f.support, f x = l.prod x 
goal: x ∈ f.support → f x = l.prod x

full_name: Equiv.Perm.Disjoint.mono
code: theorem Disjoint.mono {x y : Perm α} (h : Disjoint f g) (hf : x.support ≤ f.support)
    (hg : y.support ≤ g.support) : Disjoint x y 
goal: x.Disjoint y

full_name: Equiv.Perm.support_le_prod_of_mem
code: theorem support_le_prod_of_mem {l : List (Perm α)} (h : f ∈ l) (hl : l.Pairwise Disjoint) :
    f.support ≤ l.prod.support 
goal: f.support ≤ l.prod.support

full_name: Equiv.Perm.support_extend_domain
code: @[simp]
theorem support_extend_domain (f : α ≃ Subtype p) {g : Perm α} :
    support (g.extendDomain f) = g.support.map f.asEmbedding 
goal: (g.extendDomain f).support = Finset.map f.asEmbedding g.support

full_name: Equiv.Perm.card_support_extend_domain
code: theorem card_support_extend_domain (f : α ≃ Subtype p) {g : Perm α} :
    (g.extendDomain f).support.card = g.support.card 
goal: (g.extendDomain f).support.card = g.support.card

full_name: Equiv.Perm.card_support_eq_zero
code: theorem card_support_eq_zero {f : Perm α} : f.support.card = 0 ↔ f = 1 
goal: f.support.card = 0 ↔ f = 1

full_name: Equiv.Perm.one_lt_card_support_of_ne_one
code: theorem one_lt_card_support_of_ne_one {f : Perm α} (h : f ≠ 1) : 1 < f.support.card 
goal: 1 < f.support.card

full_name: Equiv.Perm.card_support_ne_one
code: theorem card_support_ne_one (f : Perm α) : f.support.card ≠ 1 
goal: f.support.card ≠ 1

full_name: Equiv.Perm.card_support_le_one
code: @[simp]
theorem card_support_le_one {f : Perm α} : f.support.card ≤ 1 ↔ f = 1 
goal: f.support.card ≤ 1 ↔ f = 1

full_name: Equiv.Perm.two_le_card_support_of_ne_one
code: theorem two_le_card_support_of_ne_one {f : Perm α} (h : f ≠ 1) : 2 ≤ f.support.card 
goal: 2 ≤ f.support.card

full_name: Equiv.Perm.card_support_swap_mul
code: theorem card_support_swap_mul {f : Perm α} {x : α} (hx : f x ≠ x) :
    (swap x (f x) * f).support.card < f.support.card 
goal: (Equiv.swap x (f x) * f).support.card < f.support.card

full_name: Equiv.Perm.card_support_swap
code: theorem card_support_swap {x y : α} (hxy : x ≠ y) : (swap x y).support.card = 2 
goal: (Equiv.swap x y).support.card = 2

full_name: Equiv.Perm.card_support_eq_two
code: @[simp]
theorem card_support_eq_two {f : Perm α} : f.support.card = 2 ↔ IsSwap f 
goal: f.support.card = 2 ↔ f.IsSwap

full_name: Equiv.Perm.Disjoint.card_support_mul
code: theorem Disjoint.card_support_mul (h : Disjoint f g) :
    (f * g).support.card = f.support.card + g.support.card 
goal: (f * g).support.card = f.support.card + g.support.card

full_name: Equiv.Perm.card_support_prod_list_of_pairwise_disjoint
code: theorem card_support_prod_list_of_pairwise_disjoint {l : List (Perm α)} (h : l.Pairwise Disjoint) :
    l.prod.support.card = (l.map (Finset.card ∘ support)).sum 
goal: l.prod.support.card = (List.map (Finset.card ∘ Equiv.Perm.support) l).sum

full_name: Equiv.Perm.support_subtype_perm
code: @[simp]
theorem support_subtype_perm [DecidableEq α] {s : Finset α} (f : Perm α) (h) :
    ((f.subtypePerm h : Perm { x // x ∈ s }).support) =
    (s.attach.filter ((fun x => decide (f x ≠ x))) : Finset { x // x ∈ s }) 
goal: (f.subtypePerm h).support = Finset.filter (fun x => decide (f ↑x ≠ ↑x) = true) s.attach

full_name: Equiv.Perm.fixed_point_card_lt_of_ne_one
code: theorem fixed_point_card_lt_of_ne_one [DecidableEq α] [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
    (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 
goal: (Finset.filter (fun x => σ x = x) Finset.univ).card < Fintype.card α - 1

full_name: Equiv.Perm.support_conj
code: @[simp]
theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbedding 
goal: (σ * τ * σ⁻¹).support = Finset.map (Equiv.toEmbedding σ) τ.support

full_name: Equiv.Perm.card_support_conj
code: theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card 
goal: (σ * τ * σ⁻¹).support.card = τ.support.card