l3lab/ntp-mathlib huggingface dataset:
instance instSMulPosStrictMono [SMulPosStrictMono α β] : SMulPosStrictMono α βᵒᵈ where
  elim _b hb a₁ a₂ ha := by
    rw [← neg_lt_neg_iff, ← smul_neg, ← smul_neg]
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b b₁ b₂ : β
inst✝⁴ : Preorder α
inst✝³ : Ring α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : SMulPosStrictMono α β
_b : βᵒᵈ
hb : 0 < _b
a₁ a₂ : α
ha : a₁ < a₂
⊢ a₂ • -_b < a₁ • -_b

Next tactic:
exact smul_lt_smul_of_pos_right (β := β) ha $ neg_pos.2 hb
instance instSMulPosReflectLT [SMulPosReflectLT α β] : SMulPosReflectLT α βᵒᵈ where
  elim _b hb a₁ a₂ h := by
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b b₁ b₂ : β
inst✝⁴ : Preorder α
inst✝³ : Ring α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : SMulPosReflectLT α β
_b : βᵒᵈ
hb : 0 ≤ _b
a₁ a₂ : α
h : a₁ • _b < a₂ • _b
⊢ a₁ < a₂

Next tactic:
rw [← neg_lt_neg_iff, ← smul_neg, ← smul_neg] at h
instance instSMulPosReflectLT [SMulPosReflectLT α β] : SMulPosReflectLT α βᵒᵈ where
  elim _b hb a₁ a₂ h := by
    rw [← neg_lt_neg_iff, ← smul_neg, ← smul_neg] at h
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b b₁ b₂ : β
inst✝⁴ : Preorder α
inst✝³ : Ring α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : SMulPosReflectLT α β
_b : βᵒᵈ
hb : 0 ≤ _b
a₁ a₂ : α
h : a₂ • -_b < a₁ • -_b
⊢ a₁ < a₂

Next tactic:
exact lt_of_smul_lt_smul_right (β := β) h $ neg_nonneg.2 hb
instance instSMulPosReflectLE [SMulPosReflectLE α β] : SMulPosReflectLE α βᵒᵈ where
  elim _b hb a₁ a₂ h := by
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b b₁ b₂ : β
inst✝⁴ : Preorder α
inst✝³ : Ring α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : SMulPosReflectLE α β
_b : βᵒᵈ
hb : 0 < _b
a₁ a₂ : α
h : a₁ • _b ≤ a₂ • _b
⊢ a₁ ≤ a₂

Next tactic:
rw [← neg_le_neg_iff, ← smul_neg, ← smul_neg] at h
instance instSMulPosReflectLE [SMulPosReflectLE α β] : SMulPosReflectLE α βᵒᵈ where
  elim _b hb a₁ a₂ h := by
    rw [← neg_le_neg_iff, ← smul_neg, ← smul_neg] at h
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b b₁ b₂ : β
inst✝⁴ : Preorder α
inst✝³ : Ring α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : SMulPosReflectLE α β
_b : βᵒᵈ
hb : 0 < _b
a₁ a₂ : α
h : a₂ • -_b ≤ a₁ • -_b
⊢ a₁ ≤ a₂

Next tactic:
exact le_of_smul_le_smul_right (β := β) h $ neg_pos.2 hb
instance instSMulPosReflectLE [∀ i, SMulPosReflectLE α (β i)] : SMulPosReflectLE α (∀ i, β i) where
  elim _b hb _a₁ _a₂ h := by
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : Preorder α
inst✝² : (i : ι) → Preorder (β i)
inst✝¹ : (i : ι) → SMulZeroClass α (β i)
inst✝ : ∀ (i : ι), SMulPosReflectLE α (β i)
_b : (i : ι) → β i
hb : 0 < _b
_a₁ _a₂ : α
h : _a₁ • _b ≤ _a₂ • _b
⊢ _a₁ ≤ _a₂

Next tactic:
obtain ⟨-, i, hi⟩ := lt_def.1 hb
instance instSMulPosReflectLE [∀ i, SMulPosReflectLE α (β i)] : SMulPosReflectLE α (∀ i, β i) where
  elim _b hb _a₁ _a₂ h := by
    obtain ⟨-, i, hi⟩ := lt_def.1 hb; 

Proof state:
case intro.intro
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : Preorder α
inst✝² : (i : ι) → Preorder (β i)
inst✝¹ : (i : ι) → SMulZeroClass α (β i)
inst✝ : ∀ (i : ι), SMulPosReflectLE α (β i)
_b : (i : ι) → β i
hb : 0 < _b
_a₁ _a₂ : α
h : _a₁ • _b ≤ _a₂ • _b
i : ι
hi : OfNat.ofNat 0 i < _b i
⊢ _a₁ ≤ _a₂

Next tactic:
exact le_of_smul_le_smul_right (h _) hi
instance instPosSMulStrictMono [∀ i, PosSMulStrictMono α (β i)] :
    PosSMulStrictMono α (∀ i, β i) where
  elim := by
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), PosSMulStrictMono α (β i)
⊢ ∀ ⦃a : α⦄, 0 < a → ∀ ⦃b₁ b₂ : (i : ι) → β i⦄, b₁ < b₂ → a • b₁ < a • b₂

Next tactic:
simp_rw [lt_def]
instance instPosSMulStrictMono [∀ i, PosSMulStrictMono α (β i)] :
    PosSMulStrictMono α (∀ i, β i) where
  elim := by
    simp_rw [lt_def]
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), PosSMulStrictMono α (β i)
⊢ ∀ ⦃a : α⦄,
    0 < a → ∀ ⦃b₁ b₂ : (i : ι) → β i⦄, (b₁ ≤ b₂ ∧ ∃ i, b₁ i < b₂ i) → a • b₁ ≤ a • b₂ ∧ ∃ i, (a • b₁) i < (a • b₂) i

Next tactic:
rintro _a ha _b₁ _b₂ ⟨hb, i, hi⟩
instance instPosSMulStrictMono [∀ i, PosSMulStrictMono α (β i)] :
    PosSMulStrictMono α (∀ i, β i) where
  elim := by
    simp_rw [lt_def]
    rintro _a ha _b₁ _b₂ ⟨hb, i, hi⟩
    

Proof state:
case intro.intro
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), PosSMulStrictMono α (β i)
_a : α
ha : 0 < _a
_b₁ _b₂ : (i : ι) → β i
hb : _b₁ ≤ _b₂
i : ι
hi : _b₁ i < _b₂ i
⊢ _a • _b₁ ≤ _a • _b₂ ∧ ∃ i, (_a • _b₁) i < (_a • _b₂) i

Next tactic:
exact ⟨smul_le_smul_of_nonneg_left hb ha.le, i, smul_lt_smul_of_pos_left hi ha⟩
instance instSMulPosStrictMono [∀ i, SMulPosStrictMono α (β i)] :
    SMulPosStrictMono α (∀ i, β i) where
  elim := by
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), SMulPosStrictMono α (β i)
⊢ ∀ ⦃b : (i : ι) → β i⦄, 0 < b → ∀ ⦃a₁ a₂ : α⦄, a₁ < a₂ → a₁ • b < a₂ • b

Next tactic:
simp_rw [lt_def]
instance instSMulPosStrictMono [∀ i, SMulPosStrictMono α (β i)] :
    SMulPosStrictMono α (∀ i, β i) where
  elim := by
    simp_rw [lt_def]
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), SMulPosStrictMono α (β i)
⊢ ∀ ⦃b : (i : ι) → β i⦄,
    (0 ≤ b ∧ ∃ i, OfNat.ofNat 0 i < b i) → ∀ ⦃a₁ a₂ : α⦄, a₁ < a₂ → a₁ • b ≤ a₂ • b ∧ ∃ i, (a₁ • b) i < (a₂ • b) i

Next tactic:
rintro a ⟨ha, i, hi⟩ _b₁ _b₂ hb
instance instSMulPosStrictMono [∀ i, SMulPosStrictMono α (β i)] :
    SMulPosStrictMono α (∀ i, β i) where
  elim := by
    simp_rw [lt_def]
    rintro a ⟨ha, i, hi⟩ _b₁ _b₂ hb
    

Proof state:
case intro.intro
α : Type u_1
β✝ : Type u_2
a✝ a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), SMulPosStrictMono α (β i)
a : (i : ι) → β i
ha : 0 ≤ a
i : ι
hi : OfNat.ofNat 0 i < a i
_b₁ _b₂ : α
hb : _b₁ < _b₂
⊢ _b₁ • a ≤ _b₂ • a ∧ ∃ i, (_b₁ • a) i < (_b₂ • a) i

Next tactic:
exact ⟨smul_le_smul_of_nonneg_right hb.le ha, i, smul_lt_smul_of_pos_right hb hi⟩
instance instSMulPosReflectLT [∀ i, SMulPosReflectLT α (β i)] : SMulPosReflectLT α (∀ i, β i) where
  elim := by
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), SMulPosReflectLT α (β i)
⊢ ∀ ⦃b : (i : ι) → β i⦄, 0 ≤ b → ∀ ⦃a₁ a₂ : α⦄, a₁ • b < a₂ • b → a₁ < a₂

Next tactic:
simp_rw [lt_def]
instance instSMulPosReflectLT [∀ i, SMulPosReflectLT α (β i)] : SMulPosReflectLT α (∀ i, β i) where
  elim := by
    simp_rw [lt_def]
    

Proof state:
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), SMulPosReflectLT α (β i)
⊢ ∀ ⦃b : (i : ι) → β i⦄, 0 ≤ b → ∀ ⦃a₁ a₂ : α⦄, (a₁ • b ≤ a₂ • b ∧ ∃ i, (a₁ • b) i < (a₂ • b) i) → a₁ < a₂

Next tactic:
rintro b hb _a₁ _a₂ ⟨-, i, hi⟩
instance instSMulPosReflectLT [∀ i, SMulPosReflectLT α (β i)] : SMulPosReflectLT α (∀ i, β i) where
  elim := by
    simp_rw [lt_def]
    rintro b hb _a₁ _a₂ ⟨-, i, hi⟩
    

Proof state:
case intro.intro
α : Type u_1
β✝ : Type u_2
a a₁ a₂ : α
b✝ b₁ b₂ : β✝
ι : Type u_3
β : ι → Type u_4
inst✝⁵ : Zero α
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : PartialOrder α
inst✝² : (i : ι) → PartialOrder (β i)
inst✝¹ : (i : ι) → SMulWithZero α (β i)
inst✝ : ∀ (i : ι), SMulPosReflectLT α (β i)
b : (i : ι) → β i
hb : 0 ≤ b
_a₁ _a₂ : α
i : ι
hi : (_a₁ • b) i < (_a₂ • b) i
⊢ _a₁ < _a₂

Next tactic:
exact lt_of_smul_lt_smul_right hi $ hb _
lemma PosSMulMono.lift [PosSMulMono α γ] : PosSMulMono α β where
  elim a ha b₁ b₂ hb := by 

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : PosSMulMono α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
hb : b₁ ≤ b₂
⊢ a • b₁ ≤ a • b₂

Next tactic:
simp only [← hf, smul] at *
lemma PosSMulMono.lift [PosSMulMono α γ] : PosSMulMono α β where
  elim a ha b₁ b₂ hb := by simp only [← hf, smul] at *; 

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
zero : f 0 = 0
inst✝ : PosSMulMono α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
hb : f b₁ ≤ f b₂
⊢ a • f b₁ ≤ a • f b₂

Next tactic:
exact smul_le_smul_of_nonneg_left hb ha
lemma PosSMulStrictMono.lift [PosSMulStrictMono α γ] : PosSMulStrictMono α β where
  elim a ha b₁ b₂ hb :=  by
    

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : PosSMulStrictMono α γ
a : α
ha : 0 < a
b₁ b₂ : β
hb : b₁ < b₂
⊢ a • b₁ < a • b₂

Next tactic:
simp only [← lt_iff_lt_of_le_iff_le' hf hf, smul] at *
lemma PosSMulStrictMono.lift [PosSMulStrictMono α γ] : PosSMulStrictMono α β where
  elim a ha b₁ b₂ hb :=  by
    simp only [← lt_iff_lt_of_le_iff_le' hf hf, smul] at *; 

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
zero : f 0 = 0
inst✝ : PosSMulStrictMono α γ
a : α
ha : 0 < a
b₁ b₂ : β
smul : α → β → True
hb : f b₁ < f b₂
⊢ a • f b₁ < a • f b₂

Next tactic:
exact smul_lt_smul_of_pos_left hb ha
lemma PosSMulReflectLE.lift [PosSMulReflectLE α γ] : PosSMulReflectLE α β where
  elim a ha b₁ b₂ h := hf.1 $ le_of_smul_le_smul_left (by 

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : PosSMulReflectLE α γ
a : α
ha : 0 < a
b₁ b₂ : β
h : a • b₁ ≤ a • b₂
⊢ a • f b₁ ≤ a • f b₂

Next tactic:
simpa only [smul] using hf.2 h
lemma PosSMulReflectLT.lift [PosSMulReflectLT α γ] : PosSMulReflectLT α β where
  elim a ha b₁ b₂ h := by
    

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : PosSMulReflectLT α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
h : a • b₁ < a • b₂
⊢ b₁ < b₂

Next tactic:
simp only [← lt_iff_lt_of_le_iff_le' hf hf, smul] at *
lemma PosSMulReflectLT.lift [PosSMulReflectLT α γ] : PosSMulReflectLT α β where
  elim a ha b₁ b₂ h := by
    simp only [← lt_iff_lt_of_le_iff_le' hf hf, smul] at *; 

Proof state:
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
zero : f 0 = 0
inst✝ : PosSMulReflectLT α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
smul : α → β → True
h : a • f b₁ < a • f b₂
⊢ f b₁ < f b₂

Next tactic:
exact lt_of_smul_lt_smul_left h ha
lemma SMulPosMono.lift [SMulPosMono α γ] : SMulPosMono α β where
  elim b hb a₁ a₂ ha := by
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : SMulPosMono α γ
b : β
hb : 0 ≤ b
a₁ a₂ : α
ha : a₁ ≤ a₂
⊢ a₁ • b ≤ a₂ • b

Next tactic:
simp only [← hf, zero, smul] at *
lemma SMulPosMono.lift [SMulPosMono α γ] : SMulPosMono α β where
  elim b hb a₁ a₂ ha := by
    simp only [← hf, zero, smul] at *; 

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosMono α γ
b : β
a₁ a₂ : α
ha : a₁ ≤ a₂
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 ≤ f b
⊢ a₁ • f b ≤ a₂ • f b

Next tactic:
exact smul_le_smul_of_nonneg_right ha hb
lemma SMulPosStrictMono.lift [SMulPosStrictMono α γ] : SMulPosStrictMono α β where
  elim b hb a₁ a₂ ha := by
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : SMulPosStrictMono α γ
b : β
hb : 0 < b
a₁ a₂ : α
ha : a₁ < a₂
⊢ a₁ • b < a₂ • b

Next tactic:
simp only [← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
lemma SMulPosStrictMono.lift [SMulPosStrictMono α γ] : SMulPosStrictMono α β where
  elim b hb a₁ a₂ ha := by
    simp only [← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
inst✝ : SMulPosStrictMono α γ
b : β
a₁ a₂ : α
ha : a₁ < a₂
smul : α → β → True
zero : True
hb : 0 < f b
⊢ a₁ • f b < a₂ • f b

Next tactic:
exact smul_lt_smul_of_pos_right ha hb
lemma SMulPosReflectLE.lift [SMulPosReflectLE α γ] : SMulPosReflectLE α β where
  elim b hb a₁ a₂ h := by
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : SMulPosReflectLE α γ
b : β
hb : 0 < b
a₁ a₂ : α
h : a₁ • b ≤ a₂ • b
⊢ a₁ ≤ a₂

Next tactic:
simp only [← hf, ← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
lemma SMulPosReflectLE.lift [SMulPosReflectLE α γ] : SMulPosReflectLE α β where
  elim b hb a₁ a₂ h := by
    simp only [← hf, ← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosReflectLE α γ
b : β
a₁ a₂ : α
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 < f b
h : a₁ • f b ≤ a₂ • f b
⊢ a₁ ≤ a₂

Next tactic:
exact le_of_smul_le_smul_right h hb
lemma SMulPosReflectLT.lift [SMulPosReflectLT α γ] : SMulPosReflectLT α β where
  elim b hb a₁ a₂ h := by
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : SMulPosReflectLT α γ
b : β
hb : 0 ≤ b
a₁ a₂ : α
h : a₁ • b < a₂ • b
⊢ a₁ < a₂

Next tactic:
simp only [← hf, ← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
lemma SMulPosReflectLT.lift [SMulPosReflectLT α γ] : SMulPosReflectLT α β where
  elim b hb a₁ a₂ h := by
    simp only [← hf, ← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
    

Proof state:
α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosReflectLT α γ
b : β
a₁ a₂ : α
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 ≤ f b
h : a₁ • f b < a₂ • f b
⊢ a₁ < a₂

Next tactic:
exact lt_of_smul_lt_smul_right h hb
instance {n m} [Fintype m] [DecidableEq m] [Fintype n] [DecidableEq n] (R) [Fintype R] :
    Fintype (Matrix m n R) := by 

Proof state:
n : Type ?u.20
m : Type ?u.8
inst✝⁴ : Fintype m
inst✝³ : DecidableEq m
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type ?u.35
inst✝ : Fintype R
⊢ Fintype (Matrix m n R)

Next tactic:
unfold Matrix
instance {n m} [Fintype m] [DecidableEq m] [Fintype n] [DecidableEq n] (R) [Fintype R] :
    Fintype (Matrix m n R) := by unfold Matrix; 

Proof state:
n : Type ?u.20
m : Type ?u.8
inst✝⁴ : Fintype m
inst✝³ : DecidableEq m
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type ?u.35
inst✝ : Fintype R
⊢ Fintype (m → n → R)

Next tactic:
infer_instance
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  

Proof state:
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
⊢ vecMul ((LinearMap.stdBasis R (fun x => R) i) 1) M j = M i j

Next tactic:
have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    

Proof state:
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
⊢ ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j

Next tactic:
simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  

Proof state:
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ vecMul ((LinearMap.stdBasis R (fun x => R) i) 1) M j = M i j

Next tactic:
simp only [vecMul, dotProduct]
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  simp only [vecMul, dotProduct]
  

Proof state:
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ ∑ x : m, (LinearMap.stdBasis R (fun x => R) i) 1 x * M x j = M i j

Next tactic:
convert this
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  simp only [vecMul, dotProduct]
  convert this
  

Proof state:
case h.e'_2.a.h.e'_5
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
⊢ (LinearMap.stdBasis R (fun x => R) i) 1 x✝ = if i = x✝ then 1 else 0

Next tactic:
split_ifs with h
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  simp only [vecMul, dotProduct]
  convert this
  split_ifs with h <;> 

Proof state:
case pos
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : i = x✝
⊢ (LinearMap.stdBasis R (fun x => R) i) 1 x✝ = 1

Next tactic:
simp only [stdBasis_apply]
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  simp only [vecMul, dotProduct]
  convert this
  split_ifs with h <;> 

Proof state:
case neg
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : ¬i = x✝
⊢ (LinearMap.stdBasis R (fun x => R) i) 1 x✝ = 0

Next tactic:
simp only [stdBasis_apply]
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  simp only [vecMul, dotProduct]
  convert this
  split_ifs with h <;> simp only [stdBasis_apply]
  · 

Proof state:
case pos
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : i = x✝
⊢ Function.update 0 i 1 x✝ = 1

Next tactic:
rw [h, Function.update_same]
@[simp]
theorem Matrix.vecMul_stdBasis (M : Matrix m n R) (i j) :
    M.vecMul (LinearMap.stdBasis R (fun _ => R) i 1) j = M i j := by
  have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
  simp only [vecMul, dotProduct]
  convert this
  split_ifs with h <;> simp only [stdBasis_apply]
  · rw [h, Function.update_same]
  · 

Proof state:
case neg
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : ¬i = x✝
⊢ Function.update 0 i 1 x✝ = 0

Next tactic:
rw [Function.update_noteq (Ne.symm h), Pi.zero_apply]