Theorem: BVExpr.bitblast.blastRotateLeft_eq_eval_getLsb (LeanSAT/Reflect/BVExpr/BitBlast/Lemmas/RotateLeft.lean)

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx : Nat
hidx : idx < w
hidx2 : idx < target.distance % w
⊢ w - target.distance % w + idx < w
Tactic:
omega
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx : Nat
hidx : idx < w
hidx2 : ¬idx < target.distance % w
⊢ idx - target.distance % w < w
Tactic:
omega
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
⊢ ∀ (idx : Nat) (hidx : idx < w),
    ⟦{ aig := (blastRotateLeft aig target).aig, ref := (blastRotateLeft aig target).stream.getRef idx hidx }, assign⟧ =
      if hidx2 : idx < target.distance % w then
        ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx) ⋯ }, assign⟧
      else ⟦{ aig := aig, ref := target.stream.getRef (idx - target.distance % w) ⋯ }, assign⟧
Tactic:
intros
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := (blastRotateLeft aig target).aig, ref := (blastRotateLeft aig target).stream.getRef idx✝ hidx✝ }, assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := (blastRotateLeft aig target).aig, ref := (blastRotateLeft aig target).stream.getRef idx✝ hidx✝ }, assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
unfold blastRotateLeft
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{
        aig :=
          (match target with
            | { stream := input, distance := distance } =>
              { aig := aig, stream := blastRotateLeft.go input distance 0 ⋯ RefStream.empty }).aig,
        ref :=
          (match target with
                | { stream := input, distance := distance } =>
                  { aig := aig, stream := blastRotateLeft.go input distance 0 ⋯ RefStream.empty }).stream.getRef
            idx✝ hidx✝ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{
        aig :=
          (match target with
            | { stream := input, distance := distance } =>
              { aig := aig, stream := blastRotateLeft.go input distance 0 ⋯ RefStream.empty }).aig,
        ref :=
          (match target with
                | { stream := input, distance := distance } =>
                  { aig := aig, stream := blastRotateLeft.go input distance 0 ⋯ RefStream.empty }).stream.getRef
            idx✝ hidx✝ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
dsimp
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := aig, ref := (blastRotateLeft.go target.stream target.distance 0 ⋯ RefStream.empty).getRef idx✝ hidx✝ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := aig, ref := (blastRotateLeft.go target.stream target.distance 0 ⋯ RefStream.empty).getRef idx✝ hidx✝ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
rw [blastRotateLeft.go_getRef]
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := aig,
        ref :=
          if hidx3 : idx✝ < target.distance % w then target.stream.getRef (w - target.distance % w + idx✝) ⋯
          else target.stream.getRef (idx✝ - target.distance % w) ⋯ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

case a
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ 0 ≤ idx✝

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := aig,
        ref :=
          if hidx3 : idx✝ < target.distance % w then target.stream.getRef (w - target.distance % w + idx✝) ⋯
          else target.stream.getRef (idx✝ - target.distance % w) ⋯ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

case a
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ 0 ≤ idx✝
Tactic:
. split
  . rfl
  . rfl
State after:
case a
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ 0 ≤ idx✝

State before:
case a
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ 0 ≤ idx✝
Tactic:
. omega
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ ⟦{ aig := aig,
        ref :=
          if hidx3 : idx✝ < target.distance % w then target.stream.getRef (w - target.distance % w + idx✝) ⋯
          else target.stream.getRef (idx✝ - target.distance % w) ⋯ },
      assign⟧ =
    if hidx2 : idx✝ < target.distance % w then
      ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
    else ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
split
State after:
case isTrue
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧

case isFalse
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : ¬idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

State before:
case isTrue
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧

case isFalse
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : ¬idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
. rfl
State after:
case isFalse
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : ¬idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧

State before:
case isFalse
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : ¬idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
. rfl
State after:
no goals

State before:
case isTrue
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (w - target.distance % w + idx✝) ⋯ }, assign⟧
Tactic:
rfl
State after:
no goals

State before:
case isFalse
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
h✝ : ¬idx✝ < target.distance % w
⊢ ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧ =
    ⟦{ aig := aig, ref := target.stream.getRef (idx✝ - target.distance % w) ⋯ }, assign⟧
Tactic:
rfl
State after:
no goals

State before:
case a
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
w : Nat
aig : AIG α
target : aig.ShiftTarget w
assign : α → Bool
idx✝ : Nat
hidx✝ : idx✝ < w
⊢ 0 ≤ idx✝
Tactic:
omega
State after:
no goals