Theorem: Equiv.Perm.signAux_swap_zero_one'
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: refine Eq.symm (prod_subset (fun ⟨x₁, x₂⟩ => by
  simp (config := { contextual := true }) [mem_finPairsLT, Fin.one_pos]) fun a ha₁ ha₂ => ?_)
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
⊢ (swap 0 1).signAux = ∏ x ∈ {⟨1, 0⟩}, if (swap 0 1) x.fst ≤ (swap 0 1) x.snd then -1 else 1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a : (_ : Fin (n + 2)) × Fin (n + 2)
ha₁ : a ∈ finPairsLT (n + 2)
ha₂ : a ∉ {⟨1, 0⟩}
⊢ (if (swap 0 1) a.fst ≤ (swap 0 1) a.snd then -1 else 1) = 1

tactic: rcases a with ⟨a₁, a₂⟩
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a : (_ : Fin (n + 2)) × Fin (n + 2)
ha₁ : a ∈ finPairsLT (n + 2)
ha₂ : a ∉ {⟨1, 0⟩}
⊢ (if (swap 0 1) a.fst ≤ (swap 0 1) a.snd then -1 else 1) = 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₁ : ⟨a₁, a₂⟩ ∈ finPairsLT (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
⊢ (if (swap 0 1) ⟨a₁, a₂⟩.fst ≤ (swap 0 1) ⟨a₁, a₂⟩.snd then -1 else 1) = 1

tactic: replace ha₁ : a₂ < a₁ := mem_finPairsLT.1 ha₁
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₁ : ⟨a₁, a₂⟩ ∈ finPairsLT (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
⊢ (if (swap 0 1) ⟨a₁, a₂⟩.fst ≤ (swap 0 1) ⟨a₁, a₂⟩.snd then -1 else 1) = 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
⊢ (if (swap 0 1) ⟨a₁, a₂⟩.fst ≤ (swap 0 1) ⟨a₁, a₂⟩.snd then -1 else 1) = 1

tactic: dsimp only
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
⊢ (if (swap 0 1) ⟨a₁, a₂⟩.fst ≤ (swap 0 1) ⟨a₁, a₂⟩.snd then -1 else 1) = 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: rcases a₁.zero_le.eq_or_lt with (rfl | H)
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: case mk.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₂ : Fin (n + 2)
ha₂ : ⟨0, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < 0
⊢ (if (swap 0 1) 0 ≤ (swap 0 1) a₂ then -1 else 1) = 1

case mk.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: rcases a₂.zero_le.eq_or_lt with (rfl | H')
state_before: case mk.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₂ : ⟨a₁, 0⟩ ∉ {⟨1, 0⟩}
ha₁ : 0 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1

case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: simp (config := { contextual := true }) [mem_finPairsLT, Fin.one_pos]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
x✝ : (_ : Fin (n + 2)) × Fin (n + 2)
x₁ x₂ : Fin (n + 2)
⊢ ⟨x₁, x₂⟩ ∈ {⟨1, 0⟩} → ⟨x₁, x₂⟩ ∈ finPairsLT (n + 2)
state_after: no goals

tactic: exact absurd a₂.zero_le ha₁.not_le
state_before: case mk.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₂ : Fin (n + 2)
ha₂ : ⟨0, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < 0
⊢ (if (swap 0 1) 0 ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: no goals

tactic: simp only [and_true_iff, eq_self_iff_true, heq_iff_eq, mem_singleton, Sigma.mk.inj_iff] at ha₂
state_before: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₂ : ⟨a₁, 0⟩ ∉ {⟨1, 0⟩}
ha₁ : 0 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1
state_after: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1

tactic: have : 1 < a₁ := lt_of_le_of_ne (Nat.succ_le_of_lt ha₁)
  (Ne.symm (by intro h; apply ha₂; simp [h]))
state_before: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1
state_after: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
this : 1 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1

tactic: have h01 : Equiv.swap (0 : Fin (n + 2)) 1 0 = 1 := by simp
state_before: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
this : 1 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1
state_after: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
this : 1 < a₁
h01 : (swap 0 1) 0 = 1
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1

tactic: rw [swap_apply_of_ne_of_ne (ne_of_gt H) ha₂, h01, if_neg this.not_le]
state_before: case mk.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
this : 1 < a₁
h01 : (swap 0 1) 0 = 1
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 0 then -1 else 1) = 1
state_after: no goals

tactic: intro h
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
⊢ a₁ ≠ 1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
h : a₁ = 1
⊢ False

tactic: apply ha₂
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
h : a₁ = 1
⊢ False
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
h : a₁ = 1
⊢ a₁ = 1

tactic: simp [h]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
h : a₁ = 1
⊢ a₁ = 1
state_after: no goals

tactic: simp
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
ha₁ : 0 < a₁
ha₂ : ¬a₁ = 1
this : 1 < a₁
⊢ (swap 0 1) 0 = 1
state_after: no goals

tactic: have le : 1 ≤ a₂ := Nat.succ_le_of_lt H'
state_before: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: have lt : 1 < a₁ := le.trans_lt ha₁
state_before: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: have h01 : Equiv.swap (0 : Fin (n + 2)) 1 1 = 0 := by simp only [swap_apply_right]
state_before: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
h01 : (swap 0 1) 1 = 0
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: rcases le.eq_or_lt with (rfl | lt')
state_before: case mk.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
h01 : (swap 0 1) 1 = 0
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: case mk.inr.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
lt : 1 < a₁
h01 : (swap 0 1) 1 = 0
ha₂ : ⟨a₁, 1⟩ ∉ {⟨1, 0⟩}
ha₁ : 1 < a₁
H' : 0 < 1
le : 1 ≤ 1
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 1 then -1 else 1) = 1

case mk.inr.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
h01 : (swap 0 1) 1 = 0
lt' : 1 < a₂
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1

tactic: simp only [swap_apply_right]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
⊢ (swap 0 1) 1 = 0
state_after: no goals

tactic: rw [swap_apply_of_ne_of_ne H.ne' lt.ne', h01, if_neg H.not_le]
state_before: case mk.inr.inr.inl
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ : Fin (n + 2)
H : 0 < a₁
lt : 1 < a₁
h01 : (swap 0 1) 1 = 0
ha₂ : ⟨a₁, 1⟩ ∉ {⟨1, 0⟩}
ha₁ : 1 < a₁
H' : 0 < 1
le : 1 ≤ 1
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) 1 then -1 else 1) = 1
state_after: no goals

tactic: rw [swap_apply_of_ne_of_ne (ne_of_gt H) (ne_of_gt lt),
  swap_apply_of_ne_of_ne (ne_of_gt H') (ne_of_gt lt'), if_neg ha₁.not_le]
state_before: case mk.inr.inr.inr
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
a₁ a₂ : Fin (n + 2)
ha₂ : ⟨a₁, a₂⟩ ∉ {⟨1, 0⟩}
ha₁ : a₂ < a₁
H : 0 < a₁
H' : 0 < a₂
le : 1 ≤ a₂
lt : 1 < a₁
h01 : (swap 0 1) 1 = 0
lt' : 1 < a₂
⊢ (if (swap 0 1) a₁ ≤ (swap 0 1) a₂ then -1 else 1) = 1
state_after: no goals