Theorem: AIG.RefStream.denote_fold_and (LeanSAT/AIG/RefStreamOperator.lean)

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ ⟦fold aig (FoldTarget.mkAnd s), assign⟧ = true ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
unfold fold
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ ⟦let res := aig.mkConstCached true;
        let aig_1 := res.aig;
        let acc := res.ref;
        let input := (FoldTarget.mkAnd s).stream.cast ⋯;
        fold.go aig_1 acc 0 (FoldTarget.mkAnd s).len input (FoldTarget.mkAnd s).func,
        assign⟧ =
      true ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ ⟦let res := aig.mkConstCached true;
        let aig_1 := res.aig;
        let acc := res.ref;
        let input := (FoldTarget.mkAnd s).stream.cast ⋯;
        fold.go aig_1 acc 0 (FoldTarget.mkAnd s).len input (FoldTarget.mkAnd s).func,
        assign⟧ =
      true ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
simp only [FoldTarget.mkAnd]
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ ⟦fold.go (aig.mkConstCached true).aig (aig.mkConstCached true).ref 0 len (s.cast ⋯) mkAndCached, assign⟧ = true ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ ⟦fold.go (aig.mkConstCached true).aig (aig.mkConstCached true).ref 0 len (s.cast ⋯) mkAndCached, assign⟧ = true ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
rw [fold.denote_go_and]
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (⟦{ aig := (aig.mkConstCached true).aig, ref := (aig.mkConstCached true).ref }, assign⟧ = true ∧
      ∀ (idx : Nat) (hidx1 : idx < len),
        0 ≤ idx → ⟦{ aig := (aig.mkConstCached true).aig, ref := (s.cast ⋯).getRef idx hidx1 }, assign⟧ = true) ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

case hcurr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ 0 ≤ len

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (⟦{ aig := (aig.mkConstCached true).aig, ref := (aig.mkConstCached true).ref }, assign⟧ = true ∧
      ∀ (idx : Nat) (hidx1 : idx < len),
        0 ≤ idx → ⟦{ aig := (aig.mkConstCached true).aig, ref := (s.cast ⋯).getRef idx hidx1 }, assign⟧ = true) ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

case hcurr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ 0 ≤ len
Tactic:
. simp only [denote_projected_entry, mkConstCached_eval_eq_mkConst_eval, denote_mkConst,
  Nat.zero_le, getRef_cast, Ref_cast', true_implies, true_and]
  constructor
  . intro h idx hidx
    specialize h idx hidx
    rw [AIG.LawfulOperator.denote_mem_prefix (f := mkConstCached)] at h
    rw [← h]
  . intro h idx hidx
    specialize h idx hidx
    rw [AIG.LawfulOperator.denote_mem_prefix (f := mkConstCached)]
    . simp only [← h]
    . apply RefStream.hrefs
      simp [FoldTarget.mkAnd, hidx]
State after:
case hcurr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ 0 ≤ len

State before:
case hcurr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ 0 ≤ len
Tactic:
. omega
State after:
no goals

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (⟦{ aig := (aig.mkConstCached true).aig, ref := (aig.mkConstCached true).ref }, assign⟧ = true ∧
      ∀ (idx : Nat) (hidx1 : idx < len),
        0 ≤ idx → ⟦{ aig := (aig.mkConstCached true).aig, ref := (s.cast ⋯).getRef idx hidx1 }, assign⟧ = true) ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
simp only [denote_projected_entry, mkConstCached_eval_eq_mkConst_eval, denote_mkConst,
Nat.zero_le, getRef_cast, Ref_cast', true_implies, true_and]
State after:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ =
        true) ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

State before:
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ =
        true) ↔
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
constructor
State after:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ =
        true) →
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true) →
    ∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true

State before:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ =
        true) →
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true) →
    ∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true
Tactic:
. intro h idx hidx
  specialize h idx hidx
  rw [AIG.LawfulOperator.denote_mem_prefix (f := mkConstCached)] at h
  rw [← h]
State after:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true) →
    ∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true) →
    ∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true
Tactic:
. intro h idx hidx
  specialize h idx hidx
  rw [AIG.LawfulOperator.denote_mem_prefix (f := mkConstCached)]
  . simp only [← h]
  . apply RefStream.hrefs
    simp [FoldTarget.mkAnd, hidx]
State after:
no goals

State before:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ =
        true) →
    ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
intro h idx hidx
State after:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
h :
  ∀ (idx : Nat) (hidx1 : idx < len),
    ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true
idx : Nat
hidx : idx < len
⊢ ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

State before:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
h :
  ∀ (idx : Nat) (hidx1 : idx < len),
    ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true
idx : Nat
hidx : idx < len
⊢ ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
specialize h idx hidx
State after:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

State before:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
Tactic:
rw [AIG.LawfulOperator.denote_mem_prefix (f := mkConstCached)] at h
State after:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h✝ : ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
h : ⟦{ aig := aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ?mp } }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size

State before:
case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h✝ : ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
h : ⟦{ aig := aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ?mp } }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true

case mp
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size
Tactic:
rw [← h]
State after:
no goals

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ (∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true) →
    ∀ (idx : Nat) (hidx1 : idx < len),
      ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx1).gate, hgate := ⋯ } }, assign⟧ = true
Tactic:
intro h idx hidx
State after:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
h : ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
idx : Nat
hidx : idx < len
⊢ ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
h : ∀ (idx : Nat) (hidx : idx < len), ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
idx : Nat
hidx : idx < len
⊢ ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
Tactic:
specialize h idx hidx
State after:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ ⟦{ aig := (aig.mkConstCached true).aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ⋯ } }, assign⟧ = true
Tactic:
rw [AIG.LawfulOperator.denote_mem_prefix (f := mkConstCached)]
State after:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ?mpr } }, assign⟧ = true

case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ?mpr } }, assign⟧ = true

case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size
Tactic:
. simp only [← h]
State after:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size
Tactic:
. apply RefStream.hrefs
  simp [FoldTarget.mkAnd, hidx]
State after:
no goals

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ ⟦{ aig := aig, ref := { gate := (s.getRef idx hidx).gate, hgate := ?mpr } }, assign⟧ = true
Tactic:
simp only [← h]
State after:
no goals

State before:
case mpr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ (s.getRef idx hidx).gate < aig.decls.size
Tactic:
apply RefStream.hrefs
State after:
case mpr.h
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ idx < len

State before:
case mpr.h
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
idx : Nat
hidx : idx < len
h : ⟦{ aig := aig, ref := s.getRef idx hidx }, assign⟧ = true
⊢ idx < len
Tactic:
simp [FoldTarget.mkAnd, hidx]
State after:
no goals

State before:
case hcurr
α : Type
inst✝² : BEq α
inst✝¹ : Hashable α
inst✝ : DecidableEq α
aig✝ : AIG α
len : Nat
assign : α → Bool
aig : AIG α
s : aig.RefStream len
⊢ 0 ≤ len
Tactic:
omega
State after:
no goals