l3lab/ntp-mathlib huggingface dataset:
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · 

Proof state:
case C1.antisymm.refl
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝¹ : Lists'.Subset l₁ l₂
a✝ : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₂ }
⊢ of' l₁ ~ { fst := true, snd := l₂ }

Next tactic:
exact h₁'
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    

Proof state:
case C1.antisymm.antisymm
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
⊢ of' l₁ ~ { fst := true, snd := l₃ }

Next tactic:
cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    

Proof state:
case C1.antisymm.antisymm.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
⊢ of' l₁ ~ { fst := true, snd := l₃ }

Next tactic:
cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    

Proof state:
case C1.antisymm.antisymm.intro.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
⊢ of' l₁ ~ { fst := true, snd := l₃ }

Next tactic:
apply Equiv.antisymm_iff.2
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; 

Proof state:
case C1.antisymm.antisymm.intro.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
⊢ l₁ ⊆ l₃ ∧ l₃ ⊆ l₁

Next tactic:
constructor
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> 

Proof state:
case C1.antisymm.antisymm.intro.intro.left
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
⊢ l₁ ⊆ l₃

Next tactic:
apply Lists'.subset_def.2
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> 

Proof state:
case C1.antisymm.antisymm.intro.intro.right
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
⊢ l₃ ⊆ l₁

Next tactic:
apply Lists'.subset_def.2
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · 

Proof state:
case C1.antisymm.antisymm.intro.intro.left
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
⊢ ∀ (a : Lists α), a ∈ Lists'.toList l₁ → a ∈ l₃

Next tactic:
intro a₁ m₁
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      

Proof state:
case C1.antisymm.antisymm.intro.intro.left
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
a₁ : Lists α
m₁ : a₁ ∈ Lists'.toList l₁
⊢ a₁ ∈ l₃

Next tactic:
rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      

Proof state:
case C1.antisymm.antisymm.intro.intro.left.intro.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
a₁ : Lists α
m₁ : a₁ ∈ Lists'.toList l₁
a₂ : Lists α
m₂ : a₂ ∈ Lists'.toList l₂
e₁₂ : a₁ ~ a₂
⊢ a₁ ∈ l₃

Next tactic:
rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      

Proof state:
case C1.antisymm.antisymm.intro.intro.left.intro.intro.intro.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
a₁ : Lists α
m₁ : a₁ ∈ Lists'.toList l₁
a₂ : Lists α
m₂ : a₂ ∈ Lists'.toList l₂
e₁₂ : a₁ ~ a₂
a₃ : Lists α
m₃ : a₃ ∈ Lists'.toList l₃
e₂₃ : a₂ ~ a₃
⊢ a₁ ∈ l₃

Next tactic:
exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
    · 

Proof state:
case C1.antisymm.antisymm.intro.intro.right
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
⊢ ∀ (a : Lists α), a ∈ Lists'.toList l₃ → a ∈ l₁

Next tactic:
intro a₃ m₃
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
    · intro a₃ m₃
      

Proof state:
case C1.antisymm.antisymm.intro.intro.right
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
a₃ : Lists α
m₃ : a₃ ∈ Lists'.toList l₃
⊢ a₃ ∈ l₁

Next tactic:
rcases Lists'.mem_of_subset' hr₂ m₃ with ⟨a₂, m₂, e₃₂⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
    · intro a₃ m₃
      rcases Lists'.mem_of_subset' hr₂ m₃ with ⟨a₂, m₂, e₃₂⟩
      

Proof state:
case C1.antisymm.antisymm.intro.intro.right.intro.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
a₃ : Lists α
m₃ : a₃ ∈ Lists'.toList l₃
a₂ : Lists α
m₂ : a₂ ∈ Lists'.toList l₂
e₃₂ : a₃ ~ a₂
⊢ a₃ ∈ l₁

Next tactic:
rcases Lists'.mem_of_subset' hr₁ m₂ with ⟨a₁, m₁, e₂₁⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
    · intro a₃ m₃
      rcases Lists'.mem_of_subset' hr₂ m₃ with ⟨a₂, m₂, e₃₂⟩
      rcases Lists'.mem_of_subset' hr₁ m₂ with ⟨a₁, m₁, e₂₁⟩
      

Proof state:
case C1.antisymm.antisymm.intro.intro.right.intro.intro.intro.intro
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
l₁ : Lists' α true
IH : ∀ (l' : Lists α), l' ∈ Lists'.toList l₁ → trans l'
l₂ : Lists' α true
a✝³ : Lists'.Subset l₁ l₂
a✝² : Lists'.Subset l₂ l₁
h₁' : of' l₁ ~ { fst := true, snd := l₂ }
l₃ : Lists' α true
a✝¹ : Lists'.Subset l₂ l₃
a✝ : Lists'.Subset l₃ l₂
h₂' : { fst := true, snd := l₂ } ~ { fst := true, snd := l₃ }
hl₁ : l₁ ⊆ l₂
hr₁ : l₂ ⊆ l₁
hl₂ : l₂ ⊆ l₃
hr₂ : l₃ ⊆ l₂
a₃ : Lists α
m₃ : a₃ ∈ Lists'.toList l₃
a₂ : Lists α
m₂ : a₂ ∈ Lists'.toList l₂
e₃₂ : a₃ ~ a₂
a₁ : Lists α
m₁ : a₁ ∈ Lists'.toList l₁
e₂₁ : a₂ ~ a₁
⊢ a₃ ∈ l₁

Next tactic:
exact ⟨a₁, m₁, (IH _ m₁ e₂₁.symm e₃₂.symm).symm⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
    · intro a₃ m₃
      rcases Lists'.mem_of_subset' hr₂ m₃ with ⟨a₂, m₂, e₃₂⟩
      rcases Lists'.mem_of_subset' hr₁ m₂ with ⟨a₁, m₁, e₂₁⟩
      exact ⟨a₁, m₁, (IH _ m₁ e₂₁.symm e₃₂.symm).symm⟩
  · 

Proof state:
case D0
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
⊢ ∀ (l' : Lists α), l' ∈ Lists'.toList Lists'.nil → trans l'

Next tactic:
rintro _ ⟨⟩
theorem Equiv.trans : ∀ {l₁ l₂ l₃ : Lists α}, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃ := by
  let trans := fun l₁ : Lists α => ∀ ⦃l₂ l₃⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
  suffices PProd (∀ l₁, trans l₁) (∀ (l : Lists' α true), ∀ l' ∈ l.toList, trans l') by exact this.1
  apply inductionMut
  · intro a l₂ l₃ h₁ h₂
    rwa [← equiv_atom.1 h₁] at h₂
  · intro l₁ IH l₂ l₃ h₁ h₂
    -- Porting note: Two 'have's are for saving the state.
    have h₁' := h₁
    have h₂' := h₂
    cases' h₁ with _ _ l₂
    · exact h₂
    cases' h₂ with _ _ l₃
    · exact h₁'
    cases' Equiv.antisymm_iff.1 h₁' with hl₁ hr₁
    cases' Equiv.antisymm_iff.1 h₂' with hl₂ hr₂
    apply Equiv.antisymm_iff.2; constructor <;> apply Lists'.subset_def.2
    · intro a₁ m₁
      rcases Lists'.mem_of_subset' hl₁ m₁ with ⟨a₂, m₂, e₁₂⟩
      rcases Lists'.mem_of_subset' hl₂ m₂ with ⟨a₃, m₃, e₂₃⟩
      exact ⟨a₃, m₃, IH _ m₁ e₁₂ e₂₃⟩
    · intro a₃ m₃
      rcases Lists'.mem_of_subset' hr₂ m₃ with ⟨a₂, m₂, e₃₂⟩
      rcases Lists'.mem_of_subset' hr₁ m₂ with ⟨a₁, m₁, e₂₁⟩
      exact ⟨a₁, m₁, (IH _ m₁ e₂₁.symm e₃₂.symm).symm⟩
  · rintro _ ⟨⟩
  · 

Proof state:
case D1
α : Type u_1
trans : Lists α → Prop := fun l₁ => ∀ ⦃l₂ l₃ : Lists α⦄, l₁ ~ l₂ → l₂ ~ l₃ → l₁ ~ l₃
⊢ ∀ (a : Lists α) (l : Lists' α true),
    trans a →
      (∀ (l' : Lists α), l' ∈ Lists'.toList l → trans l') →
        ∀ (l' : Lists α), l' ∈ Lists'.toList (Lists'.cons a l) → trans l'

Next tactic:
intro a l IH₁ IH