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

tactic: rw [← signAux_inv g]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (f * g).signAux = f.signAux * g.signAux
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (f * g).signAux = f.signAux * g⁻¹.signAux

tactic: unfold signAux
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (f * g).signAux = f.signAux * g⁻¹.signAux
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (∏ x ∈ finPairsLT n, if (f * g) x.fst ≤ (f * g) x.snd then -1 else 1) =
    (∏ x ∈ finPairsLT n, if f x.fst ≤ f x.snd then -1 else 1) *
      ∏ x ∈ finPairsLT n, if g⁻¹ x.fst ≤ g⁻¹ x.snd then -1 else 1

tactic: rw [← prod_mul_distrib]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (∏ x ∈ finPairsLT n, if (f * g) x.fst ≤ (f * g) x.snd then -1 else 1) =
    (∏ x ∈ finPairsLT n, if f x.fst ≤ f x.snd then -1 else 1) *
      ∏ x ∈ finPairsLT n, if g⁻¹ x.fst ≤ g⁻¹ x.snd then -1 else 1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (∏ x ∈ finPairsLT n, if (f * g) x.fst ≤ (f * g) x.snd then -1 else 1) =
    ∏ x ∈ finPairsLT n, (if f x.fst ≤ f x.snd then -1 else 1) * if g⁻¹ x.fst ≤ g⁻¹ x.snd then -1 else 1

tactic: refine prod_nbij (signBijAux g) signBijAux_mem signBijAux_injOn signBijAux_surj ?_
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ (∏ x ∈ finPairsLT n, if (f * g) x.fst ≤ (f * g) x.snd then -1 else 1) =
    ∏ x ∈ finPairsLT n, (if f x.fst ≤ f x.snd then -1 else 1) * if g⁻¹ x.fst ≤ g⁻¹ x.snd then -1 else 1
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ ∀ a ∈ finPairsLT n,
    (if (f * g) a.fst ≤ (f * g) a.snd then -1 else 1) =
      (if f (g.signBijAux a).fst ≤ f (g.signBijAux a).snd then -1 else 1) *
        if g⁻¹ (g.signBijAux a).fst ≤ g⁻¹ (g.signBijAux a).snd then -1 else 1

tactic: rintro ⟨a, b⟩ hab
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
⊢ ∀ a ∈ finPairsLT n,
    (if (f * g) a.fst ≤ (f * g) a.snd then -1 else 1) =
      (if f (g.signBijAux a).fst ≤ f (g.signBijAux a).snd then -1 else 1) *
        if g⁻¹ (g.signBijAux a).fst ≤ g⁻¹ (g.signBijAux a).snd then -1 else 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if (f * g) ⟨a, b⟩.fst ≤ (f * g) ⟨a, b⟩.snd then -1 else 1) =
    (if f (g.signBijAux ⟨a, b⟩).fst ≤ f (g.signBijAux ⟨a, b⟩).snd then -1 else 1) *
      if g⁻¹ (g.signBijAux ⟨a, b⟩).fst ≤ g⁻¹ (g.signBijAux ⟨a, b⟩).snd then -1 else 1

tactic: dsimp only [signBijAux]
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if (f * g) ⟨a, b⟩.fst ≤ (f * g) ⟨a, b⟩.snd then -1 else 1) =
    (if f (g.signBijAux ⟨a, b⟩).fst ≤ f (g.signBijAux ⟨a, b⟩).snd then -1 else 1) *
      if g⁻¹ (g.signBijAux ⟨a, b⟩).fst ≤ g⁻¹ (g.signBijAux ⟨a, b⟩).snd then -1 else 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if (f * g) a ≤ (f * g) b then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1

tactic: rw [mul_apply, mul_apply]
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if (f * g) a ≤ (f * g) b then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1

tactic: rw [mem_finPairsLT] at hab
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩ ∈ finPairsLT n
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1
state_after: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1

tactic: by_cases h : g b < g a
state_before: case mk
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1
state_after: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1

case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1

tactic: rw [dif_pos h]
state_before: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1
state_after: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if f ⟨g a, g b⟩.fst ≤ f ⟨g a, g b⟩.snd then -1 else 1) * if g⁻¹ ⟨g a, g b⟩.fst ≤ g⁻¹ ⟨g a, g b⟩.snd then -1 else 1

tactic: simp only [not_le_of_gt hab, mul_one, mul_ite, mul_neg, Perm.inv_apply_self, if_false]
state_before: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if f ⟨g a, g b⟩.fst ≤ f ⟨g a, g b⟩.snd then -1 else 1) * if g⁻¹ ⟨g a, g b⟩.fst ≤ g⁻¹ ⟨g a, g b⟩.snd then -1 else 1
state_after: no goals

tactic: rw [dif_neg h, inv_apply_self, inv_apply_self, if_pos hab.le]
state_before: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) =
    (if
          f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            f (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1) *
      if
          g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).fst ≤
            g⁻¹ (if x : g b < g a then ⟨g a, g b⟩ else ⟨g b, g a⟩).snd then
        -1
      else 1
state_after: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1

tactic: by_cases h₁ : f (g b) ≤ f (g a)
state_before: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1
state_after: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1

case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : ¬f (g b) ≤ f (g a)
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1

tactic: have : f (g b) ≠ f (g a) := by
  rw [Ne, f.injective.eq_iff, g.injective.eq_iff]
  exact ne_of_lt hab
state_before: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1
state_after: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
this : f (g b) ≠ f (g a)
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1

tactic: rw [if_pos h₁, if_neg (h₁.lt_of_ne this).not_le]
state_before: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
this : f (g b) ≠ f (g a)
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1
state_after: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
this : f (g b) ≠ f (g a)
⊢ 1 = -1 * -1

tactic: rfl
state_before: case pos
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
this : f (g b) ≠ f (g a)
⊢ 1 = -1 * -1
state_after: no goals

tactic: rw [Ne, f.injective.eq_iff, g.injective.eq_iff]
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
⊢ f (g b) ≠ f (g a)
state_after: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
⊢ ¬b = a

tactic: exact ne_of_lt hab
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : f (g b) ≤ f (g a)
⊢ ¬b = a
state_after: no goals

tactic: rw [if_neg h₁, if_pos (lt_of_not_ge h₁).le]
state_before: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : ¬f (g b) ≤ f (g a)
⊢ (if f (g a) ≤ f (g b) then -1 else 1) = (if f ⟨g b, g a⟩.fst ≤ f ⟨g b, g a⟩.snd then -1 else 1) * -1
state_after: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : ¬f (g b) ≤ f (g a)
⊢ -1 = 1 * -1

tactic: rfl
state_before: case neg
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
f g : Perm (Fin n)
a b : Fin n
hab : ⟨a, b⟩.snd < ⟨a, b⟩.fst
h : ¬g b < g a
h₁ : ¬f (g b) ≤ f (g a)
⊢ -1 = 1 * -1
state_after: no goals