Theorem: BVExpr.bitblast.go_decl_eq (LeanSAT/Reflect/BVExpr/BitBlast/Impl/Expr.lean)

State before:
w : Nat
aig : AIG BVBit
expr : BVExpr w
⊢ ∀ (idx : Nat) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
Tactic:
intros idx h1 h2
State after:
w : Nat
aig : AIG BVBit
expr : BVExpr w
idx : Nat
h1 : idx < aig.decls.size
h2 : idx < (go aig expr).val.aig.decls.size
⊢ (go aig expr).val.aig.decls[idx] = aig.decls[idx]

State before:
w : Nat
aig : AIG BVBit
expr : BVExpr w
idx : Nat
h1 : idx < aig.decls.size
h2 : idx < (go aig expr).val.aig.decls.size
⊢ (go aig expr).val.aig.decls[idx] = aig.decls[idx]
Tactic:
induction expr generalizing aig with
| var =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastVar)]
| const =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastConst)]
| bin lhs op rhs lih rih =>
  match op with
  | .and | .or | .xor =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := AIG.RefStream.zip)]
    rw [rih, lih]
    . apply Nat.lt_of_lt_of_le
      . exact h1
      . exact (bitblast.go aig lhs).property
    . apply Nat.lt_of_lt_of_le
      . exact h1
      . apply Nat.le_trans
        . exact (bitblast.go aig lhs).property
        . exact (go (go aig lhs).1.aig rhs).property
  | .add =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastAdd)]
    rw [rih, lih]
    . apply Nat.lt_of_lt_of_le
      . exact h1
      . exact (bitblast.go aig lhs).property
    . apply Nat.lt_of_lt_of_le
      . exact h1
      . apply Nat.le_trans
        . exact (bitblast.go aig lhs).property
        . exact (go (go aig lhs).1.aig rhs).property
| un op expr ih =>
  match op with
  | .not =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastNot)]
    rw [ih]
    apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (go aig expr).property
  | .shiftLeftConst _ =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastShiftLeftConst)]
    rw [ih]
    apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (go aig expr).property
  | .shiftRightConst _ =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastShiftRightConst)]
    rw [ih]
    apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (go aig expr).property
  | .rotateLeft _ =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastRotateLeft)]
    rw [ih]
    apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (go aig expr).property
  | .rotateRight _ =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastRotateRight)]
    rw [ih]
    apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (go aig expr).property
  | .arithShiftRightConst _ =>
    dsimp [go]
    rw [AIG.LawfulStreamOperator.decl_eq (f := blastArithShiftRightConst)]
    rw [ih]
    apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (go aig expr).property
| zeroExtend w inner ih =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastZeroExtend)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig inner).property
| signExtend w inner ih =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastSignExtend)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig inner).property
| append lhs rhs lih rih =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastAppend)]
  rw [rih, lih]
  . apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (bitblast.go aig lhs).property
  . apply Nat.lt_of_lt_of_le
    . exact h1
    . apply Nat.le_trans
      . exact (bitblast.go aig lhs).property
      . exact (go (go aig lhs).1.aig rhs).property
| extract hi lo inner ih =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastExtract)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig inner).property
State after:
no goals

State before:
case var
w idx w✝ idx✝ : Nat
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (var idx✝)).val.aig.decls.size
⊢ (go aig (var idx✝)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
case var
w idx w✝ idx✝ : Nat
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (var idx✝)).val.aig.decls.size
⊢ (blastVar aig { ident := idx✝ }).aig.decls[idx] = aig.decls[idx]

State before:
case var
w idx w✝ idx✝ : Nat
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (var idx✝)).val.aig.decls.size
⊢ (blastVar aig { ident := idx✝ }).aig.decls[idx] = aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastVar)]
State after:
no goals

State before:
case const
w idx w✝ : Nat
val✝ : BitVec w✝
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (const val✝)).val.aig.decls.size
⊢ (go aig (const val✝)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
case const
w idx w✝ : Nat
val✝ : BitVec w✝
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (const val✝)).val.aig.decls.size
⊢ (blastConst aig val✝).aig.decls[idx] = aig.decls[idx]

State before:
case const
w idx w✝ : Nat
val✝ : BitVec w✝
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (const val✝)).val.aig.decls.size
⊢ (blastConst aig val✝).aig.decls[idx] = aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastConst)]
State after:
no goals

State before:
case bin
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin op rhs)).val.aig.decls.size
⊢ (go aig (lhs.bin op rhs)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
match op with
| .and | .or | .xor =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := AIG.RefStream.zip)]
  rw [rih, lih]
  . apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (bitblast.go aig lhs).property
  . apply Nat.lt_of_lt_of_le
    . exact h1
    . apply Nat.le_trans
      . exact (bitblast.go aig lhs).property
      . exact (go (go aig lhs).1.aig rhs).property
| .add =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastAdd)]
  rw [rih, lih]
  . apply Nat.lt_of_lt_of_le
    . exact h1
    . exact (bitblast.go aig lhs).property
  . apply Nat.lt_of_lt_of_le
    . exact h1
    . apply Nat.le_trans
      . exact (bitblast.go aig lhs).property
      . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (AIG.RefStream.zip (go (go aig lhs).1.aig rhs).1.aig
            (AIG.RefStream.ZipTarget.mk
              { lhs := (go aig lhs).1.stream.cast ⋯, rhs := (go (go aig lhs).1.aig rhs).1.stream }
              AIG.mkXorCached)).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (AIG.RefStream.zip (go (go aig lhs).1.aig rhs).1.aig
            (AIG.RefStream.ZipTarget.mk
              { lhs := (go aig lhs).1.stream.cast ⋯, rhs := (go (go aig lhs).1.aig rhs).1.stream }
              AIG.mkXorCached)).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := AIG.RefStream.zip)]
State after:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (go (go aig lhs).1.aig rhs).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).1.aig.decls.size

State before:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (go (go aig lhs).1.aig rhs).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).1.aig.decls.size
Tactic:
rw [rih, lih]
State after:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size

case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size

case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (bitblast.go aig lhs).property
State after:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.lt_of_lt_of_le
  . exact h1
  . apply Nat.le_trans
    . exact (bitblast.go aig lhs).property
    . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig lhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig lhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size
Tactic:
. exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size
Tactic:
exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.le_trans
  . exact (bitblast.go aig lhs).property
  . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
apply Nat.le_trans
State after:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?h2.a.m

case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ ?h2.a.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.a.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ Nat

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?h2.a.m

case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ ?h2.a.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.a.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact (bitblast.go aig lhs).property
State after:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?h2.a.m
Tactic:
exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.xor rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (blastAdd (go (go aig lhs).1.aig rhs).1.aig
            { lhs := (go aig lhs).1.stream.cast ⋯, rhs := (go (go aig lhs).1.aig rhs).1.stream }).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (blastAdd (go (go aig lhs).1.aig rhs).1.aig
            { lhs := (go aig lhs).1.stream.cast ⋯, rhs := (go (go aig lhs).1.aig rhs).1.stream }).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastAdd)]
State after:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (go (go aig lhs).1.aig rhs).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).1.aig.decls.size

State before:
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (go (go aig lhs).1.aig rhs).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).1.aig.decls.size
Tactic:
rw [rih, lih]
State after:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size

case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size

case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (bitblast.go aig lhs).property
State after:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.lt_of_lt_of_le
  . exact h1
  . apply Nat.le_trans
    . exact (bitblast.go aig lhs).property
    . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig lhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig lhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size
Tactic:
. exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size
Tactic:
exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case h2
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ ?h2.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.le_trans
  . exact (bitblast.go aig lhs).property
  . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
apply Nat.le_trans
State after:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?h2.a.m

case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ ?h2.a.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.a.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ Nat

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?h2.a.m

case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ ?h2.a.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case h2.a.m
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact (bitblast.go aig lhs).property
State after:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?h2.a.m
Tactic:
exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case h2.a.a
w idx w✝ : Nat
lhs : BVExpr w✝
op : BVBinOp
rhs : BVExpr w✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.bin BVBinOp.add rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case un
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un op expr)).val.aig.decls.size
⊢ (go aig (un op expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
match op with
| .not =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastNot)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig expr).property
| .shiftLeftConst _ =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastShiftLeftConst)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig expr).property
| .shiftRightConst _ =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastShiftRightConst)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig expr).property
| .rotateLeft _ =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastRotateLeft)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig expr).property
| .rotateRight _ =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastRotateRight)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig expr).property
| .arithShiftRightConst _ =>
  dsimp [go]
  rw [AIG.LawfulStreamOperator.decl_eq (f := blastArithShiftRightConst)]
  rw [ih]
  apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (go aig expr).property
State after:
no goals

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ (go aig (un BVUnOp.not expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ (blastNot (go aig expr).1.aig (go aig expr).1.stream).aig.decls[idx] = aig.decls[idx]

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ (blastNot (go aig expr).1.aig (go aig expr).1.stream).aig.decls[idx] = aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastNot)]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size
Tactic:
rw [ih]
State after:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
. exact (go aig expr).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (un BVUnOp.not expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
exact (go aig expr).property
State after:
no goals

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ (blastShiftLeftConst (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ (blastShiftLeftConst (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastShiftLeftConst)]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size
Tactic:
rw [ih]
State after:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
. exact (go aig expr).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftLeftConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
exact (go aig expr).property
State after:
no goals

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ (blastShiftRightConst (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ (blastShiftRightConst (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastShiftRightConst)]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size
Tactic:
rw [ih]
State after:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
. exact (go aig expr).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.shiftRightConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
exact (go aig expr).property
State after:
no goals

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ (blastRotateLeft (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ (blastRotateLeft (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastRotateLeft)]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size
Tactic:
rw [ih]
State after:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
. exact (go aig expr).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateLeft n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
exact (go aig expr).property
State after:
no goals

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ (blastRotateRight (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ (blastRotateRight (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastRotateRight)]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size
Tactic:
rw [ih]
State after:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
. exact (go aig expr).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.rotateRight n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
exact (go aig expr).property
State after:
no goals

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ (blastArithShiftRightConst (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ (blastArithShiftRightConst (go aig expr).1.aig { stream := (go aig expr).1.stream, distance := n✝ }).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastArithShiftRightConst)]
State after:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size

State before:
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ (go aig expr).1.aig.decls[idx] = aig.decls[idx]

case h1
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).1.aig.decls.size
Tactic:
rw [ih]
State after:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size

State before:
case h2
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < (go aig expr).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ Nat

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m

case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ ?h2.m ≤ (go aig expr).val.aig.decls.size

case h2.m
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
. exact (go aig expr).property
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ idx < ?h2.m
Tactic:
exact h1
State after:
no goals

State before:
case h2.a
w idx w✝ : Nat
op : BVUnOp
expr : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig expr).val.aig.decls.size),
    (go aig expr).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
n✝ : Nat
h2 : idx < (go aig (un (BVUnOp.arithShiftRightConst n✝) expr)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig expr).val.aig.decls.size
Tactic:
exact (go aig expr).property
State after:
no goals

State before:
case zeroExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ (go aig (zeroExtend w inner)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
case zeroExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ (blastZeroExtend (go aig inner).1.aig { w := w✝, stream := (go aig inner).1.stream }).aig.decls[idx] = aig.decls[idx]

State before:
case zeroExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ (blastZeroExtend (go aig inner).1.aig { w := w✝, stream := (go aig inner).1.stream }).aig.decls[idx] = aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastZeroExtend)]
State after:
case zeroExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ (go aig inner).1.aig.decls[idx] = aig.decls[idx]

case zeroExtend.h1
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).1.aig.decls.size

State before:
case zeroExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ (go aig inner).1.aig.decls[idx] = aig.decls[idx]

case zeroExtend.h1
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).1.aig.decls.size
Tactic:
rw [ih]
State after:
case zeroExtend.h2
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).val.aig.decls.size

State before:
case zeroExtend.h2
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < ?zeroExtend.h2.m

case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ ?zeroExtend.h2.m ≤ (go aig inner).val.aig.decls.size

case zeroExtend.h2.m
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ Nat

State before:
case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < ?zeroExtend.h2.m

case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ ?zeroExtend.h2.m ≤ (go aig inner).val.aig.decls.size

case zeroExtend.h2.m
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size

State before:
case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size
Tactic:
. exact (go aig inner).property
State after:
no goals

State before:
case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ idx < ?zeroExtend.h2.m
Tactic:
exact h1
State after:
no goals

State before:
case zeroExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (zeroExtend w inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size
Tactic:
exact (go aig inner).property
State after:
no goals

State before:
case signExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ (go aig (signExtend w inner)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
case signExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ (blastSignExtend (go aig inner).1.aig { w := w✝, stream := (go aig inner).1.stream }).aig.decls[idx] = aig.decls[idx]

State before:
case signExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ (blastSignExtend (go aig inner).1.aig { w := w✝, stream := (go aig inner).1.stream }).aig.decls[idx] = aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastSignExtend)]
State after:
case signExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ (go aig inner).1.aig.decls[idx] = aig.decls[idx]

case signExtend.h1
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).1.aig.decls.size

State before:
case signExtend
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ (go aig inner).1.aig.decls[idx] = aig.decls[idx]

case signExtend.h1
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).1.aig.decls.size
Tactic:
rw [ih]
State after:
case signExtend.h2
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).val.aig.decls.size

State before:
case signExtend.h2
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < (go aig inner).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < ?signExtend.h2.m

case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ ?signExtend.h2.m ≤ (go aig inner).val.aig.decls.size

case signExtend.h2.m
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ Nat

State before:
case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < ?signExtend.h2.m

case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ ?signExtend.h2.m ≤ (go aig inner).val.aig.decls.size

case signExtend.h2.m
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size

State before:
case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size
Tactic:
. exact (go aig inner).property
State after:
no goals

State before:
case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ idx < ?signExtend.h2.m
Tactic:
exact h1
State after:
no goals

State before:
case signExtend.h2.a
w✝¹ idx w✝ w : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (signExtend w inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size
Tactic:
exact (go aig inner).property
State after:
no goals

State before:
case append
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (go aig (lhs.append rhs)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
case append
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (blastAppend (go (go aig lhs).1.aig rhs).1.aig
            (AppendTarget.mk ((go aig lhs).1.stream.cast ⋯) (go (go aig lhs).1.aig rhs).1.stream ⋯)).aig.decls[idx] =
    aig.decls[idx]

State before:
case append
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (blastAppend (go (go aig lhs).1.aig rhs).1.aig
            (AppendTarget.mk ((go aig lhs).1.stream.cast ⋯) (go (go aig lhs).1.aig rhs).1.stream ⋯)).aig.decls[idx] =
    aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastAppend)]
State after:
case append
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (go (go aig lhs).1.aig rhs).1.aig.decls[idx] = aig.decls[idx]

case append.h1
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).1.aig.decls.size

State before:
case append
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (go (go aig lhs).1.aig rhs).1.aig.decls[idx] = aig.decls[idx]

case append.h1
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).1.aig.decls.size
Tactic:
rw [rih, lih]
State after:
case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size

case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size

case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.lt_of_lt_of_le
  . exact h1
  . exact (bitblast.go aig lhs).property
State after:
case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.lt_of_lt_of_le
  . exact h1
  . apply Nat.le_trans
    . exact (bitblast.go aig lhs).property
    . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go aig lhs).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < ?append.h2.m

case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ ?append.h2.m ≤ (go aig lhs).val.aig.decls.size

case append.h2.m
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ Nat

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < ?append.h2.m

case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ ?append.h2.m ≤ (go aig lhs).val.aig.decls.size

case append.h2.m
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size
Tactic:
. exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < ?append.h2.m
Tactic:
exact h1
State after:
no goals

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig lhs).val.aig.decls.size
Tactic:
exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case append.h2
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < ?append.h2.m

case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ ?append.h2.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case append.h2.m
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ Nat

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ idx < ?append.h2.m

case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ ?append.h2.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case append.h2.m
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. apply Nat.le_trans
  . exact (bitblast.go aig lhs).property
  . exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case append.h2.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
apply Nat.le_trans
State after:
case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?append.h2.a.m

case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ ?append.h2.a.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case append.h2.a.m
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ Nat

State before:
case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?append.h2.a.m

case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ ?append.h2.a.m ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

case append.h2.a.m
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ Nat
Tactic:
. exact (bitblast.go aig lhs).property
State after:
case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size

State before:
case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
. exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ aig.decls.size ≤ ?append.h2.a.m
Tactic:
exact (bitblast.go aig lhs).property
State after:
no goals

State before:
case append.h2.a.a
w idx l✝ r✝ : Nat
lhs : BVExpr l✝
rhs : BVExpr r✝
lih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig lhs).val.aig.decls.size),
    (go aig lhs).val.aig.decls[idx] = aig.decls[idx]
rih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig rhs).val.aig.decls.size),
    (go aig rhs).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (lhs.append rhs)).val.aig.decls.size
⊢ (go aig lhs).val.aig.decls.size ≤ (go (go aig lhs).1.aig rhs).val.aig.decls.size
Tactic:
exact (go (go aig lhs).1.aig rhs).property
State after:
no goals

State before:
case extract
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ (go aig (extract hi lo inner)).val.aig.decls[idx] = aig.decls[idx]
Tactic:
dsimp [go]
State after:
case extract
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ (blastExtract (go aig inner).1.aig (ExtractTarget.mk (go aig inner).1.stream hi lo ⋯)).aig.decls[idx] = aig.decls[idx]

State before:
case extract
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ (blastExtract (go aig inner).1.aig (ExtractTarget.mk (go aig inner).1.stream hi lo ⋯)).aig.decls[idx] = aig.decls[idx]
Tactic:
rw [AIG.LawfulStreamOperator.decl_eq (f := blastExtract)]
State after:
case extract
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ (go aig inner).1.aig.decls[idx] = aig.decls[idx]

case extract.h1
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < (go aig inner).1.aig.decls.size

State before:
case extract
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ (go aig inner).1.aig.decls[idx] = aig.decls[idx]

case extract.h1
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < (go aig inner).1.aig.decls.size
Tactic:
rw [ih]
State after:
case extract.h2
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < (go aig inner).val.aig.decls.size

State before:
case extract.h2
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < (go aig inner).val.aig.decls.size
Tactic:
apply Nat.lt_of_lt_of_le
State after:
case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < ?extract.h2.m

case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ ?extract.h2.m ≤ (go aig inner).val.aig.decls.size

case extract.h2.m
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ Nat

State before:
case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < ?extract.h2.m

case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ ?extract.h2.m ≤ (go aig inner).val.aig.decls.size

case extract.h2.m
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ Nat
Tactic:
. exact h1
State after:
case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size

State before:
case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size
Tactic:
. exact (go aig inner).property
State after:
no goals

State before:
case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ idx < ?extract.h2.m
Tactic:
exact h1
State after:
no goals

State before:
case extract.h2.a
w idx w✝ hi lo : Nat
inner : BVExpr w✝
ih :
  ∀ (aig : AIG BVBit) (h1 : idx < aig.decls.size) (h2 : idx < (go aig inner).val.aig.decls.size),
    (go aig inner).val.aig.decls[idx] = aig.decls[idx]
aig : AIG BVBit
h1 : idx < aig.decls.size
h2 : idx < (go aig (extract hi lo inner)).val.aig.decls.size
⊢ aig.decls.size ≤ (go aig inner).val.aig.decls.size
Tactic:
exact (go aig inner).property
State after:
no goals