internlm/Lean-Github huggingface dataset:
Theorem: algebra.lex_le_trans
Proof state before:
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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
⊢ match { val := [], property := p }, { val := [], property := l } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x :: tail, property := property }, { val := y :: tail_1, property := property_1 } =>
    if x = y then Order.lex_impl (Vector.tail { val := [], property := p }) (Vector.tail { val := [], property := l })
    else x ≤ y
Tactic:
split
Proof state after:
case h_1
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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ : { val := [], property := p } = { val := [], property := property✝¹ }
heq✝ : { val := [], property := l } = { val := [], property := property✝ }
⊢ True

case 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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := [], property := p } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := [], property := l } = { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then Order.lex_impl (tail { val := [], property := p }) (tail { val := [], property := l }) else x✝ ≤ y✝
Theorem: algebra.lex_le_trans
Proof state before:
case h_1
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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ : { val := [], property := p } = { val := [], property := property✝¹ }
heq✝ : { val := [], property := l } = { val := [], property := property✝ }
⊢ True

case 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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := [], property := p } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := [], property := l } = { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then Order.lex_impl (tail { val := [], property := p }) (tail { val := [], property := l }) else x✝ ≤ y✝
Tactic:
simp
Proof state after:
case 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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := [], property := p } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := [], property := l } = { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then Order.lex_impl (tail { val := [], property := p }) (tail { val := [], property := l }) else x✝ ≤ y✝
Theorem: algebra.lex_le_trans
Proof state before:
case 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
p q l : List.length [] = m
ab : Order.lex_impl { val := [], property := p } { val := [], property := q }
bc : Order.lex_impl { val := [], property := q } { val := [], property := l }
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
heq✝¹ : { val := [], property := p } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := [], property := l } = { val := y✝ :: tail✝, property := property✝ }
⊢ if x✝ = y✝ then Order.lex_impl (tail { val := [], property := p }) (tail { val := [], property := l }) else x✝ ≤ y✝
Tactic:
simp at *
Proof state after:
no goals
Theorem: algebra.lex_le_trans
Proof state before:
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
ab : Order.lex_impl { val := x :: xs, property := p } { val := y :: ys, property := q }
bc : Order.lex_impl { val := y :: ys, property := q } { val := z :: zs, property := l }
⊢ Order.lex_impl { val := x :: xs, property := p } { val := z :: zs, property := l }
Tactic:
rw [Order.lex_impl]
Proof state after:
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
ab : Order.lex_impl { val := x :: xs, property := p } { val := y :: ys, property := q }
bc : Order.lex_impl { val := y :: ys, property := q } { val := z :: zs, property := l }
⊢ match { val := x :: xs, property := p }, { val := z :: zs, property := l } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x_1 :: tail, property := property }, { val := y :: tail_1, property := property_1 } =>
    if x_1 = y then
      Order.lex_impl (Vector.tail { val := x :: xs, property := p }) (Vector.tail { val := z :: zs, property := l })
    else x_1 ≤ y
Theorem: algebra.lex_le_trans
Proof state before:
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
ab : Order.lex_impl { val := x :: xs, property := p } { val := y :: ys, property := q }
bc : Order.lex_impl { val := y :: ys, property := q } { val := z :: zs, property := l }
⊢ match { val := x :: xs, property := p }, { val := z :: zs, property := l } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x_1 :: tail, property := property }, { val := y :: tail_1, property := property_1 } =>
    if x_1 = y then
      Order.lex_impl (Vector.tail { val := x :: xs, property := p }) (Vector.tail { val := z :: zs, property := l })
    else x_1 ≤ y
Tactic:
rw [Order.lex_impl] at ab bc
Proof state after:
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
ab :
  match { val := x :: xs, property := p }, { val := y :: ys, property := q } 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 { val := x :: xs, property := p }) (Vector.tail { val := y :: ys, property := q })
    else x_1 ≤ y_1
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
⊢ match { val := x :: xs, property := p }, { val := z :: zs, property := l } with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x_1 :: tail, property := property }, { val := y :: tail_1, property := property_1 } =>
    if x_1 = y then
      Order.lex_impl (Vector.tail { val := x :: xs, property := p }) (Vector.tail { val := z :: zs, property := l })
    else x_1 ≤ y
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.inr.h_2.inl
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
neq₁ : ¬x = z
neq₂ : ¬x = y
ab : x ≤ z
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝¹ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (y✝ :: tail✝) = m
eq : y = z
bc : Order.lex_impl (tail { val := y :: ys, property := q }) (tail { val := z :: zs, property := l })
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z

case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
h✝ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Tactic:
exact ab
Proof state after:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
h✝ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
h✝ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Tactic:
rename_i neq₃
Proof state after:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Tactic:
rw [x_cross_one_eq_x, y_cross_one_eq_y] at neq₂ ab
Proof state after:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬x✝ = y✝
bc : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Tactic:
rw [x_cross_eq_x, y_cross_eq_x] at neq₃ bc
Proof state after:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬y = z
bc : y ≤ z
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬y = z
bc : y ≤ z
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
⊢ x ≤ z
Tactic:
have le_le := Nat.le_trans ab bc
Proof state after:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬y = z
bc : y ≤ z
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
le_le : x ≤ z
⊢ x ≤ z
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.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
neq₁ : ¬x = z
neq₂ : ¬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
neq₃ : ¬y = z
bc : y ≤ z
heq₁ : x = x✝¹ ∧ xs = tail✝³
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : y = x✝ ∧ ys = tail✝¹
heq₄ : z = y✝ ∧ zs = tail✝
x_cross_one_eq_x : x✝¹ = x
y_cross_one_eq_y : y✝¹ = y
x_cross_eq_x : x✝ = y
y_cross_eq_x : y✝ = z
le_le : x ≤ z
⊢ x ≤ z
Tactic:
exact le_le
Proof state after:
no goals
Theorem: algebra.lex_le_trans
Proof state before:
case h_2.inr.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✝
⊢ x ≤ z
Tactic:
rename_i neq₁ eq₁ _ _ _ _ _ _ _ _ eq₂ heq₁ heq₂ heq₃ heq₄
Proof state after:
case h_2.inr.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 ℕ
neq₁ : List.length (y✝ :: tail✝¹) = m
eq₁ : { val := x :: xs, property := p } = { val := x✝¹ :: tail✝², property := property✝¹ }
heq✝ : { val := y :: ys, property := q } = { val := y✝ :: tail✝¹, property := neq₁ }
h✝¹ : ¬x = z
h✝ : ¬x✝¹ = y✝
ab : x✝¹ ≤ y✝
v₁✝ v₂✝ : Vector ℕ m
x✝ : ℕ
tail✝ : List ℕ
property✝ : List.length (x✝ :: tail✝) = m
eq₂ : ℕ
heq₁ : List ℕ
heq₂ : List.length (eq₂ :: heq₁) = m
heq₃ : { val := y :: ys, property := q } = { val := x✝ :: tail✝, property := property✝ }
heq₄ : { val := z :: zs, property := l } = { val := eq₂ :: heq₁, property := heq₂ }
bc :
  if x✝ = eq₂ then Order.lex_impl (tail { val := y :: ys, property := q }) (tail { val := z :: zs, property := l })
  else x✝ ≤ eq₂
⊢ x ≤ z