l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem support_transfer (hp) : (p.transfer H hp).support = p.support := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
⊢ support (Walk.transfer p H hp) = support p

Next tactic:
induction p
@[simp]
theorem support_transfer (hp) : (p.transfer H hp).support = p.support := by
  induction p <;> 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges nil, e ∈ edgeSet H
⊢ support (Walk.transfer nil H hp) = support nil

Next tactic:
simp [*]
@[simp]
theorem support_transfer (hp) : (p.transfer H hp).support = p.support := by
  induction p <;> 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
p_ih✝ : ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H), support (Walk.transfer p✝ H hp) = support p✝
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
⊢ support (Walk.transfer (cons h✝ p✝) H hp) = support (cons h✝ p✝)

Next tactic:
simp [*]
@[simp]
theorem length_transfer (hp) : (p.transfer H hp).length = p.length := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
⊢ length (Walk.transfer p H hp) = length p

Next tactic:
induction p
@[simp]
theorem length_transfer (hp) : (p.transfer H hp).length = p.length := by
  induction p <;> 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges nil, e ∈ edgeSet H
⊢ length (Walk.transfer nil H hp) = length nil

Next tactic:
simp [*]
@[simp]
theorem length_transfer (hp) : (p.transfer H hp).length = p.length := by
  induction p <;> 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
p_ih✝ : ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H), length (Walk.transfer p✝ H hp) = length p✝
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
⊢ length (Walk.transfer (cons h✝ p✝) H hp) = length (cons h✝ p✝)

Next tactic:
simp [*]
protected theorem IsPath.transfer (hp) (pp : p.IsPath) :
    (p.transfer H hp).IsPath := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
pp : IsPath p
⊢ IsPath (Walk.transfer p H hp)

Next tactic:
induction p with
  | nil => simp
  | cons _ _ ih =>
    simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
    exact ⟨ih _ pp.1, pp.2⟩
protected theorem IsPath.transfer (hp) (pp : p.IsPath) :
    (p.transfer H hp).IsPath := by
  induction p with
  

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges Walk.nil, e ∈ edgeSet H
pp : IsPath Walk.nil
⊢ IsPath (Walk.transfer Walk.nil H hp)

Next tactic:
| nil => simp
protected theorem IsPath.transfer (hp) (pp : p.IsPath) :
    (p.transfer H hp).IsPath := by
  induction p with
  | nil => 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges Walk.nil, e ∈ edgeSet H
pp : IsPath Walk.nil
⊢ IsPath (Walk.transfer Walk.nil H hp)

Next tactic:
simp
protected theorem IsPath.transfer (hp) (pp : p.IsPath) :
    (p.transfer H hp).IsPath := by
  induction p with
  | nil => simp
  

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H), IsPath p✝ → IsPath (Walk.transfer p✝ H hp)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
pp : IsPath (cons h✝ p✝)
⊢ IsPath (Walk.transfer (cons h✝ p✝) H hp)

Next tactic:
| cons _ _ ih =>
    simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
    exact ⟨ih _ pp.1, pp.2⟩
protected theorem IsPath.transfer (hp) (pp : p.IsPath) :
    (p.transfer H hp).IsPath := by
  induction p with
  | nil => simp
  | cons _ _ ih =>
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H), IsPath p✝ → IsPath (Walk.transfer p✝ H hp)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
pp : IsPath (cons h✝ p✝)
⊢ IsPath (Walk.transfer (cons h✝ p✝) H hp)

Next tactic:
simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
protected theorem IsPath.transfer (hp) (pp : p.IsPath) :
    (p.transfer H hp).IsPath := by
  induction p with
  | nil => simp
  | cons _ _ ih =>
    simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H), IsPath p✝ → IsPath (Walk.transfer p✝ H hp)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
pp : IsPath p✝ ∧ u✝ ∉ support p✝
⊢ IsPath (Walk.transfer p✝ H (_ : ∀ e ∈ edges p✝, e ∈ edgeSet H)) ∧ u✝ ∉ support p✝

Next tactic:
exact ⟨ih _ pp.1, pp.2⟩
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
q : Walk G u u
qc : IsCycle q
hq : ∀ e ∈ edges q, e ∈ edgeSet H
⊢ IsCycle (Walk.transfer q H hq)

Next tactic:
cases q with
  | nil => simp at qc
  | cons _ q =>
    simp only [edges_cons, List.find?, List.mem_cons, forall_eq_or_imp, mem_edgeSet] at hq
    simp only [Walk.transfer, cons_isCycle_iff, edges_transfer q hq.2] at qc ⊢
    exact ⟨qc.1.transfer hq.2, qc.2⟩
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  cases q with
  

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
qc : IsCycle nil
hq : ∀ e ∈ edges nil, e ∈ edgeSet H
⊢ IsCycle (Walk.transfer nil H hq)

Next tactic:
| nil => simp at qc
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  cases q with
  | nil => 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
qc : IsCycle nil
hq : ∀ e ∈ edges nil, e ∈ edgeSet H
⊢ IsCycle (Walk.transfer nil H hq)

Next tactic:
simp at qc
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  cases q with
  | nil => simp at qc
  

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
v✝ : V
h✝ : Adj G u v✝
q : Walk G v✝ u
qc : IsCycle (cons h✝ q)
hq : ∀ e ∈ edges (cons h✝ q), e ∈ edgeSet H
⊢ IsCycle (Walk.transfer (cons h✝ q) H hq)

Next tactic:
| cons _ q =>
    simp only [edges_cons, List.find?, List.mem_cons, forall_eq_or_imp, mem_edgeSet] at hq
    simp only [Walk.transfer, cons_isCycle_iff, edges_transfer q hq.2] at qc ⊢
    exact ⟨qc.1.transfer hq.2, qc.2⟩
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  cases q with
  | nil => simp at qc
  | cons _ q =>
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
v✝ : V
h✝ : Adj G u v✝
q : Walk G v✝ u
qc : IsCycle (cons h✝ q)
hq : ∀ e ∈ edges (cons h✝ q), e ∈ edgeSet H
⊢ IsCycle (Walk.transfer (cons h✝ q) H hq)

Next tactic:
simp only [edges_cons, List.find?, List.mem_cons, forall_eq_or_imp, mem_edgeSet] at hq
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  cases q with
  | nil => simp at qc
  | cons _ q =>
    simp only [edges_cons, List.find?, List.mem_cons, forall_eq_or_imp, mem_edgeSet] at hq
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
v✝ : V
h✝ : Adj G u v✝
q : Walk G v✝ u
qc : IsCycle (cons h✝ q)
hq✝ : ∀ e ∈ edges (cons h✝ q), e ∈ edgeSet H
hq : Adj H u v✝ ∧ ∀ a ∈ edges q, a ∈ edgeSet H
⊢ IsCycle (Walk.transfer (cons h✝ q) H hq✝)

Next tactic:
simp only [Walk.transfer, cons_isCycle_iff, edges_transfer q hq.2] at qc ⊢
protected theorem IsCycle.transfer {q : G.Walk u u} (qc : q.IsCycle) (hq) :
    (q.transfer H hq).IsCycle := by
  cases q with
  | nil => simp at qc
  | cons _ q =>
    simp only [edges_cons, List.find?, List.mem_cons, forall_eq_or_imp, mem_edgeSet] at hq
    simp only [Walk.transfer, cons_isCycle_iff, edges_transfer q hq.2] at qc ⊢
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
v✝ : V
h✝ : Adj G u v✝
q : Walk G v✝ u
hq✝ : ∀ e ∈ edges (cons h✝ q), e ∈ edgeSet H
hq : Adj H u v✝ ∧ ∀ a ∈ edges q, a ∈ edgeSet H
qc : IsPath q ∧ ⟦(u, v✝)⟧ ∉ edges q
⊢ IsPath (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H)) ∧ ⟦(u, v✝)⟧ ∉ edges q

Next tactic:
exact ⟨qc.1.transfer hq.2, qc.2⟩
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
K : SimpleGraph V
hp' : ∀ e ∈ edges (Walk.transfer p H hp), e ∈ edgeSet K
⊢ Walk.transfer (Walk.transfer p H hp) K hp' = Walk.transfer p K (_ : ∀ e ∈ edges p, e ∈ edgeSet K)

Next tactic:
induction p with
  | nil => simp
  | cons _ _ ih =>
    simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
    apply ih
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') := by
  induction p with
  

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H K : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges nil, e ∈ edgeSet H
hp' : ∀ e ∈ edges (Walk.transfer nil H hp), e ∈ edgeSet K
⊢ Walk.transfer (Walk.transfer nil H hp) K hp' = Walk.transfer nil K (_ : ∀ e ∈ edges nil, e ∈ edgeSet K)

Next tactic:
| nil => simp
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') := by
  induction p with
  | nil => 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H K : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges nil, e ∈ edgeSet H
hp' : ∀ e ∈ edges (Walk.transfer nil H hp), e ∈ edgeSet K
⊢ Walk.transfer (Walk.transfer nil H hp) K hp' = Walk.transfer nil K (_ : ∀ e ∈ edges nil, e ∈ edgeSet K)

Next tactic:
simp
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') := by
  induction p with
  | nil => simp
  

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H K : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H) (hp' : ∀ e ∈ edges (Walk.transfer p✝ H hp), e ∈ edgeSet K),
    Walk.transfer (Walk.transfer p✝ H hp) K hp' = Walk.transfer p✝ K (_ : ∀ e ∈ edges p✝, e ∈ edgeSet K)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
hp' : ∀ e ∈ edges (Walk.transfer (cons h✝ p✝) H hp), e ∈ edgeSet K
⊢ Walk.transfer (Walk.transfer (cons h✝ p✝) H hp) K hp' =
    Walk.transfer (cons h✝ p✝) K (_ : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet K)

Next tactic:
| cons _ _ ih =>
    simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
    apply ih
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') := by
  induction p with
  | nil => simp
  | cons _ _ ih =>
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H K : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H) (hp' : ∀ e ∈ edges (Walk.transfer p✝ H hp), e ∈ edgeSet K),
    Walk.transfer (Walk.transfer p✝ H hp) K hp' = Walk.transfer p✝ K (_ : ∀ e ∈ edges p✝, e ∈ edgeSet K)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
hp' : ∀ e ∈ edges (Walk.transfer (cons h✝ p✝) H hp), e ∈ edgeSet K
⊢ Walk.transfer (Walk.transfer (cons h✝ p✝) H hp) K hp' =
    Walk.transfer (cons h✝ p✝) K (_ : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet K)

Next tactic:
simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
@[simp]
theorem transfer_transfer (hp) {K : SimpleGraph V} (hp') :
    (p.transfer H hp).transfer K hp' = p.transfer K (p.edges_transfer hp ▸ hp') := by
  induction p with
  | nil => simp
  | cons _ _ ih =>
    simp only [Walk.transfer, cons.injEq, heq_eq_eq, true_and]
    

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H K : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H) (hp' : ∀ e ∈ edges (Walk.transfer p✝ H hp), e ∈ edgeSet K),
    Walk.transfer (Walk.transfer p✝ H hp) K hp' = Walk.transfer p✝ K (_ : ∀ e ∈ edges p✝, e ∈ edgeSet K)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
hp' : ∀ e ∈ edges (Walk.transfer (cons h✝ p✝) H hp), e ∈ edgeSet K
⊢ Walk.transfer (Walk.transfer p✝ H (_ : ∀ e ∈ edges p✝, e ∈ edgeSet H)) K
      (_ : ∀ e ∈ edges (Walk.transfer p✝ H (_ : ∀ e ∈ edges p✝, e ∈ edgeSet H)), e ∈ edgeSet K) =
    Walk.transfer p✝ K (_ : ∀ e ∈ edges p✝, e ∈ edgeSet K)

Next tactic:
apply ih
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
q : Walk G v w
hpq : ∀ e ∈ edges (append p q), e ∈ edgeSet H
e : Sym2 V
he : e ∈ edges p
⊢ e ∈ edges (append p q)

Next tactic:
simp [he]
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
q : Walk G v w
hpq : ∀ e ∈ edges (append p q), e ∈ edgeSet H
e : Sym2 V
he : e ∈ edges q
⊢ e ∈ edges (append p q)

Next tactic:
simp [he]
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by simp [he])) := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
q : Walk G v w
hpq : ∀ e ∈ edges (append p q), e ∈ edgeSet H
⊢ Walk.transfer (append p q) H hpq =
    append (Walk.transfer p H (_ : ∀ e ∈ edges p, e ∈ edgeSet H)) (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))

Next tactic:
induction p with
  | nil => simp
  | cons _ _ ih => simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by simp [he])) := by
  induction p with
  

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
u✝ : V
q : Walk G u✝ w
hpq : ∀ e ∈ edges (append nil q), e ∈ edgeSet H
⊢ Walk.transfer (append nil q) H hpq =
    append (Walk.transfer nil H (_ : ∀ e ∈ edges nil, e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))

Next tactic:
| nil => simp
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by simp [he])) := by
  induction p with
  | nil => 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
u✝ : V
q : Walk G u✝ w
hpq : ∀ e ∈ edges (append nil q), e ∈ edgeSet H
⊢ Walk.transfer (append nil q) H hpq =
    append (Walk.transfer nil H (_ : ∀ e ∈ edges nil, e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))

Next tactic:
simp
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by simp [he])) := by
  induction p with
  | nil => simp
  

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (q : Walk G w✝ w) (hpq : ∀ e ∈ edges (append p✝ q), e ∈ edgeSet H),
    Walk.transfer (append p✝ q) H hpq =
      append (Walk.transfer p✝ H (_ : ∀ e ∈ edges p✝, e ∈ edgeSet H))
        (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))
q : Walk G w✝ w
hpq : ∀ e ∈ edges (append (cons h✝ p✝) q), e ∈ edgeSet H
⊢ Walk.transfer (append (cons h✝ p✝) q) H hpq =
    append (Walk.transfer (cons h✝ p✝) H (_ : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))

Next tactic:
| cons _ _ ih => simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
@[simp]
theorem transfer_append (q : G.Walk v w) (hpq) :
    (p.append q).transfer H hpq =
      (p.transfer H fun e he => hpq _ (by simp [he])).append
        (q.transfer H fun e he => hpq _ (by simp [he])) := by
  induction p with
  | nil => simp
  | cons _ _ ih => 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
w : V
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (q : Walk G w✝ w) (hpq : ∀ e ∈ edges (append p✝ q), e ∈ edgeSet H),
    Walk.transfer (append p✝ q) H hpq =
      append (Walk.transfer p✝ H (_ : ∀ e ∈ edges p✝, e ∈ edgeSet H))
        (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))
q : Walk G w✝ w
hpq : ∀ e ∈ edges (append (cons h✝ p✝) q), e ∈ edgeSet H
⊢ Walk.transfer (append (cons h✝ p✝) q) H hpq =
    append (Walk.transfer (cons h✝ p✝) H (_ : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H))
      (Walk.transfer q H (_ : ∀ e ∈ edges q, e ∈ edgeSet H))

Next tactic:
simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
⊢ ∀ e ∈ edges (reverse p), e ∈ edgeSet H

Next tactic:
simp only [edges_reverse, List.mem_reverse]
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; 

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
⊢ ∀ e ∈ edges p, e ∈ edgeSet H

Next tactic:
exact hp
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; exact hp) := by
  

Proof state:
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ e ∈ edges p, e ∈ edgeSet H
⊢ reverse (Walk.transfer p H hp) = Walk.transfer (reverse p) H (_ : ∀ e ∈ edges (reverse p), e ∈ edgeSet H)

Next tactic:
induction p with
  | nil => simp
  | cons _ _ ih => simp only [transfer_append, Walk.transfer, reverse_nil, reverse_cons, ih]
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; exact hp) := by
  induction p with
  

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges nil, e ∈ edgeSet H
⊢ reverse (Walk.transfer nil H hp) = Walk.transfer (reverse nil) H (_ : ∀ e ∈ edges (reverse nil), e ∈ edgeSet H)

Next tactic:
| nil => simp
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; exact hp) := by
  induction p with
  | nil => 

Proof state:
case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ e ∈ edges nil, e ∈ edgeSet H
⊢ reverse (Walk.transfer nil H hp) = Walk.transfer (reverse nil) H (_ : ∀ e ∈ edges (reverse nil), e ∈ edgeSet H)

Next tactic:
simp
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; exact hp) := by
  induction p with
  | nil => simp
  

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H),
    reverse (Walk.transfer p✝ H hp) = Walk.transfer (reverse p✝) H (_ : ∀ e ∈ edges (reverse p✝), e ∈ edgeSet H)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
⊢ reverse (Walk.transfer (cons h✝ p✝) H hp) =
    Walk.transfer (reverse (cons h✝ p✝)) H (_ : ∀ e ∈ edges (reverse (cons h✝ p✝)), e ∈ edgeSet H)

Next tactic:
| cons _ _ ih => simp only [transfer_append, Walk.transfer, reverse_nil, reverse_cons, ih]
@[simp]
theorem reverse_transfer (hp) :
    (p.transfer H hp).reverse =
      p.reverse.transfer H (by simp only [edges_reverse, List.mem_reverse]; exact hp) := by
  induction p with
  | nil => simp
  | cons _ _ ih => 

Proof state:
case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih :
  ∀ (hp : ∀ e ∈ edges p✝, e ∈ edgeSet H),
    reverse (Walk.transfer p✝ H hp) = Walk.transfer (reverse p✝) H (_ : ∀ e ∈ edges (reverse p✝), e ∈ edgeSet H)
hp : ∀ e ∈ edges (cons h✝ p✝), e ∈ edgeSet H
⊢ reverse (Walk.transfer (cons h✝ p✝) H hp) =
    Walk.transfer (reverse (cons h✝ p✝)) H (_ : ∀ e ∈ edges (reverse (cons h✝ p✝)), e ∈ edgeSet H)

Next tactic:
simp only [transfer_append, Walk.transfer, reverse_nil, reverse_cons, ih]