internlm/Lean-Github huggingface dataset:
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
k_ne_j : ⟨↑k, k_in_bounds⟩ ≠ j
⊢ derivedLits_arr[k].fst.val ≠ ↑i
Tactic:
simp only [Fin.getElem_fin, Array.getElem_eq_data_get, ne_eq, derivedLits_arr_def]
Proof state after:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
k_ne_j : ⟨↑k, k_in_bounds⟩ ≠ j
⊢ ¬(derivedLits.get ⟨↑k, ⋯⟩).fst.val = ↑i
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
k_ne_j : ⟨↑k, k_in_bounds⟩ ≠ j
⊢ ¬(derivedLits.get ⟨↑k, ⋯⟩).fst.val = ↑i
Tactic:
exact h3 ⟨k.1, k_in_bounds⟩ k_ne_j
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
Tactic:
have k_property := k.2
Proof state after:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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_property : ↑k < derivedLits_arr.size
⊢ ↑k < derivedLits.length
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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_property : ↑k < derivedLits_arr.size
⊢ ↑k < derivedLits.length
Tactic:
simp only [derivedLits_arr_def, Array.size_mk] at k_property
Proof state after:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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_property : ↑k < derivedLits.length
⊢ ↑k < derivedLits.length
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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_property : ↑k < derivedLits.length
⊢ ↑k < derivedLits.length
Tactic:
exact k_property
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
⊢ ⟨↑k, k_in_bounds⟩ ≠ j
Tactic:
apply Fin.ne_of_val_ne
Proof state after:
case h
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
⊢ ¬↑⟨↑k, k_in_bounds⟩ = ↑j
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
case h
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
⊢ ¬↑⟨↑k, k_in_bounds⟩ = ↑j
Tactic:
simp only
Proof state after:
case h
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
⊢ ¬↑k = ↑j
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
case h
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j : Fin derivedLits.length
j_eq_i : (derivedLits.get j).fst.val = ↑i
h1 : f'.assignments[↑i] = addAssignment (derivedLits.get j).snd f.assignments[↑i]
h2 : ¬hasAssignment (derivedLits.get j).snd f.assignments[↑i] = true
h3 : ∀ (k : Fin derivedLits.length), k ≠ j → (derivedLits.get 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 < derivedLits.length
⊢ ¬↑k = ↑j
Tactic:
exact Fin.val_ne_of_ne k_ne_j
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin derivedLits.length
j1_eq_i : (derivedLits.get j1).fst.val = ↑i
j2_eq_i : (derivedLits.get j2).fst.val = ↑i
j1_eq_true : (derivedLits.get j1).snd = true
j2_eq_false : (derivedLits.get j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin derivedLits.length), k ≠ j1 → k ≠ j2 → (derivedLits.get k).fst.val ≠ ↑i
⊢ ∃ j1 j2 i_gt_zero,
    ↑j1 ≥ 0 ∧
      ↑j2 ≥ 0 ∧
        derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
          derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
            f'.assignments[↑i] = both ∧
              f.assignments[↑i] = unassigned ∧
                ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i
Tactic:
have j1_lt_derivedLits_arr_size : j1.1 < derivedLits_arr.size := by
  simp only [derivedLits_arr_def, Array.size_mk]
  exact j1.2
Proof state after:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin derivedLits.length
j1_eq_i : (derivedLits.get j1).fst.val = ↑i
j2_eq_i : (derivedLits.get j2).fst.val = ↑i
j1_eq_true : (derivedLits.get j1).snd = true
j2_eq_false : (derivedLits.get j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin derivedLits.length), k ≠ j1 → k ≠ j2 → (derivedLits.get k).fst.val ≠ ↑i
j1_lt_derivedLits_arr_size : ↑j1 < derivedLits_arr.size
⊢ ∃ j1 j2 i_gt_zero,
    ↑j1 ≥ 0 ∧
      ↑j2 ≥ 0 ∧
        derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
          derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
            f'.assignments[↑i] = both ∧
              f.assignments[↑i] = unassigned ∧
                ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin derivedLits.length
j1_eq_i : (derivedLits.get j1).fst.val = ↑i
j2_eq_i : (derivedLits.get j2).fst.val = ↑i
j1_eq_true : (derivedLits.get j1).snd = true
j2_eq_false : (derivedLits.get j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin derivedLits.length), k ≠ j1 → k ≠ j2 → (derivedLits.get k).fst.val ≠ ↑i
j1_lt_derivedLits_arr_size : ↑j1 < derivedLits_arr.size
⊢ ∃ j1 j2 i_gt_zero,
    ↑j1 ≥ 0 ∧
      ↑j2 ≥ 0 ∧
        derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
          derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
            f'.assignments[↑i] = both ∧
              f.assignments[↑i] = unassigned ∧
                ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i
Tactic:
have j2_lt_derivedLits_arr_size : j2.1 < derivedLits_arr.size := by
  simp only [derivedLits_arr_def, Array.size_mk]
  exact j2.2
Proof state after:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin derivedLits.length
j1_eq_i : (derivedLits.get j1).fst.val = ↑i
j2_eq_i : (derivedLits.get j2).fst.val = ↑i
j1_eq_true : (derivedLits.get j1).snd = true
j2_eq_false : (derivedLits.get j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin derivedLits.length), k ≠ j1 → k ≠ j2 → (derivedLits.get k).fst.val ≠ ↑i
j1_lt_derivedLits_arr_size : ↑j1 < derivedLits_arr.size
j2_lt_derivedLits_arr_size : ↑j2 < derivedLits_arr.size
⊢ ∃ j1 j2 i_gt_zero,
    ↑j1 ≥ 0 ∧
      ↑j2 ≥ 0 ∧
        derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
          derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
            f'.assignments[↑i] = both ∧
              f.assignments[↑i] = unassigned ∧
                ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i
Theorem: LRAT.DefaultFormula.restoreAssignments_performRupCheck_base_case
Proof state before:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin derivedLits.length
j1_eq_i : (derivedLits.get j1).fst.val = ↑i
j2_eq_i : (derivedLits.get j2).fst.val = ↑i
j1_eq_true : (derivedLits.get j1).snd = true
j2_eq_false : (derivedLits.get j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin derivedLits.length), k ≠ j1 → k ≠ j2 → (derivedLits.get k).fst.val ≠ ↑i
j1_lt_derivedLits_arr_size : ↑j1 < derivedLits_arr.size
j2_lt_derivedLits_arr_size : ↑j2 < derivedLits_arr.size
⊢ ∃ j1 j2 i_gt_zero,
    ↑j1 ≥ 0 ∧
      ↑j2 ≥ 0 ∧
        derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
          derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
            f'.assignments[↑i] = both ∧
              f.assignments[↑i] = unassigned ∧
                ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i
Tactic:
have i_gt_zero : i.1 > 0 := by rw [← j1_eq_i]; exact (List.get derivedLits j1).1.2.1
Proof state after:
case inr.inr.intro.intro.intro.intro.intro.intro.intro.intro
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 : List (Literal (PosFin n))
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
_derivedLits_arr_nodup : ∀ (i j : Fin derivedLits_arr.size), i ≠ j → derivedLits_arr[i] ≠ derivedLits_arr[j]
i : Fin n
j1 j2 : Fin derivedLits.length
j1_eq_i : (derivedLits.get j1).fst.val = ↑i
j2_eq_i : (derivedLits.get j2).fst.val = ↑i
j1_eq_true : (derivedLits.get j1).snd = true
j2_eq_false : (derivedLits.get j2).snd = false
h1 : f'.assignments[↑i] = both
h2 : f.assignments[↑i] = unassigned
h3 : ∀ (k : Fin derivedLits.length), k ≠ j1 → k ≠ j2 → (derivedLits.get 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
⊢ ∃ j1 j2 i_gt_zero,
    ↑j1 ≥ 0 ∧
      ↑j2 ≥ 0 ∧
        derivedLits_arr[j1] = (⟨↑i, ⋯⟩, true) ∧
          derivedLits_arr[j2] = (⟨↑i, ⋯⟩, false) ∧
            f'.assignments[↑i] = both ∧
              f.assignments[↑i] = unassigned ∧
                ∀ (k : Fin derivedLits_arr.size), ↑k ≥ 0 → k ≠ j1 → k ≠ j2 → derivedLits_arr[k].fst.val ≠ ↑i