-- Mathlib/.lake/packages/lean4/src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean
theorem restoreAssignments_performRupCheck_base_case {n : Nat} (f : DefaultFormula n)
    (f_assignments_size : f.assignments.size = n)
    (f' : DefaultFormula n) (_f'_def : f' = (performRupCheck f rupHints).1)
    (f'_assignments_size : f'.assignments.size = n) (derivedLits : CNF.Clause (PosFin n))
    (derivedLits_arr : Array (Literal (PosFin n)))
    (derivedLits_arr_def : derivedLits_arr = {toList := derivedLits})
    (derivedLits_satisfies_invariant :
      DerivedLitsInvariant f f_assignments_size f'.assignments f'_assignments_size derivedLits)
    (_derivedLits_arr_nodup : ∀ (i j : Fin (Array.size derivedLits_arr)), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]) :
    ClearInsertInductionMotive f f_assignments_size derivedLits_arr 0 f'.assignments

Proof state:
case inr.inl.intro.intro.intro.intro.right.right
rupHints : Array Nat
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
f' : DefaultFormula n
_f'_def : f' = (f.performRupCheck rupHints).fst
f'_assignments_size : f'.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin (List.length derivedLits)
j_eq_i : (List.get derivedLits j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (List.get derivedLits j).snd f.assignments[↑i]
h2 : ¬hasAssignment (List.get derivedLits j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin (List.length derivedLits)), k ≠ j → (List.get derivedLits k).fst.val ≠ ↑i
j_lt_derivedLits_arr_size : ↑j < derivedLits_arr.size
i_gt_zero : ↑i > 0
k : Fin derivedLits_arr.size
a✝ : ↑k ≥ 0
k_ne_j✝ : k ≠ ⟨↑j, j_lt_derivedLits_arr_size⟩
k_in_bounds : ↑k < List.length derivedLits
k_ne_j : ⟨↑k, k_in_bounds⟩ ≠ j
⊢ derivedLits_arr[k].fst.val ≠ ↑i

Tactic:
simp only [Fin.getElem_fin, ne_eq, derivedLits_arr_def]

Result:
case inr.inl.intro.intro.intro.intro.right.right
rupHints : Array Nat
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
f' : DefaultFormula n
_f'_def : f' = (f.performRupCheck rupHints).fst
f'_assignments_size : f'.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin (List.length derivedLits)
j_eq_i : (List.get derivedLits j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (List.get derivedLits j).snd f.assignments[↑i]
h2 : ¬hasAssignment (List.get derivedLits j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin (List.length derivedLits)), k ≠ j → (List.get derivedLits k).fst.val ≠ ↑i
j_lt_derivedLits_arr_size : ↑j < derivedLits_arr.size
i_gt_zero : ↑i > 0
k : Fin derivedLits_arr.size
a✝ : ↑k ≥ 0
k_ne_j✝ : k ≠ ⟨↑j, j_lt_derivedLits_arr_size⟩
k_in_bounds : ↑k < List.length derivedLits
k_ne_j : ⟨↑k, k_in_bounds⟩ ≠ j
⊢ ¬{ toList := derivedLits }[↑k].fst.val = ↑i

Proof state:
rupHints : Array Nat
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
f' : DefaultFormula n
_f'_def : f' = (f.performRupCheck rupHints).fst
f'_assignments_size : f'.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
derivedLits_satisfies_invariant :
  f.DerivedLitsInvariant f_assignments_size f'.assignments f'_assignments_size derivedLits
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
⊢ f.ClearInsertInductionMotive f_assignments_size derivedLits_arr 0 f'.assignments

Tactic:
apply Exists.intro f'_assignments_size

Result:
rupHints : Array Nat
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
f' : DefaultFormula n
_f'_def : f' = (f.performRupCheck rupHints).fst
f'_assignments_size : f'.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
derivedLits_satisfies_invariant :
  f.DerivedLitsInvariant f_assignments_size f'.assignments f'_assignments_size derivedLits
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
⊢ ∀ (i : Fin n),
    let_fun i_lt_assignments_size := ⋯;
    let_fun i_lt_f_assignments_size := ⋯;
    let assignments_i := f'.assignments[↑i];
    let fassignments_i := f.assignments[↑i];
    (assignments_i = fassignments_i ∧ ∀ (j : Fin derivedLits_arr.size), ↑j ≥ 0 → derivedLits_arr[j].fst.val ≠ ↑i) ∨
      (∃ j b i_gt_zero,
          ↑j ≥ 0 ∧
            derivedLits_arr[j] = (⟨↑i, ⋯⟩, b) ∧
              assignments_i = addAssignment b fassignments_i ∧
                ¬hasAssignment b fassignments_i = true ∧
                  ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j → derivedLits_arr[k].fst.val ≠ ↑i) ∨
        ∃ j1 j2 i_gt_zero,
          ↑j1 ≥ 0 ∧
            ↑j2 ≥ 0 ∧
              derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
                derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
                  assignments_i = both ∧
                    fassignments_i = unassigned ∧
                      ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i

Proof state:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro.left
rupHints : Array Nat
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
f' : DefaultFormula n
_f'_def : f' = (f.performRupCheck rupHints).fst
f'_assignments_size : f'.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin (List.length derivedLits)
j1_eq_i : (List.get derivedLits j1).fst.val = ↑i
j2_eq_i : (List.get derivedLits j2).fst.val = ↑i
j1_eq_true : (List.get derivedLits j1).snd = true
j2_eq_false : (List.get derivedLits j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length derivedLits)), k ≠ j1 → k ≠ j2 → (List.get derivedLits k).fst.val ≠ ↑i
j1_lt_derivedLits_arr_size : ↑j1 < derivedLits_arr.size
j2_lt_derivedLits_arr_size : ↑j2 < derivedLits_arr.size
i_gt_zero : ↑i > 0
⊢ { toList := derivedLits }[↑j1] = (⟨(List.get derivedLits j1).fst.val, ⋯⟩, true)

Tactic:
rw [← j1_eq_true]

Result:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro.left
rupHints : Array Nat
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
f' : DefaultFormula n
_f'_def : f' = (f.performRupCheck rupHints).fst
f'_assignments_size : f'.assignments.size = n
derivedLits : CNF.Clause (PosFin n)
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { toList := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin (List.length derivedLits)
j1_eq_i : (List.get derivedLits j1).fst.val = ↑i
j2_eq_i : (List.get derivedLits j2).fst.val = ↑i
j1_eq_true : (List.get derivedLits j1).snd = true
j2_eq_false : (List.get derivedLits j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin (List.length derivedLits)), k ≠ j1 → k ≠ j2 → (List.get derivedLits k).fst.val ≠ ↑i
j1_lt_derivedLits_arr_size : ↑j1 < derivedLits_arr.size
j2_lt_derivedLits_arr_size : ↑j2 < derivedLits_arr.size
i_gt_zero : ↑i > 0
⊢ { toList := derivedLits }[↑j1] = (⟨(List.get derivedLits j1).fst.val, ⋯⟩, (List.get derivedLits j1).snd)