Theorem: Holor.sum_unitVec_mul_slice
File: Mathlib/Data/Holor.lean

tactic: apply slice_eq _ _ _
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
⊢ ∑ i in Finset.attach (Finset.range d), unitVec d ↑i ⊗ slice x ↑i (_ : Nat.succ ↑i ≤ d) = x

tactic: ext (i hid)
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
⊢ slice (∑ i in Finset.attach (Finset.range d), unitVec d ↑i ⊗ slice x ↑i (_ : Nat.succ ↑i ≤ d)) = slice x

tactic: rw [← slice_sum]
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ slice (∑ i in Finset.attach (Finset.range d), unitVec d ↑i ⊗ slice x ↑i (_ : Nat.succ ↑i ≤ d)) i hid = slice x i hid

tactic: simp only [slice_unitVec_mul hid]
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ∑ x_1 in Finset.attach (Finset.range d), slice (unitVec d ↑x_1 ⊗ slice x ↑x_1 (_ : Nat.succ ↑x_1 ≤ d)) i hid =
    slice x i hid

tactic: rw [Finset.sum_eq_single (Subtype.mk i <| Finset.mem_range.2 hid)]
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (∑ x_1 in Finset.attach (Finset.range d), if i = ↑x_1 then slice x ↑x_1 (_ : Nat.succ ↑x_1 ≤ d) else 0) =
    slice x i hid

tactic: simp
state_before: case h.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ (if i = ↑{ val := i, property := (_ : i ∈ Finset.range d) } then
      slice x ↑{ val := i, property := (_ : i ∈ Finset.range d) }
        (_ : Nat.succ ↑{ val := i, property := (_ : i ∈ Finset.range d) } ≤ d)
    else 0) =
    slice x i hid

tactic: intro (b : { x // x ∈ Finset.range d }) (_ : b ∈ (Finset.range d).attach)(hbi : b ≠ ⟨i, _⟩)
state_before: case h.h.h₀
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ∀ (b : { x // x ∈ Finset.range d }),
    b ∈ Finset.attach (Finset.range d) →
      b ≠ { val := i, property := (_ : i ∈ Finset.range d) } →
        (if i = ↑b then slice x ↑b (_ : Nat.succ ↑b ≤ d) else 0) = 0

tactic: have hbi' : i ≠ b := by simpa only [Ne.def, Subtype.ext_iff, Subtype.coe_mk] using hbi.symm
state_before: case h.h.h₀
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
b : { x // x ∈ Finset.range d }
x✝ : b ∈ Finset.attach (Finset.range d)
hbi : b ≠ { val := i, property := (_ : i ∈ Finset.range d) }
⊢ (if i = ↑b then slice x ↑b (_ : Nat.succ ↑b ≤ d) else 0) = 0

tactic: simp [hbi']
state_before: case h.h.h₀
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
b : { x // x ∈ Finset.range d }
x✝ : b ∈ Finset.attach (Finset.range d)
hbi : b ≠ { val := i, property := (_ : i ∈ Finset.range d) }
hbi' : i ≠ ↑b
⊢ (if i = ↑b then slice x ↑b (_ : Nat.succ ↑b ≤ d) else 0) = 0

tactic: simpa only [Ne.def, Subtype.ext_iff, Subtype.coe_mk] using hbi.symm
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
b : { x // x ∈ Finset.range d }
x✝ : b ∈ Finset.attach (Finset.range d)
hbi : b ≠ { val := i, property := (_ : i ∈ Finset.range d) }
⊢ i ≠ ↑b

tactic: intro (hid' : Subtype.mk i _ ∉ Finset.attach (Finset.range d))
state_before: case h.h.h₁
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
⊢ ¬{ val := i, property := (_ : i ∈ Finset.range d) } ∈ Finset.attach (Finset.range d) →
    (if i = ↑{ val := i, property := (_ : i ∈ Finset.range d) } then
        slice x ↑{ val := i, property := (_ : i ∈ Finset.range d) }
          (_ : Nat.succ ↑{ val := i, property := (_ : i ∈ Finset.range d) } ≤ d)
      else 0) =
      0

tactic: exfalso
state_before: case h.h.h₁
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
hid' : ¬{ val := i, property := (_ : i ∈ Finset.range d) } ∈ Finset.attach (Finset.range d)
⊢ (if i = ↑{ val := i, property := (_ : i ∈ Finset.range d) } then
      slice x ↑{ val := i, property := (_ : i ∈ Finset.range d) }
        (_ : Nat.succ ↑{ val := i, property := (_ : i ∈ Finset.range d) } ≤ d)
    else 0) =
    0

tactic: exact absurd (Finset.mem_attach _ _) hid'
state_before: case h.h.h₁.h
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α (d :: ds)
i : ℕ
hid : i < d
hid' : ¬{ val := i, property := (_ : i ∈ Finset.range d) } ∈ Finset.attach (Finset.range d)
⊢ False