internlm/Lean-Github huggingface dataset:
Theorem: algebra.Order.lex_true_of_ble_lex_true
Proof state before:
case h_2.inr.h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝⁴ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝³ : List.length (y :: ys) = m
v₁✝¹ v₂✝¹ : Vector ℕ m
x✝¹ : ℕ
heq₁✝ : List ℕ
heq₂✝ : List.length (x✝¹ :: heq₁✝) = m
y✝¹ : ℕ
tail✝² : List ℕ
property✝² : List.length (y✝¹ :: tail✝²) = m
hneq₁ : ¬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✝) = true
h : x✝ ≤ y✝
heq₁ : x = x✝¹ ∧ xs = heq₁✝
heq₂ : y = y✝¹ ∧ ys = tail✝²
heq₃ : x = x✝ ∧ xs = tail✝¹
heq₄ : y = y✝ ∧ ys = tail✝
eq₁ : x = x✝¹
eq₂ : y = y✝¹
eq₃ : x✝¹ = x✝
eq₄ : y✝¹ = y✝
⊢ x✝ ≤ y✝
Tactic:
exact h
Proof state after:
no goals
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h : lex_impl v₁ v₂
⊢ algebra.Order.ble_lex_impl v₁ v₂ = true
Tactic:
rename_i n
Proof state after:
n : ℕ
v₁ v₂ : Vector ℕ n
h : lex_impl v₁ v₂
⊢ algebra.Order.ble_lex_impl v₁ v₂ = true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
n : ℕ
v₁ v₂ : Vector ℕ n
h : lex_impl v₁ v₂
⊢ algebra.Order.ble_lex_impl v₁ v₂ = true
Tactic:
exact aux n v₁ v₂ h
Proof state after:
no goals
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
h : lex_impl a b
⊢ algebra.Order.ble_lex_impl a b = true
Tactic:
match a, b with
 | ⟨[], _⟩, ⟨[], _⟩       => rw [Order.ble_lex_impl]
 | ⟨x::xs, _⟩, ⟨y::ys, _⟩ => rw [Order.ble_lex_impl]
                             split;rfl
                             split
                             rw [lex_impl] at h
                             simp at h
                             split at h
                             apply Order.ble_eq_true_of_lex h
                             rename_i heq₁ heq₂ neq eq
                             simp at heq₁ heq₂
                             have eq₁ := heq₁.left
                             have eq₂ := heq₂.left
                             simp at neq
                             rw [eq₁, eq₂] at eq
                             contradiction
                             rw [lex_impl] at h
                             simp at h
                             split at h
                             rename_i heq₁ heq₂ neq eq
                             simp at heq₁ heq₂
                             have eq₁ := heq₁.left
                             have eq₂ := heq₂.left
                             simp at neq
                             rw [eq₁, eq₂] at eq
                             contradiction
                             simp
                             rename_i heq₁ heq₂ _ _
                             simp at heq₁ heq₂
                             have eq₁ := Eq.symm heq₁.left
                             have eq₂ := Eq.symm heq₂.left
                             rwa [eq₁, eq₂]
Proof state after:
no goals
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
property✝¹ property✝ : List.length [] = m
h : lex_impl { val := [], property := property✝¹ } { val := [], property := property✝ }
⊢ algebra.Order.ble_lex_impl { val := [], property := property✝¹ } { val := [], property := property✝ } = true
Tactic:
rw [Order.ble_lex_impl]
Proof state after:
no goals
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝¹ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝ : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝¹ } { val := y :: ys, property := property✝ }
⊢ algebra.Order.ble_lex_impl { val := x :: xs, property := property✝¹ } { val := y :: ys, property := property✝ } = true
Tactic:
rw [Order.ble_lex_impl]
Proof state after:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝¹ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝ : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝¹ } { val := y :: ys, property := property✝ }
⊢ (match { val := x :: xs, property := property✝¹ }, { val := y :: ys, property := property✝ } 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) = true then
        algebra.Order.ble_lex_impl (Vector.tail { val := x :: xs, property := property✝¹ })
          (Vector.tail { val := y :: ys, property := property✝ })
      else decide (x_1 ≤ y_1)) =
    true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝¹ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝ : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝¹ } { val := y :: ys, property := property✝ }
⊢ (match { val := x :: xs, property := property✝¹ }, { val := y :: ys, property := property✝ } 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) = true then
        algebra.Order.ble_lex_impl (Vector.tail { val := x :: xs, property := property✝¹ })
          (Vector.tail { val := y :: ys, property := property✝ })
      else decide (x_1 ≤ y_1)) =
    true
Tactic:
split
Proof state after:
case h_1
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, property := property✝² }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ : { val := x :: xs, property := property✝³ } = { val := [], property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := [], property := property✝ }
⊢ true = true

case h_2
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
⊢ (if (x✝ == y✝) = true then
      algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
        (tail { val := y :: ys, property := property✝² })
    else decide (x✝ ≤ y✝)) =
    true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
case h_1
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, property := property✝² }
v₁✝ v₂✝ : Vector ℕ m
property✝¹ property✝ : List.length [] = m
heq✝¹ : { val := x :: xs, property := property✝³ } = { val := [], property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := [], property := property✝ }
⊢ true = true

case h_2
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
⊢ (if (x✝ == y✝) = true then
      algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
        (tail { val := y :: ys, property := property✝² })
    else decide (x✝ ≤ y✝)) =
    true
Tactic:
rfl
Proof state after:
case h_2
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
⊢ (if (x✝ == y✝) = true then
      algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
        (tail { val := y :: ys, property := property✝² })
    else decide (x✝ ≤ y✝)) =
    true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
case h_2
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
⊢ (if (x✝ == y✝) = true then
      algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
        (tail { val := y :: ys, property := property✝² })
    else decide (x✝ ≤ y✝)) =
    true
Tactic:
split
Proof state after:
case h_2.inl
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : (x✝ == y✝) = true
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝² : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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 := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝¹ : (x✝ == y✝) = true
h✝ : ¬x = y
h : x ≤ y
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Tactic:
rename_i heq₁ heq₂ neq eq
Proof state after:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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 := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq₂ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
neq : (x✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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 := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq₂ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
neq : (x✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Tactic:
simp at heq₁ heq₂
Proof state after:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
heq₁ : x = x✝ ∧ xs = tail✝¹
heq₂ : y = y✝ ∧ ys = tail✝
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
heq₁ : x = x✝ ∧ xs = tail✝¹
heq₂ : y = y✝ ∧ ys = tail✝
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Tactic:
have eq₁ := heq₁.left
Proof state after:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
heq₁ : x = x✝ ∧ xs = tail✝¹
heq₂ : y = y✝ ∧ ys = tail✝
eq₁ : x = x✝
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Theorem: algebra.Order.ble_eq_true_of_lex
Proof state before:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
heq₁ : x = x✝ ∧ xs = tail✝¹
heq₂ : y = y✝ ∧ ys = tail✝
eq₁ : x = x✝
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true
Tactic:
have eq₂ := heq₂.left
Proof state after:
case h_2.inl.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = 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✝ == y✝) = true
eq : ¬x = y
h : x ≤ y
heq₁ : x = x✝ ∧ xs = tail✝¹
heq₂ : y = y✝ ∧ ys = tail✝
eq₁ : x = x✝
eq₂ : y = y✝
⊢ algebra.Order.ble_lex_impl (tail { val := x :: xs, property := property✝³ })
      (tail { val := y :: ys, property := property✝² }) =
    true

case h_2.inr
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝¹ : lex_impl v₁ v₂
m : ℕ
a b : Vector ℕ m
x : ℕ
xs : List ℕ
property✝³ : List.length (x :: xs) = m
y : ℕ
ys : List ℕ
property✝² : List.length (y :: ys) = m
h : lex_impl { val := x :: xs, property := property✝³ } { val := y :: ys, 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✝¹ : { val := x :: xs, property := property✝³ } = { val := x✝ :: tail✝¹, property := property✝¹ }
heq✝ : { val := y :: ys, property := property✝² } = { val := y✝ :: tail✝, property := property✝ }
h✝ : ¬(x✝ == y✝) = true
⊢ decide (x✝ ≤ y✝) = true