internlm/Lean-Github huggingface dataset:
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
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:
rw [Order.lex_impl] at h
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 :
  match { val := x :: xs, property := p₁ }, { val := y :: ys, 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 { val := x :: xs, property := p₁ }) (Vector.tail { val := y :: ys, property := p₂ })
    else x_1 ≤ 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✝¹ :
  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.inr.h_2.inl.refl.refl.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
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
property✝¹ : List.length ((x + z) :: List.zipWith (fun x y => x + y) xs zs) = m
h✝ : ¬x + z = y + z
property✝ : List.length ((y + z) :: List.zipWith (fun x y => x + y) ys zs) = m
⊢ x + z ≤ y + z

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:
simp [eq]
Proof state after:
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✝¹
Theorem: algebra.lex_add_le_add
Proof state before:
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:
rename_i var_mul₁ var_mul₂ _ _ _ _ _ _ _ _ _ heq₁ heq₂ eq
Proof state after:
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
var_mul₁ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝¹ :: tail✝³, property := property✝³ }
var_mul₂ :
  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✝ }
eq : ¬x✝ = y✝
h : x✝ ≤ y✝
⊢ x✝¹ ≤ y✝¹
Theorem: algebra.lex_add_le_add
Proof state before:
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
var_mul₁ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝¹ :: tail✝³, property := property✝³ }
var_mul₂ :
  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✝ }
eq : ¬x✝ = y✝
h : x✝ ≤ y✝
⊢ x✝¹ ≤ y✝¹
Tactic:
cases heq₁
Proof state after:
case h_2.inr.h_2.inr.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₁ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝ :: tail✝², property := property✝³ }
var_mul₂ :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { 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✝¹ }
eq : ¬x = y✝
h : x ≤ y✝
property✝ : List.length (x :: xs) = m
⊢ x✝ ≤ y✝¹
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.h_2.inr.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₁ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝ :: tail✝², property := property✝³ }
var_mul₂ :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { 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✝¹ }
eq : ¬x = y✝
h : x ≤ y✝
property✝ : List.length (x :: xs) = m
⊢ x✝ ≤ y✝¹
Tactic:
cases heq₂
Proof state after:
case h_2.inr.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₂✝¹ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝³ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝² : List.length (y✝ :: tail✝) = m
var_mul₁ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝ :: tail✝¹, property := property✝³ }
var_mul₂ :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { val := y✝ :: tail✝, property := property✝² }
h✝ : ¬x✝ = y✝
v₁✝ v₂✝ : Vector ℕ m
property✝¹ : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝ : List.length (y :: ys) = m
⊢ x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.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₂✝¹ : Vector ℕ m
x✝ : ℕ
tail✝¹ : List ℕ
property✝³ : List.length (x✝ :: tail✝¹) = m
y✝ : ℕ
tail✝ : List ℕ
property✝² : List.length (y✝ :: tail✝) = m
var_mul₁ :
  Variables.mul { val := x :: xs, property := p₁ } { val := z :: zs, property := p₃ } =
    { val := x✝ :: tail✝¹, property := property✝³ }
var_mul₂ :
  Variables.mul { val := y :: ys, property := p₂ } { val := z :: zs, property := p₃ } =
    { val := y✝ :: tail✝, property := property✝² }
h✝ : ¬x✝ = y✝
v₁✝ v₂✝ : Vector ℕ m
property✝¹ : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝ : List.length (y :: ys) = m
⊢ x✝ ≤ y✝
Tactic:
simp [map₂, Variables.mul, List.zipWith] at var_mul₁ var_mul₂
Proof state after:
case h_2.inr.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₂✝¹ : 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
property✝¹ : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝ : List.length (y :: ys) = m
⊢ x✝ ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.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₂✝¹ : 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
property✝¹ : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝ : List.length (y :: ys) = m
⊢ x✝ ≤ y✝
Tactic:
cases var_mul₁
Proof state after:
case h_2.inr.h_2.inr.refl.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
y✝ : ℕ
tail✝ : List ℕ
property✝³ : List.length (y✝ :: tail✝) = m
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✝³ }
v₁✝ v₂✝ : Vector ℕ m
property✝² : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝¹ : List.length (y :: ys) = m
h✝ : ¬x + z = y✝
property✝ : List.length ((x + z) :: List.zipWith (fun x y => x + y) xs zs) = m
⊢ x + z ≤ y✝
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.h_2.inr.refl.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
y✝ : ℕ
tail✝ : List ℕ
property✝³ : List.length (y✝ :: tail✝) = m
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✝³ }
v₁✝ v₂✝ : Vector ℕ m
property✝² : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝¹ : List.length (y :: ys) = m
h✝ : ¬x + z = y✝
property✝ : List.length ((x + z) :: List.zipWith (fun x y => x + y) xs zs) = m
⊢ x + z ≤ y✝
Tactic:
cases var_mul₂
Proof state after:
case h_2.inr.h_2.inr.refl.refl.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
property✝³ : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝² : List.length (y :: ys) = m
property✝¹ : List.length ((x + z) :: List.zipWith (fun x y => x + y) xs zs) = m
h✝ : ¬x + z = y + z
property✝ : List.length ((y + z) :: List.zipWith (fun x y => x + y) ys zs) = m
⊢ x + z ≤ y + z
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.h_2.inr.refl.refl.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
property✝³ : List.length (x :: xs) = m
eq : ¬x = y
h : x ≤ y
property✝² : List.length (y :: ys) = m
property✝¹ : List.length ((x + z) :: List.zipWith (fun x y => x + y) xs zs) = m
h✝ : ¬x + z = y + z
property✝ : List.length ((y + z) :: List.zipWith (fun x y => x + y) ys zs) = m
⊢ x + z ≤ y + z
Tactic:
simp at *
Proof state after:
case h_2.inr.h_2.inr.refl.refl.refl.refl
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p₁ : succ (List.length xs) = m
y : ℕ
ys : List ℕ
p₂ : succ (List.length ys) = m
z : ℕ
zs : List ℕ
p₃ : succ (List.length zs) = m
v₁✝¹ v₂✝¹ v₁✝ v₂✝ : Vector ℕ m
property✝³ : succ (List.length xs) = m
eq : ¬x = y
h : x ≤ y
property✝² : succ (List.length ys) = m
property✝¹ : succ (min (List.length xs) (List.length zs)) = m
h✝ : ¬x = y
property✝ : succ (min (List.length ys) (List.length zs)) = m
⊢ x ≤ y
Theorem: algebra.lex_add_le_add
Proof state before:
case h_2.inr.h_2.inr.refl.refl.refl.refl
n : ℕ
v₁ v₂ v₃ : Variables n order.Lex
m : ℕ
a b c : Variables m order.Lex
x : ℕ
xs : List ℕ
p₁ : succ (List.length xs) = m
y : ℕ
ys : List ℕ
p₂ : succ (List.length ys) = m
z : ℕ
zs : List ℕ
p₃ : succ (List.length zs) = m
v₁✝¹ v₂✝¹ v₁✝ v₂✝ : Vector ℕ m
property✝³ : succ (List.length xs) = m
eq : ¬x = y
h : x ≤ y
property✝² : succ (List.length ys) = m
property✝¹ : succ (min (List.length xs) (List.length zs)) = m
h✝ : ¬x = y
property✝ : succ (min (List.length ys) (List.length zs)) = m
⊢ x ≤ y
Tactic:
exact h
Proof state after:
no goals
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h : algebra.Order.ble_lex_impl v₁ v₂ = true
⊢ lex v₁ v₂
Tactic:
rename_i n
Proof state after:
n : ℕ
v₁ v₂ : Vector ℕ n
h : algebra.Order.ble_lex_impl v₁ v₂ = true
⊢ lex v₁ v₂
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
n : ℕ
v₁ v₂ : Vector ℕ n
h : algebra.Order.ble_lex_impl v₁ v₂ = true
⊢ lex v₁ v₂
Tactic:
exact aux n v₁ v₂ h
Proof state after:
no goals
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
h : algebra.Order.ble_lex_impl a b = true
⊢ lex a b
Tactic:
rw [Order.lex]
Proof state after:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
h : algebra.Order.ble_lex_impl a b = true
⊢ lex_impl a b
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
h : algebra.Order.ble_lex_impl a b = true
⊢ lex_impl a b
Tactic:
rw [Order.lex_impl]
Proof state after:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
h : algebra.Order.ble_lex_impl a b = true
⊢ match a, b 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 lex_impl (Vector.tail a) (Vector.tail b) else x ≤ y
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
h : algebra.Order.ble_lex_impl a b = true
⊢ match a, b 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 lex_impl (Vector.tail a) (Vector.tail b) else x ≤ y
Tactic:
match a, b with
  | ⟨[], _⟩  , ⟨[], _⟩     => simp
  | ⟨x::xs, _⟩, ⟨y::ys, _⟩ => split
                              simp
                              split
                              rw [Order.ble_lex_impl] at h
                              simp at h
                              split at h
                              exact aux (m-1) (tail ⟨x::xs, _⟩) (tail ⟨y::ys, _⟩) h
                              simp at *
                              rename_i heq₁ hneq heq₂ heq₃
                              have eq₁ := heq₂.left
                              have eq₂ := heq₃.left
                              rw [eq₁, eq₂] at hneq
                              contradiction                                  
                              rename_i heq₁ heq₂ hneq₁ 
                              rw [Order.ble_lex_impl] at h
                              split at h
                              simp at *
                              split at h
                              rename_i heq₃ heq₄ hneq₂
                              simp at heq₁ heq₂ heq₃ heq₄ hneq₂
                              have eq₁ := heq₁.left
                              have eq₂ := heq₂.left
                              have eq₃ := heq₃.left
                              have eq₄ := heq₄.left
                              rw [eq₁] at eq₃
                              rw [eq₂] at eq₄
                              rw [eq₃, eq₄] at hneq₁
                              contradiction
                              simp at h
                              rename_i heq₁ heq₂ _ _ _ _ _ _ _ _ _ _ _ heq₃ heq₄ _ 
                              simp at heq₁ heq₂ heq₃ heq₄
                              have eq₁ := heq₁.left
                              have eq₂ := heq₂.left
                              have eq₃ := heq₃.left
                              have eq₄ := heq₄.left
                              rw [eq₁] at eq₃
                              rw [eq₂] at eq₄
                              rw [eq₃, eq₄]
                              exact h
Proof state after:
no goals
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
property✝¹ property✝ : List.length [] = m
h : algebra.Order.ble_lex_impl { val := [], property := property✝¹ } { val := [], property := property✝ } = true
⊢ match { val := [], property := property✝¹ }, { val := [], property := property✝ } 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
      lex_impl (Vector.tail { val := [], property := property✝¹ }) (Vector.tail { val := [], property := property✝ })
    else x ≤ y
Tactic:
simp
Proof state after:
no goals