internlm/Lean-Github huggingface dataset:
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Tactic:
have ulp_dvd : ulp n b ∣ ulp n (a - b) := by
  apply ulp_dvd_ulp
  apply le_tsub_of_add_le_left
  rewrite [← Nat.two_mul]
  exact hba
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Tactic:
have hba' : b ≤ a := Nat.le_trans (Nat.le_mul_of_pos_left two_pos) hba
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Tactic:
have ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b :=
  ulp_sub_le_of_two_mul_le_of_lt_round npos hfaithful₀ hfaithful₁ hfa hba lt_round
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ trunc n (next n (trunc n (a - b)) - (a - b)) = next n (trunc n (a - b)) - (a - b)
Tactic:
apply trunc_eq_of_le_of_ulp_dvd b
Proof state after:
case hle
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ next n (trunc n (a - b)) - (a - b) ≤ b

case hdvd
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b)) - (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hle
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ next n (trunc n (a - b)) - (a - b) ≤ b

case hdvd
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b)) - (a - b)
Tactic:
. rewrite [next_trunc_sub_eq_ulp_sub_mod npos]
  exact ulp_sub_le
Proof state after:
case hdvd
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b)) - (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b)) - (a - b)
Tactic:
. apply Nat.dvd_sub'
  . rewrite [next, ulp_trunc npos]
    apply Nat.dvd_add
    . trans ulp n (a - b)
      . exact ulp_dvd
      . exact ulp_dvd_trunc n _
    . exact ulp_dvd
  . apply Nat.dvd_sub hba'
    . trans ulp n a
      . exact ulp_dvd_ulp n hba'
      . exact ulp_dvd_of_trunc_eq hfa
    . exact ulp_dvd_of_trunc_eq hfb
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ ulp n b ∣ ulp n (a - b)
Tactic:
apply ulp_dvd_ulp
Proof state after:
case h
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ b ≤ a - b
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case h
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ b ≤ a - b
Tactic:
apply le_tsub_of_add_le_left
Proof state after:
case h.h
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ b + b ≤ a
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case h.h
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ b + b ≤ a
Tactic:
rewrite [← Nat.two_mul]
Proof state after:
case h.h
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ 2 * b ≤ a
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case h.h
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
⊢ 2 * b ≤ a
Tactic:
exact hba
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hle
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ next n (trunc n (a - b)) - (a - b) ≤ b
Tactic:
rewrite [next_trunc_sub_eq_ulp_sub_mod npos]
Proof state after:
case hle
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hle
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
Tactic:
exact ulp_sub_le
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b)) - (a - b)
Tactic:
apply Nat.dvd_sub'
Proof state after:
case hdvd.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b))

case hdvd.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a - b
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b))

case hdvd.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a - b
Tactic:
. rewrite [next, ulp_trunc npos]
  apply Nat.dvd_add
  . trans ulp n (a - b)
    . exact ulp_dvd
    . exact ulp_dvd_trunc n _
  . exact ulp_dvd
Proof state after:
case hdvd.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a - b
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a - b
Tactic:
. apply Nat.dvd_sub hba'
  . trans ulp n a
    . exact ulp_dvd_ulp n hba'
    . exact ulp_dvd_of_trunc_eq hfa
  . exact ulp_dvd_of_trunc_eq hfb
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ next n (trunc n (a - b))
Tactic:
rewrite [next, ulp_trunc npos]
Proof state after:
case hdvd.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ trunc n (a - b) + ulp n (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ trunc n (a - b) + ulp n (a - b)
Tactic:
apply Nat.dvd_add
Proof state after:
case hdvd.h₁.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ trunc n (a - b)

case hdvd.h₁.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ trunc n (a - b)

case hdvd.h₁.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)
Tactic:
. trans ulp n (a - b)
  . exact ulp_dvd
  . exact ulp_dvd_trunc n _
Proof state after:
case hdvd.h₁.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)
Tactic:
. exact ulp_dvd
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ trunc n (a - b)
Tactic:
trans ulp n (a - b)
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)

round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) ∣ trunc n (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)

round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) ∣ trunc n (a - b)
Tactic:
. exact ulp_dvd
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) ∣ trunc n (a - b)
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) ∣ trunc n (a - b)
Tactic:
. exact ulp_dvd_trunc n _
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)
Tactic:
exact ulp_dvd
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n (a - b) ∣ trunc n (a - b)
Tactic:
exact ulp_dvd_trunc n _
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₁.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n (a - b)
Tactic:
exact ulp_dvd
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a - b
Tactic:
apply Nat.dvd_sub hba'
Proof state after:
case hdvd.h₂.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a

case hdvd.h₂.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ b
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₂.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a

case hdvd.h₂.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ b
Tactic:
. trans ulp n a
  . exact ulp_dvd_ulp n hba'
  . exact ulp_dvd_of_trunc_eq hfa
Proof state after:
case hdvd.h₂.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ b
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₂.h₂
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ b
Tactic:
. exact ulp_dvd_of_trunc_eq hfb
Proof state after:
no goals
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
case hdvd.h₂.h₁
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ a
Tactic:
trans ulp n a
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n a

round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n a ∣ a
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n b ∣ ulp n a

round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n a ∣ a
Tactic:
. exact ulp_dvd_ulp n hba'
Proof state after:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n a ∣ a
Theorem: b₁_hi_of_two_mul_le_of_lt_round
Proof state before:
round : ℕ → ℕ
n a b : ℕ
npos : 0 < n
hfaithful₀ : faithful₀ n round
hfaithful₁ : faithful₁ n round
hfa : trunc n a = a
hfb : trunc n b = b
hba : 2 * b ≤ a
lt_round : a - b < round (a - b)
ulp_dvd : ulp n b ∣ ulp n (a - b)
hba' : b ≤ a
ulp_sub_le : ulp n (a - b) - (a - b) % ulp n (a - b) ≤ b
⊢ ulp n a ∣ a
Tactic:
. exact ulp_dvd_of_trunc_eq hfa
Proof state after:
no goals