[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ det M = ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, M (↑σ i) i
[PROOFSTEP]
simp [det_apply, Units.smul_def]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ det (diagonal d) = ∏ i : n, d i
[PROOFSTEP]
rw [det_apply']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, diagonal d (↑σ i) i = ∏ i : n, d i
[PROOFSTEP]
refine' (Finset.sum_eq_single 1 _ _).trans _
[GOAL]
case refine'_1
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ∀ (b : Perm n), b ∈ univ → b ≠ 1 → ↑↑(↑sign b) * ∏ i : n, diagonal d (↑b i) i = 0
[PROOFSTEP]
rintro σ - h2
[GOAL]
case refine'_1
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
⊢ ↑↑(↑sign σ) * ∏ i : n, diagonal d (↑σ i) i = 0
[PROOFSTEP]
cases' not_forall.1 (mt Equiv.ext h2) with x h3
[GOAL]
case refine'_1.intro
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
x : n
h3 : ¬↑σ x = ↑1 x
⊢ ↑↑(↑sign σ) * ∏ i : n, diagonal d (↑σ i) i = 0
[PROOFSTEP]
convert mul_zero (ε σ)
[GOAL]
case h.e'_2.h.e'_6
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
x : n
h3 : ¬↑σ x = ↑1 x
⊢ ∏ i : n, diagonal d (↑σ i) i = 0
[PROOFSTEP]
apply Finset.prod_eq_zero (mem_univ x)
[GOAL]
case h.e'_2.h.e'_6
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
x : n
h3 : ¬↑σ x = ↑1 x
⊢ diagonal d (↑σ x) x = 0
[PROOFSTEP]
exact if_neg h3
[GOAL]
case refine'_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ¬1 ∈ univ → ↑↑(↑sign 1) * ∏ i : n, diagonal d (↑1 i) i = 0
[PROOFSTEP]
simp
[GOAL]
case refine'_3
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ↑↑(↑sign 1) * ∏ i : n, diagonal d (↑1 i) i = ∏ i : n, d i
[PROOFSTEP]
simp
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ det 1 = 1
[PROOFSTEP]
rw [← diagonal_one]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ det (diagonal fun x => 1) = 1
[PROOFSTEP]
simp [-diagonal_one]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : IsEmpty n
A : Matrix n n R
⊢ det A = 1
[PROOFSTEP]
simp [det_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : IsEmpty n
⊢ det = const (Matrix n n R) 1
[PROOFSTEP]
ext
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : IsEmpty n
x✝ : Matrix n n R
⊢ det x✝ = const (Matrix n n R) 1 x✝
[PROOFSTEP]
exact det_isEmpty
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁷ : DecidableEq n✝
inst✝⁶ : Fintype n✝
inst✝⁵ : DecidableEq m
inst✝⁴ : Fintype m
R : Type v
inst✝³ : CommRing R
n : Type u_3
inst✝² : Unique n
inst✝¹ : DecidableEq n
inst✝ : Fintype n
A : Matrix n n R
⊢ det A = A default default
[PROOFSTEP]
simp [det_apply, univ_unique]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
⊢ det A = A k k
[PROOFSTEP]
have := uniqueOfSubsingleton k
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
this : Unique n
⊢ det A = A k k
[PROOFSTEP]
convert det_unique A
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬Bijective p
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ x : n, M (↑σ x) (p x) * N (p x) x = 0
[PROOFSTEP]
obtain ⟨i, j, hpij, hij⟩ : ∃ i j, p i = p j ∧ i ≠ j :=
  by
  rw [← Finite.injective_iff_bijective, Injective] at H 
  push_neg at H 
  exact H
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬Bijective p
⊢ ∃ i j, p i = p j ∧ i ≠ j
[PROOFSTEP]
rw [← Finite.injective_iff_bijective, Injective] at H 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬∀ ⦃a₁ a₂ : n⦄, p a₁ = p a₂ → a₁ = a₂
⊢ ∃ i j, p i = p j ∧ i ≠ j
[PROOFSTEP]
push_neg at H 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : Exists fun ⦃a₁⦄ => Exists fun ⦃a₂⦄ => p a₁ = p a₂ ∧ a₁ ≠ a₂
⊢ ∃ i j, p i = p j ∧ i ≠ j
[PROOFSTEP]
exact H
[GOAL]
case intro.intro.intro
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬Bijective p
i j : n
hpij : p i = p j
hij : i ≠ j
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ x : n, M (↑σ x) (p x) * N (p x) x = 0
[PROOFSTEP]
exact
  sum_involution (fun σ _ => σ * Equiv.swap i j)
    (fun σ _ =>
      by
      have : (∏ x, M (σ x) (p x)) = ∏ x, M ((σ * Equiv.swap i j) x) (p x) :=
        Fintype.prod_equiv (swap i j) _ _ (by simp [apply_swap_eq_self hpij])
      simp [this, sign_swap hij, -sign_swap', prod_mul_distrib])
    (fun σ _ _ => (not_congr mul_swap_eq_iff).mpr hij) (fun _ _ => mem_univ _) fun σ _ => mul_swap_involutive i j σ
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬Bijective p
i j : n
hpij : p i = p j
hij : i ≠ j
σ : Perm n
x✝ : σ ∈ univ
⊢ ↑↑(↑sign σ) * ∏ x : n, M (↑σ x) (p x) * N (p x) x +
      ↑↑(↑sign ((fun σ x => σ * Equiv.swap i j) σ x✝)) *
        ∏ x : n, M (↑((fun σ x => σ * Equiv.swap i j) σ x✝) x) (p x) * N (p x) x =
    0
[PROOFSTEP]
have : (∏ x, M (σ x) (p x)) = ∏ x, M ((σ * Equiv.swap i j) x) (p x) :=
  Fintype.prod_equiv (swap i j) _ _ (by simp [apply_swap_eq_self hpij])
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬Bijective p
i j : n
hpij : p i = p j
hij : i ≠ j
σ : Perm n
x✝ : σ ∈ univ
⊢ ∀ (x : n), M (↑σ x) (p x) = M (↑(σ * Equiv.swap i j) (↑(Equiv.swap i j) x)) (p (↑(Equiv.swap i j) x))
[PROOFSTEP]
simp [apply_swap_eq_self hpij]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
p : n → n
H : ¬Bijective p
i j : n
hpij : p i = p j
hij : i ≠ j
σ : Perm n
x✝ : σ ∈ univ
this : ∏ x : n, M (↑σ x) (p x) = ∏ x : n, M (↑(σ * Equiv.swap i j) x) (p x)
⊢ ↑↑(↑sign σ) * ∏ x : n, M (↑σ x) (p x) * N (p x) x +
      ↑↑(↑sign ((fun σ x => σ * Equiv.swap i j) σ x✝)) *
        ∏ x : n, M (↑((fun σ x => σ * Equiv.swap i j) σ x✝) x) (p x) * N (p x) x =
    0
[PROOFSTEP]
simp [this, sign_swap hij, -sign_swap', prod_mul_distrib]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
⊢ det (M * N) = ∑ p : n → n, ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, M (↑σ i) (p i) * N (p i) i
[PROOFSTEP]
simp only [det_apply', mul_apply, prod_univ_sum, mul_sum, Fintype.piFinset_univ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
⊢ ∑ x : Perm n, ∑ x_1 : n → n, ↑↑(↑sign x) * ∏ x_2 : n, M (↑x x_2) (x_1 x_2) * N (x_1 x_2) x_2 =
    ∑ x : n → n, ∑ x_1 : Perm n, ↑↑(↑sign x_1) * ∏ x_2 : n, M (↑x_1 x_2) (x x_2) * N (x x_2) x_2
[PROOFSTEP]
rw [Finset.sum_comm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
f : n → n
x✝ : f ∈ univ
hbij : ¬f ∈ filter Bijective univ
⊢ ¬Bijective fun i => f i
[PROOFSTEP]
simpa only [true_and_iff, mem_filter, mem_univ] using hbij
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
x✝³ x✝² : n → n
x✝¹ : x✝³ ∈ filter Bijective univ
x✝ : x✝² ∈ filter Bijective univ
h : (fun p h => ofBijective p (_ : Bijective p)) x✝³ x✝¹ = (fun p h => ofBijective p (_ : Bijective p)) x✝² x✝
⊢ x✝³ = x✝²
[PROOFSTEP]
injection h
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
⊢ ∑ τ : Perm n, ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, M (↑σ i) (↑τ i) * N (↑τ i) i =
    ∑ σ : Perm n, ∑ τ : Perm n, (∏ i : n, N (↑σ i) i) * ↑↑(↑sign τ) * ∏ j : n, M (↑τ j) (↑σ j)
[PROOFSTEP]
simp only [mul_comm, mul_left_comm, prod_mul_distrib, mul_assoc]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
⊢ (∏ i : n, N (↑σ i) i) * ↑↑(↑sign τ) * ∏ j : n, M (↑τ j) (↑σ j) =
    (∏ i : n, N (↑σ i) i) * (↑↑(↑sign σ) * ↑↑(↑sign (↑(Equiv.mulRight σ⁻¹) τ))) *
      ∏ i : n, M (↑(↑(Equiv.mulRight σ⁻¹) τ) i) i
[PROOFSTEP]
have : (∏ j, M (τ j) (σ j)) = ∏ j, M ((τ * σ⁻¹) j) j :=
  by
  rw [← (σ⁻¹ : _ ≃ _).prod_comp]
  simp only [Equiv.Perm.coe_mul, apply_inv_self, Function.comp_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
⊢ ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
[PROOFSTEP]
rw [← (σ⁻¹ : _ ≃ _).prod_comp]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
⊢ ∏ i : n, M (↑τ (↑σ⁻¹ i)) (↑σ (↑σ⁻¹ i)) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
[PROOFSTEP]
simp only [Equiv.Perm.coe_mul, apply_inv_self, Function.comp_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
this : ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
⊢ (∏ i : n, N (↑σ i) i) * ↑↑(↑sign τ) * ∏ j : n, M (↑τ j) (↑σ j) =
    (∏ i : n, N (↑σ i) i) * (↑↑(↑sign σ) * ↑↑(↑sign (↑(Equiv.mulRight σ⁻¹) τ))) *
      ∏ i : n, M (↑(↑(Equiv.mulRight σ⁻¹) τ) i) i
[PROOFSTEP]
have h : ε σ * ε (τ * σ⁻¹) = ε τ :=
  calc
    ε σ * ε (τ * σ⁻¹) = ε (τ * σ⁻¹ * σ) := by
      rw [mul_comm, sign_mul (τ * σ⁻¹)]
      simp only [Int.cast_mul, Units.val_mul]
    _ = ε τ := by simp only [inv_mul_cancel_right]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
this : ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
⊢ ↑↑(↑sign σ) * ↑↑(↑sign (τ * σ⁻¹)) = ↑↑(↑sign (τ * σ⁻¹ * σ))
[PROOFSTEP]
rw [mul_comm, sign_mul (τ * σ⁻¹)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
this : ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
⊢ ↑↑(↑sign (τ * σ⁻¹)) * ↑↑(↑sign σ) = ↑↑(↑sign (τ * σ⁻¹) * ↑sign σ)
[PROOFSTEP]
simp only [Int.cast_mul, Units.val_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
this : ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
⊢ ↑↑(↑sign (τ * σ⁻¹ * σ)) = ↑↑(↑sign τ)
[PROOFSTEP]
simp only [inv_mul_cancel_right]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
this : ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
h : ↑↑(↑sign σ) * ↑↑(↑sign (τ * σ⁻¹)) = ↑↑(↑sign τ)
⊢ (∏ i : n, N (↑σ i) i) * ↑↑(↑sign τ) * ∏ j : n, M (↑τ j) (↑σ j) =
    (∏ i : n, N (↑σ i) i) * (↑↑(↑sign σ) * ↑↑(↑sign (↑(Equiv.mulRight σ⁻¹) τ))) *
      ∏ i : n, M (↑(↑(Equiv.mulRight σ⁻¹) τ) i) i
[PROOFSTEP]
simp_rw [Equiv.coe_mulRight, h]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
σ : Perm n
x✝ : σ ∈ univ
τ : Perm n
this : ∏ j : n, M (↑τ j) (↑σ j) = ∏ j : n, M (↑(τ * σ⁻¹) j) j
h : ↑↑(↑sign σ) * ↑↑(↑sign (τ * σ⁻¹)) = ↑↑(↑sign τ)
⊢ (∏ x : n, N (↑σ x) x) * ↑↑(↑sign τ) * ∏ x : n, M (↑τ x) (↑σ x) =
    (∏ x : n, N (↑σ x) x) * ↑↑(↑sign τ) * ∏ x : n, M (↑(τ * σ⁻¹) x) x
[PROOFSTEP]
simp only [this]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix n n R
⊢ ∑ σ : Perm n, ∑ τ : Perm n, (∏ i : n, N (↑σ i) i) * (↑↑(↑sign σ) * ↑↑(↑sign τ)) * ∏ i : n, M (↑τ i) i = det M * det N
[PROOFSTEP]
simp only [det_apply', Finset.mul_sum, mul_comm, mul_left_comm, mul_assoc]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix m m R
⊢ det (M * N) = det (N * M)
[PROOFSTEP]
rw [det_mul, det_mul, mul_comm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N P : Matrix m m R
⊢ det (M * (N * P)) = det (N * (M * P))
[PROOFSTEP]
rw [← Matrix.mul_assoc, ← Matrix.mul_assoc, det_mul, det_mul_comm M N, ← det_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N P : Matrix m m R
⊢ det (M * N * P) = det (M * P * N)
[PROOFSTEP]
rw [Matrix.mul_assoc, Matrix.mul_assoc, det_mul, det_mul_comm N P, ← det_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : (Matrix m m R)ˣ
N : Matrix m m R
⊢ det (↑M * N * ↑M⁻¹) = det N
[PROOFSTEP]
rw [det_mul_right_comm, Units.mul_inv, one_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ det Mᵀ = det M
[PROOFSTEP]
rw [det_apply', det_apply']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, Mᵀ (↑σ i) i = ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, M (↑σ i) i
[PROOFSTEP]
refine' Fintype.sum_bijective _ inv_involutive.bijective _ _ _
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ ∀ (x : Perm n), ↑↑(↑sign x) * ∏ i : n, Mᵀ (↑x i) i = ↑↑(↑sign x⁻¹) * ∏ i : n, M (↑x⁻¹ i) i
[PROOFSTEP]
intro σ
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ↑↑(↑sign σ) * ∏ i : n, Mᵀ (↑σ i) i = ↑↑(↑sign σ⁻¹) * ∏ i : n, M (↑σ⁻¹ i) i
[PROOFSTEP]
rw [sign_inv]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ↑↑(↑sign σ) * ∏ i : n, Mᵀ (↑σ i) i = ↑↑(↑sign σ) * ∏ i : n, M (↑σ⁻¹ i) i
[PROOFSTEP]
congr 1
[GOAL]
case e_a
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ∏ i : n, Mᵀ (↑σ i) i = ∏ i : n, M (↑σ⁻¹ i) i
[PROOFSTEP]
apply Fintype.prod_equiv σ
[GOAL]
case e_a.h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ∀ (x : n), Mᵀ (↑σ x) x = M (↑σ⁻¹ (↑σ x)) (↑σ x)
[PROOFSTEP]
intros
[GOAL]
case e_a.h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
x✝ : n
⊢ Mᵀ (↑σ x✝) x✝ = M (↑σ⁻¹ (↑σ x✝)) (↑σ x✝)
[PROOFSTEP]
simp
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
σ : Perm n
M : Matrix n n R
⊢ ↑sign σ • ↑detRowAlternating M = ↑↑(↑sign σ) * det M
[PROOFSTEP]
simp [Units.smul_def]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
⊢ det (submatrix A ↑e ↑e) = det A
[PROOFSTEP]
rw [det_apply', det_apply']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, submatrix A (↑e) (↑e) (↑σ i) i = ∑ σ : Perm m, ↑↑(↑sign σ) * ∏ i : m, A (↑σ i) i
[PROOFSTEP]
apply Fintype.sum_equiv (Equiv.permCongr e)
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
⊢ ∀ (x : Perm n),
    ↑↑(↑sign x) * ∏ i : n, submatrix A (↑e) (↑e) (↑x i) i =
      ↑↑(↑sign (↑(permCongr e) x)) * ∏ i : m, A (↑(↑(permCongr e) x) i) i
[PROOFSTEP]
intro σ
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
σ : Perm n
⊢ ↑↑(↑sign σ) * ∏ i : n, submatrix A (↑e) (↑e) (↑σ i) i =
    ↑↑(↑sign (↑(permCongr e) σ)) * ∏ i : m, A (↑(↑(permCongr e) σ) i) i
[PROOFSTEP]
rw [Equiv.Perm.sign_permCongr e σ]
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
σ : Perm n
⊢ ↑↑(↑sign σ) * ∏ i : n, submatrix A (↑e) (↑e) (↑σ i) i = ↑↑(↑sign σ) * ∏ i : m, A (↑(↑(permCongr e) σ) i) i
[PROOFSTEP]
congr 1
[GOAL]
case h.e_a
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
σ : Perm n
⊢ ∏ i : n, submatrix A (↑e) (↑e) (↑σ i) i = ∏ i : m, A (↑(↑(permCongr e) σ) i) i
[PROOFSTEP]
apply Fintype.prod_equiv e
[GOAL]
case h.e_a.h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
σ : Perm n
⊢ ∀ (x : n), submatrix A (↑e) (↑e) (↑σ x) x = A (↑(↑(permCongr e) σ) (↑e x)) (↑e x)
[PROOFSTEP]
intro i
[GOAL]
case h.e_a.h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
e : n ≃ m
A : Matrix m m R
σ : Perm n
i : n
⊢ submatrix A (↑e) (↑e) (↑σ i) i = A (↑(↑(permCongr e) σ) (↑e i)) (↑e i)
[PROOFSTEP]
rw [Equiv.permCongr_apply, Equiv.symm_apply_apply, submatrix_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
σ : Perm n
⊢ det (PEquiv.toMatrix (toPEquiv σ)) = ↑↑(↑sign σ)
[PROOFSTEP]
rw [← Matrix.mul_one (σ.toPEquiv.toMatrix : Matrix n n R), PEquiv.toPEquiv_mul_matrix, det_permute, det_one, mul_one]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
c : R
⊢ det (c • A) = det ((diagonal fun x => c) * A)
[PROOFSTEP]
rw [smul_eq_diagonal_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
c : R
⊢ det (diagonal fun x => c) * det A = c ^ Fintype.card n * det A
[PROOFSTEP]
simp [card_univ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁸ : DecidableEq n
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq m
inst✝⁵ : Fintype m
R : Type v
inst✝⁴ : CommRing R
α : Type u_3
inst✝³ : Monoid α
inst✝² : DistribMulAction α R
inst✝¹ : IsScalarTower α R R
inst✝ : SMulCommClass α R R
c : α
A : Matrix n n R
⊢ det (c • A) = c ^ Fintype.card n • det A
[PROOFSTEP]
rw [← smul_one_smul R c A, det_smul, smul_pow, one_pow, smul_mul_assoc, one_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
⊢ det (-A) = (-1) ^ Fintype.card n * det A
[PROOFSTEP]
rw [← det_smul, neg_one_smul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
⊢ det (-A) = (-1) ^ Fintype.card n • det A
[PROOFSTEP]
rw [← det_smul_of_tower, Units.neg_smul, one_smul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
v : n → R
A : Matrix n n R
⊢ (↑of fun i j => v j * A i j) = A * diagonal v
[PROOFSTEP]
ext
[GOAL]
case a.h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
v : n → R
A : Matrix n n R
i✝ x✝ : n
⊢ ↑of (fun i j => v j * A i j) i✝ x✝ = (A * diagonal v) i✝ x✝
[PROOFSTEP]
simp [mul_comm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
v : n → R
A : Matrix n n R
⊢ det (A * diagonal v) = (∏ i : n, v i) * det A
[PROOFSTEP]
rw [det_mul, det_diagonal, mul_comm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
S : Type w
inst✝ : CommRing S
f : R →+* S
M : Matrix n n R
⊢ ↑f (det M) = det (↑(RingHom.mapMatrix f) M)
[PROOFSTEP]
simp [Matrix.det_apply', f.map_sum, f.map_prod]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
j : n
h : ∀ (i : n), A i j = 0
⊢ det A = 0
[PROOFSTEP]
rw [← det_transpose]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
j : n
h : ∀ (i : n), A i j = 0
⊢ det Aᵀ = 0
[PROOFSTEP]
exact det_eq_zero_of_row_eq_zero j h
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
i j : n
i_ne_j : i ≠ j
hij : ∀ (k : n), M k i = M k j
⊢ det M = 0
[PROOFSTEP]
rw [← det_transpose, det_zero_of_row_eq i_ne_j]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
i j : n
i_ne_j : i ≠ j
hij : ∀ (k : n), M k i = M k j
⊢ Mᵀ i = Mᵀ j
[PROOFSTEP]
exact funext hij
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
u v : n → R
⊢ det (updateColumn M j (u + v)) = det (updateColumn M j u) + det (updateColumn M j v)
[PROOFSTEP]
rw [← det_transpose, ← updateRow_transpose, det_updateRow_add]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
u v : n → R
⊢ det (updateRow Mᵀ j u) + det (updateRow Mᵀ j v) = det (updateColumn M j u) + det (updateColumn M j v)
[PROOFSTEP]
simp [updateRow_transpose, det_transpose]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ det (updateColumn M j (s • u)) = s * det (updateColumn M j u)
[PROOFSTEP]
rw [← det_transpose, ← updateRow_transpose, det_updateRow_smul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s * det (updateRow Mᵀ j u) = s * det (updateColumn M j u)
[PROOFSTEP]
simp [updateRow_transpose, det_transpose]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ det (updateColumn (s • M) j u) = s ^ (Fintype.card n - 1) * det (updateColumn M j u)
[PROOFSTEP]
rw [← det_transpose, ← updateRow_transpose, transpose_smul, det_updateRow_smul']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
s : R
u : n → R
⊢ s ^ (Fintype.card n - 1) * det (updateRow Mᵀ j u) = s ^ (Fintype.card n - 1) * det (updateColumn M j u)
[PROOFSTEP]
simp [updateRow_transpose, det_transpose]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B C : Matrix n n R
hC : det C = 1
hA : A = B * C
⊢ det B * det C = det B
[PROOFSTEP]
rw [hC, mul_one]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B C : Matrix n n R
hC : det C = 1
hA : A = C * B
⊢ det C * det B = det B
[PROOFSTEP]
rw [hC, one_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
⊢ det (updateRow A i (A i + A j)) = det A
[PROOFSTEP]
simp [det_updateRow_add, det_zero_of_row_eq hij (updateRow_self.trans (updateRow_ne hij.symm).symm)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
⊢ det (updateColumn A i fun k => A k i + A k j) = det A
[PROOFSTEP]
rw [← det_transpose, ← updateRow_transpose, ← det_transpose A]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
⊢ det (updateRow Aᵀ i fun k => A k i + A k j) = det Aᵀ
[PROOFSTEP]
exact det_updateRow_add_self Aᵀ hij
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ det (updateRow A i (A i + c • A j)) = det A
[PROOFSTEP]
simp [det_updateRow_add, det_updateRow_smul, det_zero_of_row_eq hij (updateRow_self.trans (updateRow_ne hij.symm).symm)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ det (updateColumn A i fun k => A k i + c • A k j) = det A
[PROOFSTEP]
rw [← det_transpose, ← updateRow_transpose, ← det_transpose A]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ det (updateRow Aᵀ i fun k => A k i + c • A k j) = det Aᵀ
[PROOFSTEP]
exact det_updateRow_add_smul_self Aᵀ hij c
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
s : Finset n
⊢ ∀ (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
[PROOFSTEP]
induction s using Finset.induction_on generalizing B with
| empty =>
  rintro c hs k - A_eq
  have : ∀ i, c i = 0 := by
    intro i
    specialize hs i
    contrapose! hs
    simp [hs]
  congr
  ext i j
  rw [A_eq, this, zero_mul, add_zero]
| @insert i s _hi ih =>
  intro c hs k hk A_eq
  have hAi : A i = B i + c i • B k := funext (A_eq i)
  rw [@ih (updateRow B i (A i)) (Function.update c i 0), hAi, det_updateRow_add_smul_self]
  · exact mt (fun h => show k ∈ insert i s from h ▸ Finset.mem_insert_self _ _) hk
  · intro i' hi'
    rw [Function.update_apply]
    split_ifs with hi'i
    · rfl
    · exact hs i' fun h => hi' ((Finset.mem_insert.mp h).resolve_left hi'i)
  · exact k
  · exact fun h => hk (Finset.mem_insert_of_mem h)
  · intro i' j'
    rw [updateRow_apply, Function.update_apply]
    split_ifs with hi'i
    · simp [hi'i]
    rw [A_eq, updateRow_ne fun h : k = i => hk <| h ▸ Finset.mem_insert_self k s]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
s : Finset n
⊢ ∀ (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
[PROOFSTEP]
induction s using Finset.induction_on generalizing B with
| empty =>
  rintro c hs k - A_eq
  have : ∀ i, c i = 0 := by
    intro i
    specialize hs i
    contrapose! hs
    simp [hs]
  congr
  ext i j
  rw [A_eq, this, zero_mul, add_zero]
| @insert i s _hi ih =>
  intro c hs k hk A_eq
  have hAi : A i = B i + c i • B k := funext (A_eq i)
  rw [@ih (updateRow B i (A i)) (Function.update c i 0), hAi, det_updateRow_add_smul_self]
  · exact mt (fun h => show k ∈ insert i s from h ▸ Finset.mem_insert_self _ _) hk
  · intro i' hi'
    rw [Function.update_apply]
    split_ifs with hi'i
    · rfl
    · exact hs i' fun h => hi' ((Finset.mem_insert.mp h).resolve_left hi'i)
  · exact k
  · exact fun h => hk (Finset.mem_insert_of_mem h)
  · intro i' j'
    rw [updateRow_apply, Function.update_apply]
    split_ifs with hi'i
    · simp [hi'i]
    rw [A_eq, updateRow_ne fun h : k = i => hk <| h ▸ Finset.mem_insert_self k s]
[GOAL]
case empty
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
⊢ ∀ (c : n → R),
    (∀ (i : n), ¬i ∈ ∅ → c i = 0) → ∀ (k : n), ¬k ∈ ∅ → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
[PROOFSTEP]

| empty =>
  rintro c hs k - A_eq
  have : ∀ i, c i = 0 := by
    intro i
    specialize hs i
    contrapose! hs
    simp [hs]
  congr
  ext i j
  rw [A_eq, this, zero_mul, add_zero]
[GOAL]
case empty
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
⊢ ∀ (c : n → R),
    (∀ (i : n), ¬i ∈ ∅ → c i = 0) → ∀ (k : n), ¬k ∈ ∅ → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
[PROOFSTEP]
rintro c hs k - A_eq
[GOAL]
case empty
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ (i : n), ¬i ∈ ∅ → c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
⊢ det A = det B
[PROOFSTEP]
have : ∀ i, c i = 0 := by
  intro i
  specialize hs i
  contrapose! hs
  simp [hs]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ (i : n), ¬i ∈ ∅ → c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
⊢ ∀ (i : n), c i = 0
[PROOFSTEP]
intro i
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ (i : n), ¬i ∈ ∅ → c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
i : n
⊢ c i = 0
[PROOFSTEP]
specialize hs i
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
i : n
hs : ¬i ∈ ∅ → c i = 0
⊢ c i = 0
[PROOFSTEP]
contrapose! hs
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
i : n
hs : c i ≠ 0
⊢ ¬i ∈ ∅ ∧ c i ≠ 0
[PROOFSTEP]
simp [hs]
[GOAL]
case empty
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ (i : n), ¬i ∈ ∅ → c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
this : ∀ (i : n), c i = 0
⊢ det A = det B
[PROOFSTEP]
congr
[GOAL]
case empty.e_M
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ (i : n), ¬i ∈ ∅ → c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
this : ∀ (i : n), c i = 0
⊢ A = B
[PROOFSTEP]
ext i j
[GOAL]
case empty.e_M.a.h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B : Matrix n n R
c : n → R
hs : ∀ (i : n), ¬i ∈ ∅ → c i = 0
k : n
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
this : ∀ (i : n), c i = 0
i j : n
⊢ A i j = B i j
[PROOFSTEP]
rw [A_eq, this, zero_mul, add_zero]
[GOAL]
case insert
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
⊢ ∀ (c : n → R),
    (∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0) →
      ∀ (k : n), ¬k ∈ insert i s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
[PROOFSTEP]

| @insert i s _hi ih =>
  intro c hs k hk A_eq
  have hAi : A i = B i + c i • B k := funext (A_eq i)
  rw [@ih (updateRow B i (A i)) (Function.update c i 0), hAi, det_updateRow_add_smul_self]
  · exact mt (fun h => show k ∈ insert i s from h ▸ Finset.mem_insert_self _ _) hk
  · intro i' hi'
    rw [Function.update_apply]
    split_ifs with hi'i
    · rfl
    · exact hs i' fun h => hi' ((Finset.mem_insert.mp h).resolve_left hi'i)
  · exact k
  · exact fun h => hk (Finset.mem_insert_of_mem h)
  · intro i' j'
    rw [updateRow_apply, Function.update_apply]
    split_ifs with hi'i
    · simp [hi'i]
    rw [A_eq, updateRow_ne fun h : k = i => hk <| h ▸ Finset.mem_insert_self k s]
[GOAL]
case insert
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
⊢ ∀ (c : n → R),
    (∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0) →
      ∀ (k : n), ¬k ∈ insert i s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
[PROOFSTEP]
intro c hs k hk A_eq
[GOAL]
case insert
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
⊢ det A = det B
[PROOFSTEP]
have hAi : A i = B i + c i • B k := funext (A_eq i)
[GOAL]
case insert
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
⊢ det A = det B
[PROOFSTEP]
rw [@ih (updateRow B i (A i)) (Function.update c i 0), hAi, det_updateRow_add_smul_self]
[GOAL]
case insert.hij
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
⊢ i ≠ k
[PROOFSTEP]
exact mt (fun h => show k ∈ insert i s from h ▸ Finset.mem_insert_self _ _) hk
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
⊢ ∀ (i_1 : n), ¬i_1 ∈ s → update c i 0 i_1 = 0
[PROOFSTEP]
intro i' hi'
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' : n
hi' : ¬i' ∈ s
⊢ update c i 0 i' = 0
[PROOFSTEP]
rw [Function.update_apply]
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' : n
hi' : ¬i' ∈ s
⊢ (if i' = i then 0 else c i') = 0
[PROOFSTEP]
split_ifs with hi'i
[GOAL]
case pos
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' : n
hi' : ¬i' ∈ s
hi'i : i' = i
⊢ 0 = 0
[PROOFSTEP]
rfl
[GOAL]
case neg
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' : n
hi' : ¬i' ∈ s
hi'i : ¬i' = i
⊢ c i' = 0
[PROOFSTEP]
exact hs i' fun h => hi' ((Finset.mem_insert.mp h).resolve_left hi'i)
[GOAL]
case insert.k
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
⊢ n
[PROOFSTEP]
exact k
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
⊢ ¬k ∈ s
[PROOFSTEP]
exact fun h => hk (Finset.mem_insert_of_mem h)
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
⊢ ∀ (i_1 j : n), A i_1 j = updateRow B i (A i) i_1 j + update c i 0 i_1 * updateRow B i (A i) k j
[PROOFSTEP]
intro i' j'
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' j' : n
⊢ A i' j' = updateRow B i (A i) i' j' + update c i 0 i' * updateRow B i (A i) k j'
[PROOFSTEP]
rw [updateRow_apply, Function.update_apply]
[GOAL]
case insert.x
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' j' : n
⊢ A i' j' = (if i' = i then A i j' else B i' j') + (if i' = i then 0 else c i') * updateRow B i (A i) k j'
[PROOFSTEP]
split_ifs with hi'i
[GOAL]
case pos
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' j' : n
hi'i : i' = i
⊢ A i' j' = A i j' + 0 * updateRow B i (A i) k j'
[PROOFSTEP]
simp [hi'i]
[GOAL]
case neg
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i : n
s : Finset n
_hi : ¬i ∈ s
ih :
  ∀ {B : Matrix n n R} (c : n → R),
    (∀ (i : n), ¬i ∈ s → c i = 0) → ∀ (k : n), ¬k ∈ s → (∀ (i j : n), A i j = B i j + c i * B k j) → det A = det B
B : Matrix n n R
c : n → R
hs : ∀ (i_1 : n), ¬i_1 ∈ insert i s → c i_1 = 0
k : n
hk : ¬k ∈ insert i s
A_eq : ∀ (i j : n), A i j = B i j + c i * B k j
hAi : A i = B i + c i • B k
i' j' : n
hi'i : ¬i' = i
⊢ A i' j' = B i' j' + c i' * updateRow B i (A i) k j'
[PROOFSTEP]
rw [A_eq, updateRow_ne fun h : k = i => hk <| h ▸ Finset.mem_insert_self k s]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k : Fin (n + 1)
⊢ ∀ (c : Fin n → R),
    (∀ (i : Fin n), k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
[PROOFSTEP]
refine' Fin.induction _ (fun k ih => _) k
[GOAL]
case refine'_1
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k : Fin (n + 1)
⊢ ∀ (c : Fin n → R),
    (∀ (i : Fin n), 0 < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
[PROOFSTEP]
intro c hc M N h0 hsucc
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
⊢ ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
[PROOFSTEP]
intro c hc M N h0 hsucc
[GOAL]
case refine'_1
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k : Fin (n + 1)
c : Fin n → R
hc : ∀ (i : Fin n), 0 < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
⊢ det M = det N
[PROOFSTEP]
congr
[GOAL]
case refine'_1.e_M
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k : Fin (n + 1)
c : Fin n → R
hc : ∀ (i : Fin n), 0 < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
⊢ M = N
[PROOFSTEP]
ext i j
[GOAL]
case refine'_1.e_M.a.h
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k : Fin (n + 1)
c : Fin n → R
hc : ∀ (i : Fin n), 0 < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
i j : Fin (Nat.succ n)
⊢ M i j = N i j
[PROOFSTEP]
refine' Fin.cases (h0 j) (fun i => _) i
[GOAL]
case refine'_1.e_M.a.h
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k : Fin (n + 1)
c : Fin n → R
hc : ∀ (i : Fin n), 0 < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
i✝ j : Fin (Nat.succ n)
i : Fin n
⊢ M (Fin.succ i) j = N (Fin.succ i) j
[PROOFSTEP]
rw [hsucc, hc i (Fin.succ_pos _), zero_mul, add_zero]
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
⊢ det M = det N
[PROOFSTEP]
set M' := updateRow M k.succ (N k.succ) with hM'
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
⊢ det M = det N
[PROOFSTEP]
have hM : M = updateRow M' k.succ (M' k.succ + c k • M (Fin.castSucc k)) :=
  by
  ext i j
  by_cases hi : i = k.succ
  · simp [hi, hM', hsucc, updateRow_self]
  rw [updateRow_ne hi, hM', updateRow_ne hi]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
⊢ M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
[PROOFSTEP]
ext i j
[GOAL]
case a.h
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
i j : Fin (Nat.succ n)
⊢ M i j = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k)) i j
[PROOFSTEP]
by_cases hi : i = k.succ
[GOAL]
case pos
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
i j : Fin (Nat.succ n)
hi : i = Fin.succ k
⊢ M i j = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k)) i j
[PROOFSTEP]
simp [hi, hM', hsucc, updateRow_self]
[GOAL]
case neg
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
i j : Fin (Nat.succ n)
hi : ¬i = Fin.succ k
⊢ M i j = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k)) i j
[PROOFSTEP]
rw [updateRow_ne hi, hM', updateRow_ne hi]
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
⊢ det M = det N
[PROOFSTEP]
have k_ne_succ : (Fin.castSucc k) ≠ k.succ := (Fin.castSucc_lt_succ k).ne
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
⊢ det M = det N
[PROOFSTEP]
have M_k : M (Fin.castSucc k) = M' (Fin.castSucc k) := (updateRow_ne k_ne_succ).symm
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
⊢ det M = det N
[PROOFSTEP]
rw [hM, M_k, det_updateRow_add_smul_self M' k_ne_succ.symm, ih (Function.update c k 0)]
[GOAL]
case refine'_2._hc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
⊢ ∀ (i : Fin n), Fin.castSucc k < Fin.succ i → update c k 0 i = 0
[PROOFSTEP]
intro i hi
[GOAL]
case refine'_2._hc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
hi : Fin.castSucc k < Fin.succ i
⊢ update c k 0 i = 0
[PROOFSTEP]
rw [Fin.lt_iff_val_lt_val, Fin.coe_castSucc, Fin.val_succ, Nat.lt_succ_iff] at hi 
[GOAL]
case refine'_2._hc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
hi : ↑k ≤ ↑i
⊢ update c k 0 i = 0
[PROOFSTEP]
rw [Function.update_apply]
[GOAL]
case refine'_2._hc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
hi : ↑k ≤ ↑i
⊢ (if i = k then 0 else c i) = 0
[PROOFSTEP]
split_ifs with hik
[GOAL]
case pos
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
hi : ↑k ≤ ↑i
hik : i = k
⊢ 0 = 0
[PROOFSTEP]
rfl
[GOAL]
case neg
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
hi : ↑k ≤ ↑i
hik : ¬i = k
⊢ c i = 0
[PROOFSTEP]
exact hc _ (Fin.succ_lt_succ_iff.mpr (lt_of_le_of_ne hi (Ne.symm hik)))
[GOAL]
case refine'_2._h0
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
⊢ ∀ (j : Fin (Nat.succ n)), M' 0 j = N 0 j
[PROOFSTEP]
rwa [hM', updateRow_ne (Fin.succ_ne_zero _).symm]
[GOAL]
case refine'_2._hsucc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
⊢ ∀ (i : Fin n) (j : Fin (Nat.succ n)), M' (Fin.succ i) j = N (Fin.succ i) j + update c k 0 i * M' (Fin.castSucc i) j
[PROOFSTEP]
intro i j
[GOAL]
case refine'_2._hsucc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
⊢ M' (Fin.succ i) j = N (Fin.succ i) j + update c k 0 i * M' (Fin.castSucc i) j
[PROOFSTEP]
rw [Function.update_apply]
[GOAL]
case refine'_2._hsucc
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
⊢ M' (Fin.succ i) j = N (Fin.succ i) j + (if i = k then 0 else c i) * M' (Fin.castSucc i) j
[PROOFSTEP]
split_ifs with hik
[GOAL]
case pos
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : i = k
⊢ M' (Fin.succ i) j = N (Fin.succ i) j + 0 * M' (Fin.castSucc i) j
[PROOFSTEP]
rw [zero_mul, add_zero, hM', hik, updateRow_self]
[GOAL]
case neg
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : ¬i = k
⊢ M' (Fin.succ i) j = N (Fin.succ i) j + c i * M' (Fin.castSucc i) j
[PROOFSTEP]
rw [hM', updateRow_ne ((Fin.succ_injective _).ne hik), hsucc]
[GOAL]
case neg
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : ¬i = k
⊢ N (Fin.succ i) j + c i * M (Fin.castSucc i) j =
    N (Fin.succ i) j + c i * updateRow M (Fin.succ k) (N (Fin.succ k)) (Fin.castSucc i) j
[PROOFSTEP]
by_cases hik2 : k < i
[GOAL]
case pos
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : ¬i = k
hik2 : k < i
⊢ N (Fin.succ i) j + c i * M (Fin.castSucc i) j =
    N (Fin.succ i) j + c i * updateRow M (Fin.succ k) (N (Fin.succ k)) (Fin.castSucc i) j
[PROOFSTEP]
simp [hc i (Fin.succ_lt_succ_iff.mpr hik2)]
[GOAL]
case neg
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : ¬i = k
hik2 : ¬k < i
⊢ N (Fin.succ i) j + c i * M (Fin.castSucc i) j =
    N (Fin.succ i) j + c i * updateRow M (Fin.succ k) (N (Fin.succ k)) (Fin.castSucc i) j
[PROOFSTEP]
rw [updateRow_ne]
[GOAL]
case neg
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : ¬i = k
hik2 : ¬k < i
⊢ Fin.castSucc i ≠ Fin.succ k
[PROOFSTEP]
apply ne_of_lt
[GOAL]
case neg.h
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
k✝ : Fin (n + 1)
k : Fin n
ih :
  ∀ (c : Fin n → R),
    (∀ (i : Fin n), Fin.castSucc k < Fin.succ i → c i = 0) →
      ∀ {M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R},
        (∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j) →
          (∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j) →
            det M = det N
c : Fin n → R
hc : ∀ (i : Fin n), Fin.succ k < Fin.succ i → c i = 0
M N : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
h0 : ∀ (j : Fin (Nat.succ n)), M 0 j = N 0 j
hsucc : ∀ (i : Fin n) (j : Fin (Nat.succ n)), M (Fin.succ i) j = N (Fin.succ i) j + c i * M (Fin.castSucc i) j
M' : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R := updateRow M (Fin.succ k) (N (Fin.succ k))
hM' : M' = updateRow M (Fin.succ k) (N (Fin.succ k))
hM : M = updateRow M' (Fin.succ k) (M' (Fin.succ k) + c k • M (Fin.castSucc k))
k_ne_succ : Fin.castSucc k ≠ Fin.succ k
M_k : M (Fin.castSucc k) = M' (Fin.castSucc k)
i : Fin n
j : Fin (Nat.succ n)
hik : ¬i = k
hik2 : ¬k < i
⊢ Fin.castSucc i < Fin.succ k
[PROOFSTEP]
rwa [Fin.lt_iff_val_lt_val, Fin.coe_castSucc, Fin.val_succ, Nat.lt_succ_iff, ← not_lt]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A B : Matrix (Fin (n + 1)) (Fin (n + 1)) R
c : Fin n → R
A_zero : ∀ (i : Fin (n + 1)), A i 0 = B i 0
A_succ : ∀ (i : Fin (n + 1)) (j : Fin n), A i (Fin.succ j) = B i (Fin.succ j) + c j * A i (Fin.castSucc j)
⊢ det A = det B
[PROOFSTEP]
rw [← det_transpose A, ← det_transpose B]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A B : Matrix (Fin (n + 1)) (Fin (n + 1)) R
c : Fin n → R
A_zero : ∀ (i : Fin (n + 1)), A i 0 = B i 0
A_succ : ∀ (i : Fin (n + 1)) (j : Fin n), A i (Fin.succ j) = B i (Fin.succ j) + c j * A i (Fin.castSucc j)
⊢ det Aᵀ = det Bᵀ
[PROOFSTEP]
exact det_eq_of_forall_row_eq_smul_add_pred c A_zero fun i j => A_succ j i
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
⊢ det (blockDiagonal M) = ∏ k : o, det (M k)
[PROOFSTEP]
simp_rw [det_apply']
  -- The right hand side is a product of sums, rewrite it as a sum of products.
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
⊢ ∑ x : Perm (n × o), ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 =
    ∏ x : o, ∑ x_1 : Perm n, ↑↑(↑sign x_1) * ∏ x_2 : n, M x (↑x_1 x_2) x_2
[PROOFSTEP]
rw [Finset.prod_sum]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
⊢ ∑ x : Perm (n × o), ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 =
    ∑ p in pi univ fun x => univ,
      ∏ x in attach univ, ↑↑(↑sign (p ↑x (_ : ↑x ∈ univ))) * ∏ x_1 : n, M (↑x) (↑(p ↑x (_ : ↑x ∈ univ)) x_1) x_1
[PROOFSTEP]
simp_rw [Finset.prod_attach_univ, Finset.univ_pi_univ]
  -- We claim that the only permutations contributing to the sum are those that
    -- preserve their second component.
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
⊢ ∑ x : Perm (n × o), ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 =
    ∑ x : (a : o) → a ∈ univ → Perm n,
      ∏ x_1 : o,
        ↑↑(↑sign (x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ))) *
          ∏ x_2 : n, M x_1 (↑(x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ)) x_2) x_2
[PROOFSTEP]
let preserving_snd : Finset (Equiv.Perm (n × o)) := Finset.univ.filter fun σ => ∀ x, (σ x).snd = x.snd
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
⊢ ∑ x : Perm (n × o), ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 =
    ∑ x : (a : o) → a ∈ univ → Perm n,
      ∏ x_1 : o,
        ↑↑(↑sign (x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ))) *
          ∏ x_2 : n, M x_1 (↑(x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ)) x_2) x_2
[PROOFSTEP]
have mem_preserving_snd : ∀ {σ : Equiv.Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ x, (σ x).snd = x.snd := fun {σ} =>
  Finset.mem_filter.trans ⟨fun h => h.2, fun h => ⟨Finset.mem_univ _, h⟩⟩
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∑ x : Perm (n × o), ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 =
    ∑ x : (a : o) → a ∈ univ → Perm n,
      ∏ x_1 : o,
        ↑↑(↑sign (x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ))) *
          ∏ x_2 : n, M x_1 (↑(x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ)) x_2) x_2
[PROOFSTEP]
rw [← Finset.sum_subset (Finset.subset_univ preserving_snd) _]
  -- And that these are in bijection with `o → Equiv.Perm m`.
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∑ x in preserving_snd, ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 =
    ∑ x : (a : o) → a ∈ univ → Perm n,
      ∏ x_1 : o,
        ↑↑(↑sign (x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ))) *
          ∏ x_2 : n, M x_1 (↑(x x_1 (_ : ↑{ val := x_1, property := (_ : x_1 ∈ univ) } ∈ univ)) x_2) x_2
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (x : Perm (n × o)), x ∈ univ → ¬x ∈ preserving_snd → ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 = 0
[PROOFSTEP]
rw [(Finset.sum_bij
      (fun (σ : ∀ k : o, k ∈ Finset.univ → Equiv.Perm n) _ => prodCongrLeft fun k => σ k (Finset.mem_univ k)) _ _ _
      _).symm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (a : (k : o) → k ∈ univ → Perm n) (ha : a ∈ univ),
    (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha ∈ preserving_snd
[PROOFSTEP]
intro σ _
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : (k : o) → k ∈ univ → Perm n
ha✝ : σ ∈ univ
⊢ (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝ ∈ preserving_snd
[PROOFSTEP]
rw [mem_preserving_snd]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : (k : o) → k ∈ univ → Perm n
ha✝ : σ ∈ univ
⊢ ∀ (x : n × o), (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝) x).snd = x.snd
[PROOFSTEP]
rintro ⟨-, x⟩
[GOAL]
case mk
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : (k : o) → k ∈ univ → Perm n
ha✝ : σ ∈ univ
fst✝ : n
x : o
⊢ (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝) (fst✝, x)).snd = (fst✝, x).snd
[PROOFSTEP]
simp only [prodCongrLeft_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (a : (k : o) → k ∈ univ → Perm n) (ha : a ∈ univ),
    ∏ x : o,
        ↑↑(↑sign (a x (_ : ↑{ val := x, property := (_ : x ∈ univ) } ∈ univ))) *
          ∏ x_1 : n, M x (↑(a x (_ : ↑{ val := x, property := (_ : x ∈ univ) } ∈ univ)) x_1) x_1 =
      ↑↑(↑sign ((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha)) *
        ∏ x : n × o, blockDiagonal M (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha) x) x
[PROOFSTEP]
intro σ _
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : (k : o) → k ∈ univ → Perm n
ha✝ : σ ∈ univ
⊢ ∏ x : o,
      ↑↑(↑sign (σ x (_ : ↑{ val := x, property := (_ : x ∈ univ) } ∈ univ))) *
        ∏ x_1 : n, M x (↑(σ x (_ : ↑{ val := x, property := (_ : x ∈ univ) } ∈ univ)) x_1) x_1 =
    ↑↑(↑sign ((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝)) *
      ∏ x : n × o, blockDiagonal M (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝) x) x
[PROOFSTEP]
rw [Finset.prod_mul_distrib, ← Finset.univ_product_univ, Finset.prod_product_right]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : (k : o) → k ∈ univ → Perm n
ha✝ : σ ∈ univ
⊢ (∏ x : o, ↑↑(↑sign (σ x (_ : ↑{ val := x, property := (_ : x ∈ univ) } ∈ univ)))) *
      ∏ x : o, ∏ x_1 : n, M x (↑(σ x (_ : ↑{ val := x, property := (_ : x ∈ univ) } ∈ univ)) x_1) x_1 =
    ↑↑(↑sign ((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝)) *
      ∏ y : o, ∏ x : n, blockDiagonal M (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha✝) (x, y)) (x, y)
[PROOFSTEP]
simp only [sign_prodCongrLeft, Units.coe_prod, Int.cast_prod, blockDiagonal_apply_eq, prodCongrLeft_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (a₁ a₂ : (k : o) → k ∈ univ → Perm n) (ha₁ : a₁ ∈ univ) (ha₂ : a₂ ∈ univ),
    (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a₁ ha₁ =
        (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a₂ ha₂ →
      a₁ = a₂
[PROOFSTEP]
intro σ σ' _ _ eq
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ σ' : (k : o) → k ∈ univ → Perm n
ha₁✝ : σ ∈ univ
ha₂✝ : σ' ∈ univ
eq :
  (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha₁✝ =
    (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ' ha₂✝
⊢ σ = σ'
[PROOFSTEP]
ext x hx k
[GOAL]
case h.h.H
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ σ' : (k : o) → k ∈ univ → Perm n
ha₁✝ : σ ∈ univ
ha₂✝ : σ' ∈ univ
eq :
  (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ ha₁✝ =
    (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) σ' ha₂✝
x : o
hx : x ∈ univ
k : n
⊢ ↑(σ x hx) k = ↑(σ' x hx) k
[PROOFSTEP]
simp only at eq 
[GOAL]
case h.h.H
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ σ' : (k : o) → k ∈ univ → Perm n
ha₁✝ : σ ∈ univ
ha₂✝ : σ' ∈ univ
eq : (prodCongrLeft fun k => σ k (_ : k ∈ univ)) = prodCongrLeft fun k => σ' k (_ : k ∈ univ)
x : o
hx : x ∈ univ
k : n
⊢ ↑(σ x hx) k = ↑(σ' x hx) k
[PROOFSTEP]
have :
  ∀ k x,
    prodCongrLeft (fun k => σ k (Finset.mem_univ _)) (k, x) =
      prodCongrLeft (fun k => σ' k (Finset.mem_univ _)) (k, x) :=
  fun k x => by rw [eq]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ σ' : (k : o) → k ∈ univ → Perm n
ha₁✝ : σ ∈ univ
ha₂✝ : σ' ∈ univ
eq : (prodCongrLeft fun k => σ k (_ : k ∈ univ)) = prodCongrLeft fun k => σ' k (_ : k ∈ univ)
x✝ : o
hx : x✝ ∈ univ
k✝ k : n
x : o
⊢ ↑(prodCongrLeft fun k => σ k (_ : k ∈ univ)) (k, x) = ↑(prodCongrLeft fun k => σ' k (_ : k ∈ univ)) (k, x)
[PROOFSTEP]
rw [eq]
[GOAL]
case h.h.H
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ σ' : (k : o) → k ∈ univ → Perm n
ha₁✝ : σ ∈ univ
ha₂✝ : σ' ∈ univ
eq : (prodCongrLeft fun k => σ k (_ : k ∈ univ)) = prodCongrLeft fun k => σ' k (_ : k ∈ univ)
x : o
hx : x ∈ univ
k : n
this :
  ∀ (k : n) (x : o),
    ↑(prodCongrLeft fun k => σ k (_ : k ∈ univ)) (k, x) = ↑(prodCongrLeft fun k => σ' k (_ : k ∈ univ)) (k, x)
⊢ ↑(σ x hx) k = ↑(σ' x hx) k
[PROOFSTEP]
simp only [prodCongrLeft_apply, Prod.mk.inj_iff] at this 
[GOAL]
case h.h.H
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ σ' : (k : o) → k ∈ univ → Perm n
ha₁✝ : σ ∈ univ
ha₂✝ : σ' ∈ univ
eq : (prodCongrLeft fun k => σ k (_ : k ∈ univ)) = prodCongrLeft fun k => σ' k (_ : k ∈ univ)
x : o
hx : x ∈ univ
k : n
this : ∀ (k : n) (x : o), ↑(σ x (_ : x ∈ univ)) k = ↑(σ' x (_ : x ∈ univ)) k ∧ True
⊢ ↑(σ x hx) k = ↑(σ' x hx) k
[PROOFSTEP]
exact (this k x).1
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (b : n × o ≃ n × o), b ∈ preserving_snd → ∃ a ha, b = (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha
[PROOFSTEP]
intro σ hσ
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : σ ∈ preserving_snd
⊢ ∃ a ha, σ = (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha
[PROOFSTEP]
rw [mem_preserving_snd] at hσ 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∃ a ha, σ = (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha
[PROOFSTEP]
have hσ' : ∀ x, (σ⁻¹ x).snd = x.snd := by
  intro x
  conv_rhs => rw [← Perm.apply_inv_self σ x, hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
[PROOFSTEP]
intro x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
x : n × o
⊢ (↑σ⁻¹ x).snd = x.snd
[PROOFSTEP]
conv_rhs => rw [← Perm.apply_inv_self σ x, hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
x : n × o
| x.snd
[PROOFSTEP]
rw [← Perm.apply_inv_self σ x, hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
x : n × o
| x.snd
[PROOFSTEP]
rw [← Perm.apply_inv_self σ x, hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
x : n × o
| x.snd
[PROOFSTEP]
rw [← Perm.apply_inv_self σ x, hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
⊢ ∃ a ha, σ = (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha
[PROOFSTEP]
have mk_apply_eq : ∀ k x, ((σ (x, k)).fst, k) = σ (x, k) :=
  by
  intro k x
  ext
  · simp only
  · simp only [hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
⊢ ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
[PROOFSTEP]
intro k x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
k : o
x : n
⊢ ((↑σ (x, k)).fst, k) = ↑σ (x, k)
[PROOFSTEP]
ext
[GOAL]
case h₁
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
k : o
x : n
⊢ ((↑σ (x, k)).fst, k).fst = (↑σ (x, k)).fst
[PROOFSTEP]
simp only
[GOAL]
case h₂
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
k : o
x : n
⊢ ((↑σ (x, k)).fst, k).snd = (↑σ (x, k)).snd
[PROOFSTEP]
simp only [hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
⊢ ∃ a ha, σ = (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha
[PROOFSTEP]
have mk_inv_apply_eq : ∀ k x, ((σ⁻¹ (x, k)).fst, k) = σ⁻¹ (x, k) :=
  by
  intro k x
  conv_lhs => rw [← Perm.apply_inv_self σ (x, k)]
  ext
  · simp only [apply_inv_self]
  · simp only [hσ']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
⊢ ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
[PROOFSTEP]
intro k x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
⊢ ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
[PROOFSTEP]
conv_lhs => rw [← Perm.apply_inv_self σ (x, k)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
| ((↑σ⁻¹ (x, k)).fst, k)
[PROOFSTEP]
rw [← Perm.apply_inv_self σ (x, k)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
| ((↑σ⁻¹ (x, k)).fst, k)
[PROOFSTEP]
rw [← Perm.apply_inv_self σ (x, k)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
| ((↑σ⁻¹ (x, k)).fst, k)
[PROOFSTEP]
rw [← Perm.apply_inv_self σ (x, k)]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
⊢ ((↑σ⁻¹ (↑σ (↑σ⁻¹ (x, k)))).fst, k) = ↑σ⁻¹ (x, k)
[PROOFSTEP]
ext
[GOAL]
case h₁
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
⊢ ((↑σ⁻¹ (↑σ (↑σ⁻¹ (x, k)))).fst, k).fst = (↑σ⁻¹ (x, k)).fst
[PROOFSTEP]
simp only [apply_inv_self]
[GOAL]
case h₂
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
k : o
x : n
⊢ ((↑σ⁻¹ (↑σ (↑σ⁻¹ (x, k)))).fst, k).snd = (↑σ⁻¹ (x, k)).snd
[PROOFSTEP]
simp only [hσ']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
⊢ ∃ a ha, σ = (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ)) a ha
[PROOFSTEP]
refine' ⟨fun k _ => ⟨fun x => (σ (x, k)).fst, fun x => (σ⁻¹ (x, k)).fst, _, _⟩, _, _⟩
[GOAL]
case refine'_1
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
k : o
x✝ : k ∈ univ
⊢ LeftInverse (fun x => (↑σ⁻¹ (x, k)).fst) fun x => (↑σ (x, k)).fst
[PROOFSTEP]
intro x
[GOAL]
case refine'_1
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
k : o
x✝ : k ∈ univ
x : n
⊢ (fun x => (↑σ⁻¹ (x, k)).fst) ((fun x => (↑σ (x, k)).fst) x) = x
[PROOFSTEP]
simp only [mk_apply_eq, inv_apply_self]
[GOAL]
case refine'_2
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
k : o
x✝ : k ∈ univ
⊢ Function.RightInverse (fun x => (↑σ⁻¹ (x, k)).fst) fun x => (↑σ (x, k)).fst
[PROOFSTEP]
intro x
[GOAL]
case refine'_2
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
k : o
x✝ : k ∈ univ
x : n
⊢ (fun x => (↑σ (x, k)).fst) ((fun x => (↑σ⁻¹ (x, k)).fst) x) = x
[PROOFSTEP]
simp only [mk_inv_apply_eq, apply_inv_self]
[GOAL]
case refine'_3
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
⊢ (fun k x =>
      { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
        left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
        right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) }) ∈
    univ
[PROOFSTEP]
apply Finset.mem_univ
[GOAL]
case refine'_4
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
⊢ σ =
    (fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ))
      (fun k x =>
        { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
          left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
          right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) })
      (_ :
        (fun k x =>
            { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
              left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
              right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) }) ∈
          univ)
[PROOFSTEP]
ext ⟨k, x⟩
[GOAL]
case refine'_4.H.mk.h₁
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
k : n
x : o
⊢ (↑σ (k, x)).fst =
    (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ))
            (fun k x =>
              { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
                left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
                right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) })
            (_ :
              (fun k x =>
                  { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
                    left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
                    right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) }) ∈
                univ))
        (k, x)).fst
[PROOFSTEP]
simp only [coe_fn_mk, prodCongrLeft_apply]
[GOAL]
case refine'_4.H.mk.h₂
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : n × o ≃ n × o
hσ : ∀ (x : n × o), (↑σ x).snd = x.snd
hσ' : ∀ (x : n × o), (↑σ⁻¹ x).snd = x.snd
mk_apply_eq : ∀ (k : o) (x : n), ((↑σ (x, k)).fst, k) = ↑σ (x, k)
mk_inv_apply_eq : ∀ (k : o) (x : n), ((↑σ⁻¹ (x, k)).fst, k) = ↑σ⁻¹ (x, k)
k : n
x : o
⊢ (↑σ (k, x)).snd =
    (↑((fun σ x => prodCongrLeft fun k => σ k (_ : k ∈ univ))
            (fun k x =>
              { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
                left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
                right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) })
            (_ :
              (fun k x =>
                  { toFun := fun x => (↑σ (x, k)).fst, invFun := fun x => (↑σ⁻¹ (x, k)).fst,
                    left_inv := (_ : ∀ (x : n), (↑σ⁻¹ ((↑σ (x, k)).fst, k)).fst = x),
                    right_inv := (_ : ∀ (x : n), (↑σ ((↑σ⁻¹ (x, k)).fst, k)).fst = x) }) ∈
                univ))
        (k, x)).snd
[PROOFSTEP]
simp only [prodCongrLeft_apply, hσ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ∀ (x : Perm (n × o)), x ∈ univ → ¬x ∈ preserving_snd → ↑↑(↑sign x) * ∏ x_1 : n × o, blockDiagonal M (↑x x_1) x_1 = 0
[PROOFSTEP]
intro σ _ hσ
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : Perm (n × o)
a✝ : σ ∈ univ
hσ : ¬σ ∈ preserving_snd
⊢ ↑↑(↑sign σ) * ∏ x : n × o, blockDiagonal M (↑σ x) x = 0
[PROOFSTEP]
rw [mem_preserving_snd] at hσ 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : Perm (n × o)
a✝ : σ ∈ univ
hσ : ¬∀ (x : n × o), (↑σ x).snd = x.snd
⊢ ↑↑(↑sign σ) * ∏ x : n × o, blockDiagonal M (↑σ x) x = 0
[PROOFSTEP]
obtain ⟨⟨k, x⟩, hkx⟩ := not_forall.mp hσ
[GOAL]
case intro.mk
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : Perm (n × o)
a✝ : σ ∈ univ
hσ : ¬∀ (x : n × o), (↑σ x).snd = x.snd
k : n
x : o
hkx : ¬(↑σ (k, x)).snd = (k, x).snd
⊢ ↑↑(↑sign σ) * ∏ x : n × o, blockDiagonal M (↑σ x) x = 0
[PROOFSTEP]
rw [Finset.prod_eq_zero (Finset.mem_univ (k, x)), mul_zero]
[GOAL]
case intro.mk
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : Perm (n × o)
a✝ : σ ∈ univ
hσ : ¬∀ (x : n × o), (↑σ x).snd = x.snd
k : n
x : o
hkx : ¬(↑σ (k, x)).snd = (k, x).snd
⊢ blockDiagonal M (↑σ (k, x)) (k, x) = 0
[PROOFSTEP]
rw [← @Prod.mk.eta _ _ (σ (k, x)), blockDiagonal_apply_ne]
[GOAL]
case intro.mk.h
m : Type u_1
n : Type u_2
inst✝⁶ : DecidableEq n
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
R : Type v
inst✝² : CommRing R
o : Type u_3
inst✝¹ : Fintype o
inst✝ : DecidableEq o
M : o → Matrix n n R
preserving_snd : Finset (Perm (n × o)) := filter (fun σ => ∀ (x : n × o), (↑σ x).snd = x.snd) univ
mem_preserving_snd : ∀ {σ : Perm (n × o)}, σ ∈ preserving_snd ↔ ∀ (x : n × o), (↑σ x).snd = x.snd
σ : Perm (n × o)
a✝ : σ ∈ univ
hσ : ¬∀ (x : n × o), (↑σ x).snd = x.snd
k : n
x : o
hkx : ¬(↑σ (k, x)).snd = (k, x).snd
⊢ (↑σ (k, x)).snd ≠ x
[PROOFSTEP]
exact hkx
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ det (fromBlocks A B 0 D) = det A * det D
[PROOFSTEP]
classical
simp_rw [det_apply']
convert Eq.symm <| sum_subset (β := R) (subset_univ ((sumCongrHom m n).range : Set (Perm (Sum m n))).toFinset) ?_
rw [sum_mul_sum]
simp_rw [univ_product_univ]
rw [(sum_bij (fun (σ : Perm m × Perm n) _ => Equiv.sumCongr σ.fst σ.snd) _ _ _ _).symm]
· intro σ₁₂ h
  simp only
  erw [Set.mem_toFinset, MonoidHom.mem_range]
  use σ₁₂
  simp only [sumCongrHom_apply]
· simp only [forall_prop_of_true, Prod.forall, mem_univ]
  intro σ₁ σ₂
  rw [Fintype.prod_sum_type]
  simp_rw [Equiv.sumCongr_apply, Sum.map_inr, Sum.map_inl, fromBlocks_apply₁₁, fromBlocks_apply₂₂]
  rw [mul_mul_mul_comm]
  congr
  rw [sign_sumCongr, Units.val_mul, Int.cast_mul]
· intro σ₁ σ₂ h₁ h₂
  dsimp only
  intro h
  have h2 : ∀ x, Perm.sumCongr σ₁.fst σ₁.snd x = Perm.sumCongr σ₂.fst σ₂.snd x :=
    by
    intro x
    exact congr_fun (congr_arg toFun h) x
  simp only [Sum.map_inr, Sum.map_inl, Perm.sumCongr_apply, Sum.forall, Sum.inl.injEq, Sum.inr.injEq] at h2 
  ext x
  · exact h2.left x
  · exact h2.right x
· intro σ hσ
  erw [Set.mem_toFinset, MonoidHom.mem_range] at hσ 
  obtain ⟨σ₁₂, hσ₁₂⟩ := hσ
  use σ₁₂
  rw [← hσ₁₂]
  simp
· rintro σ - hσn
  have h1 : ¬∀ x, ∃ y, Sum.inl y = σ (Sum.inl x) :=
    by
    rw [Set.mem_toFinset] at hσn 
    simpa only [Set.MapsTo, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] using
      mt mem_sumCongrHom_range_of_perm_mapsTo_inl hσn
  obtain ⟨a, ha⟩ := not_forall.mp h1
  cases' hx : σ (Sum.inl a) with a2 b
  · have hn := (not_exists.mp ha) a2
    exact absurd hx.symm hn
  · rw [Finset.prod_eq_zero (Finset.mem_univ (Sum.inl a)), mul_zero]
    rw [hx, fromBlocks_apply₂₁, zero_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ det (fromBlocks A B 0 D) = det A * det D
[PROOFSTEP]
simp_rw [det_apply']
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∑ x : Perm (m ⊕ n), ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1 =
    (∑ x : Perm m, ↑↑(↑sign x) * ∏ x_1 : m, A (↑x x_1) x_1) * ∑ x : Perm n, ↑↑(↑sign x) * ∏ x_1 : n, D (↑x x_1) x_1
[PROOFSTEP]
convert Eq.symm <| sum_subset (β := R) (subset_univ ((sumCongrHom m n).range : Set (Perm (Sum m n))).toFinset) ?_
[GOAL]
case h.e'_3
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ (∑ x : Perm m, ↑↑(↑sign x) * ∏ x_1 : m, A (↑x x_1) x_1) * ∑ x : Perm n, ↑↑(↑sign x) * ∏ x_1 : n, D (↑x x_1) x_1 =
    ∑ x in Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)),
      ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1
case convert_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (x : Perm (m ⊕ n)),
    x ∈ univ →
      ¬x ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)) →
        ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1 = 0
[PROOFSTEP]
rw [sum_mul_sum]
[GOAL]
case h.e'_3
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∑ p in univ ×ˢ univ, (↑↑(↑sign p.fst) * ∏ x : m, A (↑p.fst x) x) * (↑↑(↑sign p.snd) * ∏ x : n, D (↑p.snd x) x) =
    ∑ x in Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)),
      ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1
case convert_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (x : Perm (m ⊕ n)),
    x ∈ univ →
      ¬x ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)) →
        ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1 = 0
[PROOFSTEP]
simp_rw [univ_product_univ]
[GOAL]
case h.e'_3
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∑ p : Perm m × Perm n, (↑↑(↑sign p.fst) * ∏ x : m, A (↑p.fst x) x) * (↑↑(↑sign p.snd) * ∏ x : n, D (↑p.snd x) x) =
    ∑ x in Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)),
      ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1
case convert_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (x : Perm (m ⊕ n)),
    x ∈ univ →
      ¬x ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)) →
        ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1 = 0
[PROOFSTEP]
rw [(sum_bij (fun (σ : Perm m × Perm n) _ => Equiv.sumCongr σ.fst σ.snd) _ _ _ _).symm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (a : Perm m × Perm n) (ha : a ∈ univ),
    (fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
[PROOFSTEP]
intro σ₁₂ h
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁₂ : Perm m × Perm n
h : σ₁₂ ∈ univ
⊢ (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₁₂ h ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
[PROOFSTEP]
simp only
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁₂ : Perm m × Perm n
h : σ₁₂ ∈ univ
⊢ Equiv.sumCongr σ₁₂.fst σ₁₂.snd ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
[PROOFSTEP]
erw [Set.mem_toFinset, MonoidHom.mem_range]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁₂ : Perm m × Perm n
h : σ₁₂ ∈ univ
⊢ ∃ x, ↑(sumCongrHom m n) x = Equiv.sumCongr σ₁₂.fst σ₁₂.snd
[PROOFSTEP]
use σ₁₂
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁₂ : Perm m × Perm n
h : σ₁₂ ∈ univ
⊢ ↑(sumCongrHom m n) σ₁₂ = Equiv.sumCongr σ₁₂.fst σ₁₂.snd
[PROOFSTEP]
simp only [sumCongrHom_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (a : Perm m × Perm n) (ha : a ∈ univ),
    (↑↑(↑sign a.fst) * ∏ x : m, A (↑a.fst x) x) * (↑↑(↑sign a.snd) * ∏ x : n, D (↑a.snd x) x) =
      ↑↑(↑sign ((fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha)) *
        ∏ x : m ⊕ n, fromBlocks A B 0 D (↑((fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha) x) x
[PROOFSTEP]
simp only [forall_prop_of_true, Prod.forall, mem_univ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (a : Perm m) (b : Perm n),
    (↑↑(↑sign a) * ∏ x : m, A (↑a x) x) * (↑↑(↑sign b) * ∏ x : n, D (↑b x) x) =
      ↑↑(↑sign (Equiv.sumCongr a b)) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑(Equiv.sumCongr a b) x) x
[PROOFSTEP]
intro σ₁ σ₂
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ : Perm m
σ₂ : Perm n
⊢ (↑↑(↑sign σ₁) * ∏ x : m, A (↑σ₁ x) x) * (↑↑(↑sign σ₂) * ∏ x : n, D (↑σ₂ x) x) =
    ↑↑(↑sign (Equiv.sumCongr σ₁ σ₂)) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑(Equiv.sumCongr σ₁ σ₂) x) x
[PROOFSTEP]
rw [Fintype.prod_sum_type]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ : Perm m
σ₂ : Perm n
⊢ (↑↑(↑sign σ₁) * ∏ x : m, A (↑σ₁ x) x) * (↑↑(↑sign σ₂) * ∏ x : n, D (↑σ₂ x) x) =
    ↑↑(↑sign (Equiv.sumCongr σ₁ σ₂)) *
      ((∏ a₁ : m, fromBlocks A B 0 D (↑(Equiv.sumCongr σ₁ σ₂) (Sum.inl a₁)) (Sum.inl a₁)) *
        ∏ a₂ : n, fromBlocks A B 0 D (↑(Equiv.sumCongr σ₁ σ₂) (Sum.inr a₂)) (Sum.inr a₂))
[PROOFSTEP]
simp_rw [Equiv.sumCongr_apply, Sum.map_inr, Sum.map_inl, fromBlocks_apply₁₁, fromBlocks_apply₂₂]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ : Perm m
σ₂ : Perm n
⊢ (↑↑(↑sign σ₁) * ∏ x : m, A (↑σ₁ x) x) * (↑↑(↑sign σ₂) * ∏ x : n, D (↑σ₂ x) x) =
    ↑↑(↑sign (Equiv.sumCongr σ₁ σ₂)) * ((∏ x : m, A (↑σ₁ x) x) * ∏ x : n, D (↑σ₂ x) x)
[PROOFSTEP]
rw [mul_mul_mul_comm]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ : Perm m
σ₂ : Perm n
⊢ ↑↑(↑sign σ₁) * ↑↑(↑sign σ₂) * ((∏ x : m, A (↑σ₁ x) x) * ∏ x : n, D (↑σ₂ x) x) =
    ↑↑(↑sign (Equiv.sumCongr σ₁ σ₂)) * ((∏ x : m, A (↑σ₁ x) x) * ∏ x : n, D (↑σ₂ x) x)
[PROOFSTEP]
congr
[GOAL]
case e_a
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ : Perm m
σ₂ : Perm n
⊢ ↑↑(↑sign σ₁) * ↑↑(↑sign σ₂) = ↑↑(↑sign (Equiv.sumCongr σ₁ σ₂))
[PROOFSTEP]
rw [sign_sumCongr, Units.val_mul, Int.cast_mul]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (a₁ a₂ : Perm m × Perm n) (ha₁ : a₁ ∈ univ) (ha₂ : a₂ ∈ univ),
    (fun σ x => Equiv.sumCongr σ.fst σ.snd) a₁ ha₁ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) a₂ ha₂ → a₁ = a₂
[PROOFSTEP]
intro σ₁ σ₂ h₁ h₂
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
⊢ (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₁ h₁ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₂ h₂ → σ₁ = σ₂
[PROOFSTEP]
dsimp only
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
⊢ Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd → σ₁ = σ₂
[PROOFSTEP]
intro h
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
⊢ σ₁ = σ₂
[PROOFSTEP]
have h2 : ∀ x, Perm.sumCongr σ₁.fst σ₁.snd x = Perm.sumCongr σ₂.fst σ₂.snd x :=
  by
  intro x
  exact congr_fun (congr_arg toFun h) x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
⊢ ∀ (x : m ⊕ n), ↑(Perm.sumCongr σ₁.fst σ₁.snd) x = ↑(Perm.sumCongr σ₂.fst σ₂.snd) x
[PROOFSTEP]
intro x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
x : m ⊕ n
⊢ ↑(Perm.sumCongr σ₁.fst σ₁.snd) x = ↑(Perm.sumCongr σ₂.fst σ₂.snd) x
[PROOFSTEP]
exact congr_fun (congr_arg toFun h) x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
h2 : ∀ (x : m ⊕ n), ↑(Perm.sumCongr σ₁.fst σ₁.snd) x = ↑(Perm.sumCongr σ₂.fst σ₂.snd) x
⊢ σ₁ = σ₂
[PROOFSTEP]
simp only [Sum.map_inr, Sum.map_inl, Perm.sumCongr_apply, Sum.forall, Sum.inl.injEq, Sum.inr.injEq] at h2 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
h2 : (∀ (a : m), ↑σ₁.fst a = ↑σ₂.fst a) ∧ ∀ (b : n), ↑σ₁.snd b = ↑σ₂.snd b
⊢ σ₁ = σ₂
[PROOFSTEP]
ext x
[GOAL]
case h₁.H
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
h2 : (∀ (a : m), ↑σ₁.fst a = ↑σ₂.fst a) ∧ ∀ (b : n), ↑σ₁.snd b = ↑σ₂.snd b
x : m
⊢ ↑σ₁.fst x = ↑σ₂.fst x
[PROOFSTEP]
exact h2.left x
[GOAL]
case h₂.H
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ₁ σ₂ : Perm m × Perm n
h₁ : σ₁ ∈ univ
h₂ : σ₂ ∈ univ
h : Equiv.sumCongr σ₁.fst σ₁.snd = Equiv.sumCongr σ₂.fst σ₂.snd
h2 : (∀ (a : m), ↑σ₁.fst a = ↑σ₂.fst a) ∧ ∀ (b : n), ↑σ₁.snd b = ↑σ₂.snd b
x : n
⊢ ↑σ₁.snd x = ↑σ₂.snd x
[PROOFSTEP]
exact h2.right x
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (b : m ⊕ n ≃ m ⊕ n),
    b ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)) → ∃ a ha, b = (fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha
[PROOFSTEP]
intro σ hσ
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : m ⊕ n ≃ m ⊕ n
hσ : σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
⊢ ∃ a ha, σ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha
[PROOFSTEP]
erw [Set.mem_toFinset, MonoidHom.mem_range] at hσ 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : m ⊕ n ≃ m ⊕ n
hσ : ∃ x, ↑(sumCongrHom m n) x = σ
⊢ ∃ a ha, σ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha
[PROOFSTEP]
obtain ⟨σ₁₂, hσ₁₂⟩ := hσ
[GOAL]
case intro
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : m ⊕ n ≃ m ⊕ n
σ₁₂ : Perm m × Perm n
hσ₁₂ : ↑(sumCongrHom m n) σ₁₂ = σ
⊢ ∃ a ha, σ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) a ha
[PROOFSTEP]
use σ₁₂
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : m ⊕ n ≃ m ⊕ n
σ₁₂ : Perm m × Perm n
hσ₁₂ : ↑(sumCongrHom m n) σ₁₂ = σ
⊢ ∃ ha, σ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₁₂ ha
[PROOFSTEP]
rw [← hσ₁₂]
[GOAL]
case h
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : m ⊕ n ≃ m ⊕ n
σ₁₂ : Perm m × Perm n
hσ₁₂ : ↑(sumCongrHom m n) σ₁₂ = σ
⊢ ∃ ha, ↑(sumCongrHom m n) σ₁₂ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₁₂ ha
[PROOFSTEP]
simp
[GOAL]
case convert_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
⊢ ∀ (x : Perm (m ⊕ n)),
    x ∈ univ →
      ¬x ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n)) →
        ↑↑(↑sign x) * ∏ x_1 : m ⊕ n, fromBlocks A B 0 D (↑x x_1) x_1 = 0
[PROOFSTEP]
rintro σ - hσn
[GOAL]
case convert_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
⊢ ↑↑(↑sign σ) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑σ x) x = 0
[PROOFSTEP]
have h1 : ¬∀ x, ∃ y, Sum.inl y = σ (Sum.inl x) :=
  by
  rw [Set.mem_toFinset] at hσn 
  simpa only [Set.MapsTo, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] using
    mt mem_sumCongrHom_range_of_perm_mapsTo_inl hσn
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
⊢ ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
[PROOFSTEP]
rw [Set.mem_toFinset] at hσn 
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ ↑(MonoidHom.range (sumCongrHom m n))
⊢ ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
[PROOFSTEP]
simpa only [Set.MapsTo, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] using
  mt mem_sumCongrHom_range_of_perm_mapsTo_inl hσn
[GOAL]
case convert_2
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
h1 : ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
⊢ ↑↑(↑sign σ) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑σ x) x = 0
[PROOFSTEP]
obtain ⟨a, ha⟩ := not_forall.mp h1
[GOAL]
case convert_2.intro
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
h1 : ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
a : m
ha : ¬∃ y, Sum.inl y = ↑σ (Sum.inl a)
⊢ ↑↑(↑sign σ) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑σ x) x = 0
[PROOFSTEP]
cases' hx : σ (Sum.inl a) with a2 b
[GOAL]
case convert_2.intro.inl
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
h1 : ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
a : m
ha : ¬∃ y, Sum.inl y = ↑σ (Sum.inl a)
a2 : m
hx : ↑σ (Sum.inl a) = Sum.inl a2
⊢ ↑↑(↑sign σ) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑σ x) x = 0
[PROOFSTEP]
have hn := (not_exists.mp ha) a2
[GOAL]
case convert_2.intro.inl
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
h1 : ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
a : m
ha : ¬∃ y, Sum.inl y = ↑σ (Sum.inl a)
a2 : m
hx : ↑σ (Sum.inl a) = Sum.inl a2
hn : ¬Sum.inl a2 = ↑σ (Sum.inl a)
⊢ ↑↑(↑sign σ) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑σ x) x = 0
[PROOFSTEP]
exact absurd hx.symm hn
[GOAL]
case convert_2.intro.inr
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
h1 : ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
a : m
ha : ¬∃ y, Sum.inl y = ↑σ (Sum.inl a)
b : n
hx : ↑σ (Sum.inl a) = Sum.inr b
⊢ ↑↑(↑sign σ) * ∏ x : m ⊕ n, fromBlocks A B 0 D (↑σ x) x = 0
[PROOFSTEP]
rw [Finset.prod_eq_zero (Finset.mem_univ (Sum.inl a)), mul_zero]
[GOAL]
case convert_2.intro.inr
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
B : Matrix m n R
D : Matrix n n R
σ : Perm (m ⊕ n)
hσn : ¬σ ∈ Set.toFinset ↑(MonoidHom.range (sumCongrHom m n))
h1 : ¬∀ (x : m), ∃ y, Sum.inl y = ↑σ (Sum.inl x)
a : m
ha : ¬∃ y, Sum.inl y = ↑σ (Sum.inl a)
b : n
hx : ↑σ (Sum.inl a) = Sum.inr b
⊢ fromBlocks A B 0 D (↑σ (Sum.inl a)) (Sum.inl a) = 0
[PROOFSTEP]
rw [hx, fromBlocks_apply₂₁, zero_apply]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix m m R
C : Matrix n m R
D : Matrix n n R
⊢ det (fromBlocks A 0 C D) = det A * det D
[PROOFSTEP]
rw [← det_transpose, fromBlocks_transpose, transpose_zero, det_fromBlocks_zero₂₁, det_transpose, det_transpose]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
⊢ det A = ∑ i : Fin (Nat.succ n), (-1) ^ ↑i * A i 0 * det (submatrix A (Fin.succAbove i) Fin.succ)
[PROOFSTEP]
rw [Matrix.det_apply, Finset.univ_perm_fin_succ, ← Finset.univ_product_univ]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
⊢ ∑ σ in Finset.map (Equiv.toEmbedding decomposeFin.symm) (univ ×ˢ univ), ↑sign σ • ∏ i : Fin (Nat.succ n), A (↑σ i) i =
    ∑ i : Fin (Nat.succ n), (-1) ^ ↑i * A i 0 * det (submatrix A (Fin.succAbove i) Fin.succ)
[PROOFSTEP]
simp only [Finset.sum_map, Equiv.toEmbedding_apply, Finset.sum_product, Matrix.submatrix]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
⊢ ∑ x : Fin (Nat.succ n),
      ∑ y : Perm (Fin n),
        ↑sign (↑decomposeFin.symm (x, y)) • ∏ x_1 : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (x, y)) x_1) x_1 =
    ∑ x : Fin (Nat.succ n), (-1) ^ ↑x * A x 0 * det (↑of fun i j => A (Fin.succAbove x i) (Fin.succ j))
[PROOFSTEP]
refine' Finset.sum_congr rfl fun i _ => Fin.cases _ (fun i => _) i
[GOAL]
case refine'_1
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
x✝ : i ∈ univ
⊢ ∑ y : Perm (Fin n), ↑sign (↑decomposeFin.symm (0, y)) • ∏ x : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (0, y)) x) x =
    (-1) ^ ↑0 * A 0 0 * det (↑of fun i j => A (Fin.succAbove 0 i) (Fin.succ j))
[PROOFSTEP]
simp only [Fin.prod_univ_succ, Matrix.det_apply, Finset.mul_sum, Equiv.Perm.decomposeFin_symm_apply_zero, Fin.val_zero,
  one_mul, Equiv.Perm.decomposeFin.symm_sign, Equiv.swap_self, if_true, id.def, eq_self_iff_true,
  Equiv.Perm.decomposeFin_symm_apply_succ, Fin.succAbove_zero, Equiv.coe_refl, pow_zero, mul_smul_comm, of_apply]
  -- `univ_perm_fin_succ` gives a different embedding of `Perm (Fin n)` into
    -- `Perm (Fin n.succ)` than the determinant of the submatrix we want,
    -- permute `A` so that we get the correct one.
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝ : i✝ ∈ univ
i : Fin n
⊢ ∑ y : Perm (Fin n),
      ↑sign (↑decomposeFin.symm (Fin.succ i, y)) •
        ∏ x : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (Fin.succ i, y)) x) x =
    (-1) ^ ↑(Fin.succ i) * A (Fin.succ i) 0 * det (↑of fun i_1 j => A (Fin.succAbove (Fin.succ i) i_1) (Fin.succ j))
[PROOFSTEP]
have : (-1 : R) ^ (i : ℕ) = (Perm.sign i.cycleRange) := by simp [Fin.sign_cycleRange]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝ : i✝ ∈ univ
i : Fin n
⊢ (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
[PROOFSTEP]
simp [Fin.sign_cycleRange]
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝ : i✝ ∈ univ
i : Fin n
this : (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
⊢ ∑ y : Perm (Fin n),
      ↑sign (↑decomposeFin.symm (Fin.succ i, y)) •
        ∏ x : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (Fin.succ i, y)) x) x =
    (-1) ^ ↑(Fin.succ i) * A (Fin.succ i) 0 * det (↑of fun i_1 j => A (Fin.succAbove (Fin.succ i) i_1) (Fin.succ j))
[PROOFSTEP]
rw [Fin.val_succ, pow_succ, this, mul_assoc, mul_assoc, mul_left_comm (ε _), ← det_permute, Matrix.det_apply,
  Finset.mul_sum, Finset.mul_sum]
  -- now we just need to move the corresponding parts to the same place
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝ : i✝ ∈ univ
i : Fin n
this : (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
⊢ ∑ y : Perm (Fin n),
      ↑sign (↑decomposeFin.symm (Fin.succ i, y)) •
        ∏ x : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (Fin.succ i, y)) x) x =
    ∑ x : Perm (Fin n),
      -1 *
        (A (Fin.succ i) 0 *
          ↑sign x •
            ∏ i_1 : Fin n,
              ↑of (fun i_2 j => A (Fin.succAbove (Fin.succ i) i_2) (Fin.succ j)) (↑(Fin.cycleRange i) (↑x i_1)) i_1)
[PROOFSTEP]
refine' Finset.sum_congr rfl fun σ _ => _
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝¹ : i✝ ∈ univ
i : Fin n
this : (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
σ : Perm (Fin n)
x✝ : σ ∈ univ
⊢ ↑sign (↑decomposeFin.symm (Fin.succ i, σ)) • ∏ x : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (Fin.succ i, σ)) x) x =
    -1 *
      (A (Fin.succ i) 0 *
        ↑sign σ •
          ∏ i_1 : Fin n,
            ↑of (fun i_2 j => A (Fin.succAbove (Fin.succ i) i_2) (Fin.succ j)) (↑(Fin.cycleRange i) (↑σ i_1)) i_1)
[PROOFSTEP]
rw [Equiv.Perm.decomposeFin.symm_sign, if_neg (Fin.succ_ne_zero i)]
[GOAL]
case refine'_2
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝¹ : i✝ ∈ univ
i : Fin n
this : (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
σ : Perm (Fin n)
x✝ : σ ∈ univ
⊢ (-1 * ↑sign σ) • ∏ x : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (Fin.succ i, σ)) x) x =
    -1 *
      (A (Fin.succ i) 0 *
        ↑sign σ •
          ∏ i_1 : Fin n,
            ↑of (fun i_2 j => A (Fin.succAbove (Fin.succ i) i_2) (Fin.succ j)) (↑(Fin.cycleRange i) (↑σ i_1)) i_1)
[PROOFSTEP]
calc
  ((-1 * Perm.sign σ : ℤ) • ∏ i', A (Perm.decomposeFin.symm (Fin.succ i, σ) i') i') =
      (-1 * Perm.sign σ : ℤ) •
        (A (Fin.succ i) 0 * ∏ i', A ((Fin.succ i).succAbove (Fin.cycleRange i (σ i'))) i'.succ) :=
    by
    simp only [Fin.prod_univ_succ, Fin.succAbove_cycleRange, Equiv.Perm.decomposeFin_symm_apply_zero,
      Equiv.Perm.decomposeFin_symm_apply_succ]
  _ =
      -1 *
        (A (Fin.succ i) 0 * (Perm.sign σ : ℤ) • ∏ i', A ((Fin.succ i).succAbove (Fin.cycleRange i (σ i'))) i'.succ) :=
    by
    simp [mul_assoc, mul_comm, _root_.neg_mul, one_mul, zsmul_eq_mul, neg_inj, neg_smul, Fin.succAbove_cycleRange,
      mul_left_comm]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝¹ : i✝ ∈ univ
i : Fin n
this : (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
σ : Perm (Fin n)
x✝ : σ ∈ univ
⊢ (-1 * ↑(↑sign σ)) • ∏ i' : Fin (Nat.succ n), A (↑(↑decomposeFin.symm (Fin.succ i, σ)) i') i' =
    (-1 * ↑(↑sign σ)) •
      (A (Fin.succ i) 0 * ∏ i' : Fin n, A (Fin.succAbove (Fin.succ i) (↑(Fin.cycleRange i) (↑σ i'))) (Fin.succ i'))
[PROOFSTEP]
simp only [Fin.prod_univ_succ, Fin.succAbove_cycleRange, Equiv.Perm.decomposeFin_symm_apply_zero,
  Equiv.Perm.decomposeFin_symm_apply_succ]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i✝ : Fin (Nat.succ n)
x✝¹ : i✝ ∈ univ
i : Fin n
this : (-1) ^ ↑i = ↑↑(↑sign (Fin.cycleRange i))
σ : Perm (Fin n)
x✝ : σ ∈ univ
⊢ (-1 * ↑(↑sign σ)) •
      (A (Fin.succ i) 0 * ∏ i' : Fin n, A (Fin.succAbove (Fin.succ i) (↑(Fin.cycleRange i) (↑σ i'))) (Fin.succ i')) =
    -1 *
      (A (Fin.succ i) 0 *
        ↑(↑sign σ) • ∏ i' : Fin n, A (Fin.succAbove (Fin.succ i) (↑(Fin.cycleRange i) (↑σ i'))) (Fin.succ i'))
[PROOFSTEP]
simp [mul_assoc, mul_comm, _root_.neg_mul, one_mul, zsmul_eq_mul, neg_inj, neg_smul, Fin.succAbove_cycleRange,
  mul_left_comm]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
⊢ det A = ∑ j : Fin (Nat.succ n), (-1) ^ ↑j * A 0 j * det (submatrix A Fin.succ (Fin.succAbove j))
[PROOFSTEP]
rw [← det_transpose A, det_succ_column_zero]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
⊢ ∑ i : Fin (Nat.succ n), (-1) ^ ↑i * Aᵀ i 0 * det (submatrix Aᵀ (Fin.succAbove i) Fin.succ) =
    ∑ j : Fin (Nat.succ n), (-1) ^ ↑j * A 0 j * det (submatrix A Fin.succ (Fin.succAbove j))
[PROOFSTEP]
refine' Finset.sum_congr rfl fun i _ => _
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
x✝ : i ∈ univ
⊢ (-1) ^ ↑i * Aᵀ i 0 * det (submatrix Aᵀ (Fin.succAbove i) Fin.succ) =
    (-1) ^ ↑i * A 0 i * det (submatrix A Fin.succ (Fin.succAbove i))
[PROOFSTEP]
rw [← det_transpose]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
x✝ : i ∈ univ
⊢ (-1) ^ ↑i * Aᵀ i 0 * det (submatrix Aᵀ (Fin.succAbove i) Fin.succ)ᵀ =
    (-1) ^ ↑i * A 0 i * det (submatrix A Fin.succ (Fin.succAbove i))
[PROOFSTEP]
simp only [transpose_apply, transpose_submatrix, transpose_transpose]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
⊢ det A = ∑ j : Fin (Nat.succ n), (-1) ^ (↑i + ↑j) * A i j * det (submatrix A (Fin.succAbove i) (Fin.succAbove j))
[PROOFSTEP]
simp_rw [pow_add, mul_assoc, ← mul_sum]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
⊢ det A =
    (-1) ^ ↑i * ∑ x : Fin (Nat.succ n), (-1) ^ ↑x * (A i x * det (submatrix A (Fin.succAbove i) (Fin.succAbove x)))
[PROOFSTEP]
have : det A = (-1 : R) ^ (i : ℕ) * (Perm.sign i.cycleRange⁻¹) * det A := by
  calc
    det A = ↑((-1 : ℤˣ) ^ (i : ℕ) * (-1 : ℤˣ) ^ (i : ℕ) : ℤˣ) * det A := by simp
    _ = (-1 : R) ^ (i : ℕ) * (Perm.sign i.cycleRange⁻¹) * det A := by simp [-Int.units_mul_self]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
⊢ det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
[PROOFSTEP]
calc
  det A = ↑((-1 : ℤˣ) ^ (i : ℕ) * (-1 : ℤˣ) ^ (i : ℕ) : ℤˣ) * det A := by simp
  _ = (-1 : R) ^ (i : ℕ) * (Perm.sign i.cycleRange⁻¹) * det A := by simp [-Int.units_mul_self]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
⊢ det A = ↑↑((-1) ^ ↑i * (-1) ^ ↑i) * det A
[PROOFSTEP]
simp
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
⊢ ↑↑((-1) ^ ↑i * (-1) ^ ↑i) * det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
[PROOFSTEP]
simp [-Int.units_mul_self]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
⊢ det A =
    (-1) ^ ↑i * ∑ x : Fin (Nat.succ n), (-1) ^ ↑x * (A i x * det (submatrix A (Fin.succAbove i) (Fin.succAbove x)))
[PROOFSTEP]
rw [this, mul_assoc]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
⊢ (-1) ^ ↑i * (↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A) =
    (-1) ^ ↑i * ∑ x : Fin (Nat.succ n), (-1) ^ ↑x * (A i x * det (submatrix A (Fin.succAbove i) (Fin.succAbove x)))
[PROOFSTEP]
congr
[GOAL]
case e_a
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
⊢ ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A =
    ∑ x : Fin (Nat.succ n), (-1) ^ ↑x * (A i x * det (submatrix A (Fin.succAbove i) (Fin.succAbove x)))
[PROOFSTEP]
rw [← det_permute, det_succ_row_zero]
[GOAL]
case e_a
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
⊢ ∑ j : Fin (Nat.succ n),
      (-1) ^ ↑j * A (↑(Fin.cycleRange i)⁻¹ 0) j *
        det (submatrix (fun i_1 => A (↑(Fin.cycleRange i)⁻¹ i_1)) Fin.succ (Fin.succAbove j)) =
    ∑ x : Fin (Nat.succ n), (-1) ^ ↑x * (A i x * det (submatrix A (Fin.succAbove i) (Fin.succAbove x)))
[PROOFSTEP]
refine' Finset.sum_congr rfl fun j _ => _
[GOAL]
case e_a
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
j : Fin (Nat.succ n)
x✝ : j ∈ univ
⊢ (-1) ^ ↑j * A (↑(Fin.cycleRange i)⁻¹ 0) j *
      det (submatrix (fun i_1 => A (↑(Fin.cycleRange i)⁻¹ i_1)) Fin.succ (Fin.succAbove j)) =
    (-1) ^ ↑j * (A i j * det (submatrix A (Fin.succAbove i) (Fin.succAbove j)))
[PROOFSTEP]
rw [mul_assoc, Matrix.submatrix, Matrix.submatrix]
[GOAL]
case e_a
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
j : Fin (Nat.succ n)
x✝ : j ∈ univ
⊢ (-1) ^ ↑j *
      (A (↑(Fin.cycleRange i)⁻¹ 0) j *
        det (↑of fun i_1 j_1 => A (↑(Fin.cycleRange i)⁻¹ (Fin.succ i_1)) (Fin.succAbove j j_1))) =
    (-1) ^ ↑j * (A i j * det (↑of fun i_1 j_1 => A (Fin.succAbove i i_1) (Fin.succAbove j j_1)))
[PROOFSTEP]
congr
[GOAL]
case e_a.e_a.e_a.e_a
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
j : Fin (Nat.succ n)
x✝ : j ∈ univ
⊢ ↑(Fin.cycleRange i)⁻¹ 0 = i
[PROOFSTEP]
rw [Equiv.Perm.inv_def, Fin.cycleRange_symm_zero]
[GOAL]
case e_a.e_a.e_a.e_M.h.e_6.h
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
j : Fin (Nat.succ n)
x✝ : j ∈ univ
⊢ (fun i_1 j_1 => A (↑(Fin.cycleRange i)⁻¹ (Fin.succ i_1)) (Fin.succAbove j j_1)) = fun i_1 j_1 =>
    A (Fin.succAbove i i_1) (Fin.succAbove j j_1)
[PROOFSTEP]
ext i' j'
[GOAL]
case e_a.e_a.e_a.e_M.h.e_6.h.h.h
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
i : Fin (Nat.succ n)
this : det A = (-1) ^ ↑i * ↑↑(↑sign (Fin.cycleRange i)⁻¹) * det A
j : Fin (Nat.succ n)
x✝ : j ∈ univ
i' j' : Fin n
⊢ A (↑(Fin.cycleRange i)⁻¹ (Fin.succ i')) (Fin.succAbove j j') = A (Fin.succAbove i i') (Fin.succAbove j j')
[PROOFSTEP]
rw [Equiv.Perm.inv_def, Fin.cycleRange_symm_succ]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
j : Fin (Nat.succ n)
⊢ det A = ∑ i : Fin (Nat.succ n), (-1) ^ (↑i + ↑j) * A i j * det (submatrix A (Fin.succAbove i) (Fin.succAbove j))
[PROOFSTEP]
rw [← det_transpose, det_succ_row _ j]
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
j : Fin (Nat.succ n)
⊢ ∑ j_1 : Fin (Nat.succ n), (-1) ^ (↑j + ↑j_1) * Aᵀ j j_1 * det (submatrix Aᵀ (Fin.succAbove j) (Fin.succAbove j_1)) =
    ∑ i : Fin (Nat.succ n), (-1) ^ (↑i + ↑j) * A i j * det (submatrix A (Fin.succAbove i) (Fin.succAbove j))
[PROOFSTEP]
refine' Finset.sum_congr rfl fun i _ => _
[GOAL]
m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin (Nat.succ n)) (Fin (Nat.succ n)) R
j i : Fin (Nat.succ n)
x✝ : i ∈ univ
⊢ (-1) ^ (↑j + ↑i) * Aᵀ j i * det (submatrix Aᵀ (Fin.succAbove j) (Fin.succAbove i)) =
    (-1) ^ (↑i + ↑j) * A i j * det (submatrix A (Fin.succAbove i) (Fin.succAbove j))
[PROOFSTEP]
rw [add_comm, ← det_transpose, transpose_apply, transpose_submatrix, transpose_transpose]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix (Fin 2) (Fin 2) R
⊢ det A = A 0 0 * A 1 1 - A 0 1 * A 1 0
[PROOFSTEP]
simp [Matrix.det_succ_row_zero, Fin.sum_univ_succ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix (Fin 2) (Fin 2) R
⊢ A 0 0 * A 1 1 + -(A 0 1 * A 1 0) = A 0 0 * A 1 1 - A 0 1 * A 1 0
[PROOFSTEP]
ring
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix (Fin 3) (Fin 3) R
⊢ det A =
    A 0 0 * A 1 1 * A 2 2 - A 0 0 * A 1 2 * A 2 1 - A 0 1 * A 1 0 * A 2 2 + A 0 1 * A 1 2 * A 2 0 +
        A 0 2 * A 1 0 * A 2 1 -
      A 0 2 * A 1 1 * A 2 0
[PROOFSTEP]
simp [Matrix.det_succ_row_zero, Fin.sum_univ_succ]
[GOAL]
m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix (Fin 3) (Fin 3) R
⊢ A 0 0 * (A 1 1 * A 2 2 + -(A 1 2 * A 2 1)) +
      (-(A 0 1 * (A 1 0 * A 2 2 + -(A 1 2 * A 2 0))) + A 0 2 * (A 1 0 * A 2 1 + -(A 1 1 * A 2 0))) =
    A 0 0 * A 1 1 * A 2 2 - A 0 0 * A 1 2 * A 2 1 - A 0 1 * A 1 0 * A 2 2 + A 0 1 * A 1 2 * A 2 0 +
        A 0 2 * A 1 0 * A 2 1 -
      A 0 2 * A 1 1 * A 2 0
[PROOFSTEP]
ring
