Support of a permutation #
THIS FILE IS SYNCHRONIZED WITH MATHLIB4. Any changes to this file require a corresponding PR to mathlib4.
Main definitions #
In the following, f g : equiv.perm α.
- equiv.perm.disjoint: two permutations- fand- gare- disjointif every element is fixed either by- f, or by- g. Equivalently,- fand- gare- disjointiff their- supportare disjoint.
- equiv.perm.is_swap:- f = swap x yfor- x ≠ y.
- equiv.perm.support: the elements- x : αthat are not fixed by- f.
Two permutations f and g are disjoint if their supports are disjoint, i.e.,
every element is fixed either by f, or by g.
Instances for equiv.perm.disjoint
        
        
    @[symm]
@[protected, instance]
    
theorem
equiv.perm.disjoint.commute
    {α : Type u_1}
    {f g : equiv.perm α}
    (h : f.disjoint g) :
commute f g
@[simp]
@[simp]
@[simp]
@[simp]
@[simp]
    
theorem
equiv.perm.disjoint.mul_left
    {α : Type u_1}
    {f g h : equiv.perm α}
    (H1 : f.disjoint h)
    (H2 : g.disjoint h) :
    
theorem
equiv.perm.disjoint.mul_right
    {α : Type u_1}
    {f g h : equiv.perm α}
    (H1 : f.disjoint g)
    (H2 : f.disjoint h) :
    
theorem
equiv.perm.disjoint_prod_right
    {α : Type u_1}
    {f : equiv.perm α}
    (l : list (equiv.perm α))
    (h : ∀ (g : equiv.perm α), g ∈ l → f.disjoint g) :
    
theorem
equiv.perm.disjoint_prod_perm
    {α : Type u_1}
    {l₁ l₂ : list (equiv.perm α)}
    (hl : list.pairwise equiv.perm.disjoint l₁)
    (hp : l₁ ~ l₂) :
    
theorem
equiv.perm.nodup_of_pairwise_disjoint
    {α : Type u_1}
    {l : list (equiv.perm α)}
    (h1 : 1 ∉ l)
    (h2 : list.pairwise equiv.perm.disjoint l) :
l.nodup
    
theorem
equiv.perm.pow_apply_eq_self_of_apply_eq_self
    {α : Type u_1}
    {f : equiv.perm α}
    {x : α}
    (hfx : ⇑f x = x)
    (n : ℕ) :
    
theorem
equiv.perm.zpow_apply_eq_self_of_apply_eq_self
    {α : Type u_1}
    {f : equiv.perm α}
    {x : α}
    (hfx : ⇑f x = x)
    (n : ℤ) :
    
theorem
equiv.perm.disjoint.zpow_disjoint_zpow
    {α : Type u_1}
    {σ τ : equiv.perm α}
    (hστ : σ.disjoint τ)
    (m n : ℤ) :
    
theorem
equiv.perm.disjoint.pow_disjoint_pow
    {α : Type u_1}
    {σ τ : equiv.perm α}
    (hστ : σ.disjoint τ)
    (m n : ℕ) :
f.is_swap indicates that the permutation f is a transposition of two elements.
@[simp]
    
theorem
equiv.perm.of_subtype_swap_eq
    {α : Type u_1}
    [decidable_eq α]
    {p : α → Prop}
    [decidable_pred p]
    (x y : subtype p) :
⇑equiv.perm.of_subtype (equiv.swap x y) = equiv.swap ↑x ↑y
    
theorem
equiv.perm.is_swap.of_subtype_is_swap
    {α : Type u_1}
    [decidable_eq α]
    {p : α → Prop}
    [decidable_pred p]
    {f : equiv.perm (subtype p)}
    (h : f.is_swap) :
    
theorem
equiv.perm.ne_and_ne_of_swap_mul_apply_ne_self
    {α : Type u_1}
    [decidable_eq α]
    {f : equiv.perm α}
    {x y : α}
    (hy : ⇑(equiv.swap x (⇑f x) * f) y ≠ y) :
The finset of nonfixed points of a permutation.
Equations
- f.support = finset.filter (λ (x : α), ⇑f x ≠ x) finset.univ
@[simp]
    
theorem
equiv.perm.mem_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {x : α} :
    
theorem
equiv.perm.not_mem_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {x : α} :
    
theorem
equiv.perm.coe_support_eq_set_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (f : equiv.perm α) :
@[simp]
    
theorem
equiv.perm.support_eq_empty_iff
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {σ : equiv.perm α} :
@[simp]
@[simp]
    
theorem
equiv.perm.support_mul_le
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (f g : equiv.perm α) :
    
theorem
equiv.perm.exists_mem_support_of_mem_support_prod
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {l : list (equiv.perm α)}
    {x : α}
    (hx : x ∈ l.prod.support) :
    
theorem
equiv.perm.support_pow_le
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (σ : equiv.perm α)
    (n : ℕ) :
@[simp]
@[simp]
    
theorem
equiv.perm.apply_mem_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {x : α} :
@[simp]
    
theorem
equiv.perm.pow_apply_mem_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {n : ℕ}
    {x : α} :
@[simp]
    
theorem
equiv.perm.zpow_apply_mem_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {n : ℤ}
    {x : α} :
    
theorem
equiv.perm.disjoint_iff_disjoint_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f g : equiv.perm α} :
    
theorem
equiv.perm.disjoint.disjoint_support
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f g : equiv.perm α}
    (h : f.disjoint g) :
    
theorem
equiv.perm.disjoint.support_mul
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f g : equiv.perm α}
    (h : f.disjoint g) :
    
theorem
equiv.perm.support_prod_of_pairwise_disjoint
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (l : list (equiv.perm α))
    (h : list.pairwise equiv.perm.disjoint l) :
    
theorem
equiv.perm.support_prod_le
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (l : list (equiv.perm α)) :
    
theorem
equiv.perm.support_zpow_le
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (σ : equiv.perm α)
    (n : ℤ) :
@[simp]
    
theorem
equiv.perm.support_swap
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {x y : α}
    (h : x ≠ y) :
(equiv.swap x y).support = {x, y}
    
theorem
equiv.perm.support_swap_iff
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (x y : α) :
(equiv.swap x y).support = {x, y} ↔ x ≠ y
    
theorem
equiv.perm.support_swap_mul_swap
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {x y z : α}
    (h : [x, y, z].nodup) :
(equiv.swap x y * equiv.swap y z).support = {x, y, z}
    
theorem
equiv.perm.support_swap_mul_ge_support_diff
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (f : equiv.perm α)
    (x y : α) :
    
theorem
equiv.perm.support_swap_mul_eq
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (f : equiv.perm α)
    (x : α)
    (h : ⇑f (⇑f x) ≠ x) :
    
theorem
equiv.perm.mem_support_swap_mul_imp_mem_support_ne
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {x y : α}
    (hy : y ∈ (equiv.swap x (⇑f x) * f).support) :
    
theorem
equiv.perm.disjoint.mem_imp
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f g : equiv.perm α}
    (h : f.disjoint g)
    {x : α}
    (hx : x ∈ f.support) :
    
theorem
equiv.perm.eq_on_support_mem_disjoint
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {l : list (equiv.perm α)}
    (h : f ∈ l)
    (hl : list.pairwise equiv.perm.disjoint l)
    (x : α)
    (H : x ∈ f.support) :
    
theorem
equiv.perm.disjoint.mono
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f g x y : equiv.perm α}
    (h : f.disjoint g)
    (hf : x.support ≤ f.support)
    (hg : y.support ≤ g.support) :
x.disjoint y
    
theorem
equiv.perm.support_le_prod_of_mem
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {l : list (equiv.perm α)}
    (h : f ∈ l)
    (hl : list.pairwise equiv.perm.disjoint l) :
@[simp]
    
theorem
equiv.perm.support_extend_domain
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {β : Type u_2}
    [decidable_eq β]
    [fintype β]
    {p : β → Prop}
    [decidable_pred p]
    (f : α ≃ subtype p)
    {g : equiv.perm α} :
(g.extend_domain f).support = finset.map f.as_embedding g.support
    
theorem
equiv.perm.card_support_extend_domain
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {β : Type u_2}
    [decidable_eq β]
    [fintype β]
    {p : β → Prop}
    [decidable_pred p]
    (f : α ≃ subtype p)
    {g : equiv.perm α} :
@[simp]
    
theorem
equiv.perm.card_support_eq_zero
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α} :
    
theorem
equiv.perm.one_lt_card_support_of_ne_one
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    (h : f ≠ 1) :
    
theorem
equiv.perm.card_support_ne_one
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    (f : equiv.perm α) :
@[simp]
    
theorem
equiv.perm.card_support_le_one
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α} :
    
theorem
equiv.perm.two_le_card_support_of_ne_one
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    (h : f ≠ 1) :
    
theorem
equiv.perm.card_support_swap_mul
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α}
    {x : α}
    (hx : ⇑f x ≠ x) :
    
theorem
equiv.perm.card_support_swap
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {x y : α}
    (hxy : x ≠ y) :
(equiv.swap x y).support.card = 2
@[simp]
    
theorem
equiv.perm.card_support_eq_two
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {f : equiv.perm α} :
    
theorem
equiv.perm.card_support_prod_list_of_pairwise_disjoint
    {α : Type u_1}
    [decidable_eq α]
    [fintype α]
    {l : list (equiv.perm α)}
    (h : list.pairwise equiv.perm.disjoint l) :
l.prod.support.card = (list.map (finset.card ∘ equiv.perm.support) l).sum
@[simp]
    
theorem
equiv.perm.support_subtype_perm
    {α : Type u_1}
    [decidable_eq α]
    {s : finset α}
    (f : equiv.perm α)
    (h : ∀ (x : α), x ∈ s ↔ ⇑f x ∈ s) :
(f.subtype_perm h).support = finset.filter (λ (x : {x // x ∈ s}), ⇑f ↑x ≠ ↑x) s.attach