internlm/Lean-Github huggingface dataset:
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
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
Tactic:
simp [hh] at h
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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬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✝¹ h✝ : List.foldl (fun x y => x + y) 0 (toList v₁) = List.foldl (fun x y => x + y) 0 (toList v₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬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:
split
Proof state after:
case inr.inl.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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬Order.lex v₁ v₂ → False
h✝ : Order.lex v₁ v₂
⊢ True

case inr.inl.inl.inr
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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬Order.lex v₁ v₂ → False
h✝ : ¬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✝ : ¬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.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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬Order.lex v₁ v₂ → False
h✝ : Order.lex v₁ v₂
⊢ True

case inr.inl.inl.inr
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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬Order.lex v₁ v₂ → False
h✝ : ¬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✝ : ¬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
Proof state after:
case inr.inl.inl.inr
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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬Order.lex v₁ v₂ → False
h✝ : ¬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✝ : ¬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.inr
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₂)
hh : List.foldl (fun x y => x + y) 0 (toList v₂) ≤ List.foldl (fun x y => x + y) 0 (toList v₁)
h : ¬Order.lex v₁ v₂ → False
h✝ : ¬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✝ : ¬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:
contradiction
Proof state after:
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.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:
split
Proof state after:
case inr.inl.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₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
h✝ : Order.lex v₁ v₂
⊢ True

case inr.inl.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✝¹ : ¬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
h✝ : ¬Order.lex v₁ v₂
⊢ 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.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₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → False
h✝ : Order.lex v₁ v₂
⊢ True

case inr.inl.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✝¹ : ¬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
h✝ : ¬Order.lex v₁ v₂
⊢ 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
Proof state after:
case inr.inl.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✝¹ : ¬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
h✝ : ¬Order.lex v₁ v₂
⊢ 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.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✝¹ : ¬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
h✝ : ¬Order.lex v₁ v₂
⊢ 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.inr.inr
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₁ → False
h✝¹ : ¬Order.lex v₁ v₂
h✝ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ 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.inr.inr
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₁ → False
h✝¹ : ¬Order.lex v₁ v₂
h✝ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ 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 h₁
Proof state after:
case inr.inl.inr.inr
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₁ → False
h✝ : ¬Order.lex v₁ v₂
h₁ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ 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.inr.inr
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₁ → False
h✝ : ¬Order.lex v₁ v₂
h₁ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ 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 nleq eq _
Proof state after:
case inr.inl.inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
nleq : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
eq : ¬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
h✝ : ¬Order.lex v₁ v₂
h₁ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ 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.inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
nleq : Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
eq : ¬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
h✝ : ¬Order.lex v₁ v₂
h₁ : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ 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:
contradiction
Proof state after:
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.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 [Order.bgrlex] at h
Proof state after:
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 :
  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
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
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 :
  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
⊢ False
Tactic:
split at h
Proof state after:
case inr.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₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False
⊢ False

case inr.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✝ : ¬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
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
case inr.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₂
h : algebra.Order.bgrlex.elem_sum v₂ ≤ algebra.Order.bgrlex.elem_sum v₁ → ¬Order.lex v₁ v₂ → False
⊢ False

case inr.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✝ : ¬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
⊢ False
Tactic:
contradiction
Proof state after:
case inr.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✝ : ¬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
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
case inr.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✝ : ¬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
⊢ False
Tactic:
rename_i nleq neq₁ neq₂
Proof state after:
case inr.inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
nleq : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
neq₁ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
neq₂ : ¬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
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
case inr.inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
nleq : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
neq₁ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
neq₂ : ¬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
⊢ False
Tactic:
have leq := Nat.le_of_not_lt nleq
Proof state after:
case inr.inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
nleq : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
neq₁ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
neq₂ : ¬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
leq : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ False
Theorem: algebra.grlex_true_of_ble_grlex_true
Proof state before:
case inr.inr.inr
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
nleq : ¬Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
neq₁ : ¬Order.grlex.elem_sum v₁ = Order.grlex.elem_sum v₂
neq₂ : ¬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
leq : Order.grlex.elem_sum v₂ ≤ Order.grlex.elem_sum v₁
⊢ False
Tactic:
exact h leq
Proof state after:
no goals
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h : Order.grlex v₁ v₂
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
simp [Order.grlex] at h
Proof state after:
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h :
  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
⊢ algebra.Order.bgrlex v₁ v₂ = true
Theorem: algebra.grble_eq_true_of_grlex
Proof state before:
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h :
  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
⊢ algebra.Order.bgrlex v₁ v₂ = true
Tactic:
split at h
Proof state after:
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 v₁ v₂ = true

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
n✝ : ℕ
v₁ v₂ : Variables n✝ order.GrLex
h✝ : Order.grlex.elem_sum v₁ < Order.grlex.elem_sum v₂
h : True
⊢ algebra.Order.bgrlex v₁ v₂ = true

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 [algebra.Order.bgrlex]
Proof state after:
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