internlm/Lean-Github huggingface dataset:
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ →
    if algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂ then ¬Order.lex v₁ v₂ → False else False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
split
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
rename_i h
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
have le := Nat.le_of_eq h
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
simp [h]
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
rename_i hle _
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
rw [Order.grlex.elem_sum, Order.grlex.elem_sum] at hle
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : List.foldl (fun x y => x + y) 0 (toList v₁) < List.foldl (fun x y => x + y) 0 (toList v₂)
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : List.foldl (fun x y => x + y) 0 (toList v₁) < List.foldl (fun x y => x + y) 0 (toList v₂)
h✝ : True
h : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
rw [algebra.Order.bgrlex.elem_sum, algebra.Order.bgrlex.elem_sum] at h
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : List.foldl (fun x y => x + y) 0 (toList v₁) < List.foldl (fun x y => x + y) 0 (toList v₂)
h✝ : True
h : List.foldl (fun x y => x + y) 0 (toList v₁) = List.foldl (fun x y => x + y) 0 (toList v₂)
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : List.foldl (fun x y => x + y) 0 (toList v₁) < List.foldl (fun x y => x + y) 0 (toList v₂)
h✝ : True
h : List.foldl (fun x y => x + y) 0 (toList v₁) = List.foldl (fun x y => x + y) 0 (toList v₂)
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
rw [h] at hle
Proof state after:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : List.foldl (fun x y => x + y) 0 (toList v₂) < List.foldl (fun x y => x + y) 0 (toList v₂)
h✝ : True
h : List.foldl (fun x y => x + y) 0 (toList v₁) = List.foldl (fun x y => x + y) 0 (toList v₂)
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
hle : List.foldl (fun x y => x + y) 0 (toList v₂) < List.foldl (fun x y => x + y) 0 (toList v₂)
h✝ : True
h : List.foldl (fun x y => x + y) 0 (toList v₁) = List.foldl (fun x y => x + y) 0 (toList v₂)
le : algebra.Order.bgrlex.elem_sum v₁ ≤ algebra.Order.bgrlex.elem_sum v₂
⊢ ¬Order.lex v₁ v₂ → False

case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
simp at hle
Proof state after:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
rename_i le neq
Proof state after:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
le : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
neq : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
le : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
neq : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
intros nleq
Proof state after:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
le : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
neq : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
nleq : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁
⊢ False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
le : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
neq : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
nleq : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁
⊢ False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
have le_contr := Nat.not_lt_of_le nleq
Proof state after:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
le : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
neq : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
nleq : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁
le_contr : ¬algebra.Order.bgrlex.elem_sum v₁ < algebra.Order.bgrlex.elem_sum v₂
⊢ False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
le : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
neq : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
nleq : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁
le_contr : ¬algebra.Order.bgrlex.elem_sum v₁ < algebra.Order.bgrlex.elem_sum v₂
⊢ False

case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
contradiction
Proof state after:
case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
split at h
Proof state after:
case inr.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : if Order.lex v₁ v₂ then True else False
⊢ algebra.Order.bgrlex v₁ v₂ = true

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inr.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : if Order.lex v₁ v₂ then True else False
⊢ algebra.Order.bgrlex v₁ v₂ = true

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
simp [algebra.Order.bgrlex]
Proof state after:
case inr.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : if Order.lex v₁ v₂ then True else False
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ →
    if algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂ then ¬Order.lex v₁ v₂ → False else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
case inr.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : if Order.lex v₁ v₂ then True else False
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ →
    if algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂ then ¬Order.lex v₁ v₂ → False else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : False
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
split
Proof state after:
case inr.inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝² : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝¹ : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : if Order.lex v₁ v₂ then True else False
h✝ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False

case inr.inl.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝² : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝¹ : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : if Order.lex v₁ v₂ then True else False
h✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
⊢ algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h : False
⊢ algebra.Order.bgrlex v₁ v₂ = true