internlm/Lean-Github huggingface dataset:
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ⟦{ aig := (go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝))).aig,
        ref := (input.getRef curr hsplit✝).cast ⋯ },
      assign⟧ =
    ⟦{ aig := aig, ref := input.getRef idx ⋯ }, assign⟧

case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ idx = curr
Tactic:
. rw [go_denote_mem_prefix]
  . simp [heq]
  . simp [Ref.hgate]
Proof state after:
case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ idx = curr
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ idx = curr
Tactic:
. omega
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ⟦{ aig := (go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝))).aig,
        ref := (input.getRef curr hsplit✝).cast ⋯ },
      assign⟧ =
    ⟦{ aig := aig, ref := input.getRef idx ⋯ }, assign⟧
Tactic:
rw [go_denote_mem_prefix]
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ⟦{ aig := aig, ref := { gate := ((input.getRef curr hsplit✝).cast ⋯).gate, hgate := ?hstart } }, assign⟧ =
    ⟦{ aig := aig, ref := input.getRef idx ⋯ }, assign⟧

case hstart
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ((input.getRef curr hsplit✝).cast ⋯).gate < aig.decls.size
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ⟦{ aig := aig, ref := { gate := ((input.getRef curr hsplit✝).cast ⋯).gate, hgate := ?hstart } }, assign⟧ =
    ⟦{ aig := aig, ref := input.getRef idx ⋯ }, assign⟧

case hstart
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ((input.getRef curr hsplit✝).cast ⋯).gate < aig.decls.size
Tactic:
. simp [heq]
Proof state after:
case hstart
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ((input.getRef curr hsplit✝).cast ⋯).gate < aig.decls.size
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
case hstart
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ((input.getRef curr hsplit✝).cast ⋯).gate < aig.decls.size
Tactic:
. simp [Ref.hgate]
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ⟦{ aig := aig, ref := { gate := ((input.getRef curr hsplit✝).cast ⋯).gate, hgate := ?hstart } }, assign⟧ =
    ⟦{ aig := aig, ref := input.getRef idx ⋯ }, assign⟧
Tactic:
simp [heq]
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
case hstart
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ ((input.getRef curr hsplit✝).cast ⋯).gate < aig.decls.size
Tactic:
simp [Ref.hgate]
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit✝ : curr < w
hsplit : idx < w
hgo : go aig w input newWidth (curr + 1) ⋯ (s.pushRef (input.getRef curr hsplit✝)) = res
⊢ idx = curr
Tactic:
omega
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
case isTrue.inl.isFalse
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝¹ : curr < newWidth
heq : curr = idx
h✝ : ¬curr < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := res.aig, ref := res.stream.getRef idx hidx1 }, assign⟧ =
    if hidx : idx < w then ⟦{ aig := aig, ref := input.getRef idx hidx }, assign⟧ else false
Tactic:
next hsplit =>
rw [heq] at hsplit
simp only [hsplit, ↓reduceDite]
rw [← hgo]
rw [go_getRef]
rw [AIG.RefStream.getRef_push_ref_eq']
. rw [go_denote_mem_prefix]
  . simp [heq]
  . simp [Ref.hgate]
. omega
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬curr < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := res.aig, ref := res.stream.getRef idx hidx1 }, assign⟧ =
    if hidx : idx < w then ⟦{ aig := aig, ref := input.getRef idx hidx }, assign⟧ else false
Tactic:
rw [heq] at hsplit
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := res.aig, ref := res.stream.getRef idx hidx1 }, assign⟧ =
    if hidx : idx < w then ⟦{ aig := aig, ref := input.getRef idx hidx }, assign⟧ else false
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := res.aig, ref := res.stream.getRef idx hidx1 }, assign⟧ =
    if hidx : idx < w then ⟦{ aig := aig, ref := input.getRef idx hidx }, assign⟧ else false
Tactic:
simp only [hsplit, ↓reduceDite]
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := res.aig, ref := res.stream.getRef idx hidx1 }, assign⟧ = false
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := res.aig, ref := res.stream.getRef idx hidx1 }, assign⟧ = false
Tactic:
rw [← hgo]
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
                  ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).stream.getRef
            idx hidx1 },
      assign⟧ =
    false
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
                  ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).stream.getRef
            idx hidx1 },
      assign⟧ =
    false
Tactic:
rw [go_getRef]
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref := (((s.cast ⋯).pushRef (aig.mkConstCached false).ref).getRef idx ?hidx).cast ⋯ },
      assign⟧ =
    false

case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ idx < curr + 1
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref := (((s.cast ⋯).pushRef (aig.mkConstCached false).ref).getRef idx ?hidx).cast ⋯ },
      assign⟧ =
    false

case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ idx < curr + 1
Tactic:
rw [AIG.RefStream.getRef_push_ref_eq']
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref := (aig.mkConstCached false).ref.cast ⋯ },
      assign⟧ =
    false

case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ idx = curr
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref := (aig.mkConstCached false).ref.cast ⋯ },
      assign⟧ =
    false

case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ idx = curr
Tactic:
. rw [go_denote_mem_prefix]
  . simp [heq]
  . simp [Ref.hgate]
Proof state after:
case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ idx = curr
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
case hidx
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ idx = curr
Tactic:
. omega
Proof state after:
no goals
Theorem: BVExpr.bitblast.blastZeroExtend.go_eq_eval_getLsb
Proof state before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{
        aig :=
          (go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
              ((s.cast ⋯).pushRef (aig.mkConstCached false).ref)).aig,
        ref := (aig.mkConstCached false).ref.cast ⋯ },
      assign⟧ =
    false
Tactic:
rw [go_denote_mem_prefix]
Proof state after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ⟦{ aig := (aig.mkConstCached false).aig,
        ref := { gate := ((aig.mkConstCached false).ref.cast ⋯).gate, hgate := ?hstart } },
      assign⟧ =
    false

case hstart
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig : AIG α
w : Nat
input : aig.RefStream w
newWidth curr : Nat
hcurr : curr ≤ newWidth
s : aig.RefStream curr
assign : α → Bool
idx : Nat
hidx1 : idx < newWidth
hidx2 : curr ≤ idx
res : RefStreamEntry α newWidth
h✝ : curr < newWidth
heq : curr = idx
hsplit : ¬idx < w
hgo :
  go (aig.mkConstCached false).aig w (input.cast ⋯) newWidth (curr + 1) ⋯
      ((s.cast ⋯).pushRef (aig.mkConstCached false).ref) =
    res
⊢ ((aig.mkConstCached false).ref.cast ⋯).gate < (aig.mkConstCached false).aig.decls.size