Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.h_2.inl.refl
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p₁ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
p₂ : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
p₃ : 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
var_mul₁ :
  { val := (x + z) :: List.zipWith (fun x y => x + y) xs zs,
      property := (_ : (fun l => List.length l = m) ((x + z) :: List.zipWith (fun x y => x + y) xs zs)) } =
    { val := x✝ :: tail✝², property := property✝³ }
var_mul₂ :
  { val := (y + z) :: List.zipWith (fun x y => x + y) ys zs,
      property := (_ : (fun l => List.length l = m) ((y + z) :: List.zipWith (fun x y => x + y) ys zs)) } =
    { val := y✝¹ :: tail✝¹, property := property✝² }
h✝ : ¬x✝ = y✝¹
v₁✝ v₂✝ : Vector ℕ m
y✝ : ℕ
tail✝ : List ℕ
property✝¹ : List.length (y✝ :: tail✝) = m
heq₂ : { val := y :: ys, property := p₂ } = { val := y✝ :: tail✝, property := property✝¹ }
h : Order.lex_impl (tail { val := x :: xs, property := p₁ }) (tail { val := y :: ys, property := p₂ })
eq : x = y✝
property✝ : List.length (x :: xs) = m
⊢ x✝ ≤ y✝¹

case h_2.inr.h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p₁ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
p₂ : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
p₃ : 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✝³ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝¹ :: tail✝³, property := property✝³ }
heq✝² :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { val := y✝¹ :: tail✝², property := property✝² }
h✝¹ : ¬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 := x :: xs, property := p₁ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := p₂ } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
h : x✝ ≤ y✝
⊢ x✝¹ ≤ y✝¹
Tactic:
cases heq₂
Proof state after:
case h_2.inr.h_2.inl.refl.refl
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p₁ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
p₂ : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
p₃ : 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
var_mul₁ :
  { val := (x + z) :: List.zipWith (fun x y => x + y) xs zs,
      property := (_ : (fun l => List.length l = m) ((x + z) :: List.zipWith (fun x y => x + y) xs zs)) } =
    { val := x✝ :: tail✝¹, property := property✝³ }
var_mul₂ :
  { val := (y + z) :: List.zipWith (fun x y => x + y) ys zs,
      property := (_ : (fun l => List.length l = m) ((y + z) :: List.zipWith (fun x y => x + y) ys zs)) } =
    { val := y✝ :: tail✝, property := property✝² }
h✝ : ¬x✝ = y✝
v₁✝ v₂✝ : Vector ℕ m
h : Order.lex_impl (tail { val := x :: xs, property := p₁ }) (tail { val := y :: ys, property := p₂ })
property✝¹ : List.length (x :: xs) = m
eq : x = y
property✝ : List.length (y :: ys) = m
⊢ x✝ ≤ y✝

case h_2.inr.h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p₁ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
p₂ : List.length (y :: ys) = m
z : ℕ
zs : List ℕ
p₃ : 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✝³ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝¹ :: tail✝³, property := property✝³ }
heq✝² :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { val := y✝¹ :: tail✝², property := property✝² }
h✝¹ : ¬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 := x :: xs, property := p₁ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := p₂ } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
h : x✝ ≤ y✝
⊢ x✝¹ ≤ y✝¹