Theorem: Sat.Valuation.mk_implies
File: Mathlib/Tactic/Sat/FromLRAT.lean

tactic: induction ps generalizing as₁ with
| nil => exact fun _ ↦ id
| cons a as ih =>
  refine fun e H ↦ @ih (a::as₁) e (H ?_)
  subst e; clear ih H
  suffices ∀ n n', n' = List.length as₁ + n →
    ∀ bs, mk (as₁.reverseAux bs) n' ↔ mk bs n from this 0 _ rfl (a::as)
  induction as₁ with simp
  | cons b as₁ ih => exact fun n bs ↦ ih (n+1) _ (Nat.succ_add ..) _
state_before: p : Prop
as ps as₁ : List Prop
⊢ as = as₁.reverseAux ps → (mk as).implies p ps as₁.length → p
state_after: no goals

tactic: exact fun _ ↦ id
state_before: case nil
p : Prop
as as₁ : List Prop
⊢ as = as₁.reverseAux [] → (mk as).implies p [] as₁.length → p
state_after: no goals

tactic: refine fun e H ↦ @ih (a::as₁) e (H ?_)
state_before: case cons
p : Prop
as✝ : List Prop
a : Prop
as : List Prop
ih : ∀ (as₁ : List Prop), as✝ = as₁.reverseAux as → (mk as✝).implies p as as₁.length → p
as₁ : List Prop
⊢ as✝ = as₁.reverseAux (a :: as) → (mk as✝).implies p (a :: as) as₁.length → p
state_after: case cons
p : Prop
as✝ : List Prop
a : Prop
as : List Prop
ih : ∀ (as₁ : List Prop), as✝ = as₁.reverseAux as → (mk as✝).implies p as as₁.length → p
as₁ : List Prop
e : as✝ = as₁.reverseAux (a :: as)
H : (mk as✝).implies p (a :: as) as₁.length
⊢ mk as✝ as₁.length ↔ a

tactic: subst e
state_before: case cons
p : Prop
as✝ : List Prop
a : Prop
as : List Prop
ih : ∀ (as₁ : List Prop), as✝ = as₁.reverseAux as → (mk as✝).implies p as as₁.length → p
as₁ : List Prop
e : as✝ = as₁.reverseAux (a :: as)
H : (mk as✝).implies p (a :: as) as₁.length
⊢ mk as✝ as₁.length ↔ a
state_after: case cons
p a : Prop
as as₁ : List Prop
ih :
  ∀ (as₁_1 : List Prop),
    as₁.reverseAux (a :: as) = as₁_1.reverseAux as → (mk (as₁.reverseAux (a :: as))).implies p as as₁_1.length → p
H : (mk (as₁.reverseAux (a :: as))).implies p (a :: as) as₁.length
⊢ mk (as₁.reverseAux (a :: as)) as₁.length ↔ a

tactic: clear ih H
state_before: case cons
p a : Prop
as as₁ : List Prop
ih :
  ∀ (as₁_1 : List Prop),
    as₁.reverseAux (a :: as) = as₁_1.reverseAux as → (mk (as₁.reverseAux (a :: as))).implies p as as₁_1.length → p
H : (mk (as₁.reverseAux (a :: as))).implies p (a :: as) as₁.length
⊢ mk (as₁.reverseAux (a :: as)) as₁.length ↔ a
state_after: case cons
p a : Prop
as as₁ : List Prop
⊢ mk (as₁.reverseAux (a :: as)) as₁.length ↔ a

tactic: suffices ∀ n n', n' = List.length as₁ + n →
  ∀ bs, mk (as₁.reverseAux bs) n' ↔ mk bs n from this 0 _ rfl (a::as)
state_before: case cons
p a : Prop
as as₁ : List Prop
⊢ mk (as₁.reverseAux (a :: as)) as₁.length ↔ a
state_after: case cons
p a : Prop
as as₁ : List Prop
⊢ ∀ (n n' : ℕ), n' = as₁.length + n → ∀ (bs : List Prop), mk (as₁.reverseAux bs) n' ↔ mk bs n

tactic: induction as₁ with simp
| cons b as₁ ih => exact fun n bs ↦ ih (n+1) _ (Nat.succ_add ..) _
state_before: case cons
p a : Prop
as as₁ : List Prop
⊢ ∀ (n n' : ℕ), n' = as₁.length + n → ∀ (bs : List Prop), mk (as₁.reverseAux bs) n' ↔ mk bs n
state_after: no goals

tactic: exact fun n bs ↦ ih (n+1) _ (Nat.succ_add ..) _
state_before: case cons.cons
p a : Prop
as : List Prop
b : Prop
as₁ : List Prop
ih : ∀ (n n' : ℕ), n' = as₁.length + n → ∀ (bs : List Prop), mk (as₁.reverseAux bs) n' ↔ mk bs n
⊢ ∀ (n : ℕ) (bs : List Prop), mk (as₁.reverseAux (b :: bs)) (as₁.length + 1 + n) ↔ mk bs n
state_after: no goals