Theorem: Batteries.RBNode.reverse_balance1
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: unfold balance1 balance2
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ (l.balance1 v r).reverse = r.reverse.balance2 v l.reverse
state_after: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b).reverse =
    match r.reverse, v, l.reverse with
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b

tactic: split <;> simp
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ (match l, v, r with
      | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
      | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
      | a, x, b => node black a x b).reverse =
    match r.reverse, v, l.reverse with
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b
state_after: case h_2
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
⊢ node red (node black r.reverse v c✝.reverse) y✝ (node black b✝.reverse x✝¹ a✝.reverse) =
    match r.reverse, v, node red (node red c✝.reverse y✝ b✝.reverse) x✝¹ a✝.reverse with
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b

case h_3
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ node black r.reverse v l.reverse =
    match r.reverse, v, l.reverse with
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b

tactic: rw [balance2.match_1.eq_2]
state_before: case h_2
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
⊢ node red (node black r.reverse v c✝.reverse) y✝ (node black b✝.reverse x✝¹ a✝.reverse) =
    match r.reverse, v, node red (node red c✝.reverse y✝ b✝.reverse) x✝¹ a✝.reverse with
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b
state_after: case h_2.x
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
⊢ ∀ (c : RBNode α) (z : α) (d : RBNode α), a✝.reverse = node red c z d → False

tactic: simp [reverse_eq_iff]
state_before: case h_2.x
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
⊢ ∀ (c : RBNode α) (z : α) (d : RBNode α), a✝.reverse = node red c z d → False
state_after: case h_2.x
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
⊢ ∀ (c : RBNode α) (z : α) (d : RBNode α), ¬a✝ = node red d.reverse z c.reverse

tactic: intros
state_before: case h_2.x
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
⊢ ∀ (c : RBNode α) (z : α) (d : RBNode α), ¬a✝ = node red d.reverse z c.reverse
state_after: case h_2.x
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝¹ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
c✝ : RBNode α
z✝ : α
d✝ : RBNode α
⊢ ¬a✝ = node red d✝.reverse z✝ c✝.reverse

tactic: solve_by_elim
state_before: case h_2.x
α : Type u_1
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝¹ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
c✝ : RBNode α
z✝ : α
d✝ : RBNode α
⊢ ¬a✝ = node red d✝.reverse z✝ c✝.reverse
state_after: no goals

tactic: rw [balance2.match_1.eq_3] <;> (simp [reverse_eq_iff]; intros; solve_by_elim)
state_before: case h_3
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ node black r.reverse v l.reverse =
    match r.reverse, v, l.reverse with
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b
state_after: no goals

tactic: simp [reverse_eq_iff]
state_before: case h_3.x
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ ∀ (b : RBNode α) (y : α) (c : RBNode α) (z : α) (d : RBNode α), l.reverse = node red (node red b y c) z d → False
state_after: case h_3.x
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ ∀ (b : RBNode α) (y : α) (c : RBNode α) (z : α) (d : RBNode α),
    ¬l = node red d.reverse z (node red c.reverse y b.reverse)

tactic: intros
state_before: case h_3.x
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ ∀ (b : RBNode α) (y : α) (c : RBNode α) (z : α) (d : RBNode α),
    ¬l = node red d.reverse z (node red c.reverse y b.reverse)
state_after: case h_3.x
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
z✝ : α
d✝ : RBNode α
⊢ ¬l = node red d✝.reverse z✝ (node red c✝.reverse y✝ b✝.reverse)

tactic: solve_by_elim
state_before: case h_3.x
α : Type u_1
l : RBNode α
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
z✝ : α
d✝ : RBNode α
⊢ ¬l = node red d✝.reverse z✝ (node red c✝.reverse y✝ b✝.reverse)
state_after: no goals