internlm/Lean-Github huggingface dataset:
Theorem: algebra.grlex_add_le_add
Proof state before:
case inl.inl.inr
n : ℕ
a b c : Variables n order.GrLex
h✝² : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝¹ : Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then True else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝ : ¬sum₁ < sum₂
⊢ if sum₁ = sum₂ then True else False

case inl.inr
n : ℕ
a b c : Variables n order.GrLex
h✝¹ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝ : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then True else False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Tactic:
(split; simp)
Proof state after:
case inl.inl.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then True else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : ¬sum₁ = sum₂
⊢ False

case inl.inr
n : ℕ
a b c : Variables n order.GrLex
h✝¹ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝ : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then True else False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Theorem: algebra.grlex_add_le_add
Proof state before:
case inl.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝² : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝¹ : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝ : ¬sum₁ < sum₂
⊢ if sum₁ = sum₂ then True else False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Tactic:
(split; simp)
Proof state after:
case inl.inr.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : ¬sum₁ = sum₂
⊢ False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Theorem: algebra.grlex_add_le_add
Proof state before:
case inl.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝² : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝¹ : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝ : ¬sum₁ < sum₂
⊢ if sum₁ = sum₂ then True else False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Tactic:
split
Proof state after:
case inl.inr.inr.inl
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : sum₁ = sum₂
⊢ True

case inl.inr.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : ¬sum₁ = sum₂
⊢ False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Theorem: algebra.grlex_add_le_add
Proof state before:
case inl.inr.inr.inl
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : sum₁ = sum₂
⊢ True

case inl.inr.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : ¬sum₁ = sum₂
⊢ False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Tactic:
simp
Proof state after:
case inl.inr.inr.inr
n : ℕ
a b c : Variables n order.GrLex
h✝³ : Order.lex (Variables.mul a c) (Variables.mul b c)
h✝² : ¬Order.lex a b
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
sum₁ : ℕ := Order.grlex.elem_sum (Variables.mul a c)
sum₂ : ℕ := Order.grlex.elem_sum (Variables.mul b c)
h✝¹ : ¬sum₁ < sum₂
h✝ : ¬sum₁ = sum₂
⊢ False

case inr
n : ℕ
a b c : Variables n order.GrLex
h_le :
  let sum₁ := Order.grlex.elem_sum a;
  let sum₂ := Order.grlex.elem_sum b;
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then if Order.lex a b then True else False else False
h✝ : ¬Order.lex (Variables.mul a c) (Variables.mul b c)
⊢ let sum₁ := Order.grlex.elem_sum (Variables.mul a c);
  let sum₂ := Order.grlex.elem_sum (Variables.mul b c);
  if sum₁ < sum₂ then True else if sum₁ = sum₂ then False else False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
⊢ Order.grlex v₁ v₂
Tactic:
simp [Order.grlex]
Proof state after:
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
⊢ if Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂ then True
  else if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
⊢ if Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂ then True
  else if Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂ then if Order.lex v₁ v₂ then True else False else False
Tactic:
split
Proof state after:
case inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
⊢ True

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

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

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

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Tactic:
simp [algebra.Order.bgrlex] 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 :
  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
⊢ if Order.lex v₁ v₂ then True else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
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 :
  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
⊢ if Order.lex v₁ v₂ then True else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Tactic:
split at h
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✝ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False
⊢ if Order.lex v₁ v₂ then True else 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✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
⊢ if Order.lex v₁ v₂ then True else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
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✝ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False
⊢ if Order.lex v₁ v₂ then True else 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✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
⊢ if Order.lex v₁ v₂ then True else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Tactic:
simp at *
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✝¹ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False
h✝ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ if Order.lex v₁ v₂ then True else 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✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
⊢ if Order.lex v₁ v₂ then True else False

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
case inr.inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝² : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
h✝¹ : algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False
h✝ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ if Order.lex v₁ v₂ then True else 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✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
⊢ if Order.lex v₁ v₂ then True else False

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

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

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

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

case inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : algebra.Order.bgrlex v₁ v₂ = true
h✝¹ : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h✝ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
⊢ False
Tactic:
rename_i hh
Proof state after:
case inr.inl.inl
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝¹ h✝ : List.foldl (fun x y => x + y) 0 (toList v₁) = List.foldl (fun x y => x + y) 0 (toList v₂)
h : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁) → ¬Order.lex v₁ v₂ → False
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
⊢ if Order.lex v₁ v₂ then True else 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✝ : ¬algebra.Order.bgrlex.elem_sum v₁ = algebra.Order.bgrlex.elem_sum v₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
⊢ if Order.lex v₁ v₂ then True else False

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