-- Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/SignExtend.lean
theorem denote_blastSignExtend (aig : AIG α) (target : ExtendTarget aig newWidth)
    (assign : α → Bool) (htarget : 0 < target.w) :
    ∀ (idx : Nat) (hidx : idx < newWidth),
        ⟦(blastSignExtend aig target).aig, (blastSignExtend aig target).vec.get idx hidx, assign⟧
          =
        if hidx : idx < target.w then
           ⟦aig, target.vec.get idx hidx, assign⟧
        else
           ⟦aig, target.vec.get (target.w - 1) (by omega), assign⟧

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
hg :
  (if hw : target.w = 0 then blastZeroExtend aig { w := target.w, vec := target.vec }
    else { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty }) =
    res
this : ¬target.w = 0
⊢ ⟦assign, { aig := res.aig, ref := res.vec.get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Tactic:
simp only [this, ↓reduceDIte] at hg

Result:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
this : ¬target.w = 0
hg : { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty } = res
⊢ ⟦assign, { aig := res.aig, ref := res.vec.get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
this : ¬target.w = 0
hg : { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty } = res
⊢ ⟦assign,
      { aig := aig, ref := if hidx2 : idx < target.w then target.vec.get idx ⋯ else target.vec.get (target.w - 1) ⋯ }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Tactic:
split <;> simp only

Result:
no goals

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
hg : blastSignExtend aig target = res
⊢ ⟦assign, { aig := res.aig, ref := res.vec.get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Tactic:
unfold blastSignExtend at hg

Result:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
hg :
  (match target with
    | { w := width, vec := input } =>
      if hw : width = 0 then blastZeroExtend aig { w := width, vec := input }
      else { aig := aig, vec := blastSignExtend.go width ⋯ input newWidth 0 ⋯ RefVec.empty }) =
    res
⊢ ⟦assign, { aig := res.aig, ref := res.vec.get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
this : ¬target.w = 0
hg : { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty } = res
⊢ ⟦assign, { aig := aig, ref := (blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty).get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Tactic:
rw [blastSignExtend.go_get]

Result:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
this : ¬target.w = 0
hg : { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty } = res
⊢ ⟦assign,
      { aig := aig, ref := if hidx2 : idx < target.w then target.vec.get idx ⋯ else target.vec.get (target.w - 1) ⋯ }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

case a
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
this : ¬target.w = 0
hg : { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty } = res
⊢ 0 ≤ idx

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
hg :
  (if hw : target.w = 0 then blastZeroExtend aig { w := target.w, vec := target.vec }
    else { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty }) =
    res
⊢ ⟦assign, { aig := res.aig, ref := res.vec.get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Tactic:
have : ¬ (target.w = 0) := by omega

Result:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx : idx < newWidth
res : RefVecEntry α newWidth
hg :
  (if hw : target.w = 0 then blastZeroExtend aig { w := target.w, vec := target.vec }
    else { aig := aig, vec := blastSignExtend.go target.w ⋯ target.vec newWidth 0 ⋯ RefVec.empty }) =
    res
this : ¬target.w = 0
⊢ ⟦assign, { aig := res.aig, ref := res.vec.get idx hidx }⟧ =
    if hidx : idx < target.w then ⟦assign, { aig := aig, ref := target.vec.get idx hidx }⟧
    else ⟦assign, { aig := aig, ref := target.vec.get (target.w - 1) ⋯ }⟧

Proof state:
α : Type
inst✝¹ : Hashable α
inst✝ : DecidableEq α
newWidth : Nat
aig : AIG α
target : aig.ExtendTarget newWidth
assign : α → Bool
htarget : 0 < target.w
idx : Nat
hidx✝ : idx < newWidth
hidx : ¬idx < target.w
⊢ target.w - 1 < target.w

Tactic:
omega

Result:
no goals