internlm/Lean-Github huggingface dataset:
Theorem: algebra.lex_add_le_add
Proof state before:
case h_1
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ :
  Variables.mul { val := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := [], property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := [], property := property✝ }
⊢ True

case h_2
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := [], property := property✝⁴ } { val := [], property := property✝² }))
      (tail (Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² }))
  else x✝ ≤ y✝
Tactic:
simp
Proof state after:
case h_2
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := [], property := property✝⁴ } { val := [], property := property✝² }))
      (tail (Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² }))
  else x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := [], property := property✝⁴ } { val := [], property := property✝² }))
      (tail (Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² }))
  else x✝ ≤ y✝
Tactic:
split
Proof state after:
case h_2.inl
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
h✝ : x✝ = y✝
⊢ Order.lex_impl (tail (Variables.mul { val := [], property := property✝⁴ } { val := [], property := property✝² }))
    (tail (Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² }))

case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inl
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
h✝ : x✝ = y✝
⊢ Order.lex_impl (tail (Variables.mul { val := [], property := property✝⁴ } { val := [], property := property✝² }))
    (tail (Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² }))

case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Tactic:
repeat (rename_i prop₁ _ _ _ _ _ _ _ _ _ prop₄ _ _ _
        simp at prop₁ prop₄
        simp [Eq.symm prop₁] at prop₄)
Proof state after:
no goals
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Tactic:
(rename_i prop₁ _ _ _ _ _ _ _ _ _ prop₄ _ _ _
 simp at prop₁ prop₄
 simp [Eq.symm prop₁] at prop₄)
Proof state after:
no goals
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
property✝⁴ property✝³ property✝² : List.length [] = m
h : Order.lex_impl { val := [], property := property✝⁴ } { val := [], property := property✝³ }
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 := [], property := property✝⁴ } { val := [], property := property✝² } =
    { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ :
  Variables.mul { val := [], property := property✝³ } { val := [], property := property✝² } =
    { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Tactic:
rename_i prop₁ _ _ _ _ _ _ _ _ _ prop₄ _ _ _
Proof state after:
case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
prop₁ property✝² property✝¹ : List.length [] = m
h : Order.lex_impl { val := [], property := prop₁ } { val := [], property := property✝² }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
prop₄ : List.length (y✝ :: tail✝) = m
heq✝¹ :
  Variables.mul { val := [], property := prop₁ } { val := [], property := property✝¹ } =
    { val := x✝ :: tail✝¹, property := property✝ }
heq✝ :
  Variables.mul { val := [], property := property✝² } { val := [], property := property✝¹ } =
    { val := y✝ :: tail✝, property := prop₄ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
prop₁ property✝² property✝¹ : List.length [] = m
h : Order.lex_impl { val := [], property := prop₁ } { val := [], property := property✝² }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
prop₄ : List.length (y✝ :: tail✝) = m
heq✝¹ :
  Variables.mul { val := [], property := prop₁ } { val := [], property := property✝¹ } =
    { val := x✝ :: tail✝¹, property := property✝ }
heq✝ :
  Variables.mul { val := [], property := property✝² } { val := [], property := property✝¹ } =
    { val := y✝ :: tail✝, property := prop₄ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Tactic:
simp at prop₁ prop₄
Proof state after:
case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
prop₁ : 0 = m
property✝² property✝¹ : List.length [] = m
h : Order.lex_impl { val := [], property := prop₁ } { val := [], property := property✝² }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
prop₄ : succ (List.length tail✝) = m
heq✝¹ :
  Variables.mul { val := [], property := prop₁ } { val := [], property := property✝¹ } =
    { val := x✝ :: tail✝¹, property := property✝ }
heq✝ :
  Variables.mul { val := [], property := property✝² } { val := [], property := property✝¹ } =
    { val := y✝ :: tail✝, property := prop₄ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
prop₁ : 0 = m
property✝² property✝¹ : List.length [] = m
h : Order.lex_impl { val := [], property := prop₁ } { val := [], property := property✝² }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
prop₄ : succ (List.length tail✝) = m
heq✝¹ :
  Variables.mul { val := [], property := prop₁ } { val := [], property := property✝¹ } =
    { val := x✝ :: tail✝¹, property := property✝ }
heq✝ :
  Variables.mul { val := [], property := property✝² } { val := [], property := property✝¹ } =
    { val := y✝ :: tail✝, property := prop₄ }
h✝ : ¬x✝ = y✝
⊢ x✝ ≤ y✝
Tactic:
simp [Eq.symm prop₁] at prop₄
Proof state after:
no goals
Theorem: algebra.lex_add_le_add
Proof state before:
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
⊢ Order.lex_impl (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ })
    (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ })
Tactic:
rw [Order.lex_impl]
Proof state after:
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
⊢ match Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ },
    Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x_1 :: tail, property := property }, { val := y_1 :: tail_1, property := property_1 } =>
    if x_1 = y_1 then
      Order.lex_impl (Vector.tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
        (Vector.tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))
    else x_1 ≤ y_1
Theorem: algebra.lex_add_le_add
Proof state before:
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
⊢ match Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ },
    Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x_1 :: tail, property := property }, { val := y_1 :: tail_1, property := property_1 } =>
    if x_1 = y_1 then
      Order.lex_impl (Vector.tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
        (Vector.tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))
    else x_1 ≤ y_1
Tactic:
split
Proof state after:
case h_1
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := [], property := property✝¹ }
heq✝ :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { val := [], property := property✝ }
⊢ True

case h_2
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
      (tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))
  else x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_1
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := [], property := property✝¹ }
heq✝ :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { val := [], property := property✝ }
⊢ True

case h_2
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
      (tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))
  else x✝ ≤ y✝
Tactic:
simp
Proof state after:
case h_2
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
      (tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))
  else x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝ }
⊢ if x✝ = y✝ then
    Order.lex_impl (tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
      (tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))
  else x✝ ≤ y✝
Tactic:
split
Proof state after:
case h_2.inl
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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝
⊢ Order.lex_impl (tail (Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ }))
    (tail (Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ }))

case 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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝
⊢ x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inl.h_2.inr.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₂✝¹ v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝² : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
eq : List.length (y✝ :: tail✝) = m
neq : ¬x✝ = y✝
h : x✝ ≤ y✝
heq₁ : x = x✝ ∧ xs = tail✝¹
heq₂ : y = y✝ ∧ ys = tail✝
eq₁ : x = x✝
eq₂ : y = y✝
property✝¹ : List.length ((x + z) :: List.zipWith (fun x y => x + y) xs zs) = m
property✝ : List.length ((y + z) :: List.zipWith (fun x y => x + y) ys zs) = m
sum_eq : x✝ = y✝
⊢ Order.lex_impl (tail { val := x :: xs, property := p₁ }) (tail { val := y :: ys, property := p₂ })

case 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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝
⊢ x✝ ≤ y✝
Tactic:
contradiction
Proof state after:
case 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
h : Order.lex_impl { val := x :: xs, property := p₁ } { val := y :: ys, property := p₂ }
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✝
⊢ x✝ ≤ y✝