Theorem: FirstOrder.Language.BoundedFormula.listDecode_encode_list
File: Mathlib/ModelTheory/Encoding.lean

tactic: rintro ⟨n, φ⟩
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List ((n : ℕ) × L.BoundedFormula α n)
⊢ ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
state_after: case mk
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List ((n : ℕ) × L.BoundedFormula α n)
n : ℕ
φ : L.BoundedFormula α n
⊢ ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n, φ⟩.snd.listEncode ++ l)).1 = ⟨n, φ⟩ ∧ ↑(listDecode (⟨n, φ⟩.snd.listEncode ++ l)).2 = l

tactic: induction' φ with _ _ _ _ φ_n φ_l φ_R ts _ _ _ ih1 ih2 _ _ ih <;> intro l
state_before: case mk
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List ((n : ℕ) × L.BoundedFormula α n)
n : ℕ
φ : L.BoundedFormula α n
⊢ ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n, φ⟩.snd.listEncode ++ l)).1 = ⟨n, φ⟩ ∧ ↑(listDecode (⟨n, φ⟩.snd.listEncode ++ l)).2 = l
state_after: case mk.falsum
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, falsum⟩.snd.listEncode ++ l)).1 = ⟨n✝, falsum⟩ ∧
    ↑(listDecode (⟨n✝, falsum⟩.snd.listEncode ++ l)).2 = l

case mk.equal
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, equal t₁✝ t₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, equal t₁✝ t₂✝⟩ ∧
    ↑(listDecode (⟨n✝, equal t₁✝ t₂✝⟩.snd.listEncode ++ l)).2 = l

case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨φ_n, rel φ_R ts⟩.snd.listEncode ++ l)).1 = ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(listDecode (⟨φ_n, rel φ_R ts⟩.snd.listEncode ++ l)).2 = l

case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, f₁✝ ⟹ f₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    ↑(listDecode (⟨n✝, f₁✝ ⟹ f₂✝⟩.snd.listEncode ++ l)).2 = l

case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧
      ↑(listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, ∀'f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, ∀'f✝⟩ ∧ ↑(listDecode (⟨n✝, ∀'f✝⟩.snd.listEncode ++ l)).2 = l

tactic: induction' l with φ l _
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l : List ((n : ℕ) × L.BoundedFormula α n)
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
⊢ (listDecode (l.bind fun φ => φ.snd.listEncode)).1 = l.headI
state_after: case nil
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
⊢ (listDecode ([].bind fun φ => φ.snd.listEncode)).1 = [].headI

case cons
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
φ : (n : ℕ) × L.BoundedFormula α n
l : List ((n : ℕ) × L.BoundedFormula α n)
tail_ih✝ : (listDecode (l.bind fun φ => φ.snd.listEncode)).1 = l.headI
⊢ (listDecode ((φ :: l).bind fun φ => φ.snd.listEncode)).1 = (φ :: l).headI

tactic: rw [List.nil_bind]
state_before: case nil
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
⊢ (listDecode ([].bind fun φ => φ.snd.listEncode)).1 = [].headI
state_after: case nil
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
⊢ (listDecode []).1 = [].headI

tactic: simp [listDecode]
state_before: case nil
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
⊢ (listDecode []).1 = [].headI
state_after: no goals

tactic: rw [cons_bind, (h φ _).1, headI_cons]
state_before: case cons
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
h :
  ∀ (φ : (n : ℕ) × L.BoundedFormula α n) (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (φ.snd.listEncode ++ l)).1 = φ ∧ ↑(listDecode (φ.snd.listEncode ++ l)).2 = l
φ : (n : ℕ) × L.BoundedFormula α n
l : List ((n : ℕ) × L.BoundedFormula α n)
tail_ih✝ : (listDecode (l.bind fun φ => φ.snd.listEncode)).1 = l.headI
⊢ (listDecode ((φ :: l).bind fun φ => φ.snd.listEncode)).1 = (φ :: l).headI
state_after: no goals

tactic: rw [listEncode, singleton_append, listDecode]
state_before: case mk.falsum
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, falsum⟩.snd.listEncode ++ l)).1 = ⟨n✝, falsum⟩ ∧
    ↑(listDecode (⟨n✝, falsum⟩.snd.listEncode ++ l)).2 = l
state_after: case mk.falsum
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (⟨⟨n✝, falsum⟩.fst, falsum⟩, ⟨l, ⋯⟩).1 = ⟨n✝, falsum⟩ ∧ ↑(⟨⟨n✝, falsum⟩.fst, falsum⟩, ⟨l, ⋯⟩).2 = l

tactic: simp only [eq_self_iff_true, heq_iff_eq, and_self_iff]
state_before: case mk.falsum
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (⟨⟨n✝, falsum⟩.fst, falsum⟩, ⟨l, ⋯⟩).1 = ⟨n✝, falsum⟩ ∧ ↑(⟨⟨n✝, falsum⟩.fst, falsum⟩, ⟨l, ⋯⟩).2 = l
state_after: no goals

tactic: rw [listEncode, cons_append, cons_append, listDecode, dif_pos]
state_before: case mk.equal
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, equal t₁✝ t₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, equal t₁✝ t₂✝⟩ ∧
    ↑(listDecode (⟨n✝, equal t₁✝ t₂✝⟩.snd.listEncode ++ l)).2 = l
state_after: case mk.equal
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (⟨⟨n✝, equal t₁✝ t₂✝⟩.fst, equal t₁✝ (⋯.mp t₂✝)⟩, ⟨[] ++ l, ⋯⟩).1 = ⟨n✝, equal t₁✝ t₂✝⟩ ∧
    ↑(⟨⟨n✝, equal t₁✝ t₂✝⟩.fst, equal t₁✝ (⋯.mp t₂✝)⟩, ⟨[] ++ l, ⋯⟩).2 = l

case mk.equal.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ ⟨n✝, equal t₁✝ t₂✝⟩.fst = ⟨n✝, equal t₁✝ t₂✝⟩.fst

tactic: simp only [eq_mp_eq_cast, cast_eq, eq_self_iff_true, heq_iff_eq, and_self_iff, nil_append]
state_before: case mk.equal
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (⟨⟨n✝, equal t₁✝ t₂✝⟩.fst, equal t₁✝ (⋯.mp t₂✝)⟩, ⟨[] ++ l, ⋯⟩).1 = ⟨n✝, equal t₁✝ t₂✝⟩ ∧
    ↑(⟨⟨n✝, equal t₁✝ t₂✝⟩.fst, equal t₁✝ (⋯.mp t₂✝)⟩, ⟨[] ++ l, ⋯⟩).2 = l
state_after: no goals

tactic: simp only [eq_self_iff_true, heq_iff_eq, and_self_iff]
state_before: case mk.equal.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ ⟨n✝, equal t₁✝ t₂✝⟩.fst = ⟨n✝, equal t₁✝ t₂✝⟩.fst
state_after: no goals

tactic: rw [listEncode, cons_append, cons_append, singleton_append, cons_append, listDecode]
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨φ_n, rel φ_R ts⟩.snd.listEncode ++ l)).1 = ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(listDecode (⟨φ_n, rel φ_R ts⟩.snd.listEncode ++ l)).2 = l
state_after: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (if h :
              ∀ (i : Fin φ_l),
                ((List.map Sum.getLeft?
                            (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                        ↑i).join.isSome =
                  true then
            if h' :
                ∀ (i : Fin φ_l),
                  (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).fst =
                    ⟨φ_n, rel φ_R ts⟩.fst then
              ⟨⟨φ_n, rel φ_R ts⟩.fst,
                rel φ_R fun i =>
                  ⋯.mp
                    (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).snd⟩
            else default
          else default,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(if h :
                ∀ (i : Fin φ_l),
                  ((List.map Sum.getLeft?
                              (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                          ↑i).join.isSome =
                    true then
              if h' :
                  ∀ (i : Fin φ_l),
                    (((List.map Sum.getLeft?
                                    (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++
                                      l)).get?
                                ↑i).join.get
                          ⋯).fst =
                      ⟨φ_n, rel φ_R ts⟩.fst then
                ⟨⟨φ_n, rel φ_R ts⟩.fst,
                  rel φ_R fun i =>
                    ⋯.mp
                      (((List.map Sum.getLeft?
                                    (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++
                                      l)).get?
                                ↑i).join.get
                          ⋯).snd⟩
              else default
            else default,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

tactic: rw [dif_pos]
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (if h :
              ∀ (i : Fin φ_l),
                ((List.map Sum.getLeft?
                            (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                        ↑i).join.isSome =
                  true then
            if h' :
                ∀ (i : Fin φ_l),
                  (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).fst =
                    ⟨φ_n, rel φ_R ts⟩.fst then
              ⟨⟨φ_n, rel φ_R ts⟩.fst,
                rel φ_R fun i =>
                  ⋯.mp
                    (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).snd⟩
            else default
          else default,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(if h :
                ∀ (i : Fin φ_l),
                  ((List.map Sum.getLeft?
                              (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                          ↑i).join.isSome =
                    true then
              if h' :
                  ∀ (i : Fin φ_l),
                    (((List.map Sum.getLeft?
                                    (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++
                                      l)).get?
                                ↑i).join.get
                          ⋯).fst =
                      ⟨φ_n, rel φ_R ts⟩.fst then
                ⟨⟨φ_n, rel φ_R ts⟩.fst,
                  rel φ_R fun i =>
                    ⋯.mp
                      (((List.map Sum.getLeft?
                                    (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++
                                      l)).get?
                                ↑i).join.get
                          ⋯).snd⟩
              else default
            else default,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l
state_after: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (if h' :
              ∀ (i : Fin φ_l),
                (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).fst =
                  ⟨φ_n, rel φ_R ts⟩.fst then
            ⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩
          else default,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(if h' :
                ∀ (i : Fin φ_l),
                  (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).fst =
                    ⟨φ_n, rel φ_R ts⟩.fst then
              ⟨⟨φ_n, rel φ_R ts⟩.fst,
                rel φ_R fun i =>
                  ⋯.mp
                    (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).snd⟩
            else default,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.isSome =
      true

tactic: swap
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (if h' :
              ∀ (i : Fin φ_l),
                (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).fst =
                  ⟨φ_n, rel φ_R ts⟩.fst then
            ⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩
          else default,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(if h' :
                ∀ (i : Fin φ_l),
                  (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).fst =
                    ⟨φ_n, rel φ_R ts⟩.fst then
              ⟨⟨φ_n, rel φ_R ts⟩.fst,
                rel φ_R fun i =>
                  ⋯.mp
                    (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).snd⟩
            else default,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.isSome =
      true
state_after: case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.isSome =
      true

case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (if h' :
              ∀ (i : Fin φ_l),
                (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).fst =
                  ⟨φ_n, rel φ_R ts⟩.fst then
            ⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩
          else default,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(if h' :
                ∀ (i : Fin φ_l),
                  (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).fst =
                    ⟨φ_n, rel φ_R ts⟩.fst then
              ⟨⟨φ_n, rel φ_R ts⟩.fst,
                rel φ_R fun i =>
                  ⋯.mp
                    (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).snd⟩
            else default,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

tactic: rw [dif_pos]
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (if h' :
              ∀ (i : Fin φ_l),
                (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).fst =
                  ⟨φ_n, rel φ_R ts⟩.fst then
            ⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩
          else default,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(if h' :
                ∀ (i : Fin φ_l),
                  (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).fst =
                    ⟨φ_n, rel φ_R ts⟩.fst then
              ⟨⟨φ_n, rel φ_R ts⟩.fst,
                rel φ_R fun i =>
                  ⋯.mp
                    (((List.map Sum.getLeft?
                                  (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                              ↑i).join.get
                        ⋯).snd⟩
            else default,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l
state_after: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (⟨⟨φ_n, rel φ_R ts⟩.fst,
            rel φ_R fun i =>
              ⋯.mp
                (((List.map Sum.getLeft?
                              (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                          ↑i).join.get
                    ⋯).snd⟩,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                ↑i).join.get
          ⋯).fst =
      ⟨φ_n, rel φ_R ts⟩.fst

tactic: swap
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (⟨⟨φ_n, rel φ_R ts⟩.fst,
            rel φ_R fun i =>
              ⋯.mp
                (((List.map Sum.getLeft?
                              (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                          ↑i).join.get
                    ⋯).snd⟩,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                ↑i).join.get
          ⋯).fst =
      ⟨φ_n, rel φ_R ts⟩.fst
state_after: case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                ↑i).join.get
          ⋯).fst =
      ⟨φ_n, rel φ_R ts⟩.fst

case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (⟨⟨φ_n, rel φ_R ts⟩.fst,
            rel φ_R fun i =>
              ⋯.mp
                (((List.map Sum.getLeft?
                              (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                          ↑i).join.get
                    ⋯).snd⟩,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l

tactic: simp only [Sigma.mk.inj_iff, heq_eq_eq, rel.injEq, true_and]
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (⟨⟨φ_n, rel φ_R ts⟩.fst,
            rel φ_R fun i =>
              ⋯.mp
                (((List.map Sum.getLeft?
                              (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                          ↑i).join.get
                    ⋯).snd⟩,
          ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).1 =
      ⟨φ_n, rel φ_R ts⟩ ∧
    ↑(⟨⟨φ_n, rel φ_R ts⟩.fst,
              rel φ_R fun i =>
                ⋯.mp
                  (((List.map Sum.getLeft?
                                (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                            ↑i).join.get
                      ⋯).snd⟩,
            ⟨drop φ_l (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l), ⋯⟩).2 =
      l
state_after: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (fun i =>
        ⋯.mp
          (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get
              ⋯).snd) =
      ts ∧
    drop φ_l (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l) = l

tactic: refine ⟨funext fun i => ?_, ?_⟩
state_before: case mk.rel
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (fun i =>
        ⋯.mp
          (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get
              ⋯).snd) =
      ts ∧
    drop φ_l (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l) = l
state_after: case mk.rel.refine_1
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
⊢ ⋯.mp
      (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get ⋯).snd =
    ts i

case mk.rel.refine_2
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ drop φ_l (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l) = l

tactic: rw [List.drop_append_eq_append_drop, length_map, length_finRange, Nat.sub_self, drop,
  drop_eq_nil_of_le, nil_append]
state_before: case mk.rel.refine_2
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ drop φ_l (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l) = l
state_after: case mk.rel.refine_2
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l)).length ≤ φ_l

tactic: rw [length_map, length_finRange]
state_before: case mk.rel.refine_2
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l)).length ≤ φ_l
state_after: no goals

tactic: intro i
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
        ↑i).join =
    some ⟨φ_n, ts i⟩

tactic: simp only [Option.join, map_append, map_map, Option.bind_eq_some, id, exists_eq_right,
  get?_eq_some, length_append, length_map, length_finRange]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
        ↑i).join =
    some ⟨φ_n, ts i⟩
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ ∃ (h : ↑i < φ_l + l.length),
    (List.map (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ List.map Sum.getLeft? l).get ⟨↑i, ⋯⟩ =
      some ⟨φ_n, ts i⟩

tactic: refine ⟨lt_of_lt_of_le i.2 le_self_add, ?_⟩
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ ∃ (h : ↑i < φ_l + l.length),
    (List.map (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ List.map Sum.getLeft? l).get ⟨↑i, ⋯⟩ =
      some ⟨φ_n, ts i⟩
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ (List.map (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ List.map Sum.getLeft? l).get ⟨↑i, ⋯⟩ =
    some ⟨φ_n, ts i⟩

tactic: rw [get_append, get_map]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ (List.map (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ List.map Sum.getLeft? l).get ⟨↑i, ⋯⟩ =
    some ⟨φ_n, ts i⟩
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) ((finRange φ_l).get ⟨↑⟨↑i, ?h⟩, ⋯⟩) = some ⟨φ_n, ts i⟩

case h
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ ↑i < (List.map (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l)).length

tactic: simp only [Sum.getLeft?, get_finRange, Fin.eta, Function.comp_apply, eq_self_iff_true,
  heq_iff_eq, and_self_iff]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) ((finRange φ_l).get ⟨↑⟨↑i, ?h⟩, ⋯⟩) = some ⟨φ_n, ts i⟩
state_after: no goals

tactic: simp only [length_map, length_finRange, is_lt]
state_before: case h
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
i : Fin φ_l
⊢ ↑i < (List.map (Sum.getLeft? ∘ fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l)).length
state_after: no goals

tactic: exact fun i => Option.isSome_iff_exists.2 ⟨⟨_, ts i⟩, h i⟩
state_before: case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.isSome =
      true
state_after: no goals

tactic: intro i
state_before: case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
⊢ ∀ (i : Fin φ_l),
    (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
                ↑i).join.get
          ⋯).fst =
      ⟨φ_n, rel φ_R ts⟩.fst
state_after: case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
⊢ (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
              ↑i).join.get
        ⋯).fst =
    ⟨φ_n, rel φ_R ts⟩.fst

tactic: obtain ⟨h1, h2⟩ := Option.eq_some_iff_get_eq.1 (h i)
state_before: case mk.rel.hc
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
⊢ (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
              ↑i).join.get
        ⋯).fst =
    ⟨φ_n, rel φ_R ts⟩.fst
state_after: case mk.rel.hc.intro
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
h1 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join.isSome =
    true
h2 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.get
      h1 =
    ⟨φ_n, ts i⟩
⊢ (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
              ↑i).join.get
        ⋯).fst =
    ⟨φ_n, rel φ_R ts⟩.fst

tactic: rw [h2]
state_before: case mk.rel.hc.intro
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
h1 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join.isSome =
    true
h2 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.get
      h1 =
    ⟨φ_n, ts i⟩
⊢ (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
              ↑i).join.get
        ⋯).fst =
    ⟨φ_n, rel φ_R ts⟩.fst
state_after: no goals

tactic: obtain ⟨h1, h2⟩ := Option.eq_some_iff_get_eq.1 (h i)
state_before: case mk.rel.refine_1
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
⊢ ⋯.mp
      (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get ⋯).snd =
    ts i
state_after: case mk.rel.refine_1.intro
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
h1 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join.isSome =
    true
h2 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.get
      h1 =
    ⟨φ_n, ts i⟩
⊢ ⋯.mp
      (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get ⋯).snd =
    ts i

tactic: rw [eq_mp_eq_cast, cast_eq_iff_heq]
state_before: case mk.rel.refine_1.intro
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
h1 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join.isSome =
    true
h2 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.get
      h1 =
    ⟨φ_n, ts i⟩
⊢ ⋯.mp
      (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get ⋯).snd =
    ts i
state_after: case mk.rel.refine_1.intro
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
h1 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join.isSome =
    true
h2 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.get
      h1 =
    ⟨φ_n, ts i⟩
⊢ HEq (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get ⋯).snd
    (ts i)

tactic: exact (Sigma.ext_iff.1 ((Sigma.eta (Option.get _ h1)).trans h2)).2
state_before: case mk.rel.refine_1.intro
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n φ_n φ_l : ℕ
φ_R : L.Relations φ_l
ts : Fin φ_l → L.Term (α ⊕ Fin φ_n)
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
h :
  ∀ (i : Fin φ_l),
    ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join =
      some ⟨φ_n, ts i⟩
i : Fin φ_l
h1 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
          ↑i).join.isSome =
    true
h2 :
  ((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨⟨φ_n, rel φ_R ts⟩.fst, ts i⟩) (finRange φ_l) ++ l)).get?
            ↑i).join.get
      h1 =
    ⟨φ_n, ts i⟩
⊢ HEq (((List.map Sum.getLeft? (List.map (fun i => Sum.inl ⟨φ_n, ts i⟩) (finRange φ_l) ++ l)).get? ↑i).join.get ⋯).snd
    (ts i)
state_after: no goals

tactic: rw [listEncode, List.append_assoc, cons_append, listDecode]
state_before: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, f₁✝ ⟹ f₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    ↑(listDecode (⟨n✝, f₁✝ ⟹ f₂✝⟩.snd.listEncode ++ l)).2 = l
state_after: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (sigmaImp (listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).1
            (listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).1,
          ⟨↑(listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).2, ⋯⟩).1 =
      ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    ↑(sigmaImp (listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).1
              (listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).1,
            ⟨↑(listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).2, ⋯⟩).2 =
      l

tactic: simp only [] at *
state_before: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (⟨n✝, f₁✝⟩.snd.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (⟨n✝, f₂✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (sigmaImp (listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).1
            (listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).1,
          ⟨↑(listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).2, ⋯⟩).1 =
      ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    ↑(sigmaImp (listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).1
              (listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).1,
            ⟨↑(listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).2, ⋯⟩).2 =
      l
state_after: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₁✝.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (f₁✝.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₂✝.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (f₂✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ sigmaImp (listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).1
        (listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).1 =
      ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    ↑(listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).2 = l

tactic: rw [(ih1 _).1, (ih1 _).2, (ih2 _).1, (ih2 _).2, sigmaImp]
state_before: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₁✝.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (f₁✝.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₂✝.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (f₂✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ sigmaImp (listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).1
        (listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).1 =
      ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    ↑(listDecode ↑(listDecode (f₁✝.listEncode ++ (f₂✝.listEncode ++ l))).2).2 = l
state_after: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₁✝.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (f₁✝.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₂✝.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (f₂✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (match ⟨n✝, f₁✝⟩, ⟨n✝, f₂✝⟩ with
      | ⟨m, φ⟩, ⟨n, ψ⟩ => if h : m = n then ⟨m, φ ⟹ ⋯.mp ψ⟩ else default) =
      ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    l = l

tactic: simp only [dite_true]
state_before: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₁✝.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (f₁✝.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₂✝.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (f₂✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (match ⟨n✝, f₁✝⟩, ⟨n✝, f₂✝⟩ with
      | ⟨m, φ⟩, ⟨n, ψ⟩ => if h : m = n then ⟨m, φ ⟹ ⋯.mp ψ⟩ else default) =
      ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧
    l = l
state_after: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₁✝.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (f₁✝.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₂✝.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (f₂✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ ⟨n✝, f₁✝ ⟹ ⋯.mp f₂✝⟩ = ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧ True

tactic: exact ⟨rfl, trivial⟩
state_before: case mk.imp
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₁✝.listEncode ++ l)).1 = ⟨n✝, f₁✝⟩ ∧ ↑(listDecode (f₁✝.listEncode ++ l)).2 = l
ih2 :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f₂✝.listEncode ++ l)).1 = ⟨n✝, f₂✝⟩ ∧ ↑(listDecode (f₂✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ ⟨n✝, f₁✝ ⟹ ⋯.mp f₂✝⟩ = ⟨n✝, f₁✝ ⟹ f₂✝⟩ ∧ True
state_after: no goals

tactic: rw [listEncode, cons_append, listDecode]
state_before: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧
      ↑(listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (listDecode (⟨n✝, ∀'f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝, ∀'f✝⟩ ∧ ↑(listDecode (⟨n✝, ∀'f✝⟩.snd.listEncode ++ l)).2 = l
state_after: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧
      ↑(listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (sigmaAll (listDecode (f✝.listEncode ++ l)).1, ⟨↑(listDecode (f✝.listEncode ++ l)).2, ⋯⟩).1 = ⟨n✝, ∀'f✝⟩ ∧
    ↑(sigmaAll (listDecode (f✝.listEncode ++ l)).1, ⟨↑(listDecode (f✝.listEncode ++ l)).2, ⋯⟩).2 = l

tactic: simp only
state_before: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧
      ↑(listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (sigmaAll (listDecode (f✝.listEncode ++ l)).1, ⟨↑(listDecode (f✝.listEncode ++ l)).2, ⋯⟩).1 = ⟨n✝, ∀'f✝⟩ ∧
    ↑(sigmaAll (listDecode (f✝.listEncode ++ l)).1, ⟨↑(listDecode (f✝.listEncode ++ l)).2, ⋯⟩).2 = l
state_after: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧
      ↑(listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ sigmaAll (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝, ∀'f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l

tactic: simp only [] at *
state_before: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧
      ↑(listDecode (⟨n✝ + 1, f✝⟩.snd.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ sigmaAll (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝, ∀'f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l
state_after: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ sigmaAll (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝, ∀'f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l

tactic: rw [(ih _).1, (ih _).2, sigmaAll]
state_before: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ sigmaAll (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝, ∀'f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l
state_after: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (match ⟨n✝ + 1, f✝⟩ with
      | ⟨n.succ, φ⟩ => ⟨n, ∀'φ⟩
      | x => default) =
      ⟨n✝, ∀'f✝⟩ ∧
    l = l

tactic: exact ⟨rfl, rfl⟩
state_before: case mk.all
L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
l✝ : List ((n : ℕ) × L.BoundedFormula α n)
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih :
  ∀ (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
    (listDecode (f✝.listEncode ++ l)).1 = ⟨n✝ + 1, f✝⟩ ∧ ↑(listDecode (f✝.listEncode ++ l)).2 = l
l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)
⊢ (match ⟨n✝ + 1, f✝⟩ with
      | ⟨n.succ, φ⟩ => ⟨n, ∀'φ⟩
      | x => default) =
      ⟨n✝, ∀'f✝⟩ ∧
    l = l
state_after: no goals