-- Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.lean
theorem assignmentsInvariant_performRupCheck_of_assignmentsInvariant {n : Nat} (f : DefaultFormula n)
    (f_AssignmentsInvariant : AssignmentsInvariant f) (rupHints : Array Nat) :
    AssignmentsInvariant (performRupCheck f rupHints).1

Proof state:
case intro.intro
n : Nat
f : DefaultFormula n
f_AssignmentsInvariant : f.AssignmentsInvariant
rupHints : Array Nat
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := f.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (f.assignments, [], false, false)
h_inductive :
  ∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
    motive (↑idx) acc → f.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint f.clauses acc rupHints[idx])
hsize : (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst.size = n
h1 : Limplies (PosFin n) f (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst
right✝ :
  (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).snd.snd.fst = true →
    Incompatible (PosFin n) (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst f
i : PosFin n
b : Bool
h :
  hasAssignment b
      { clauses := f.clauses, rupUnits := f.rupUnits, ratUnits := f.ratUnits,
            assignments :=
              (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false)
                  rupHints).fst }.assignments[i.val] =
    true
p : PosFin n → Bool
pf :
  p ⊨
    { clauses := f.clauses, rupUnits := f.rupUnits, ratUnits := f.ratUnits,
      assignments := (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst }
⊢ p ⊨ (i, b)

Tactic:
simp only at h

Result:
case intro.intro
n : Nat
f : DefaultFormula n
f_AssignmentsInvariant : f.AssignmentsInvariant
rupHints : Array Nat
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := f.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (f.assignments, [], false, false)
h_inductive :
  ∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
    motive (↑idx) acc → f.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint f.clauses acc rupHints[idx])
hsize : (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst.size = n
h1 : Limplies (PosFin n) f (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst
right✝ :
  (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).snd.snd.fst = true →
    Incompatible (PosFin n) (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst f
i : PosFin n
b : Bool
h :
  hasAssignment b (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] = true
p : PosFin n → Bool
pf :
  p ⊨
    { clauses := f.clauses, rupUnits := f.rupUnits, ratUnits := f.ratUnits,
      assignments := (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst }
⊢ p ⊨ (i, b)

Proof state:
case neg
n : Nat
f : DefaultFormula n
f_AssignmentsInvariant : f.AssignmentsInvariant
rupHints : Array Nat
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := f.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (f.assignments, [], false, false)
h_inductive :
  ∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
    motive (↑idx) acc → f.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint f.clauses acc rupHints[idx])
hsize : (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst.size = n
right✝ :
  (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).snd.snd.fst = true →
    Incompatible (PosFin n) (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst f
i : PosFin n
b : Bool
h :
  hasAssignment false (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] =
    true
p : PosFin n → Bool
pf :
  p ⊨
    { clauses := f.clauses, rupUnits := f.rupUnits, ratUnits := f.ratUnits,
      assignments := (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst }
i_in_bounds :
  i.val < (Array.foldl (fun b => confirmRupHint f.clauses b) (f.assignments, [], false, false) rupHints).fst.size
h1 :
  hasAssignment (decide (p i = false))
      (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] =
    false
hb : b = false
pi : p i = false
⊢ p i = false

Tactic:
exact pi

Result:
no goals

Proof state:
case neg
n : Nat
f : DefaultFormula n
f_AssignmentsInvariant : f.AssignmentsInvariant
rupHints : Array Nat
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := f.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (f.assignments, [], false, false)
h_inductive :
  ∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
    motive (↑idx) acc → f.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint f.clauses acc rupHints[idx])
hsize : (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst.size = n
right✝ :
  (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).snd.snd.fst = true →
    Incompatible (PosFin n) (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst f
i : PosFin n
b : Bool
h :
  hasAssignment b (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] = true
p : PosFin n → Bool
pf :
  p ⊨
    { clauses := f.clauses, rupUnits := f.rupUnits, ratUnits := f.ratUnits,
      assignments := (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst }
i_in_bounds :
  i.val < (Array.foldl (fun b => confirmRupHint f.clauses b) (f.assignments, [], false, false) rupHints).fst.size
h1 :
  hasAssignment (decide (p i = false))
      (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] =
    false
hb : b = false
⊢ p i = b

Tactic:
rw [hb]

Result:
case neg
n : Nat
f : DefaultFormula n
f_AssignmentsInvariant : f.AssignmentsInvariant
rupHints : Array Nat
motive : Nat → Array Assignment × CNF.Clause (PosFin n) × Bool × Bool → Prop := f.ConfirmRupHintFoldEntailsMotive
h_base : motive 0 (f.assignments, [], false, false)
h_inductive :
  ∀ (idx : Fin rupHints.size) (acc : Array Assignment × CNF.Clause (PosFin n) × Bool × Bool),
    motive (↑idx) acc → f.ConfirmRupHintFoldEntailsMotive (↑idx + 1) (confirmRupHint f.clauses acc rupHints[idx])
hsize : (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst.size = n
right✝ :
  (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).snd.snd.fst = true →
    Incompatible (PosFin n) (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst f
i : PosFin n
b : Bool
h :
  hasAssignment b (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] = true
p : PosFin n → Bool
pf :
  p ⊨
    { clauses := f.clauses, rupUnits := f.rupUnits, ratUnits := f.ratUnits,
      assignments := (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst }
i_in_bounds :
  i.val < (Array.foldl (fun b => confirmRupHint f.clauses b) (f.assignments, [], false, false) rupHints).fst.size
h1 :
  hasAssignment (decide (p i = false))
      (Array.foldl (confirmRupHint f.clauses) (f.assignments, [], false, false) rupHints).fst[i.val] =
    false
hb : b = false
⊢ p i = false