internlm/Lean-Github huggingface dataset:
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_eq_i : ↑k = ↑i
j_ne_k : ⟨↑j, j_in_bounds⟩ ≠ k
h3 : (derivedLits.get ⟨↑j, j_in_bounds⟩).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
⊢ False
Tactic:
simp only [derivedLits_arr_def, Fin.getElem_fin] at li_eq_lj
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_eq_i : ↑k = ↑i
j_ne_k : ⟨↑j, j_in_bounds⟩ ≠ k
h3 : (derivedLits.get ⟨↑j, j_in_bounds⟩).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
li_eq_lj : { data := derivedLits }[↑i] = { data := derivedLits }[↑j]
⊢ False
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_eq_i : ↑k = ↑i
j_ne_k : ⟨↑j, j_in_bounds⟩ ≠ k
h3 : (derivedLits.get ⟨↑j, j_in_bounds⟩).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
li_eq_lj : { data := derivedLits }[↑i] = { data := derivedLits }[↑j]
⊢ False
Tactic:
simp only [Fin.getElem_fin, derivedLits_arr_def, ne_eq, li, li_eq_lj] at h3
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_eq_i : ↑k = ↑i
j_ne_k : ⟨↑j, j_in_bounds⟩ ≠ k
li_eq_lj : { data := derivedLits }[↑i] = { data := derivedLits }[↑j]
h3 : ¬(derivedLits.get ⟨↑j, j_in_bounds⟩).fst.val = { data := derivedLits }[↑j].fst.val
⊢ False
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_eq_i : ↑k = ↑i
j_ne_k : ⟨↑j, j_in_bounds⟩ ≠ k
li_eq_lj : { data := derivedLits }[↑i] = { data := derivedLits }[↑j]
h3 : ¬(derivedLits.get ⟨↑j, j_in_bounds⟩).fst.val = { data := derivedLits }[↑j].fst.val
⊢ False
Tactic:
simp only [Array.getElem_eq_data_get, not_true] at h3
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_eq_i : ↑k = ↑i
⊢ ⟨↑j, j_in_bounds⟩ ≠ k
Tactic:
intro j_eq_k
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_eq_i : ↑k = ↑i
j_eq_k : ⟨↑j, j_in_bounds⟩ = k
⊢ False
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_eq_i : ↑k = ↑i
j_eq_k : ⟨↑j, j_in_bounds⟩ = k
⊢ False
Tactic:
simp only [← j_eq_k] at k_eq_i
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
j_eq_k : ⟨↑j, j_in_bounds⟩ = k
k_eq_i : ↑j = ↑i
⊢ False
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
j_eq_k : ⟨↑j, j_in_bounds⟩ = k
k_eq_i : ↑j = ↑i
⊢ False
Tactic:
exact i_ne_j $ Fin.eq_of_val_eq (Eq.symm k_eq_i)
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
case neg
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
h✝ : ¬↑k = ↑i
⊢ False
Tactic:
next k_ne_i =>
have i_ne_k : ⟨i.1, i_in_bounds⟩ ≠ k := by intro i_eq_k; simp only [← i_eq_k, not_true] at k_ne_i
specialize h3 ⟨i.1, i_in_bounds⟩ i_ne_k
simp (config := { decide := true }) only [Fin.getElem_fin, derivedLits_arr_def, ne_eq, Array.getElem_eq_data_get, li] at h3
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_ne_i : ¬↑k = ↑i
⊢ False
Tactic:
have i_ne_k : ⟨i.1, i_in_bounds⟩ ≠ k := by intro i_eq_k; simp only [← i_eq_k, not_true] at k_ne_i
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_ne_i : ¬↑k = ↑i
i_ne_k : ⟨↑i, i_in_bounds⟩ ≠ k
⊢ False
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_ne_i : ¬↑k = ↑i
i_ne_k : ⟨↑i, i_in_bounds⟩ ≠ k
⊢ False
Tactic:
specialize h3 ⟨i.1, i_in_bounds⟩ i_ne_k
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_ne_i : ¬↑k = ↑i
i_ne_k : ⟨↑i, i_in_bounds⟩ ≠ k
h3 : (derivedLits.get ⟨↑i, i_in_bounds⟩).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
⊢ False
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
k_ne_i : ¬↑k = ↑i
i_ne_k : ⟨↑i, i_in_bounds⟩ ≠ k
h3 : (derivedLits.get ⟨↑i, i_in_bounds⟩).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
⊢ False
Tactic:
simp (config := { decide := true }) only [Fin.getElem_fin, derivedLits_arr_def, ne_eq, Array.getElem_eq_data_get, li] at h3
Proof state after:
no goals
Theorem: LRAT.DefaultFormula.derivedLits_nodup
Proof state before:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_ne_i : ¬↑k = ↑i
⊢ ⟨↑i, i_in_bounds⟩ ≠ k
Tactic:
intro i_eq_k
Proof state after:
n : Nat
f : DefaultFormula n
f_assignments_size : f.assignments.size = n
rupHints : Array Nat
f'_assignments_size : (f.performRupCheck rupHints).fst.assignments.size = n
derivedLits : List (Literal (PosFin n))
derivedLits_satisfies_invariant :
  f.derivedLits_invariant f_assignments_size (f.performRupCheck rupHints).fst.assignments f'_assignments_size
    derivedLits
derivedLits_arr : Array (Literal (PosFin n))
derivedLits_arr_def : derivedLits_arr = { data := derivedLits }
i j : Fin derivedLits_arr.size
i_ne_j : i ≠ j
li_eq_lj : derivedLits_arr[i] = derivedLits_arr[j]
li : Literal (PosFin n) := derivedLits_arr[i]
li_in_derivedLits : li ∈ derivedLits
i_in_bounds : ↑i < derivedLits.length
j_in_bounds : ↑j < derivedLits.length
k : Fin derivedLits.length
left✝² : (derivedLits.get k).fst.val = ↑⟨li.fst.val, ⋯⟩
left✝¹ :
  (f.performRupCheck rupHints).fst.assignments[↑⟨li.fst.val, ⋯⟩] =
    addAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩]
left✝ : ¬hasAssignment (derivedLits.get k).snd f.assignments[↑⟨li.fst.val, ⋯⟩] = true
h3 : ∀ (k_1 : Fin derivedLits.length), k_1 ≠ k → (derivedLits.get k_1).fst.val ≠ ↑⟨li.fst.val, ⋯⟩
k_ne_i : ¬↑k = ↑i
i_eq_k : ⟨↑i, i_in_bounds⟩ = k
⊢ False