Theorem: Equiv.Perm.signAux_inv
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp_all [signBijAux, dif_pos h, if_neg h.not_le, apply_inv_self, apply_inv_self,
  if_neg (mem_finPairsLT.1 hab).not_le]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
⊢ (if ↑f⁻¹ { fst := a, snd := b }.fst ≤ ↑f⁻¹ { fst := a, snd := b }.snd then -1 else 1) =
    if
        ↑f ((fun a x => signBijAux f⁻¹ a) { fst := a, snd := b } hab).fst ≤
          ↑f ((fun a x => signBijAux f⁻¹ a) { fst := a, snd := b } hab).snd then
      -1
    else 1

tactic: split_ifs with h₁
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
⊢ 1 = if a ≤ b then -1 else 1

tactic: . dsimp [finPairsLT] at hab
  simp at hab
  exact absurd h₁ (not_le_of_gt hab)
state_before: case inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : a ≤ b
⊢ 1 = -1

case inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : ¬a ≤ b
⊢ 1 = 1

tactic: . rfl
state_before: case inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : ¬a ≤ b
⊢ 1 = 1

tactic: dsimp [finPairsLT] at hab
state_before: case inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : a ≤ b
⊢ 1 = -1

tactic: simp at hab
state_before: case inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ Finset.sigma univ fun a => attachFin (range ↑a) (_ : ∀ (x : ℕ), x ∈ range ↑a → x < n)
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : a ≤ b
⊢ 1 = -1

tactic: exact absurd h₁ (not_le_of_gt hab)
state_before: case inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : a ≤ b
hab : b < a
⊢ 1 = -1

tactic: rfl
state_before: case inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ b < ↑f⁻¹ a
h₁ : ¬a ≤ b
⊢ 1 = 1

tactic: simp_all [signBijAux, if_pos (le_of_not_gt h), dif_neg h, apply_inv_self, apply_inv_self,
  if_pos (mem_finPairsLT.1 hab).le]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ¬↑f⁻¹ b < ↑f⁻¹ a
⊢ (if ↑f⁻¹ { fst := a, snd := b }.fst ≤ ↑f⁻¹ { fst := a, snd := b }.snd then -1 else 1) =
    if
        ↑f ((fun a x => signBijAux f⁻¹ a) { fst := a, snd := b } hab).fst ≤
          ↑f ((fun a x => signBijAux f⁻¹ a) { fst := a, snd := b } hab).snd then
      -1
    else 1

tactic: split_ifs with h₁ h₂ h₃
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
⊢ -1 =
    if
        ↑f (if ↑f⁻¹ b < ↑f⁻¹ a then { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b } else { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }).fst ≤
          ↑f (if ↑f⁻¹ b < ↑f⁻¹ a then { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b } else { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }).snd then
      -1
    else 1

tactic: . rfl
state_before: case inl.inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ↑f⁻¹ b < ↑f⁻¹ a
h₂ : ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.fst ≤ ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.snd
⊢ -1 = -1

case inl.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ↑f⁻¹ b < ↑f⁻¹ a
h₂ : ¬↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.fst ≤ ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.snd
⊢ -1 = 1

case inr.inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = -1

case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = 1

tactic: . exact absurd h (not_le_of_gt h₁)
state_before: case inl.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ↑f⁻¹ b < ↑f⁻¹ a
h₂ : ¬↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.fst ≤ ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.snd
⊢ -1 = 1

case inr.inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = -1

case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = 1

tactic: . rfl
state_before: case inr.inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = -1

case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = 1

tactic: . dsimp at *
  dsimp [finPairsLT] at hab
  simp at *
  exact absurd h₃ (asymm_of LT.lt hab)
state_before: case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = 1

tactic: rfl
state_before: case inl.inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ↑f⁻¹ b < ↑f⁻¹ a
h₂ : ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.fst ≤ ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.snd
⊢ -1 = -1

tactic: exact absurd h (not_le_of_gt h₁)
state_before: case inl.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ↑f⁻¹ b < ↑f⁻¹ a
h₂ : ¬↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.fst ≤ ↑f { fst := ↑f⁻¹ a, snd := ↑f⁻¹ b }.snd
⊢ -1 = 1

tactic: rfl
state_before: case inr.inl
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = -1

tactic: dsimp at *
state_before: case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.fst ≤ ↑f { fst := ↑f⁻¹ b, snd := ↑f⁻¹ a }.snd
⊢ -1 = 1

tactic: dsimp [finPairsLT] at hab
state_before: case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ finPairsLT n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f (↑f⁻¹ b) ≤ ↑f (↑f⁻¹ a)
⊢ -1 = 1

tactic: simp at *
state_before: case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
hab : { fst := a, snd := b } ∈ Finset.sigma univ fun a => attachFin (range ↑a) (_ : ∀ (x : ℕ), x ∈ range ↑a → x < n)
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₁ : ¬↑f⁻¹ b < ↑f⁻¹ a
h₃ : ¬↑f (↑f⁻¹ b) ≤ ↑f (↑f⁻¹ a)
⊢ -1 = 1

tactic: exact absurd h₃ (asymm_of LT.lt hab)
state_before: case inr.inr
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a b : Fin n
h : ↑f⁻¹ a ≤ ↑f⁻¹ b
hab : b < a
h₁ : ↑f⁻¹ a ≤ ↑f⁻¹ b
h₃ : a < b
⊢ False