l3lab/ntp-mathlib huggingface dataset:
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : y = x
hy : x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
subst x
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> 

Proof state:
case neg
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : ¬y = x
hy : f y ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
try { subst x }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try 

Proof state:
case neg
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : ¬y = x
hy : f y ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
{ subst x }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { 

Proof state:
case neg
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : ¬y = x
hy : f y ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
subst x
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝ : ¬f y = x
h : f y = x
hy : f x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
try { simp [*] at * }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> try 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝ : ¬f y = x
h : f y = x
hy : f x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
{ simp [*] at * }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> try { 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝ : ¬f y = x
h : f y = x
hy : f x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
simp [*] at *
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : y = x
hy : x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
try { simp [*] at * }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> try 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : y = x
hy : x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
{ simp [*] at * }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> try { 

Proof state:
case pos
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : y = x
hy : x ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
simp [*] at *
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> 

Proof state:
case neg
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : ¬y = x
hy : f y ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
try { simp [*] at * }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> try 

Proof state:
case neg
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : ¬y = x
hy : f y ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
{ simp [*] at * }
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 := by
  simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
  by_cases h : f y = x
  · constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne.def]
  · split_ifs at hy with h h <;> try { subst x } <;> try { 

Proof state:
case neg
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
x y : α
h✝¹ h✝ : ¬f y = x
h : ¬y = x
hy : f y ≠ y
⊢ f y ≠ y ∧ y ≠ x

Next tactic:
simp [*] at *
theorem set_support_inv_eq : { x | p⁻¹ x ≠ x } = { x | p x ≠ x } := by
  

Proof state:
α : Type u_1
p q : Perm α
⊢ {x | p⁻¹ x ≠ x} = {x | p x ≠ x}

Next tactic:
ext x
theorem set_support_inv_eq : { x | p⁻¹ x ≠ x } = { x | p x ≠ x } := by
  ext x
  

Proof state:
case h
α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | p⁻¹ x ≠ x} ↔ x ∈ {x | p x ≠ x}

Next tactic:
simp only [Set.mem_setOf_eq, Ne.def]
theorem set_support_inv_eq : { x | p⁻¹ x ≠ x } = { x | p x ≠ x } := by
  ext x
  simp only [Set.mem_setOf_eq, Ne.def]
  

Proof state:
case h
α : Type u_1
p q : Perm α
x : α
⊢ ¬p⁻¹ x = x ↔ ¬p x = x

Next tactic:
rw [inv_def, symm_apply_eq, eq_comm]
theorem set_support_apply_mem {p : Perm α} {a : α} : p a ∈ { x | p x ≠ x } ↔ a ∈ { x | p x ≠ x } :=
  by 

Proof state:
α : Type u_1
p✝ q p : Perm α
a : α
⊢ p a ∈ {x | p x ≠ x} ↔ a ∈ {x | p x ≠ x}

Next tactic:
simp
theorem set_support_zpow_subset (n : ℤ) : { x | (p ^ n) x ≠ x } ⊆ { x | p x ≠ x } := by
  

Proof state:
α : Type u_1
p q : Perm α
n : ℤ
⊢ {x | (p ^ n) x ≠ x} ⊆ {x | p x ≠ x}

Next tactic:
intro x
theorem set_support_zpow_subset (n : ℤ) : { x | (p ^ n) x ≠ x } ⊆ { x | p x ≠ x } := by
  intro x
  

Proof state:
α : Type u_1
p q : Perm α
n : ℤ
x : α
⊢ x ∈ {x | (p ^ n) x ≠ x} → x ∈ {x | p x ≠ x}

Next tactic:
simp only [Set.mem_setOf_eq, Ne.def]
theorem set_support_zpow_subset (n : ℤ) : { x | (p ^ n) x ≠ x } ⊆ { x | p x ≠ x } := by
  intro x
  simp only [Set.mem_setOf_eq, Ne.def]
  

Proof state:
α : Type u_1
p q : Perm α
n : ℤ
x : α
⊢ ¬(p ^ n) x = x → ¬p x = x

Next tactic:
intro hx H
theorem set_support_zpow_subset (n : ℤ) : { x | (p ^ n) x ≠ x } ⊆ { x | p x ≠ x } := by
  intro x
  simp only [Set.mem_setOf_eq, Ne.def]
  intro hx H
  

Proof state:
α : Type u_1
p q : Perm α
n : ℤ
x : α
hx : ¬(p ^ n) x = x
H : p x = x
⊢ False

Next tactic:
simp [zpow_apply_eq_self_of_apply_eq_self H] at hx
theorem set_support_mul_subset : { x | (p * q) x ≠ x } ⊆ { x | p x ≠ x } ∪ { x | q x ≠ x } := by
  

Proof state:
α : Type u_1
p q : Perm α
⊢ {x | (p * q) x ≠ x} ⊆ {x | p x ≠ x} ∪ {x | q x ≠ x}

Next tactic:
intro x
theorem set_support_mul_subset : { x | (p * q) x ≠ x } ⊆ { x | p x ≠ x } ∪ { x | q x ≠ x } := by
  intro x
  

Proof state:
α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | (p * q) x ≠ x} → x ∈ {x | p x ≠ x} ∪ {x | q x ≠ x}

Next tactic:
simp only [Perm.coe_mul, Function.comp_apply, Ne.def, Set.mem_union, Set.mem_setOf_eq]
theorem set_support_mul_subset : { x | (p * q) x ≠ x } ⊆ { x | p x ≠ x } ∪ { x | q x ≠ x } := by
  intro x
  simp only [Perm.coe_mul, Function.comp_apply, Ne.def, Set.mem_union, Set.mem_setOf_eq]
  

Proof state:
α : Type u_1
p q : Perm α
x : α
⊢ ¬p (q x) = x → ¬p x = x ∨ ¬q x = x

Next tactic:
by_cases hq : q x = x
theorem set_support_mul_subset : { x | (p * q) x ≠ x } ⊆ { x | p x ≠ x } ∪ { x | q x ≠ x } := by
  intro x
  simp only [Perm.coe_mul, Function.comp_apply, Ne.def, Set.mem_union, Set.mem_setOf_eq]
  by_cases hq : q x = x <;> 

Proof state:
case pos
α : Type u_1
p q : Perm α
x : α
hq : q x = x
⊢ ¬p (q x) = x → ¬p x = x ∨ ¬q x = x

Next tactic:
simp [hq]
theorem set_support_mul_subset : { x | (p * q) x ≠ x } ⊆ { x | p x ≠ x } ∪ { x | q x ≠ x } := by
  intro x
  simp only [Perm.coe_mul, Function.comp_apply, Ne.def, Set.mem_union, Set.mem_setOf_eq]
  by_cases hq : q x = x <;> 

Proof state:
case neg
α : Type u_1
p q : Perm α
x : α
hq : ¬q x = x
⊢ ¬p (q x) = x → ¬p x = x ∨ ¬q x = x

Next tactic:
simp [hq]
@[simp]
theorem mem_support {x : α} : x ∈ f.support ↔ f x ≠ x := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ x ∈ support f ↔ f x ≠ x

Next tactic:
rw [support, mem_filter, and_iff_right (mem_univ x)]
theorem not_mem_support {x : α} : x ∉ f.support ↔ f x = x := by 

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ x ∉ support f ↔ f x = x

Next tactic:
simp
theorem coe_support_eq_set_support (f : Perm α) : (f.support : Set α) = { x | f x ≠ x } := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
⊢ ↑(support f) = {x | f x ≠ x}

Next tactic:
ext
theorem coe_support_eq_set_support (f : Perm α) : (f.support : Set α) = { x | f x ≠ x } := by
  ext
  

Proof state:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x✝ : α
⊢ x✝ ∈ ↑(support f) ↔ x✝ ∈ {x | f x ≠ x}

Next tactic:
simp
@[simp]
theorem support_eq_empty_iff {σ : Perm α} : σ.support = ∅ ↔ σ = 1 := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g σ : Perm α
⊢ support σ = ∅ ↔ σ = 1

Next tactic:
simp_rw [Finset.ext_iff, mem_support, Finset.not_mem_empty, iff_false_iff, not_not,
    Equiv.Perm.ext_iff, one_apply]
@[simp]
theorem support_one : (1 : Perm α).support = ∅ := by 

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
⊢ support 1 = ∅

Next tactic:
rw [support_eq_empty_iff]
theorem support_congr (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) : f = g := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : support f ⊆ support g
h' : ∀ x ∈ support g, f x = g x
⊢ f = g

Next tactic:
ext x
theorem support_congr (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) : f = g := by
  ext x
  

Proof state:
case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : support f ⊆ support g
h' : ∀ x ∈ support g, f x = g x
x : α
⊢ f x = g x

Next tactic:
by_cases hx : x ∈ g.support
theorem support_congr (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) : f = g := by
  ext x
  by_cases hx : x ∈ g.support
  · 

Proof state:
case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : support f ⊆ support g
h' : ∀ x ∈ support g, f x = g x
x : α
hx : x ∈ support g
⊢ f x = g x

Next tactic:
exact h' x hx
theorem support_congr (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) : f = g := by
  ext x
  by_cases hx : x ∈ g.support
  · exact h' x hx
  · 

Proof state:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : support f ⊆ support g
h' : ∀ x ∈ support g, f x = g x
x : α
hx : x ∉ support g
⊢ f x = g x

Next tactic:
rw [not_mem_support.mp hx, ← not_mem_support]
theorem support_congr (h : f.support ⊆ g.support) (h' : ∀ x ∈ g.support, f x = g x) : f = g := by
  ext x
  by_cases hx : x ∈ g.support
  · exact h' x hx
  · rw [not_mem_support.mp hx, ← not_mem_support]
    

Proof state:
case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : support f ⊆ support g
h' : ∀ x ∈ support g, f x = g x
x : α
hx : x ∉ support g
⊢ x ∉ support f

Next tactic:
exact fun H => hx (h H)
theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support := fun x => by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
⊢ x ∈ support (f * g) → x ∈ support f ⊔ support g

Next tactic:
simp only [sup_eq_union]
theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support := fun x => by
  simp only [sup_eq_union]
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
⊢ x ∈ support (f * g) → x ∈ support f ∪ support g

Next tactic:
rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support := fun x => by
  simp only [sup_eq_union]
  rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
⊢ f x = x ∧ g x = x → f (g x) = x

Next tactic:
rintro ⟨hf, hg⟩
theorem support_mul_le (f g : Perm α) : (f * g).support ≤ f.support ⊔ g.support := fun x => by
  simp only [sup_eq_union]
  rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
  rintro ⟨hf, hg⟩
  

Proof state:
case intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
hf : f x = x
hg : g x = x
⊢ f (g x) = x

Next tactic:
rw [hg, hf]
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
x : α
hx : x ∈ support (List.prod l)
⊢ ∃ f ∈ l, x ∈ support f

Next tactic:
contrapose! hx
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
x : α
hx : ∀ f ∈ l, x ∉ support f
⊢ x ∉ support (List.prod l)

Next tactic:
simp_rw [mem_support, not_not] at hx ⊢
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
x : α
hx : ∀ f ∈ l, f x = x
⊢ (List.prod l) x = x

Next tactic:
induction' l with f l ih
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · 

Proof state:
case nil
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
hx : ∀ f ∈ [], f x = x
⊢ (List.prod []) x = x

Next tactic:
rfl
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · rfl
  · 

Proof state:
case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
⊢ (List.prod (f :: l)) x = x

Next tactic:
rw [List.prod_cons, mul_apply, ih, hx]
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · rfl
  · rw [List.prod_cons, mul_apply, ih, hx]
    

Proof state:
case cons._
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
⊢ f ∈ f :: l
case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
⊢ ∀ f ∈ l, f x = x

Next tactic:
simp only [List.find?, List.mem_cons, true_or]
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · rfl
  · rw [List.prod_cons, mul_apply, ih, hx]
    simp only [List.find?, List.mem_cons, true_or]
    

Proof state:
case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
⊢ ∀ f ∈ l, f x = x

Next tactic:
intros f' hf'
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · rfl
  · rw [List.prod_cons, mul_apply, ih, hx]
    simp only [List.find?, List.mem_cons, true_or]
    intros f' hf'
    

Proof state:
case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
f' : Perm α
hf' : f' ∈ l
⊢ f' x = x

Next tactic:
refine' hx f' _
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · rfl
  · rw [List.prod_cons, mul_apply, ih, hx]
    simp only [List.find?, List.mem_cons, true_or]
    intros f' hf'
    refine' hx f' _
    

Proof state:
case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
f' : Perm α
hf' : f' ∈ l
⊢ f' ∈ f :: l

Next tactic:
simp only [List.find?, List.mem_cons]
theorem exists_mem_support_of_mem_support_prod {l : List (Perm α)} {x : α}
    (hx : x ∈ l.prod.support) : ∃ f : Perm α, f ∈ l ∧ x ∈ f.support := by
  contrapose! hx
  simp_rw [mem_support, not_not] at hx ⊢
  induction' l with f l ih
  · rfl
  · rw [List.prod_cons, mul_apply, ih, hx]
    simp only [List.find?, List.mem_cons, true_or]
    intros f' hf'
    refine' hx f' _
    simp only [List.find?, List.mem_cons]
    

Proof state:
case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x : α
f : Perm α
l : List (Perm α)
ih : (∀ f ∈ l, f x = x) → (List.prod l) x = x
hx : ∀ f_1 ∈ f :: l, f_1 x = x
f' : Perm α
hf' : f' ∈ l
⊢ f' = f ∨ f' ∈ l

Next tactic:
exact Or.inr hf'
@[simp]
theorem support_inv (σ : Perm α) : support σ⁻¹ = σ.support := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g σ : Perm α
⊢ support σ⁻¹ = support σ

Next tactic:
simp_rw [Finset.ext_iff, mem_support, not_iff_not, inv_eq_iff_eq.trans eq_comm, imp_true_iff]
theorem apply_mem_support {x : α} : f x ∈ f.support ↔ x ∈ f.support := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
⊢ f x ∈ support f ↔ x ∈ support f

Next tactic:
rw [mem_support, mem_support, Ne.def, Ne.def, apply_eq_iff_eq]
@[simp]
theorem apply_pow_apply_eq_iff (f : Perm α) (n : ℕ) {x : α} :
    f ((f ^ n) x) = (f ^ n) x ↔ f x = x := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
n : ℕ
x : α
⊢ f ((f ^ n) x) = (f ^ n) x ↔ f x = x

Next tactic:
rw [← mul_apply, Commute.self_pow f, mul_apply, apply_eq_iff_eq]
theorem pow_apply_mem_support {n : ℕ} {x : α} : (f ^ n) x ∈ f.support ↔ x ∈ f.support := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
n : ℕ
x : α
⊢ (f ^ n) x ∈ support f ↔ x ∈ support f

Next tactic:
simp only [mem_support, ne_eq, apply_pow_apply_eq_iff]
@[simp]
theorem apply_zpow_apply_eq_iff (f : Perm α) (n : ℤ) {x : α} :
    f ((f ^ n) x) = (f ^ n) x ↔ f x = x := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
n : ℤ
x : α
⊢ f ((f ^ n) x) = (f ^ n) x ↔ f x = x

Next tactic:
rw [← mul_apply, Commute.self_zpow f, mul_apply, apply_eq_iff_eq]
theorem zpow_apply_mem_support {n : ℤ} {x : α} : (f ^ n) x ∈ f.support ↔ x ∈ f.support := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
n : ℤ
x : α
⊢ (f ^ n) x ∈ support f ↔ x ∈ support f

Next tactic:
simp only [mem_support, ne_eq, apply_zpow_apply_eq_iff]
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 := by
  

Proof state:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ x ∈ support f ∩ support g, f x = g x
k : ℕ
⊢ ∀ x ∈ support f ∩ support g, (f ^ k) x = (g ^ k) x

Next tactic:
induction' k with k hk
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 := by
  induction' k with k hk
  · 

Proof state:
case zero
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ x ∈ support f ∩ support g, f x = g x
⊢ ∀ x ∈ support f ∩ support g, (f ^ Nat.zero) x = (g ^ Nat.zero) x

Next tactic:
simp
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 := by
  induction' k with k hk
  · simp
  · 

Proof state:
case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ x ∈ support f ∩ support g, f x = g x
k : ℕ
hk : ∀ x ∈ support f ∩ support g, (f ^ k) x = (g ^ k) x
⊢ ∀ x ∈ support f ∩ support g, (f ^ Nat.succ k) x = (g ^ Nat.succ k) x

Next tactic:
intro x hx
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 := by
  induction' k with k hk
  · simp
  · intro x hx
    

Proof state:
case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ x ∈ support f ∩ support g, f x = g x
k : ℕ
hk : ∀ x ∈ support f ∩ support g, (f ^ k) x = (g ^ k) x
x : α
hx : x ∈ support f ∩ support g
⊢ (f ^ Nat.succ k) x = (g ^ Nat.succ k) x

Next tactic:
rw [pow_succ', mul_apply, pow_succ', mul_apply, h _ hx, hk]