l3lab/ntp-mathlib huggingface dataset:
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ } ∈ finPairsLT n
h : signBijAux f { fst := a₁, snd := a₂ } = signBijAux f { fst := b₁, snd := b₂ }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
unfold signBijAux at h
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ } ∈ finPairsLT n
h :
  (if x : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst then
      { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd }
    else { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst }) =
    if x : f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst then
      { fst := f { fst := b₁, snd := b₂ }.fst, snd := f { fst := b₁, snd := b₂ }.snd }
    else { fst := f { fst := b₁, snd := b₂ }.snd, snd := f { fst := b₁, snd := b₂ }.fst }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
rw [mem_finPairsLT] at *
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ }.snd < { fst := a₁, snd := a₂ }.fst
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ }.snd < { fst := b₁, snd := b₂ }.fst
h :
  (if x : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst then
      { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd }
    else { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst }) =
    if x : f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst then
      { fst := f { fst := b₁, snd := b₂ }.fst, snd := f { fst := b₁, snd := b₂ }.snd }
    else { fst := f { fst := b₁, snd := b₂ }.snd, snd := f { fst := b₁, snd := b₂ }.fst }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
have : ¬b₁ < b₂ := hb.le.not_lt
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ }.snd < { fst := a₁, snd := a₂ }.fst
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ }.snd < { fst := b₁, snd := b₂ }.fst
h :
  (if x : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst then
      { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd }
    else { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst }) =
    if x : f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst then
      { fst := f { fst := b₁, snd := b₂ }.fst, snd := f { fst := b₁, snd := b₂ }.snd }
    else { fst := f { fst := b₁, snd := b₂ }.snd, snd := f { fst := b₁, snd := b₂ }.fst }
this : ¬b₁ < b₂
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
split_ifs at h
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    split_ifs at h <;>
    

Proof state:
case pos
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ }.snd < { fst := a₁, snd := a₂ }.fst
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ }.snd < { fst := b₁, snd := b₂ }.fst
this : ¬b₁ < b₂
h✝¹ : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst
h✝ : f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst
h :
  { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd } =
    { fst := f { fst := b₁, snd := b₂ }.fst, snd := f { fst := b₁, snd := b₂ }.snd }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
simp_all [(Equiv.injective f).eq_iff, eq_self_iff_true, and_self_iff, heq_iff_eq]
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    split_ifs at h <;>
    

Proof state:
case neg
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ }.snd < { fst := a₁, snd := a₂ }.fst
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ }.snd < { fst := b₁, snd := b₂ }.fst
this : ¬b₁ < b₂
h✝¹ : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst
h✝ : ¬f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst
h :
  { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd } =
    { fst := f { fst := b₁, snd := b₂ }.snd, snd := f { fst := b₁, snd := b₂ }.fst }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
simp_all [(Equiv.injective f).eq_iff, eq_self_iff_true, and_self_iff, heq_iff_eq]
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    split_ifs at h <;>
    

Proof state:
case pos
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ }.snd < { fst := a₁, snd := a₂ }.fst
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ }.snd < { fst := b₁, snd := b₂ }.fst
this : ¬b₁ < b₂
h✝¹ : ¬f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst
h✝ : f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst
h :
  { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst } =
    { fst := f { fst := b₁, snd := b₂ }.fst, snd := f { fst := b₁, snd := b₂ }.snd }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
simp_all [(Equiv.injective f).eq_iff, eq_self_iff_true, and_self_iff, heq_iff_eq]
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    split_ifs at h <;>
    

Proof state:
case neg
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ }.snd < { fst := a₁, snd := a₂ }.fst
b₁ b₂ : Fin n
hb : { fst := b₁, snd := b₂ }.snd < { fst := b₁, snd := b₂ }.fst
this : ¬b₁ < b₂
h✝¹ : ¬f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst
h✝ : ¬f { fst := b₁, snd := b₂ }.snd < f { fst := b₁, snd := b₂ }.fst
h :
  { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst } =
    { fst := f { fst := b₁, snd := b₂ }.snd, snd := f { fst := b₁, snd := b₂ }.fst }
⊢ { fst := a₁, snd := a₂ } = { fst := b₁, snd := b₂ }

Next tactic:
simp_all [(Equiv.injective f).eq_iff, eq_self_iff_true, and_self_iff, heq_iff_eq]
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    split_ifs at h <;>
    simp_all [(Equiv.injective f).eq_iff, eq_self_iff_true, and_self_iff, heq_iff_eq]
    · 

Proof state:
case neg
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ b₁ b₂ : Fin n
ha : b₁ < b₂
hb : b₂ < b₁
this : b₂ ≤ b₁
h✝¹ : f b₁ < f b₂
h✝ : f b₁ ≤ f b₂
h : a₁ = b₂ ∧ a₂ = b₁
⊢ b₂ = b₁ ∧ b₁ = b₂

Next tactic:
exact absurd this (not_le.mpr ha)
set_option linter.unusedVariables false in
theorem signBijAux_inj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a b : Σ_a : Fin n, Fin n,
      a ∈ finPairsLT n → b ∈ finPairsLT n → signBijAux f a = signBijAux f b → a = b :=
  fun ⟨a₁, a₂⟩ ⟨b₁, b₂⟩ ha hb h => by
    unfold signBijAux at h
    rw [mem_finPairsLT] at *
    have : ¬b₁ < b₂ := hb.le.not_lt
    split_ifs at h <;>
    simp_all [(Equiv.injective f).eq_iff, eq_self_iff_true, and_self_iff, heq_iff_eq]
    · exact absurd this (not_le.mpr ha)
    · 

Proof state:
case pos
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝¹ x✝ : (_ : Fin n) × Fin n
a₁ a₂ b₁ b₂ : Fin n
ha : b₁ < b₂
hb : b₂ < b₁
this : b₂ ≤ b₁
h✝¹ : f b₂ ≤ f b₁
h✝ : f b₂ < f b₁
h : a₂ = b₁ ∧ a₁ = b₂
⊢ b₂ = b₁ ∧ b₁ = b₂

Next tactic:
exact absurd this (not_le.mpr ha)
theorem signBijAux_surj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a ∈ finPairsLT n, ∃ (b: Σ (_: Fin n), Fin n) (_H: b ∈ finPairsLT n), a = signBijAux f b :=
  fun ⟨a₁, a₂⟩ ha =>
    if hxa : f⁻¹ a₂ < f⁻¹ a₁ then
      ⟨⟨f⁻¹ a₁, f⁻¹ a₂⟩, mem_finPairsLT.2 hxa, by
        

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : f⁻¹ a₂ < f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } = signBijAux f { fst := f⁻¹ a₁, snd := f⁻¹ a₂ }

Next tactic:
dsimp [signBijAux]
theorem signBijAux_surj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a ∈ finPairsLT n, ∃ (b: Σ (_: Fin n), Fin n) (_H: b ∈ finPairsLT n), a = signBijAux f b :=
  fun ⟨a₁, a₂⟩ ha =>
    if hxa : f⁻¹ a₂ < f⁻¹ a₁ then
      ⟨⟨f⁻¹ a₁, f⁻¹ a₂⟩, mem_finPairsLT.2 hxa, by
        dsimp [signBijAux]
        

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : f⁻¹ a₂ < f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } =
    if f (f⁻¹ a₂) < f (f⁻¹ a₁) then { fst := f (f⁻¹ a₁), snd := f (f⁻¹ a₂) }
    else { fst := f (f⁻¹ a₂), snd := f (f⁻¹ a₁) }

Next tactic:
rw [apply_inv_self, apply_inv_self, if_pos (mem_finPairsLT.1 ha)]
theorem signBijAux_surj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a ∈ finPairsLT n, ∃ (b: Σ (_: Fin n), Fin n) (_H: b ∈ finPairsLT n), a = signBijAux f b :=
  fun ⟨a₁, a₂⟩ ha =>
    if hxa : f⁻¹ a₂ < f⁻¹ a₁ then
      ⟨⟨f⁻¹ a₁, f⁻¹ a₂⟩, mem_finPairsLT.2 hxa, by
        dsimp [signBijAux]
        rw [apply_inv_self, apply_inv_self, if_pos (mem_finPairsLT.1 ha)]⟩
    else
      ⟨⟨f⁻¹ a₂, f⁻¹ a₁⟩,
        mem_finPairsLT.2 <|
          (le_of_not_gt hxa).lt_of_ne fun h => by
            

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
h : f⁻¹ a₁ = f⁻¹ a₂
⊢ False

Next tactic:
simp [mem_finPairsLT, f⁻¹.injective h, lt_irrefl] at ha
theorem signBijAux_surj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a ∈ finPairsLT n, ∃ (b: Σ (_: Fin n), Fin n) (_H: b ∈ finPairsLT n), a = signBijAux f b :=
  fun ⟨a₁, a₂⟩ ha =>
    if hxa : f⁻¹ a₂ < f⁻¹ a₁ then
      ⟨⟨f⁻¹ a₁, f⁻¹ a₂⟩, mem_finPairsLT.2 hxa, by
        dsimp [signBijAux]
        rw [apply_inv_self, apply_inv_self, if_pos (mem_finPairsLT.1 ha)]⟩
    else
      ⟨⟨f⁻¹ a₂, f⁻¹ a₁⟩,
        mem_finPairsLT.2 <|
          (le_of_not_gt hxa).lt_of_ne fun h => by
            simp [mem_finPairsLT, f⁻¹.injective h, lt_irrefl] at ha, by
              

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } = signBijAux f { fst := f⁻¹ a₂, snd := f⁻¹ a₁ }

Next tactic:
dsimp [signBijAux]
theorem signBijAux_surj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a ∈ finPairsLT n, ∃ (b: Σ (_: Fin n), Fin n) (_H: b ∈ finPairsLT n), a = signBijAux f b :=
  fun ⟨a₁, a₂⟩ ha =>
    if hxa : f⁻¹ a₂ < f⁻¹ a₁ then
      ⟨⟨f⁻¹ a₁, f⁻¹ a₂⟩, mem_finPairsLT.2 hxa, by
        dsimp [signBijAux]
        rw [apply_inv_self, apply_inv_self, if_pos (mem_finPairsLT.1 ha)]⟩
    else
      ⟨⟨f⁻¹ a₂, f⁻¹ a₁⟩,
        mem_finPairsLT.2 <|
          (le_of_not_gt hxa).lt_of_ne fun h => by
            simp [mem_finPairsLT, f⁻¹.injective h, lt_irrefl] at ha, by
              dsimp [signBijAux]
              

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ¬f⁻¹ a₂ < f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } =
    if f (f⁻¹ a₁) < f (f⁻¹ a₂) then { fst := f (f⁻¹ a₂), snd := f (f⁻¹ a₁) }
    else { fst := f (f⁻¹ a₁), snd := f (f⁻¹ a₂) }

Next tactic:
rw [apply_inv_self, apply_inv_self, if_neg (mem_finPairsLT.1 ha).le.not_lt]
theorem signBijAux_mem {n : ℕ} {f : Perm (Fin n)} :
    ∀ a : Σ_ : Fin n, Fin n, a ∈ finPairsLT n → signBijAux f a ∈ finPairsLT n :=
  fun ⟨a₁, a₂⟩ ha => by
    

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
⊢ signBijAux f { fst := a₁, snd := a₂ } ∈ finPairsLT n

Next tactic:
unfold signBijAux
theorem signBijAux_mem {n : ℕ} {f : Perm (Fin n)} :
    ∀ a : Σ_ : Fin n, Fin n, a ∈ finPairsLT n → signBijAux f a ∈ finPairsLT n :=
  fun ⟨a₁, a₂⟩ ha => by
    unfold signBijAux
    

Proof state:
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
⊢ (if x : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst then
      { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd }
    else { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst }) ∈
    finPairsLT n

Next tactic:
split_ifs with h
theorem signBijAux_mem {n : ℕ} {f : Perm (Fin n)} :
    ∀ a : Σ_ : Fin n, Fin n, a ∈ finPairsLT n → signBijAux f a ∈ finPairsLT n :=
  fun ⟨a₁, a₂⟩ ha => by
    unfold signBijAux
    split_ifs with h
    · 

Proof state:
case pos
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
h : f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst
⊢ { fst := f { fst := a₁, snd := a₂ }.fst, snd := f { fst := a₁, snd := a₂ }.snd } ∈ finPairsLT n

Next tactic:
exact mem_finPairsLT.2 h
theorem signBijAux_mem {n : ℕ} {f : Perm (Fin n)} :
    ∀ a : Σ_ : Fin n, Fin n, a ∈ finPairsLT n → signBijAux f a ∈ finPairsLT n :=
  fun ⟨a₁, a₂⟩ ha => by
    unfold signBijAux
    split_ifs with h
    · exact mem_finPairsLT.2 h
    · 

Proof state:
case neg
α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
h : ¬f { fst := a₁, snd := a₂ }.snd < f { fst := a₁, snd := a₂ }.fst
⊢ { fst := f { fst := a₁, snd := a₂ }.snd, snd := f { fst := a₁, snd := a₂ }.fst } ∈ finPairsLT n

Next tactic:
exact mem_finPairsLT.2
        ((le_of_not_gt h).lt_of_ne fun h => (mem_finPairsLT.1 ha).ne (f.injective h.symm))
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        

Proof state:
α : 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

Next 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]
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        

Proof state:
α : 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

Next tactic:
split_ifs with h₁
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · 

Proof state:
case pos
α : 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

Next tactic:
dsimp [finPairsLT] at hab
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · dsimp [finPairsLT] at hab
          

Proof state:
case pos
α : 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 ∈ range ↑a, x < n)
h : f⁻¹ b < f⁻¹ a
h₁ : a ≤ b
⊢ 1 = -1

Next tactic:
simp? at hab says
            simp only [mem_sigma, mem_univ, mem_attachFin, mem_range, Fin.val_fin_lt,
              true_and] at hab
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · dsimp [finPairsLT] at hab
          simp? at hab says
            

Proof state:
case pos
α : 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 ∈ range ↑a, x < n)
h : f⁻¹ b < f⁻¹ a
h₁ : a ≤ b
⊢ 1 = -1

Next tactic:
simp only [mem_sigma, mem_univ, mem_attachFin, mem_range, Fin.val_fin_lt,
              true_and] at hab
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · dsimp [finPairsLT] at hab
          simp? at hab says
            simp only [mem_sigma, mem_univ, mem_attachFin, mem_range, Fin.val_fin_lt,
              true_and] at hab
          

Proof state:
case pos
α : 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

Next tactic:
exact absurd h₁ (not_le_of_gt hab)
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · dsimp [finPairsLT] at hab
          simp? at hab says
            simp only [mem_sigma, mem_univ, mem_attachFin, mem_range, Fin.val_fin_lt,
              true_and] at hab
          exact absurd h₁ (not_le_of_gt hab)
        · 

Proof state:
case neg
α : 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

Next tactic:
rfl
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · dsimp [finPairsLT] at hab
          simp? at hab says
            simp only [mem_sigma, mem_univ, mem_attachFin, mem_range, Fin.val_fin_lt,
              true_and] at hab
          exact absurd h₁ (not_le_of_gt hab)
        · rfl
      else by
        

Proof state:
α : 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

Next 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]
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f :=
  prod_bij (fun a _ => signBijAux f⁻¹ a) signBijAux_mem
    (fun ⟨a, b⟩ hab =>
      if h : f⁻¹ b < f⁻¹ a then by
        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]
        split_ifs with h₁
        · dsimp [finPairsLT] at hab
          simp? at hab says
            simp only [mem_sigma, mem_univ, mem_attachFin, mem_range, Fin.val_fin_lt,
              true_and] at hab
          exact absurd h₁ (not_le_of_gt hab)
        · rfl
      else by
        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]
        

Proof state:
α : 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

Next tactic:
split_ifs with h₁ h₂ h₃