Theorem: AddMonoidAlgebra.NoZeroDivisors.of_right_ordered
File: Mathlib/Algebra/MonoidAlgebra/NoZeroDivisors.lean

tactic: contrapose! fg
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f * g = 0
⊢ f = 0 ∨ g = 0

tactic: let fmin : A := f.support.min' (support_nonempty_iff.mpr fg.1)
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
⊢ f * g ≠ 0

tactic: refine' support_nonempty_iff.mp _
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
⊢ f * g ≠ 0

tactic: obtain ⟨a, ha, H⟩ :=
  Left.exists_add_of_mem_support_single_mul fmin
    ((single fmin 1 * g : AddMonoidAlgebra R A).support.min'
      (by rw [support_single_mul] <;> simp [support_nonempty_iff.mpr fg.2]))
    (Finset.min'_mem _ _)
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
⊢ Finset.Nonempty (f * g).support

tactic: refine' ⟨fmin + a, mem_support_iff.mpr _⟩
state_before: case intro.intro
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support ?m.36783
⊢ Finset.Nonempty (f * g).support

tactic: rw [mul_apply_add_eq_mul_of_forall_ne _]
state_before: case intro.intro
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
⊢ ↑(f * g) (fmin + a) ≠ 0

tactic: rw [support_single_mul] <;> simp [support_nonempty_iff.mpr fg.2]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
⊢ Finset.Nonempty (single fmin 1 * g).support

tactic: refine' mul_ne_zero _ _
state_before: case intro.intro
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
⊢ ↑f fmin * ↑g a ≠ 0

tactic: exacts [mem_support_iff.mp (Finset.min'_mem _ _), mem_support_iff.mp ha]
state_before: case intro.intro.refine'_1
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
⊢ ↑f fmin ≠ 0

case intro.intro.refine'_2
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
⊢ ↑g a ≠ 0

tactic: rw [H]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
⊢ ∀ {a_1 b : A}, a_1 ∈ f.support → b ∈ g.support → a_1 ≠ fmin ∨ b ≠ a → a_1 + b ≠ fmin + a

tactic: rintro b c bf cg (hb | hc) <;> refine' ne_of_gt _
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
⊢ ∀ {a_1 b : A},
    a_1 ∈ f.support →
      b ∈ g.support →
        a_1 ≠ fmin ∨ b ≠ a →
          a_1 + b ≠ Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)

tactic: refine' lt_of_le_of_lt (_ : _ ≤ fmin + c) _
state_before: case inl
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
⊢ Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support) < b + c

tactic: apply Finset.min'_le
state_before: case inl.refine'_1
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
⊢ Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support) ≤ fmin + c

tactic: rw [support_single_mul _ _ (fun y => by rw [one_mul] : ∀ y : R, 1 * y = 0 ↔ _)]
state_before: case inl.refine'_1.H2
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
⊢ fmin + c ∈ (single fmin 1 * g).support

tactic: simp only [cg, Finset.mem_map, addLeftEmbedding_apply, add_right_inj, exists_prop,
  exists_eq_right]
state_before: case inl.refine'_1.H2
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
⊢ fmin + c ∈ Finset.map (addLeftEmbedding fmin) g.support

tactic: rw [one_mul]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
y : R
⊢ 1 * y = 0 ↔ y = 0

tactic: refine' add_lt_add_right _ _
state_before: case inl.refine'_2
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
⊢ fmin + c < b + c

tactic: exact Finset.min'_lt_of_mem_erase_min' _ _ (Finset.mem_erase.mpr ⟨hb, bf⟩)
state_before: case inl.refine'_2
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hb : b ≠ fmin
⊢ fmin < b

tactic: refine' lt_of_lt_of_le (_ : _ < fmin + c) _
state_before: case inr
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support) < b + c

tactic: apply Finset.min'_lt_of_mem_erase_min'
state_before: case inr.refine'_1
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support) < fmin + c

tactic: rw [← H]
state_before: case inr.refine'_1.ha
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ fmin + c ∈
    Finset.erase (single fmin 1 * g).support
      (Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support))

tactic: apply Finset.mem_erase_of_ne_of_mem
state_before: case inr.refine'_1.ha
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ fmin + c ∈ Finset.erase (single fmin 1 * g).support (fmin + a)

tactic: simpa only [Ne.def, add_right_inj]
state_before: case inr.refine'_1.ha.a
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ fmin + c ≠ fmin + a

tactic: rw [support_single_mul _ _ (fun y => by rw [one_mul] : ∀ y : R, 1 * y = 0 ↔ _)]
state_before: case inr.refine'_1.ha.a
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ fmin + c ∈ (single fmin 1 * g).support

tactic: simpa only [Finset.mem_map, addLeftEmbedding_apply, add_right_inj, exists_prop,
  exists_eq_right]
state_before: case inr.refine'_1.ha.a
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
⊢ fmin + c ∈ Finset.map (addLeftEmbedding fmin) g.support

tactic: rw [one_mul]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
y : R
⊢ 1 * y = 0 ↔ y = 0

tactic: exact add_le_add_right (Finset.min'_le _ _ bf) _
state_before: case inr.refine'_2
R : Type u_1
A : Type u_2
inst✝⁴ : Semiring R
inst✝³ : NoZeroDivisors R
inst✝² : AddLeftCancelSemigroup A
inst✝¹ : LinearOrder A
inst✝ : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
f g : AddMonoidAlgebra R A
fg : f ≠ 0 ∧ g ≠ 0
fmin : A := Finset.min' f.support (_ : Finset.Nonempty f.support)
a : A
ha : a ∈ g.support
H : fmin + a = Finset.min' (single fmin 1 * g).support (_ : Finset.Nonempty (single fmin 1 * g).support)
b c : A
bf : b ∈ f.support
cg : c ∈ g.support
hc : c ≠ a
this : CovariantClass A A (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ fmin + c ≤ b + c