Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inl.inr.h_2
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
h₁ : Order.lex v₁ v₂
h₂ : Order.lex v₂ v₃
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
q : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
l : List.length (z :: zs) = m
v₁✝¹ v₂✝¹ : Vector ℕ m
x✝¹ : ℕ
tail✝³ : List ℕ
property✝³ : List.length (x✝¹ :: tail✝³) = m
y✝¹ : ℕ
tail✝² : List ℕ
property✝² : List.length (y✝¹ :: tail✝²) = m
heq✝³ : { val := x :: xs, property := p } = { val := x✝¹ :: tail✝³, property := property✝³ }
heq✝² : { val := y :: ys, property := q } = { val := y✝¹ :: tail✝², property := property✝² }
h✝¹ : x = z
h✝ : ¬x✝¹ = y✝¹
ab : x✝¹ ≤ y✝¹
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := y :: ys, property := q } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := z :: zs, property := l } = { val := y✝ :: tail✝, property := property✝ }
bc :
  if x✝ = y✝ then Order.lex_impl (tail { val := y :: ys, property := q }) (tail { val := z :: zs, property := l })
  else x✝ ≤ y✝
⊢ Order.lex_impl (tail { val := x :: xs, property := p }) (tail { val := z :: zs, property := l })

case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
h₁ : Order.lex v₁ v₂
h₂ : Order.lex v₂ v₃
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
q : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
l : List.length (z :: zs) = m
bc :
  match { val := y :: ys, property := q }, { val := z :: zs, property := l } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x :: tail, property := property }, { val := y_1 :: tail_1, property := property_1 } =>
    if x = y_1 then
      Order.lex_impl (Vector.tail { val := y :: ys, property := q }) (Vector.tail { val := z :: zs, property := l })
    else x ≤ y_1
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := x :: xs, property := p } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := q } = { val := y✝ :: tail✝, property := property✝ }
ab :
  if x✝ = y✝ then Order.lex_impl (tail { val := x :: xs, property := p }) (tail { val := y :: ys, property := q })
  else x✝ ≤ y✝
h✝ : ¬x = z
⊢ x ≤ z
Tactic:
repeat (first | rename_i heq₁ heq₂ eq₁ neq₁ _ _ _ _ _ _ _ _ heq₃ heq₄ eq₂
                simp at heq₁ heq₂ heq₃ heq₄
                have x_cross_one_eq_x := Eq.symm (heq₁.left)
                have y_cross_one_eq_y := Eq.symm (heq₂.left)
                have x_cross_eq_x     := Eq.symm (heq₃.left)
                have y_cross_eq_x     := Eq.symm (heq₄.left)
                rw [x_cross_eq_x, y_cross_eq_x] at eq₂
                rw [x_cross_one_eq_x, y_cross_one_eq_y] at neq₁
                rw [eq₂] at neq₁
                contradiction
              | split at bc)
Proof state after:
case h_2.inl.inr.h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
h₁ : Order.lex v₁ v₂
h₂ : Order.lex v₂ v₃
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
q : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
l : List.length (z :: zs) = m
v₁✝¹ v₂✝¹ : Vector ℕ m
x✝¹ : ℕ
tail✝³ : List ℕ
property✝³ : List.length (x✝¹ :: tail✝³) = m
y✝¹ : ℕ
tail✝² : List ℕ
property✝² : List.length (y✝¹ :: tail✝²) = m
heq✝³ : { val := x :: xs, property := p } = { val := x✝¹ :: tail✝³, property := property✝³ }
heq✝² : { val := y :: ys, property := q } = { val := y✝¹ :: tail✝², property := property✝² }
h✝² : x = z
h✝¹ : ¬x✝¹ = y✝¹
ab : x✝¹ ≤ y✝¹
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := y :: ys, property := q } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := z :: zs, property := l } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
bc : x✝ ≤ y✝
⊢ Order.lex_impl (tail { val := x :: xs, property := p }) (tail { val := z :: zs, property := l })

case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
h₁ : Order.lex v₁ v₂
h₂ : Order.lex v₂ v₃
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
q : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
l : List.length (z :: zs) = m
bc :
  match { val := y :: ys, property := q }, { val := z :: zs, property := l } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x :: tail, property := property }, { val := y_1 :: tail_1, property := property_1 } =>
    if x = y_1 then
      Order.lex_impl (Vector.tail { val := y :: ys, property := q }) (Vector.tail { val := z :: zs, property := l })
    else x ≤ y_1
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := x :: xs, property := p } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := q } = { val := y✝ :: tail✝, property := property✝ }
ab :
  if x✝ = y✝ then Order.lex_impl (tail { val := x :: xs, property := p }) (tail { val := y :: ys, property := q })
  else x✝ ≤ y✝
h✝ : ¬x = z
⊢ x ≤ z