Theorem: Dfinsupp.sigmaCurry_apply
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: classical!
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
⊢ ↑(↑(sigmaCurry f) i) j = ↑f { fst := i, snd := j }

tactic: dsimp only [sigmaCurry]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
⊢ ↑(↑(sigmaCurry f) i) j = ↑f { fst := i, snd := j }

tactic: by_cases h : f ⟨i, j⟩ = 0
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
⊢ ↑(↑(mk (image (fun i => i.fst) (support f)) fun i =>
              mk
                (preimage (support f) (fun x => { fst := ↑i, snd := x })
                  (_ : Set.InjOn (Sigma.mk ↑i) ((fun x => { fst := ↑i, snd := x }) ⁻¹' ↑(support f))))
                fun j => ↑f { fst := ↑i, snd := ↑j })
          i)
      j =
    ↑f { fst := i, snd := j }

tactic: rw [h]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
⊢ ↑(↑(mk (image (fun i => i.fst) (support f)) fun i =>
              mk
                (preimage (support f) (fun x => { fst := ↑i, snd := x })
                  (_ : Set.InjOn (Sigma.mk ↑i) ((fun x => { fst := ↑i, snd := x }) ⁻¹' ↑(support f))))
                fun j => ↑f { fst := ↑i, snd := ↑j })
          i)
      j =
    ↑f { fst := i, snd := j }

tactic: rw [mk_apply (dec := fun a b ↦ Classical.propDecidable (a = b))]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
⊢ ↑(↑(mk (image (fun i => i.fst) (support f)) fun i =>
              mk
                (preimage (support f) (fun x => { fst := ↑i, snd := x })
                  (_ : Set.InjOn (Sigma.mk ↑i) ((fun x => { fst := ↑i, snd := x }) ⁻¹' ↑(support f))))
                fun j => ↑f { fst := ↑i, snd := ↑j })
          i)
      j =
    0

tactic: split_ifs
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
⊢ ↑(if H : i ∈ image (fun i => i.fst) (support f) then
          mk
            (preimage (support f) (fun x => { fst := ↑{ val := i, property := H }, snd := x })
              (_ :
                Set.InjOn (Sigma.mk ↑{ val := i, property := H })
                  ((fun x => { fst := ↑{ val := i, property := H }, snd := x }) ⁻¹' ↑(support f))))
            fun j => ↑f { fst := ↑{ val := i, property := H }, snd := ↑j }
        else 0)
      j =
    0

tactic: rw [mk_apply (dec := fun a b ↦ Classical.propDecidable (a = b))]
state_before: case pos.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
h✝ : i ∈ image (fun i => i.fst) (support f)
⊢ ↑(mk
          (preimage (support f) (fun x => { fst := ↑{ val := i, property := h✝ }, snd := x })
            (_ :
              Set.InjOn (Sigma.mk ↑{ val := i, property := h✝ })
                ((fun x => { fst := ↑{ val := i, property := h✝ }, snd := x }) ⁻¹' ↑(support f))))
          fun j => ↑f { fst := ↑{ val := i, property := h✝ }, snd := ↑j })
      j =
    0

tactic: split_ifs
state_before: case pos.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
h✝ : i ∈ image (fun i => i.fst) (support f)
⊢ (if H :
        j ∈
          preimage (support f) (fun x => { fst := ↑{ val := i, property := h✝ }, snd := x })
            (_ :
              Set.InjOn (Sigma.mk ↑{ val := i, property := h✝ })
                ((fun x => { fst := ↑{ val := i, property := h✝ }, snd := x }) ⁻¹' ↑(support f))) then
      ↑f { fst := ↑{ val := i, property := h✝ }, snd := ↑{ val := j, property := H } }
    else 0) =
    0

tactic: exact h
state_before: case pos.inl.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
h✝¹ : i ∈ image (fun i => i.fst) (support f)
h✝ :
  j ∈
    preimage (support f) (fun x => { fst := ↑{ val := i, property := h✝¹ }, snd := x })
      (_ :
        Set.InjOn (Sigma.mk ↑{ val := i, property := h✝¹ })
          ((fun x => { fst := ↑{ val := i, property := h✝¹ }, snd := x }) ⁻¹' ↑(support f)))
⊢ ↑f { fst := ↑{ val := i, property := h✝¹ }, snd := ↑{ val := j, property := h✝ } } = 0

tactic: rfl
state_before: case pos.inl.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
h✝¹ : i ∈ image (fun i => i.fst) (support f)
h✝ :
  ¬j ∈
      preimage (support f) (fun x => { fst := ↑{ val := i, property := h✝¹ }, snd := x })
        (_ :
          Set.InjOn (Sigma.mk ↑{ val := i, property := h✝¹ })
            ((fun x => { fst := ↑{ val := i, property := h✝¹ }, snd := x }) ⁻¹' ↑(support f)))
⊢ 0 = 0

tactic: rfl
state_before: case pos.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ↑f { fst := i, snd := j } = 0
h✝ : ¬i ∈ image (fun i => i.fst) (support f)
⊢ ↑0 j = 0

tactic: rw [mk_of_mem (dec := fun a b ↦ Classical.propDecidable (a = b)) ?h₁,
    mk_of_mem (dec := fun a b ↦ Classical.propDecidable (a = b))]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ ↑(↑(mk (image (fun i => i.fst) (support f)) fun i =>
              mk
                (preimage (support f) (fun x => { fst := ↑i, snd := x })
                  (_ : Set.InjOn (Sigma.mk ↑i) ((fun x => { fst := ↑i, snd := x }) ⁻¹' ↑(support f))))
                fun j => ↑f { fst := ↑i, snd := ↑j })
          i)
      j =
    ↑f { fst := i, snd := j }

tactic: case h₁ =>
  rw [@mem_image _ _ (fun a b ↦ Classical.propDecidable (a = b))]
  refine' ⟨⟨i, j⟩, _, rfl⟩
  convert (mem_support_toFun f _).2 h
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ j ∈
    preimage (support f) (fun x => { fst := ↑{ val := i, property := ?h₁ }, snd := x })
      (_ :
        Set.InjOn (Sigma.mk ↑{ val := i, property := ?h₁ })
          ((fun x => { fst := ↑{ val := i, property := ?h₁ }, snd := x }) ⁻¹' ↑(support f)))

case h₁
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ i ∈ image (fun i => i.fst) (support f)

case h₁
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ i ∈ image (fun i => i.fst) (support f)

tactic: rw [@mem_image _ _ (fun a b ↦ Classical.propDecidable (a = b))]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ i ∈ image (fun i => i.fst) (support f)

tactic: refine' ⟨⟨i, j⟩, _, rfl⟩
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ ∃ a, a ∈ support f ∧ a.fst = i

tactic: convert (mem_support_toFun f _).2 h
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ { fst := i, snd := j } ∈ support f

tactic: rw [mem_preimage]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ j ∈
    preimage (support f)
      (fun x => { fst := ↑{ val := i, property := (_ : i ∈ image (fun i => i.fst) (support f)) }, snd := x })
      (_ :
        Set.InjOn (Sigma.mk ↑{ val := i, property := (_ : i ∈ image (fun i => i.fst) (support f)) })
          ((fun x => { fst := ↑{ val := i, property := (_ : i ∈ image (fun i => i.fst) (support f)) }, snd := x }) ⁻¹'
            ↑(support f)))

tactic: convert (mem_support_toFun f _).2 h
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.598778
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → Zero (δ i j)
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
em✝ : (a : Prop) → Decidable a
h : ¬↑f { fst := i, snd := j } = 0
⊢ { fst := ↑{ val := i, property := (_ : i ∈ image (fun i => i.fst) (support f)) }, snd := j } ∈ support f