Theorem: Matrix.det_fromBlocks_zero₂₁
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: simp_rw [det_apply']
state_before: m : Type 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

tactic: convert Eq.symm <|
  sum_subset (β := R) (subset_univ ((sumCongrHom m n).range : Set (Perm (Sum m n))).toFinset) ?_
state_before: m : Type 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

tactic: rw [sum_mul_sum]
state_before: 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

tactic: simp_rw [univ_product_univ]
state_before: 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

tactic: rw [(sum_bij (fun (σ : Perm m × Perm n) _ => Equiv.sumCongr σ.fst σ.snd) _ _ _ _).symm]
state_before: 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

tactic: intro σ₁₂ h
state_before: m : Type 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))

tactic: simp only
state_before: m : Type 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))

tactic: erw [Set.mem_toFinset, MonoidHom.mem_range]
state_before: m : Type 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))

tactic: use σ₁₂
state_before: m : Type 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

tactic: simp only [sumCongrHom_apply]
state_before: m : Type 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

tactic: simp only [forall_prop_of_true, Prod.forall, mem_univ]
state_before: m : Type 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

tactic: intro σ₁ σ₂
state_before: m : Type 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

tactic: rw [Fintype.prod_sum_type]
state_before: m : Type 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

tactic: simp_rw [Equiv.sumCongr_apply, Sum.map_inr, Sum.map_inl, fromBlocks_apply₁₁,
  fromBlocks_apply₂₂]
state_before: m : Type 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₂))

tactic: rw [mul_mul_mul_comm]
state_before: m : Type 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)

tactic: congr
state_before: m : Type 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)

tactic: rw [sign_sumCongr, Units.val_mul, Int.cast_mul]
state_before: 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 σ₁ σ₂))

tactic: intro σ₁ σ₂ h₁ h₂
state_before: m : Type 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₂

tactic: dsimp only
state_before: m : Type 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₂ → σ₁ = σ₂

tactic: intro h
state_before: m : Type 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 → σ₁ = σ₂

tactic: have h2 : ∀ x, Perm.sumCongr σ₁.fst σ₁.snd x = Perm.sumCongr σ₂.fst σ₂.snd x := by
  intro x
  exact congr_fun (congr_arg toFun h) x
state_before: m : Type 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
⊢ σ₁ = σ₂

tactic: simp only [Sum.map_inr, Sum.map_inl, Perm.sumCongr_apply, Sum.forall, Sum.inl.injEq,
  Sum.inr.injEq] at h2
state_before: m : Type 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
⊢ σ₁ = σ₂

tactic: ext x
state_before: m : Type 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
⊢ σ₁ = σ₂

tactic: intro x
state_before: m : Type 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

tactic: exact congr_fun (congr_arg toFun h) x
state_before: m : Type 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

tactic: exact h2.left x
state_before: 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

tactic: exact h2.right x
state_before: 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

tactic: intro σ hσ
state_before: m : Type 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

tactic: erw [Set.mem_toFinset, MonoidHom.mem_range] at hσ
state_before: m : Type 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

tactic: obtain ⟨σ₁₂, hσ₁₂⟩ := hσ
state_before: m : Type 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

tactic: use σ₁₂
state_before: 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

tactic: rw [← hσ₁₂]
state_before: 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) σ₁₂ = σ
⊢ ∃ ha, σ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₁₂ ha

tactic: simp
state_before: 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) σ₁₂ = σ
⊢ ∃ ha, ↑(sumCongrHom m n) σ₁₂ = (fun σ x => Equiv.sumCongr σ.fst σ.snd) σ₁₂ ha

tactic: rintro σ - hσn
state_before: 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

tactic: 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
state_before: 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

tactic: obtain ⟨a, ha⟩ := not_forall.mp h1
state_before: 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

tactic: cases' hx : σ (Sum.inl a) with a2 b
state_before: 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

tactic: rw [Set.mem_toFinset] at hσn
state_before: m : Type 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)

tactic: 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
state_before: m : Type 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)

tactic: have hn := (not_exists.mp ha) a2
state_before: 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

tactic: exact absurd hx.symm hn
state_before: 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

tactic: rw [Finset.prod_eq_zero (Finset.mem_univ (Sum.inl a)), MulZeroClass.mul_zero]
state_before: 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

tactic: rw [hx, fromBlocks_apply₂₁, zero_apply]
state_before: 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