import ContractExact namespace Submission open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats local notation "ZAa" => Nat.mod_eq_of_lt local notation "ZAb" => Finset.Ico local notation "ZAc" => Float.Model.UnpackedFloat.ExtendedMantissa.ofMantissaAndAccuracy local notation "ZAd" => Finset.range local notation "ZAe" => Nat.shiftLeft_eq local notation "ZAf" => UInt64.toNat_sub_of_le local notation "ZAg" => Nat.mul_lt_mul_of_lt_of_le local notation "ZAh" => UInt64.le_iff_toNat_le local notation "ZAi" => UInt64.toNat_shiftLeft local notation "ZAj" => Nat.mul_le_mul_right local notation "ZAk" => UInt32.toNat_inj.mp local notation "ZAl" => UInt64.toNat_add local notation "ZAm" => Nat.pow_le_pow_right local notation "ZAn" => Nat.mul_lt_mul_of_pos_right local notation "ZAo" => Nat.shiftRight_eq_div_pow local notation "ZAp" => Bool.false_eq_true local notation "ZAq" => Nat.shiftLeft_add_eq_or_of_lt local notation "ZAr" => UInt64.lt_iff_toNat_lt local notation "ZAs" => Finset.sum_eq_sum_Ico_succ_bot local notation "ZAt" => Nat.zero_le local notation "ZAu" => Finset.mem_range.mp local notation "ZAv" => UInt64.toNat_shiftRight local notation "ZAw" => UInt32.toNat_toUInt64 local notation "ZAx" => Bool.and_eq_true local notation "ZAy" => Finset.sum_congr local notation "ZAz" => USize.lt_iff_toNat_lt.mpr local notation "ZBa" => UInt64.toNat_zero local notation "ZBb" => Float.Model.UnpackedFloat.ExtendedMantissa.shiftRightOne local notation "ZBc" => UInt64.toNat_toUInt32 local notation "ZBd" => Nat.and_two_pow_sub_one_eq_mod local notation "ZBe" => BitVec.ofInt local notation "ZBf" => UInt64.toNat_inj.mp local notation "ZBg" => FloatLib.Floats.Formats.BinaryInterchange.FloatFormat.toModel local notation "ZBh" => Float.Model.UnpackedFloat.Accuracy.roundToNearestEven local notation "ZBi" => Finset.sum_add_distrib local notation "ZBj" => FloatLib.Numerics.roundQuotientEven local notation "ZBk" => Nat.div_lt_iff_lt_mul local notation "ZBl" => Finset.sum_range_succ local notation "ZBm" => Finset.sum_mul local notation "ZBn" => UInt32.toNat_or local notation "ZBo" => System.Platform.numBits local notation "ZBp" => Nat.lt_or_ge local notation "ZBq" => USize.lt_iff_toNat_lt.mp local notation "ZBr" => UInt64.toNat_inj local notation "ZBs" => FloatLib.Numerics.binaryRadix local notation "ZBt" => Nat.le_log2 local notation "ZBu" => Finset.Ico_eq_empty local notation "ZBv" => Array.replicate local notation "ZBw" => UInt32.toNat_sub_of_le local notation "ZBx" => FloatLib.Floats.Formats.Flocq.bpow local notation "ZBy" => Nat.le_div_iff_mul_le local notation "ZBz" => Array.size_uset local notation "ZCa" => Finset.range_eq_Ico local notation "ZCb" => USize.toNat_zero local notation "ZCc" => Nat.div_add_mod' local notation "ZCd" => Bool.or_eq_true local notation "ZCe" => Nat.mod_lt local notation "ZCf" => Finset.sum_le_sum local notation "ZCg" => Finset.mem_Ico.mp local notation "ZCh" => UInt64.le_iff_toNat_le.mpr local notation "ZCi" => UInt32.toNat_toUSize local notation "ZCj" => UInt32.toNat_and local notation "ZCk" => Nat.log2_self_le local notation "ZCl" => UInt64.toBitVec_mul local notation "ZCm" => Nat.mul_le_mul_left local notation "ZCn" => USize.size local notation "ZCo" => Array.ofFn local notation "ZCp" => Nat.pos_of_ne_zero local notation "ZCq" => Nat.lt_of_le_of_lt local notation "ZCr" => Int.natAbs_natCast local notation "ZCs" => UInt32.ofNat local notation "ZCt" => UInt64.toNat_mul local notation "ZCu" => UInt64.toNat_and local notation "ZCv" => UInt64.toFloat32 local notation "ZCw" => Nat.lt_log2_self local notation "ZCx" => Finset.sum_const local notation "ZCy" => BitVec.ofInt_mul local notation "ZCz" => UInt64.toNat_or local notation "ZDa" => Nat.log2_lt local notation "ZDb" => Nat.add_mul_mod_self_right local notation "ZDc" => Nat.cast_sub local notation "ZDd" => UInt64.lt_iff_toNat_lt.mp local notation "ZDe" => UInt64.le_iff_toNat_le.mp local notation "ZDf" => Int.natAbs_neg local notation "ZDg" => UInt64.toNat_sub local notation "ZDh" => Nat.div_eq_of_lt local notation "ZDi" => Finset.sum_empty local notation "ZDj" => Nat.le_mul_of_pos_left local notation "ZDk" => Finset.sum_sub_distrib local notation "ZDl" => Nat.zero_add local notation "ZDm" => Nat.cast_nonneg local notation "ZDn" => Nat.add_mul_div_right local notation "ZDo" => Nat.add_comm local notation "ZDp" => USize.toNat_toUInt32 local notation "ZDq" => Nat.pow_lt_pow_right section open FloatLib.Numerics end def QO : ByteArray := ⟨(Array.range 65536).map fun i => if i % 256 = 0 then 41 else if i % 256 ≠ 255 ∧ i / 256 ≤ i % 256 ∧ i % 256 ≤ i / 256 + 7 then (i % 256 - i / 256).toUInt8 else 40⟩ lemma Qbq : QO.size = 65536 := by simp [QO, ByteArray.size] @[inline] def Qbu (w : UInt32) : USize := ((w >>> 23) &&& 0xFF).toUSize lemma Qbg (w : UInt32) : (Qbu w).toNat = ((w >>> 23) &&& 0xFF).toNat := by simp only [Qbu, ZCi] lemma Qbr (w : UInt32) : (Qbu w).toNat < 256 := by rw [Qbg, ZCj] exact ZCq Nat.and_le_right (by decide) lemma Qe (a b : USize) (h : a.toNat + b.toNat < 2 ^ 32) : (a + b).toNat = a.toNat + b.toNat := by rw [USize.toNat_add] have : 2 ^ 32 ≤ ZCn := USize.le_size have h3 : ZCn = 2 ^ ZBo := rfl exact ZAa (by omega) @[inline] def Qf (o : USize) (ho : o.toNat ≤ 65280) (w : UInt32) : UInt64 := let m := ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 m <<< (QO.uget (o + Qbu w) (by rw [Qbq, Qe _ _ (by have := Qbr w; omega)] have := Qbr w; omega)).toUInt64 @[inline] def Qi (w : UInt32) (mag : UInt64) : UInt64 := if signOf w then 0 - mag else mag @[inline] def sx (v : UInt32) : UInt64 := v.toInt32.toInt64.toUInt64 lemma Qd (t n : USize) (h : t < n) : (t + 1).toNat = t.toNat + 1 := by have h1 : t.toNat < n.toNat := ZBq h have h2 : n.toNat < ZCn := n.toNat_lt_size have h3 : ZCn = 2 ^ ZBo := rfl rw [USize.toNat_add, USize.toNat_one] exact ZAa (by omega) def QaL (IX : Array UInt32) (W : Array UInt32) (n : Nat) (w0 w1 w2 w3 : USize) : Prop := ∀ s, s < n → ∀ wr, (wr = w0 ∨ wr = w1 ∨ wr = w2 ∨ wr = w3) → wr.toNat + (IX[s]!).toNat < W.size lemma Q2 (IX W : Array UInt32) (t wr : USize) (ht : t.toNat < IX.size) (hb : wr.toNat + (IX[t.toNat]!).toNat < W.size) (hWs : W.size < 2 ^ 32) : (wr + (IX.uget t ht).toUSize).toNat < W.size := by have he : (IX.uget t ht).toUSize.toNat = (IX[t.toNat]!).toNat := by simp only [Array.uget, ZCi, getElem!_pos IX t.toNat ht] rw [Qe _ _ (by omega), he]; exact hb structure Qau where ok : Bool lo : UInt64 nn : UInt64 tp : UInt64 tn : UInt64 D : UInt64 b1 : UInt64 sd : Bool den : Word deriving Inhabited structure Qdv where a0 : UInt64 b0 : UInt64 a1 : UInt64 b1 : UInt64 a2 : UInt64 b2 : UInt64 a3 : UInt64 b3 : UInt64 chk : UInt64 structure Qbf where a0 : UInt64 b0 : UInt64 c0 : UInt64 a1 : UInt64 b1 : UInt64 c1 : UInt64 a2 : UInt64 b2 : UInt64 c2 : UInt64 a3 : UInt64 b3 : UInt64 c3 : UInt64 chk : UInt64 def QaR (IX X0 X1 W : Array UInt32) (o : USize) (ho : o.toNat ≤ 65280) (w0 w1 w2 w3 n : USize) (hI : n.toNat ≤ IX.size) (h0 : n.toNat ≤ X0.size) (h1 : n.toNat ≤ X1.size) (hW : QaL IX W n.toNat w0 w1 w2 w3) (hWs : W.size < 2 ^ 32) (t : USize) (a0 b0 a1 b1 a2 b2 a3 b3 chk : UInt64) : Qdv := if h : t < n then have ht : t.toNat < n.toNat := ZBq h have hti : t.toNat < IX.size := by omega let x0 := sx (X0.uget t (by omega)) let x1 := sx (X1.uget t (by omega)) let v0 := W.uget (w0 + (IX.uget t hti).toUSize) (Q2 IX W t w0 hti (hW _ ht w0 (by simp)) hWs) let v1 := W.uget (w1 + (IX.uget t hti).toUSize) (Q2 IX W t w1 hti (hW _ ht w1 (by simp)) hWs) let v2 := W.uget (w2 + (IX.uget t hti).toUSize) (Q2 IX W t w2 hti (hW _ ht w2 (by simp)) hWs) let v3 := W.uget (w3 + (IX.uget t hti).toUSize) (Q2 IX W t w3 hti (hW _ ht w3 (by simp)) hWs) let m0 := Qf o ho v0 let m1 := Qf o ho v1 let m2 := Qf o ho v2 let m3 := Qf o ho v3 let s0 := sx (Qi v0 m0).toUInt32 let s1 := sx (Qi v1 m1).toUInt32 let s2 := sx (Qi v2 m2).toUInt32 let s3 := sx (Qi v3 m3).toUInt32 QaR IX X0 X1 W o ho w0 w1 w2 w3 n hI h0 h1 hW hWs (t + 1) (a0 + x0 * s0) (b0 + x1 * s0) (a1 + x0 * s1) (b1 + x1 * s1) (a2 + x0 * s2) (b2 + x1 * s2) (a3 + x0 * s3) (b3 + x1 * s3) (chk ||| m0 ||| m1 ||| m2 ||| m3) else ⟨a0, b0, a1, b1, a2, b2, a3, b3, chk⟩ termination_by n.toNat - t.toNat decreasing_by rw [Qd t n h]; omega def QaW (IX X0 X1 X2 W : Array UInt32) (o : USize) (ho : o.toNat ≤ 65280) (w0 w1 w2 w3 n : USize) (hI : n.toNat ≤ IX.size) (h0 : n.toNat ≤ X0.size) (h1 : n.toNat ≤ X1.size) (h2 : n.toNat ≤ X2.size) (hW : QaL IX W n.toNat w0 w1 w2 w3) (hWs : W.size < 2 ^ 32) (t : USize) (a0 b0 c0 a1 b1 c1 a2 b2 c2 a3 b3 c3 chk : UInt64) : Qbf := if h : t < n then have ht : t.toNat < n.toNat := ZBq h have hti : t.toNat < IX.size := by omega let x0 := sx (X0.uget t (by omega)) let x1 := sx (X1.uget t (by omega)) let x2 := sx (X2.uget t (by omega)) let v0 := W.uget (w0 + (IX.uget t hti).toUSize) (Q2 IX W t w0 hti (hW _ ht w0 (by simp)) hWs) let v1 := W.uget (w1 + (IX.uget t hti).toUSize) (Q2 IX W t w1 hti (hW _ ht w1 (by simp)) hWs) let v2 := W.uget (w2 + (IX.uget t hti).toUSize) (Q2 IX W t w2 hti (hW _ ht w2 (by simp)) hWs) let v3 := W.uget (w3 + (IX.uget t hti).toUSize) (Q2 IX W t w3 hti (hW _ ht w3 (by simp)) hWs) let m0 := Qf o ho v0 let m1 := Qf o ho v1 let m2 := Qf o ho v2 let m3 := Qf o ho v3 let s0 := sx (Qi v0 m0).toUInt32 let s1 := sx (Qi v1 m1).toUInt32 let s2 := sx (Qi v2 m2).toUInt32 let s3 := sx (Qi v3 m3).toUInt32 QaW IX X0 X1 X2 W o ho w0 w1 w2 w3 n hI h0 h1 h2 hW hWs (t + 1) (a0 + x0 * s0) (b0 + x1 * s0) (c0 + x2 * s0) (a1 + x0 * s1) (b1 + x1 * s1) (c1 + x2 * s1) (a2 + x0 * s2) (b2 + x1 * s2) (c2 + x2 * s2) (a3 + x0 * s3) (b3 + x1 * s3) (c3 + x2 * s3) (chk ||| m0 ||| m1 ||| m2 ||| m3) else ⟨a0, b0, c0, a1, b1, c1, a2, b2, c2, a3, b3, c3, chk⟩ termination_by n.toNat - t.toNat decreasing_by rw [Qd t n h]; omega lemma Qw (t n : USize) (h : t < n) : t.toNat < n.toNat := ZBq h structure Qdy where a0 : UInt64 b0 : UInt64 c0 : UInt64 a1 : UInt64 b1 : UInt64 c1 : UInt64 chk : UInt64 def Qz (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (k c : USize) (IX P0 P1 P2 : Array UInt32) (hck : c.toNat ≤ k.toNat) (hs : n.toNat ≤ IX.size ∧ n.toNat ≤ P0.size ∧ n.toNat ≤ P1.size ∧ n.toNat ≤ P2.size) (ok : Bool) : Array UInt32 × Array UInt32 × Array UInt32 × Array UInt32 × USize × Bool := if h : k < n then have hk : k.toNat < n.toNat := Qw k n h have hk1 : (k + 1).toNat = k.toNat + 1 := Qd k n h let w := X.uget (o + k) (by rw [Qe _ _ (by omega)]; omega) let e := (w >>> 23) &&& 0xFF if e == 0 then Qz X o n lx lim hX hXs (k + 1) c IX P0 P1 P2 (by omega) hs (ok && (w &&& 0x7FFFFF) == 0) else have hc1 : (c + 1).toNat = c.toNat + 1 := Qd c n (ZAz (by omega)) let d := e - lx let mag := ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< d.toUInt64 let p0 := mag &&& 0x1FFFFF let p1 := (mag >>> 21) &&& 0x1FFFFF let p2 := mag >>> 42 let neg := signOf w Qz X o n lx lim hX hXs (k + 1) (c + 1) (IX.uset c k.toUInt32 (by omega)) (P0.uset c (if neg then 0 - p0 else p0).toUInt32 (by omega)) (P1.uset c (if neg then 0 - p1 else p1).toUInt32 (by omega)) (P2.uset c (if neg then 0 - p2 else p2).toUInt32 (by omega)) (by omega) (by simp only [ZBz]; exact hs) (ok && e != 255 && lx ≤ e && d ≤ lim) else (IX, P0, P1, P2, c, ok) termination_by n.toNat - k.toNat decreasing_by all_goals (rw [hk1]; omega) def Qah (W : Array UInt32) (n : USize) (hW : n.toNat ≤ W.size) (k : USize) (c : UInt32) : UInt32 := if h : k < n then have hk : k.toNat < n.toNat := Qw k n h Qah W n hW (k + 1) (c ||| W.uget k (by omega)) else c termination_by n.toNat - k.toNat decreasing_by rw [Qd k n h]; omega def QbW (X : Array UInt32) (o n : USize) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (k : USize) (lo hi : UInt32) : UInt32 × UInt32 := if h : k < n then have hk : k.toNat < n.toNat := Qw k n h let w := X.uget (o + k) (by rw [Qe _ _ (by omega)]; omega) let e := (w >>> 23) &&& 0xFF let nz := (w &&& 0x7FFFFFFF) != 0 QbW X o n hX hXs (k + 1) (if nz && e < lo then e else lo) (if nz && e > hi then e else hi) else (lo, hi) termination_by n.toNat - k.toNat decreasing_by rw [Qd k n h]; omega section open Float.Model Float.Model.UnpackedFloat open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats namespace Bridge lemma QY (em : ExtendedMantissa) (n : Nat) : (em >>> n).mantissa = em.mantissa / 2 ^ n := by show (Nat.repeat ZBb n em).mantissa = _ induction n with | zero => simp [Nat.repeat] | succ n ih => simp only [Nat.repeat, ExtendedMantissa.shiftRightOne, ih, Nat.pow_succ, Nat.div_div_eq_div_mul] lemma Qc7 (m k : Nat) (hm : m ≠ 0) : (m <<< k).log2 = m.log2 + k := by induction k with | zero => simp | succ k ih => have h1 : m <<< (k + 1) = 2 * (m <<< k) := by simp [ZAe, Nat.pow_succ]; ring have h2 : m <<< k ≠ 0 := by rw [ZAe]; exact Nat.mul_ne_zero hm (by positivity) rw [h1, Nat.log2_two_mul h2, ih]; ring lemma tgt (t : Int) (h : -149 ≤ t - 24) : Format.binary32.targetExponent t = t - 24 := by simp only [Format.targetExponent, Format.mantissaBits, Format.minExponent] omega lemma Qdr (m : Nat) (a : Accuracy) : m ≤ a.roundToNearestEven m := by cases a with | exact => simp [Accuracy.roundToNearestEven] | inexact o => cases o <;> simp [Accuracy.roundToNearestEven] lemma Qdf (em : ExtendedMantissa) : em.mantissa ≤ em.roundedMantissa := by unfold ExtendedMantissa.roundedMantissa; exact Qdr _ _ end Bridge namespace Bridge def sh0 (m : Nat) : Nat := (23 - (m.log2 : Int)).toNat def m1 (m : Nat) : Nat := m <<< sh0 m def sh1 (m : Nat) : Nat := ((m.log2 : Int) - 23).toNat def em1 (m : Nat) : ExtendedMantissa := ZAc (m1 m) .exact >>> sh1 m def rm (m : Nat) : Nat := (em1 m).roundedMantissa def sh2 (m : Nat) : Nat := (((rm m).log2 : Int) - 23).toNat def fm (m : Nat) : Nat := (ZAc (rm m) .exact >>> sh2 m).mantissa lemma Qca (m : Nat) (hm : m ≠ 0) : 2 ^ 23 ≤ (em1 m).mantissa ∧ (em1 m).mantissa < 2 ^ 24 := by have hl := ZCk hm have hu := Nat.lt_log2_self (n := m) unfold em1 rw [QY] simp only [ExtendedMantissa.ofMantissaAndAccuracy, m1, sh0, sh1] rcases ZBp m.log2 23 with h | h ·have e0 : (23 - (m.log2 : Int)).toNat = 23 - m.log2 := by omega have e1 : ((m.log2 : Int) - 23).toNat = 0 := by omega rw [e0, e1, ZAe, pow_zero, Nat.div_one] constructor ·calc 2 ^ 23 = 2 ^ m.log2 * 2 ^ (23 - m.log2) := by rw [← pow_add]; congr 1; omega _ ≤ m * 2 ^ (23 - m.log2) := ZAj _ hl ·calc m * 2 ^ (23 - m.log2) < 2 ^ (m.log2 + 1) * 2 ^ (23 - m.log2) := ZAn hu (by positivity) _ = 2 ^ 24 := by rw [← pow_add]; congr 1; omega ·have e0 : (23 - (m.log2 : Int)).toNat = 0 := by omega have e1 : ((m.log2 : Int) - 23).toNat = m.log2 - 23 := by omega rw [e0, e1, Nat.shiftLeft_zero] constructor ·rw [ZBy (by positivity), ← pow_add] calc 2 ^ (23 + (m.log2 - 23)) = 2 ^ m.log2 := by congr 1; omega _ ≤ m := hl ·rw [ZBk (by positivity), ← pow_add] calc m < 2 ^ (m.log2 + 1) := hu _ = 2 ^ (24 + (m.log2 - 23)) := by congr 1; omega lemma QcQ (m : Nat) (a : Accuracy) : a.roundToNearestEven m ≤ m + 1 := by cases a with | exact => simp [Accuracy.roundToNearestEven] | inexact o => cases o <;> simp [Accuracy.roundToNearestEven] <;> omega lemma QbM (m : Nat) (hm : m ≠ 0) : 2 ^ 23 ≤ rm m ∧ rm m ≤ 2 ^ 24 := by obtain ⟨h1, h2⟩ := Qca m hm have a := Qdf (em1 m) have b : (em1 m).roundedMantissa ≤ (em1 m).mantissa + 1 := by unfold ExtendedMantissa.roundedMantissa; exact QcQ _ _ unfold rm; omega lemma QbF (m : Nat) (hm : m ≠ 0) : 23 ≤ (rm m).log2 ∧ (rm m).log2 ≤ 24 := by obtain ⟨h1, h2⟩ := QbM m hm have hne : rm m ≠ 0 := by omega constructor ·exact (ZBt hne).2 h1 ·have : rm m < 2 ^ 25 := by omega have := (ZDa hne).2 this omega lemma QaD (m : Nat) (hm : m ≠ 0) : 2 ^ 23 ≤ fm m ∧ fm m < 2 ^ 24 := by obtain ⟨l1, l2⟩ := QbF m hm have hne : rm m ≠ 0 := by have := (QbM m hm).1; omega have hl := ZCk hne have hu := Nat.lt_log2_self (n := rm m) unfold fm rw [QY] simp only [ExtendedMantissa.ofMantissaAndAccuracy, sh2] have e2 : (((rm m).log2 : Int) - 23).toNat = (rm m).log2 - 23 := by omega rw [e2] constructor ·rw [ZBy (by positivity), ← pow_add] calc 2 ^ (23 + ((rm m).log2 - 23)) = 2 ^ (rm m).log2 := by congr 1; omega _ ≤ rm m := hl ·rw [ZBk (by positivity), ← pow_add] calc rm m < 2 ^ ((rm m).log2 + 1) := hu _ = 2 ^ (24 + ((rm m).log2 - 23)) := by congr 1; omega end Bridge namespace Bridge lemma S1 (m : Nat) (e : Int) (hm : m ≠ 0) (hT : -149 ≤ (m.log2 : Int) + e - 23) : shiftToTargetExponent Format.binary32 (m1 m) (e - (sh0 m : Int)) .exact = (em1 m, e + m.log2 - 23) := by have hl : (m1 m).log2 = m.log2 + sh0 m := Qc7 m _ hm unfold shiftToTargetExponent shiftToExponent have htot : totalExponent (m1 m) (e - (sh0 m : Int)) = (m.log2 : Int) + 1 + e := by simp only [totalExponent, hl]; push_cast; ring rw [htot, tgt _ (by omega)] have hs : ((m.log2 : Int) + 1 + e - 24 - (e - (sh0 m : Int))).toNat = sh1 m := by simp only [sh0, sh1]; omega dsimp only rw [hs] simp only [em1, Prod.mk.injEq, true_and] simp only [sh0, sh1]; omega lemma S2 (m : Nat) (e : Int) (hm : m ≠ 0) (hT : -149 ≤ (m.log2 : Int) + e - 23) : shiftToTargetExponent Format.binary32 (rm m) (e + m.log2 - 23) .exact = (ZAc (rm m) .exact >>> sh2 m, e + m.log2 - 23 + sh2 m) := by obtain ⟨l1, l2⟩ := QbF m hm unfold shiftToTargetExponent shiftToExponent have htot : totalExponent (rm m) (e + m.log2 - 23) = ((rm m).log2 : Int) + 1 + (e + m.log2 - 23) := by simp only [totalExponent] rw [htot, tgt _ (by omega)] have hs : (((rm m).log2 : Int) + 1 + (e + m.log2 - 23) - 24 - (e + m.log2 - 23)).toNat = sh2 m := by simp only [sh2]; omega dsimp only rw [hs] lemma Qbd (s : Sign) (m : Nat) (e : Int) (hm : m ≠ 0) (hT : -149 ≤ (m.log2 : Int) + e - 23) : UnpackedFloat.round Format.binary32 s m e = .finite s (fm m) (e + m.log2 - 23 + sh2 m) (by have := (QaD m hm).1; omega) := by have h0 : Format.binary32.targetExponent (totalExponent m e) = (m.log2 : Int) + e - 23 := by rw [tgt _ (by simp only [totalExponent]; omega)]; simp only [totalExponent]; ring unfold UnpackedFloat.round decreaseExponent simp only [h0] have hs0 : (e - ((m.log2 : Int) + e - 23)).toNat = sh0 m := by simp only [sh0]; omega rw [hs0] have hm1 : m <<< sh0 m = m1 m := rfl have he1 : e - ((sh0 m : Nat) : Int) = e - (sh0 m : Int) := rfl rw [hm1] unfold roundWithAccuracy rw [S1 m e hm hT] simp only [] rw [show (em1 m).roundedMantissa = rm m from rfl, S2 m e hm hT] have hfm : fm m ≠ 0 := by have := (QaD m hm).1; omega simp only [show (ExtendedMantissa.ofMantissaAndAccuracy (rm m) .exact >>> sh2 m).mantissa = fm m from rfl, hfm, dite_false] end Bridge lemma QbB (m : UInt64) : (ZCv m).toBits = UInt32.ofBitVec (UnpackedFloat.pack Format.binary32 (UnpackedFloat.ofNat Format.binary32 m.toNat)) := rfl lemma QcM (n : Nat) (hn : n ≠ 0) : UnpackedFloat.ofNat Format.binary32 n = UnpackedFloat.round Format.binary32 .positive n 0 := by simp only [UnpackedFloat.ofNat, UnpackedFloat.ofInt, UnpackedFloat.normalize] have : compare (n : Int) 0 = .gt := by rw [compare_gt_iff_gt]; omega rw [this] simp lemma QbC (neg : Bool) (m : Nat) (e : Int) : Model.roundDyadic Fmt ⟨neg, m, e⟩ = Model.ofModel Fmt (UnpackedFloat.round Format.binary32 (Model.modelSign neg) m e) := by simp [Model.roundDyadic, Model.ieeeRoundDyadic, show Fmt.isIEEE = true by decide] rfl lemma Qc1 (s : Sign) : s.toBitVec.toNat = if s = .negative then 1 else 0 := by cases s <;> rfl lemma QZ (s : Sign) (M : Nat) (E : Int) (h : 0 < M) (hM1 : 2 ^ 23 ≤ M) (hM2 : M < 2 ^ 24) (hb1 : 1 ≤ E + 150) (hb2 : E + 150 ≤ 254) : (UnpackedFloat.pack Format.binary32 (.finite s M E h)).toNat = (if s = .negative then 2 ^ 31 else 0) + (E + 150).toNat * 2 ^ 23 + M % 2 ^ 23 := by have hl : M.log2 = 23 := by have hne : M ≠ 0 := by omega apply le_antisymm ·have := (ZDa hne).2 hM2; omega ·exact (ZBt hne).2 hM1 simp only [UnpackedFloat.pack, hl] have hbias : (E + ↑Format.binary32.exponentBias + ↑Format.binary32.mantissaBitsWithoutImplicit).toNat = (E + 150).toNat := by simp only [Format.exponentBias]; norm_num; ring_nf rw [hbias] have hno : ¬ (2 ^ Format.binary32.exponentBits ≤ (E + 150).toNat + 1) := by simp only [Format.binary32]; omega simp only [hno, ite_false] have hnorm : (23 + 1 = Format.binary32.mantissaBits) := rfl simp only [hnorm, ite_true, packComponents, BitVec.toNat_append, Qc1, BitVec.toNat_ofNat] have h8 : (E + 150).toNat % 2 ^ 8 = (E + 150).toNat := ZAa (by omega) simp only [Format.binary32] at * rw [h8, ← ZAq (by omega : (E + 150).toNat < 2 ^ 8), ← ZAq (ZCe _ (by positivity) : M % 2 ^ 23 < 2 ^ 23)] split_ifs <;> simp [ZAe] <;> omega namespace Bridge lemma Qds (m : Nat) (hm : m ≠ 0) : sh2 m ≤ 1 := by have := (QbF m hm).2; simp only [sh2]; omega @[inline] def Qaj (neg : Bool) (m : UInt64) (ex : Int) : Option UInt32 := let bits := (ZCv m).toBits let E : Int := (bits >>> 23).toNat + ex if 2 ≤ E ∧ E ≤ 254 then some (ZCs ((if neg then 2 ^ 31 else 0) + E.toNat * 2 ^ 23 + bits.toNat % 2 ^ 23)) else none lemma Qb2 (neg : Bool) (m : UInt64) (ex : Int) (w : UInt32) (hm : m ≠ 0) (h : Qaj neg m ex = some w) : w = toWord (Model.roundDyadic Fmt ⟨neg, m.toNat, ex⟩) := by have hn : m.toNat ≠ 0 := by intro h0; apply hm; exact ZBf (by simpa using h0) have hn64 : m.toNat < 2 ^ 64 := m.toNat_lt have hlog : m.toNat.log2 < 64 := (ZDa hn).2 hn64 have hs2 := Qds m.toNat hn have hfm := QaD m.toNat hn have hb : (ZCv m).toBits.toNat = ((m.toNat.log2 : Int) - 23 + sh2 m.toNat + 150).toNat * 2 ^ 23 + fm m.toNat % 2 ^ 23 := by rw [QbB, QcM _ hn, Qbd _ _ _ hn (by omega)] simp only [UInt32.toNat_ofBitVec] rw [QZ _ _ _ _ hfm.1 hfm.2 (by omega) (by omega)] simp have hE : ((ZCv m).toBits >>> 23).toNat = ((m.toNat.log2 : Int) - 23 + sh2 m.toNat + 150).toNat := by rw [UInt32.toNat_shiftRight, hb] simp only [show (23 : UInt32).toNat % 32 = 23 from rfl, ZAo] have : fm m.toNat % 2 ^ 23 < 2 ^ 23 := ZCe _ (by positivity) omega have hF : (ZCv m).toBits.toNat % 2 ^ 23 = fm m.toNat % 2 ^ 23 := by rw [hb]; omega unfold Qaj at h simp only [hE, hF] at h split at h ·rename_i hc obtain ⟨hc1, hc2⟩ := hc injection h with h rw [← h, QbC, Qbd _ _ _ hn (by omega)] simp only [toWord, Model.toNatBits, Model.ofModel, Model.ofModelBits] congr 1 show _ = (UnpackedFloat.pack Format.binary32 _).toNat rw [QZ _ _ _ _ hfm.1 hfm.2 (by omega) (by omega)] cases neg <;> simp [Model.modelSign] <;> omega ·simp at h end Bridge end structure Q8 where fst : UInt64 snd : UInt64 structure Qdx where fst : Bool snd : Q8 structure J64 where fst : UInt64 snd : Nat @[inline] def QR (mh ml : UInt64) : J64 := if mh == 0 then ⟨ml, 0⟩ else if mh < 0x100000000 then ⟨(mh <<< 32) ||| (ml >>> 32) ||| (if ml &&& 0xFFFFFFFF != 0 then 1 else 0), 32⟩ else ⟨mh ||| (if ml != 0 then 1 else 0), 64⟩ @[inline] def QbJ (v : UInt64) : UInt64 := if v >>> 63 == 0 then 0 else 0xFFFFFFFFFFFFFFFF @[inline] def Q0 (v : UInt64) (d : Nat) : Q8 := match d with | 0 => ⟨QbJ v, v⟩ | 1 => ⟨(v >>> 43) ||| (QbJ v <<< 21), v <<< 21⟩ | 2 => ⟨(v >>> 22) ||| (QbJ v <<< 42), v <<< 42⟩ | 3 => ⟨(v >>> 1) ||| (QbJ v <<< 63), v <<< 63⟩ | _ => ⟨v <<< 20, 0⟩ @[inline] def Q3 (x y : Q8) : Q8 := let l := x.2 + y.2 ⟨x.1 + y.1 + (if l < x.2 then 1 else 0), l⟩ @[inline] def Qp (bw : UInt32) (sb : Int) : UInt64 := let bm : UInt64 := if expOf bw == 0 then 0 else (fracOf bw ||| 0x800000).toUInt64 <<< (sb.toNat % 21).toUInt64 if signOf bw then 0 - bm else bm @[inline] def QaK (a b c bs : UInt64) (d : Nat) : Q8 := Q3 (Q3 (Q3 (Q0 a 0) (Q0 b 1)) (Q0 c 2)) (Q0 bs d) @[inline] def QaU (t : Q8) : Qdx := let neg := t.1 >>> 63 == 1 ⟨neg, if neg then ~~~t.1 + (if t.2 == 0 then 1 else 0) else t.1, if neg then 0 - t.2 else t.2⟩ @[inline] def Qbw (relu : Bool) (bw : UInt32) (base : Nat) (a b c : UInt64) : Option Word := if expOf bw == 255 || (expOf bw == 0 && fracOf bw != 0) then none else if expOf bw != 0 && ((148 : Int) + (expOf bw).toNat - base < 0 || (148 : Int) + (expOf bw).toNat - base > 100) then none else let sb : Int := (148 : Int) + (expOf bw).toNat - base let q := QaU (QaK a b c (Qp bw sb) (min (sb.toNat / 21) 4)) let mj := QR q.2.1 q.2.2 if mj.1 == 0 then none else match Bridge.Qaj q.1 mj.1 ((mj.2 : Int) + base - 298) with | some r => some (act relu r) | none => none lemma Qaa {α : Type} [Inhabited α] (xs : Array α) (x : α) (i : Nat) (h : i < xs.size) : (xs.push x)[i]! = xs[i]! := by rw [getElem!_pos (xs.push x) i (by simp; omega), getElem!_pos xs i h, Array.getElem_push_lt h] lemma Qac {α : Type} [Inhabited α] (xs : Array α) (x : α) : (xs.push x)[xs.size]! = x := by rw [getElem!_pos (xs.push x) xs.size (by simp), Array.getElem_push_eq] lemma Qg (a : Array UInt32) (i : USize) (v : UInt32) (h : i.toNat < a.size) (s : Nat) : (a.uset i v h)[s]! = if s = i.toNat then v else a[s]! := by by_cases hs : s < a.size ·rw [getElem!_pos (a.uset i v h) s (by simpa using hs), getElem!_pos a s hs] simp only [Array.uset, Array.getElem_set] by_cases hsi : s = i.toNat ·subst hsi; simp ·rw [if_neg (Ne.symm hsi), if_neg hsi] ·rw [getElem!_neg (a.uset i v h) s (by simpa using hs), getElem!_neg a s hs] rw [if_neg (by omega)] lemma Qdm (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (k c : USize) (IX P0 P1 P2 : Array UInt32) (hck : c.toNat ≤ k.toNat) (hs : n.toNat ≤ IX.size ∧ n.toNat ≤ P0.size ∧ n.toNat ≤ P1.size ∧ n.toNat ≤ P2.size) (ok : Bool) (hkn : k.toNat ≤ n.toNat) (hIX : ∀ s, s < c.toNat → (IX[s]!).toNat < n.toNat) : let r := Qz X o n lx lim hX hXs k c IX P0 P1 P2 hck hs ok (∀ s, s < r.2.2.2.2.1.toNat → (r.1[s]!).toNat < n.toNat) ∧ r.2.2.2.2.1.toNat ≤ n.toNat ∧ n.toNat ≤ r.1.size ∧ n.toNat ≤ r.2.1.size ∧ n.toNat ≤ r.2.2.1.size ∧ n.toNat ≤ r.2.2.2.1.size := by induction k, c, IX, P0, P1, P2, hck, hs, ok using Qz.induct X o n lx lim hX hXs with | case1 k c IX P0 P1 P2 hck hs ok h hk hk1 w e he ih => unfold Qz; simp only [dite_cond_eq_true (eq_true h)] split ·exact ih (by omega) hIX ·exact absurd he ‹_› | case2 k c IX P0 P1 P2 hck hs ok h hk hk1 w e he hc1 d mag p0 p1 p2 neg ih => unfold Qz; simp only [dite_cond_eq_true (eq_true h)] split ·exact absurd ‹_› he ·apply ih (by omega) intro s hs' rw [hc1] at hs' rw [Qg] split_ifs with hsc ·simp only [ZDp] have : k.toNat < 2 ^ 32 := by omega rw [ZAa this]; exact hk ·exact hIX s (by omega) | case3 k c IX P0 P1 P2 hck hs ok h => unfold Qz; simp only [dite_cond_eq_false (eq_false h)] exact ⟨hIX, by omega, hs⟩ lemma Qc (m : Nat) (h : m < 2 ^ 32) : m.toUSize.toNat = m := by have : 2 ^ 32 ≤ ZCn := USize.le_size have h3 : ZCn = 2 ^ ZBo := rfl simp only [Nat.toUSize] exact ZAa (by omega) lemma ZZc {j m : Nat} (n : Nat) (hj : j < m) : j * n + n ≤ m * n := by have h : (j + 1) * n ≤ m * n := ZAj _ hj rwa [Nat.add_mul, Nat.one_mul] at h lemma ZZb {i n b : Nat} (h : (i + 1) * n ≤ b) (hb : b < 2 ^ 32) : i * n < 2 ^ 32 ∧ i * n + n ≤ b := by rw [Nat.add_mul, Nat.one_mul] at h; omega lemma ZZa {j n m b : Nat} (hj : j < m) (h : m * n ≤ b) (hb : b < 2 ^ 32) : j * n < 2 ^ 32 ∧ j * n + n ≤ b := by have := ZZc n hj; omega lemma Qbh (IX : Array UInt32) (Wn nz inW outW jr : Nat) (hjr : jr < outW) (hIX : ∀ s, s < nz → (IX[s]!).toNat < inW) (hWsz : outW * inW ≤ Wn) (hWs : Wn < 2 ^ 32) : ∀ s, s < nz → (jr * inW).toUSize.toNat + (IX[s]!).toNat < Wn := by intro s hs have h1 := hIX s hs obtain ⟨h2, h3⟩ := ZZa hjr hWsz hWs rw [Qc _ h2] omega lemma Qdp (IX W : Array UInt32) (nz inW outW j : Nat) (hj : j < outW) (hIX : ∀ s, s < nz → (IX[s]!).toNat < inW) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) : QaL IX W nz (j * inW).toUSize ((if j + 1 < outW then j + 1 else j) * inW).toUSize ((if j + 2 < outW then j + 2 else j) * inW).toUSize ((if j + 3 < outW then j + 3 else j) * inW).toUSize := by intro s hs wr hwr rcases hwr with rfl | rfl | rfl | rfl ·exact Qbh IX W.size nz inW outW j hj hIX hWsz hWs s hs ·exact Qbh IX W.size nz inW outW _ (by split <;> omega) hIX hWsz hWs s hs ·exact Qbh IX W.size nz inW outW _ (by split <;> omega) hIX hWsz hWs s hs ·exact Qbh IX W.size nz inW outW _ (by split <;> omega) hIX hWsz hWs s hs def Qx (D : Array UInt32) (n : Nat) (w0 w1 w2 w3 : USize) : Prop := w0.toNat + n ≤ D.size ∧ w1.toNat + n ≤ D.size ∧ w2.toNat + n ≤ D.size ∧ w3.toNat + n ≤ D.size lemma QE (D : Array UInt32) (w t : USize) (n : Nat) (ht : t.toNat < n) (hw : w.toNat + n ≤ D.size) (hDs : D.size < 2 ^ 32) : (w + t).toNat < D.size := by rw [Qe _ _ (by omega)]; omega def QaS (U0 U1 D : Array UInt32) (w0 w1 w2 w3 n : USize) (h0 : n.toNat ≤ U0.size) (h1 : n.toNat ≤ U1.size) (hW : Qx D n.toNat w0 w1 w2 w3) (hDs : D.size < 2 ^ 32) (t : USize) (a0 b0 a1 b1 a2 b2 a3 b3 : UInt64) : Qdv := if h : t < n then have ht : t.toNat < n.toNat := ZBq h let x0 := (U0.uget t (by omega)).toUInt64 let x1 := (U1.uget t (by omega)).toUInt64 let d0 := (D.uget (w0 + t) (QE D w0 t _ ht hW.1 hDs)).toUInt64 let d1 := (D.uget (w1 + t) (QE D w1 t _ ht hW.2.1 hDs)).toUInt64 let d2 := (D.uget (w2 + t) (QE D w2 t _ ht hW.2.2.1 hDs)).toUInt64 let d3 := (D.uget (w3 + t) (QE D w3 t _ ht hW.2.2.2 hDs)).toUInt64 QaS U0 U1 D w0 w1 w2 w3 n h0 h1 hW hDs (t + 1) (a0 + x0 * d0) (b0 + x1 * d0) (a1 + x0 * d1) (b1 + x1 * d1) (a2 + x0 * d2) (b2 + x1 * d2) (a3 + x0 * d3) (b3 + x1 * d3) else ⟨a0, b0, a1, b1, a2, b2, a3, b3, 0⟩ termination_by n.toNat - t.toNat decreasing_by rw [Qd t n h]; omega def Qad (U0 U1 U2 D : Array UInt32) (w0 w1 n : USize) (h0 : n.toNat ≤ U0.size) (h1 : n.toNat ≤ U1.size) (h2 : n.toNat ≤ U2.size) (hW : Qx D n.toNat w0 w1 w0 w1) (hDs : D.size < 2 ^ 32) (t : USize) (a0 b0 c0 a1 b1 c1 : UInt64) : Qdy := if h : t < n then have ht : t.toNat < n.toNat := ZBq h let x0 := (U0.uget t (by omega)).toUInt64 let x1 := (U1.uget t (by omega)).toUInt64 let x2 := (U2.uget t (by omega)).toUInt64 let d0 := (D.uget (w0 + t) (QE D w0 t _ ht hW.1 hDs)).toUInt64 let d1 := (D.uget (w1 + t) (QE D w1 t _ ht hW.2.1 hDs)).toUInt64 Qad U0 U1 U2 D w0 w1 n h0 h1 h2 hW hDs (t + 1) (a0 + x0 * d0) (b0 + x1 * d0) (c0 + x2 * d0) (a1 + x0 * d1) (b1 + x1 * d1) (c1 + x2 * d1) else ⟨a0, b0, c0, a1, b1, c1, 0⟩ termination_by n.toNat - t.toNat decreasing_by rw [Qd t n h]; omega @[inline] def Qb8 (neg : Bool) (p : UInt64) : UInt64 := if neg then 0x200000 - p else 0x200000 + p def Qv (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (k : USize) (U0 U1 U2 : Array UInt32) (hs : n.toNat ≤ U0.size ∧ n.toNat ≤ U1.size ∧ n.toNat ≤ U2.size) (s0 s1 s2 : UInt64) (ok : Bool) : Array UInt32 × Array UInt32 × Array UInt32 × UInt64 × UInt64 × UInt64 × Bool := if h : k < n then have hk : k.toNat < n.toNat := Qw k n h let w := X.uget (o + k) (by rw [Qe _ _ (by omega)]; omega) let e := (w >>> 23) &&& 0xFF let d := e - lx let mag : UInt64 := if e == 0 then 0 else ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< d.toUInt64 let neg := signOf w let q0 := (Qb8 neg (mag &&& 0x1FFFFF)).toUInt32 let q1 := (Qb8 neg ((mag >>> 21) &&& 0x1FFFFF)).toUInt32 let q2 := (Qb8 neg (mag >>> 42)).toUInt32 Qv X o n lx lim hX hXs (k + 1) (U0.uset k q0 (by omega)) (U1.uset k q1 (by omega)) (U2.uset k q2 (by omega)) (by simp only [ZBz]; exact hs) (s0 + q0.toUInt64) (s1 + q1.toUInt64) (s2 + q2.toUInt64) (ok && (if e == 0 then (w &&& 0x7FFFFF) == 0 else e != 255 && lx ≤ e && d ≤ lim)) else (U0, U1, U2, s0, s1, s2, ok) termination_by n.toNat - k.toNat decreasing_by rw [Qd k n h]; omega def Ql (W : Array UInt32) (wo : USize) (hwo : wo.toNat ≤ 65280) (o n : USize) (hW : o.toNat + n.toNat ≤ W.size) (hWs : W.size < 2 ^ 32) (k : USize) (D : Array UInt32) (hD : W.size ≤ D.size) (c sd : UInt64) : Array UInt32 × UInt64 × UInt64 := if h : k < n then have hk : k.toNat < n.toNat := Qw k n h have hok : (o + k).toNat = o.toNat + k.toNat := Qe _ _ (by omega) let v := W.uget (o + k) (by omega) let m := Qf wo hwo v let u := (Qi v m + 0x80000000).toUInt32 Ql W wo hwo o n hW hWs (k + 1) (D.uset (o + k) u (by omega)) (by simp only [ZBz]; exact hD) (c ||| m) (sd + u.toUInt64) else (D, c, sd) termination_by n.toNat - k.toNat decreasing_by rw [Qd k n h]; omega lemma Qc2 (D : Array UInt32) (inW outW j : Nat) (hj : j < outW) (hDsz : outW * inW ≤ D.size) (hDs : D.size < 2 ^ 32) : Qx D inW (j * inW).toUSize ((if j + 1 < outW then j + 1 else j) * inW).toUSize ((if j + 2 < outW then j + 2 else j) * inW).toUSize ((if j + 3 < outW then j + 3 else j) * inW).toUSize := by have hr : ∀ jr, jr < outW → (jr * inW).toUSize.toNat + inW ≤ D.size := by intro jr hjr obtain ⟨h2, h3⟩ := ZZa hjr hDsz hDs rw [Qc _ h2]; exact h3 exact ⟨hr j hj, hr _ (by split <;> omega), hr _ (by split <;> omega), hr _ (by split <;> omega)⟩ lemma Qbo (D : Array UInt32) (n : Nat) (w0 w1 w2 w3 : USize) (h : Qx D n w0 w1 w2 w3) : Qx D n w0 w1 w0 w1 := ⟨h.1, h.2.1, h.1, h.2.1⟩ lemma Qbj (D : Array UInt32) (n : Nat) (w0 w1 w2 w3 : USize) (h : Qx D n w0 w1 w2 w3) : Qx D n w2 w3 w2 w3 := ⟨h.2.2.1, h.2.2.2, h.2.2.1, h.2.2.2⟩ lemma Qch (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (k : USize) (U0 U1 U2 : Array UInt32) (hs : n.toNat ≤ U0.size ∧ n.toNat ≤ U1.size ∧ n.toNat ≤ U2.size) (s0 s1 s2 : UInt64) (ok : Bool) : (Qv X o n lx lim hX hXs k U0 U1 U2 hs s0 s1 s2 ok).1.size = U0.size ∧ (Qv X o n lx lim hX hXs k U0 U1 U2 hs s0 s1 s2 ok).2.1.size = U1.size ∧ (Qv X o n lx lim hX hXs k U0 U1 U2 hs s0 s1 s2 ok).2.2.1.size = U2.size := by induction k, U0, U1, U2, hs, s0, s1, s2, ok using Qv.induct X o n lx lim hX hXs with | case1 k U0 U1 U2 hs s0 s1 s2 ok h => rename_i ih unfold Qv; simp only [dite_cond_eq_true (eq_true h)] obtain ⟨a, b, c⟩ := ih; simp only [ZBz] at a b c; exact ⟨a, b, c⟩ | case2 k U0 U1 U2 hs s0 s1 s2 ok h => unfold Qv; simp only [dite_cond_eq_false (eq_false h)]; simp lemma QL (W : Array UInt32) (wo : USize) (hwo : wo.toNat ≤ 65280) (o n : USize) (hW : o.toNat + n.toNat ≤ W.size) (hWs : W.size < 2 ^ 32) (k : USize) (D : Array UInt32) (hD : W.size ≤ D.size) (c sd : UInt64) : (Ql W wo hwo o n hW hWs k D hD c sd).1.size = D.size := by induction k, D, hD, c, sd using Ql.induct W wo hwo o n hW hWs with | case1 k D hD c sd h => rename_i ih unfold Ql; simp only [dite_cond_eq_true (eq_true h)] rw [ih]; simp | case2 k D hD c sd h => unfold Ql; simp only [dite_cond_eq_false (eq_false h)] def QbD : DotFn := dotOf def QaT (inW : Nat) (relu : Bool) (X W b : Array Word) (i j : Nat) : Word := act relu (QbD (inW + 1) (fun t => if t < inW then X[i * inW + t]! else oneW) (fun t => if t < inW then W[j * inW + t]! else b[j]!)) def QT (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i j : Nat) (out : Array Word) : Array Word := if j < outW then QT inW outW relu X W b i (j + 1) (out.push (QaT inW relu X W b i j)) else out termination_by outW - j @[inline] def Qdb (inW : Nat) (relu : Bool) (X W b : Array Word) (i jj : Nat) (r : Option Word) : Word := match r with | some w => w | none => QaT inW relu X W b i jj @[inline] def QP (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i j base : Nat) (r : Qbf) (ok : Nat → Bool) (out : Array Word) : Array Word := let f := fun (jj : Nat) (pa pb pc : UInt64) => Qdb inW relu X W b i jj (if ok jj then Qbw relu b[jj]! base pa pb pc else none) let out := out.push (f j r.a0 r.b0 r.c0) let out := if j + 1 < outW then out.push (f (j + 1) r.a1 r.b1 r.c1) else out let out := if j + 2 < outW then out.push (f (j + 2) r.a2 r.b2 r.c2) else out if j + 3 < outW then out.push (f (j + 3) r.a3 r.b3 r.c3) else out def Qu (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (IX X0 X1 X2 : Array UInt32) (nz : USize) (wide : Bool) (o : USize) (ho : o.toNat ≤ 65280) (base : Nat) (hI : nz.toNat ≤ IX.size) (h0 : nz.toNat ≤ X0.size) (h1 : nz.toNat ≤ X1.size) (h2 : nz.toNat ≤ X2.size) (hIX : ∀ s, s < nz.toNat → (IX[s]!).toNat < inW) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (j : Nat) (out : Array Word) : Array Word := if hj : j < outW then let w0 := (j * inW).toUSize let w1 := ((if j + 1 < outW then j + 1 else j) * inW).toUSize let w2 := ((if j + 2 < outW then j + 2 else j) * inW).toUSize let w3 := ((if j + 3 < outW then j + 3 else j) * inW).toUSize have hr := Qdp IX W nz.toNat inW outW j hj hIX hWsz hWs let r : Qbf := if wide then QaW IX X0 X1 X2 W o ho w0 w1 w2 w3 nz hI h0 h1 h2 hr hWs 0 0 0 0 0 0 0 0 0 0 0 0 0 0 else let q := QaR IX X0 X1 W o ho w0 w1 w2 w3 nz hI h0 h1 hr hWs 0 0 0 0 0 0 0 0 0 0 ⟨q.a0, q.b0, 0, q.a1, q.b1, 0, q.a2, q.b2, 0, q.a3, q.b3, 0, q.chk⟩ let ok := r.chk < 0x80000000 Qu inW outW relu X W b i IX X0 X1 X2 nz wide o ho base hI h0 h1 h2 hIX hWsz hWs (j + 4) (QP inW outW relu X W b i j base r (fun _ => ok) out) else out termination_by outW - j lemma Qbn (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (z : Array UInt32) (hz : n.toNat ≤ z.size) : let r := Qz X o n lx lim hX hXs 0 0 z z z z (by simp) ⟨hz, hz, hz, hz⟩ true (∀ s, s < r.2.2.2.2.1.toNat → (r.1[s]!).toNat < n.toNat) ∧ r.2.2.2.2.1.toNat ≤ n.toNat ∧ n.toNat ≤ r.1.size ∧ n.toNat ≤ r.2.1.size ∧ n.toNat ≤ r.2.2.1.size ∧ n.toNat ≤ r.2.2.2.1.size := Qdm X o n lx lim hX hXs 0 0 z z z z (by simp) ⟨hz, hz, hz, hz⟩ true (by simp) (by simp) @[inline] def Qax (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (o : USize) (ho : o.toNat ≤ 65280) (lw : Nat) (lx lim : UInt32) (wide : Bool) (hXsz : (i + 1) * inW ≤ X.size) (hWsz : outW * inW ≤ W.size) (hXs : X.size < 2 ^ 32) (hWs : W.size < 2 ^ 32) (hin : inW < 2048) (out : Array Word) : Array Word := let xo := (i * inW).toUSize let n := inW.toUSize have hn : n.toNat = inW := Qc _ (by omega) have hX : xo.toNat + n.toNat ≤ X.size := by obtain ⟨h2, h3⟩ := ZZb hXsz hXs; rw [hn, Qc _ h2]; exact h3 let z : Array UInt32 := ZBv inW 0 have hz : n.toNat ≤ z.size := by simp [z, hn] let r := Qz X xo n lx lim hX hXs 0 0 z z z z (by simp) ⟨hz, hz, hz, hz⟩ true have hd : (∀ s, s < r.2.2.2.2.1.toNat → (r.1[s]!).toNat < n.toNat) ∧ r.2.2.2.2.1.toNat ≤ n.toNat ∧ n.toNat ≤ r.1.size ∧ n.toNat ≤ r.2.1.size ∧ n.toNat ≤ r.2.2.1.size ∧ n.toNat ≤ r.2.2.2.1.size := Qbn X xo n lx lim hX hXs z hz if r.2.2.2.2.2 && 1 ≤ lx && (r.2.2.2.2.1.toNat == inW || (((Qah W (outW * inW).toUSize (by rw [Qc _ (by omega)]; omega) 0 0) >>> 23) &&& 0xFF) != 0xFF) then Qu inW outW relu X W b i r.1 r.2.1 r.2.2.1 r.2.2.2.1 r.2.2.2.2.1 wide o ho (lx.toNat + lw - 2) (by omega) (by omega) (by omega) (by omega) (fun s hs => by rw [← hn]; exact hd.1 s hs) hWsz hWs 0 out else QT inW outW relu X W b i 0 out def QbX (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (o : USize) (ho : o.toNat ≤ 65280) (lw : Nat) (hXsz : (i + 1) * inW ≤ X.size) (hWsz : outW * inW ≤ W.size) (hXs : X.size < 2 ^ 32) (hWs : W.size < 2 ^ 32) (hin : inW < 2048) (out : Array Word) : Array Word := have hX : (i * inW).toUSize.toNat + inW.toUSize.toNat ≤ X.size := by obtain ⟨h2, h3⟩ := ZZb hXsz hXs; rw [Qc _ h2, Qc inW (by omega)]; exact h3 let lh := QbW X (i * inW).toUSize inW.toUSize hX hXs 0 255 0 let wide : Bool := lh.2 - lh.1 > 18 Qax inW outW relu X W b i o ho lw lh.1 (if wide then 39 else 18) wide hXsz hWsz hXs hWs hin out def Q6 (rows inW outW : Nat) (relu : Bool) (X W b : Array Word) (o : USize) (ho : o.toNat ≤ 65280) (lw : Nat) (hXsz : rows * inW ≤ X.size) (hWsz : outW * inW ≤ W.size) (hXs : X.size < 2 ^ 32) (hWs : W.size < 2 ^ 32) (hin : inW < 2048) (i : Nat) (out : Array Word) : Array Word := if hi : i < rows then Q6 rows inW outW relu X W b o ho lw hXsz hWsz hXs hWs hin (i + 1) (QbX (i := i) inW outW relu X W b o ho lw (le_trans (ZAj _ hi) hXsz) hWsz hXs hWs hin out) else out termination_by rows - i def Qh (W : Array UInt32) (wo : USize) (hwo : wo.toNat ≤ 65280) (inW outW : Nat) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (j : Nat) (D : Array UInt32) (hD : W.size ≤ D.size) (oks : Array Bool) (sds : Array UInt64) : Array UInt32 × Array Bool × Array UInt64 := if hj : j < outW then have h1 : (j * inW).toUSize.toNat + inW.toUSize.toNat ≤ W.size := by obtain ⟨h2, h3⟩ := ZZa hj hWsz hWs rw [Qc _ h2, Qc inW (by omega)]; exact h3 let r := Ql W wo hwo (j * inW).toUSize inW.toUSize h1 hWs 0 D hD 0 0 Qh W wo hwo inW outW hWsz hWs (j + 1) r.1 (by rw [QL]; exact hD) (oks.push (r.2.1 < 0x80000000)) (sds.push r.2.2) else (D, oks, sds) termination_by outW - j lemma Qbi (W : Array UInt32) (wo : USize) (hwo : wo.toNat ≤ 65280) (inW outW : Nat) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (j : Nat) (D : Array UInt32) (hD : W.size ≤ D.size) (oks : Array Bool) (sds : Array UInt64) : (Qh W wo hwo inW outW hWsz hWs j D hD oks sds).1.size = D.size := by induction j, D, hD, oks, sds using Qh.induct W wo hwo inW outW hWsz hWs with | case1 j D hD oks sds hj => rename_i ih unfold Qh; simp only [dite_cond_eq_true (eq_true hj)] rw [ih]; exact QL _ _ _ _ _ _ _ _ _ _ _ _ | case2 j D hD oks sds hj => unfold Qh; simp only [dite_cond_eq_false (eq_false hj)] @[inline] def Qm (n acc su sd : UInt64) : UInt64 := acc - su * 2147483648 - sd * 2097152 + n * 4503599627370496 def Qn (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (U0 U1 U2 D : Array UInt32) (oks : Array Bool) (sds : Array UInt64) (s0 s1 s2 : UInt64) (wide : Bool) (base : Nat) (h0 : inW ≤ U0.size) (h1 : inW ≤ U1.size) (h2 : inW ≤ U2.size) (hin : inW < 2048) (hDsz : outW * inW ≤ D.size) (hDs : D.size < 2 ^ 32) (j : Nat) (out : Array Word) : Array Word := if hj : j < outW then let n := inW.toUSize have hn : n.toNat = inW := Qc _ (by omega) let w0 := (j * inW).toUSize let w1 := ((if j + 1 < outW then j + 1 else j) * inW).toUSize let w2 := ((if j + 2 < outW then j + 2 else j) * inW).toUSize let w3 := ((if j + 3 < outW then j + 3 else j) * inW).toUSize have hr : Qx D n.toNat w0 w1 w2 w3 := by rw [hn]; exact Qc2 D inW outW j hj hDsz hDs let nn := inW.toUInt64 let e0 := sds[j]! let e1 := sds[if j + 1 < outW then j + 1 else j]! let e2 := sds[if j + 2 < outW then j + 2 else j]! let e3 := sds[if j + 3 < outW then j + 3 else j]! let r : Qbf := if wide then let p := Qad U0 U1 U2 D w0 w1 n (by omega) (by omega) (by omega) (Qbo _ _ _ _ _ _ hr) hDs 0 0 0 0 0 0 0 let q := Qad U0 U1 U2 D w2 w3 n (by omega) (by omega) (by omega) (Qbj _ _ _ _ _ _ hr) hDs 0 0 0 0 0 0 0 ⟨Qm nn p.a0 s0 e0, Qm nn p.b0 s1 e0, Qm nn p.c0 s2 e0, Qm nn p.a1 s0 e1, Qm nn p.b1 s1 e1, Qm nn p.c1 s2 e1, Qm nn q.a0 s0 e2, Qm nn q.b0 s1 e2, Qm nn q.c0 s2 e2, Qm nn q.a1 s0 e3, Qm nn q.b1 s1 e3, Qm nn q.c1 s2 e3, 0⟩ else let q := QaS U0 U1 D w0 w1 w2 w3 n (by omega) (by omega) hr hDs 0 0 0 0 0 0 0 0 0 ⟨Qm nn q.a0 s0 e0, Qm nn q.b0 s1 e0, 0, Qm nn q.a1 s0 e1, Qm nn q.b1 s1 e1, 0, Qm nn q.a2 s0 e2, Qm nn q.b2 s1 e2, 0, Qm nn q.a3 s0 e3, Qm nn q.b3 s1 e3, 0, 0⟩ Qn inW outW relu X W b i U0 U1 U2 D oks sds s0 s1 s2 wide base h0 h1 h2 hin hDsz hDs (j + 4) (QP inW outW relu X W b i j base r (fun jj => oks[jj]!) out) else out termination_by outW - j def Qt (rows inW outW : Nat) (relu : Bool) (X W b : Array Word) (D : Array UInt32) (oks : Array Bool) (sds : Array UInt64) (lw : Nat) (hXsz : rows * inW ≤ X.size) (hDsz : outW * inW ≤ D.size) (hXs : X.size < 2 ^ 32) (hDs : D.size < 2 ^ 32) (hin : inW < 2048) (U0 U1 U2 : Array UInt32) (hU : inW ≤ U0.size ∧ inW ≤ U1.size ∧ inW ≤ U2.size) (i : Nat) (out : Array Word) : Array Word := if hi : i < rows then let xo := (i * inW).toUSize let n := inW.toUSize have hn : n.toNat = inW := Qc _ (by omega) have hX : xo.toNat + n.toNat ≤ X.size := by obtain ⟨h2, h3⟩ := ZZa hi hXsz hXs rw [hn, Qc _ h2]; exact h3 let lh := QbW X xo n hX hXs 0 255 0 let wide : Bool := lh.2 - lh.1 > 18 let r := Qv X xo n lh.1 (if wide then 39 else 18) hX hXs 0 U0 U1 U2 (by rw [hn]; exact hU) 0 0 0 true have hr : inW ≤ r.1.size ∧ inW ≤ r.2.1.size ∧ inW ≤ r.2.2.1.size := by obtain ⟨e0, e1, e2⟩ := Qch X xo n lh.1 (if wide then 39 else 18) hX hXs 0 U0 U1 U2 (by rw [hn]; exact hU) 0 0 0 true exact ⟨by rw [e0]; exact hU.1, by rw [e1]; exact hU.2.1, by rw [e2]; exact hU.2.2⟩ let out := if r.2.2.2.2.2.2 && 1 ≤ lh.1 then Qn inW outW relu X W b i r.1 r.2.1 r.2.2.1 D oks sds r.2.2.2.1 r.2.2.2.2.1 r.2.2.2.2.2.1 wide (lh.1.toNat + lw - 2) hr.1 hr.2.1 hr.2.2 hin hDsz hDs 0 out else QT inW outW relu X W b i 0 out Qt rows inW outW relu X W b D oks sds lw hXsz hDsz hXs hDs hin r.1 r.2.1 r.2.2.1 hr (i + 1) out else out termination_by rows - i def Q7 (W : Array UInt32) (inW outW : Nat) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (j cnt : Nat) (hi : UInt32) : UInt32 := match cnt with | 0 => hi | c + 1 => if hj : j < outW then have h1 : (j * inW).toUSize.toNat + inW.toUSize.toNat ≤ W.size := by obtain ⟨h2, h3⟩ := ZZa hj hWsz hWs rw [Qc _ h2, Qc inW (by omega)]; exact h3 let h := (QbW W (j * inW).toUSize inW.toUSize h1 hWs 0 255 0).2 Q7 W inW outW hWsz hWs (j + 1) c (if h > hi then h else hi) else hi lemma QaM (lw : UInt32) (h : lw ≤ 254) : (lw.toUSize * 256).toNat ≤ 65280 := by have h1 : lw.toNat ≤ 254 := h have h2 : (lw.toUSize).toNat = lw.toNat := ZCi lw rw [USize.toNat_mul, h2] have : 2 ^ 32 ≤ ZCn := USize.le_size have h3 : ZCn = 2 ^ ZBo := rfl simp only [USize.toNat_ofNat] rw [ZAa (by omega : 256 < 2 ^ ZBo), ZAa (by omega)] omega def Qbv (rows inW outW : Nat) (relu : Bool) (X W b : Array Word) : Array Word := if hg : rows * inW ≤ X.size ∧ outW * inW ≤ W.size ∧ 0 < inW ∧ inW < 2048 ∧ X.size < 2 ^ 32 ∧ W.size < 2 ^ 32 then let lw0 := (Q7 W inW outW hg.2.1 hg.2.2.2.2.2 0 4 0 - 7) let lw : UInt32 := if lw0 == 0 || lw0 > 254 then 1 else lw0 have hlw : lw ≤ 254 := by simp only [lw]; split <;> simp_all let wo := lw.toUSize * 256 if rows ≥ 2 then let pd := Qh W wo (QaM lw hlw) inW outW hg.2.1 hg.2.2.2.2.2 0 (ZBv W.size 0) (by simp) #[] #[] have hD : pd.1.size = W.size := by rw [Qbi]; simp let z : Array UInt32 := ZBv inW 0 Qt rows inW outW relu X W b pd.1 pd.2.1 pd.2.2 lw.toNat hg.1 (by rw [hD]; exact hg.2.1) hg.2.2.2.2.1 (by rw [hD]; exact hg.2.2.2.2.2) hg.2.2.2.1 z z z (by simp [z]) 0 #[] else Q6 rows inW outW relu X W b wo (QaM lw hlw) lw.toNat hg.1 hg.2.1 hg.2.2.2.2.1 hg.2.2.2.2.2 hg.2.2.2.1 0 #[] else linearWith QbD rows inW outW relu X W b lemma QH (x y k : Nat) (hx : x < 2 ^ k) (hy : y % 2 ^ k = 0) : x ||| y = x + y := by have : y = (y / 2 ^ k) <<< k := by rw [ZAe]; exact (Nat.div_mul_cancel (Nat.dvd_of_mod_eq_zero hy)).symm rw [this, Nat.lor_comm, ← ZAq hx]; ring lemma QbV (i : USize) (h : i.toNat < QO.size) : QO.uget i h = if i.toNat % 256 = 0 then 41 else if i.toNat % 256 ≠ 255 ∧ i.toNat / 256 ≤ i.toNat % 256 ∧ i.toNat % 256 ≤ i.toNat / 256 + 7 then (i.toNat % 256 - i.toNat / 256).toUInt8 else 40 := by simp [ByteArray.uget, QO] lemma Qdh (w : UInt32) : (Qbu w).toNat = (expOf w).toNat := by rw [Qbg]; rfl lemma Q1 (w : UInt32) : (w &&& 0x7FFFFF).toNat < 2 ^ 23 := by rw [ZCj]; exact ZCq Nat.and_le_right (by decide) lemma QaF (lw : Nat) (hlw : lw ≤ 254) (o : USize) (hoe : o.toNat = lw * 256) (ho : o.toNat ≤ 65280) (w : UInt32) (hm : (Qf o ho w).toNat < 2 ^ 31) : (Qf o ho w).toNat = mantOf w * 2 ^ ((expOf w).toNat - lw) ∧ (mantOf w = 0 ∨ ((expOf w).toNat ≠ 0 ∧ (expOf w).toNat ≠ 255 ∧ lw ≤ (expOf w).toNat ∧ (expOf w).toNat ≤ lw + 7)) := by have he := expOf_toNat_lt w have hf := Q1 w have heu := Qdh w have hidx : (o + Qbu w).toNat = lw * 256 + (expOf w).toNat := by rw [Qe _ _ (by have := Qbr w; omega), hoe, heu] have hfr : (fracOf w).toNat = (w &&& 0x7FFFFF).toNat := rfl have hf' : w.toNat &&& 8388607 < 2 ^ 23 := by simpa [ZCj] using hf have hm23 : ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64.toNat = 2 ^ 23 + (fracOf w).toNat := by rw [ZAw, ZBn, hfr] rw [QH _ _ 23 hf (by norm_num)]; norm_num; omega unfold Qf at hm ⊢ simp only [QbV, hidx] at hm ⊢ have hmod : (lw * 256 + (expOf w).toNat) % 256 = (expOf w).toNat := by omega have hdiv : (lw * 256 + (expOf w).toNat) / 256 = lw := by omega simp only [hmod, hdiv] at hm ⊢ rw [ZAi, hm23] at hm ⊢ have hml : mantOf w < 2 ^ 24 := mantOf_lt_24 w split_ifs at hm ⊢ with h0 hc · have h41 : ((41 : UInt8).toUInt64.toNat % 64) = 41 := by decide rw [h41, ZAe] at hm ⊢ have hw : (2 ^ 23 + (fracOf w).toNat) * 2 ^ 41 % 2 ^ 64 = (fracOf w).toNat * 2 ^ 41 := by have : (fracOf w).toNat * 2 ^ 41 < 2 ^ 64 := by calc (fracOf w).toNat * 2 ^ 41 < 2 ^ 23 * 2 ^ 41 := ZAn (by omega) (by positivity) _ = 2 ^ 64 := by norm_num rw [Nat.add_mul, show (2 : Nat) ^ 23 * 2 ^ 41 = 2 ^ 64 by norm_num, Nat.add_mod, Nat.mod_self, zero_add, Nat.mod_mod, ZAa this] rw [hw] at hm ⊢ have hf0 : (fracOf w).toNat = 0 := by by_contra hne have : 2 ^ 41 ≤ (fracOf w).toNat * 2 ^ 41 := ZDj _ (ZCp hne) omega have he0 : expOf w = 0 := ZAk (by simpa using h0) have hm0 : mantOf w = 0 := by simp [mantOf, he0, hf0] rw [hf0, hm0]; simp · have hmant : mantOf w = 2 ^ 23 + (fracOf w).toNat := by have : expOf w ≠ 0 := fun h' => h0 (by simp [h']) simp [mantOf, this] have ht : (((expOf w).toNat - lw).toUInt8.toUInt64.toNat % 64) = (expOf w).toNat - lw := by simp only [UInt8.toNat_toUInt64, Nat.toUInt8, UInt8.toNat_ofNat']; omega rw [ht, ZAe, ← hmant] at hm ⊢ refine ⟨ZAa ?_, Or.inr ⟨h0, hc.1, hc.2.1, hc.2.2⟩⟩ calc mantOf w * 2 ^ ((expOf w).toNat - lw) < 2 ^ 24 * 2 ^ 8 := ZAg hml (ZAm (by norm_num) (by omega)) (by positivity) _ ≤ 2 ^ 64 := by norm_num · exfalso have h40 : ((40 : UInt8).toUInt64.toNat % 64) = 40 := by decide rw [h40, ZAe] at hm have hlt : (2 ^ 23 + (fracOf w).toNat) * 2 ^ 40 < 2 ^ 64 := by calc (2 ^ 23 + (fracOf w).toNat) * 2 ^ 40 < 2 ^ 24 * 2 ^ 40 := ZAn (by omega) (by positivity) _ = 2 ^ 64 := by norm_num rw [ZAa hlt] at hm have : 2 ^ 63 ≤ (2 ^ 23 + (fracOf w).toNat) * 2 ^ 40 := by calc 2 ^ 63 = 2 ^ 23 * 2 ^ 40 := by norm_num _ ≤ _ := ZAj _ (by omega) omega def wAt (W IX : Array UInt32) (wr : USize) (s : Nat) : UInt32 := W[wr.toNat + (IX[s]!).toNat]! lemma Qk (a : Array UInt32) (i : USize) (h : i.toNat < a.size) : a.uget i h = a[i.toNat]! := by simp only [Array.uget, getElem!_pos a i.toNat h] lemma QC (IX W : Array UInt32) (t wr : USize) (ht : t.toNat < IX.size) (hb : wr.toNat + (IX[t.toNat]!).toNat < W.size) (hWs : W.size < 2 ^ 32) (h) : W.uget (wr + (IX.uget t ht).toUSize) h = wAt W IX wr t.toNat := by have he : (IX.uget t ht).toUSize.toNat = (IX[t.toNat]!).toNat := by simp only [Array.uget, ZCi, getElem!_pos IX t.toNat ht] rw [Qk, Qe _ _ (by omega), he]; rfl lemma Qcw (x y : UInt64) : (x ||| y).toNat < 2 ^ 31 ↔ x.toNat < 2 ^ 31 ∧ y.toNat < 2 ^ 31 := by rw [ZCz] constructor ·intro h; exact ⟨ZCq Nat.left_le_or h, ZCq Nat.right_le_or h⟩ ·intro ⟨h1, h2⟩; exact Nat.or_lt_two_pow h1 h2 lemma Qb (f : Nat → UInt64) (t n : Nat) (h : t < n) : ∑ s ∈ ZAb t n, f s = f t + ∑ s ∈ ZAb (t + 1) n, f s := ZAs h f lemma QcH (IX X0 X1 W : Array UInt32) (o : USize) (ho : o.toNat ≤ 65280) (w0 w1 w2 w3 n : USize) (hI : n.toNat ≤ IX.size) (h0 : n.toNat ≤ X0.size) (h1 : n.toNat ≤ X1.size) (hW : QaL IX W n.toNat w0 w1 w2 w3) (hWs : W.size < 2 ^ 32) (t : USize) (a0 b0 a1 b1 a2 b2 a3 b3 chk : UInt64) : let r := QaR IX X0 X1 W o ho w0 w1 w2 w3 n hI h0 h1 hW hWs t a0 b0 a1 b1 a2 b2 a3 b3 chk let g := fun (P : Array UInt32) (wr : USize) (s : Nat) => sx P[s]! * sx (Qi (wAt W IX wr s) (Qf o ho (wAt W IX wr s))).toUInt32 r.a0 = a0 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w0 s ∧ r.b0 = b0 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w0 s ∧ r.a1 = a1 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w1 s ∧ r.b1 = b1 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w1 s ∧ r.a2 = a2 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w2 s ∧ r.b2 = b2 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w2 s ∧ r.a3 = a3 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w3 s ∧ r.b3 = b3 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w3 s ∧ (r.chk.toNat < 2 ^ 31 → chk.toNat < 2 ^ 31 ∧ ∀ s, t.toNat ≤ s → s < n.toNat → (Qf o ho (wAt W IX w0 s)).toNat < 2 ^ 31 ∧ (Qf o ho (wAt W IX w1 s)).toNat < 2 ^ 31 ∧ (Qf o ho (wAt W IX w2 s)).toNat < 2 ^ 31 ∧ (Qf o ho (wAt W IX w3 s)).toNat < 2 ^ 31) := by induction t, a0, b0, a1, b1, a2, b2, a3, b3, chk using QaR.induct IX X0 X1 W o ho w0 w1 w2 w3 n hI h0 h1 hW hWs with | case1 t a0 b0 a1 b1 a2 b2 a3 b3 chk h ht hti x0 x1 v0 v1 v2 v3 m0 m1 m2 m3 s0 s1 s2 s3 ih => unfold QaR simp only [dite_cond_eq_true (eq_true h)] obtain ⟨e0, e1, e2, e3, e4, e5, e6, e7, ec⟩ := ih have hsucc := Qd t n h have hx0 : x0 = sx X0[t.toNat]! := by simp only [x0, Qk] have hx1 : x1 = sx X1[t.toNat]! := by simp only [x1, Qk] have hv0 : v0 = wAt W IX w0 t.toNat := by simp only [v0]; exact QC _ _ _ _ _ (hW _ ht w0 (by simp)) hWs _ have hv1 : v1 = wAt W IX w1 t.toNat := by simp only [v1]; exact QC _ _ _ _ _ (hW _ ht w1 (by simp)) hWs _ have hv2 : v2 = wAt W IX w2 t.toNat := by simp only [v2]; exact QC _ _ _ _ _ (hW _ ht w2 (by simp)) hWs _ have hv3 : v3 = wAt W IX w3 t.toNat := by simp only [v3]; exact QC _ _ _ _ _ (hW _ ht w3 (by simp)) hWs _ rw [hsucc] at e0 e1 e2 e3 e4 e5 e6 e7 ec refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ ·rw [e0, Qb _ _ _ ht, ← add_assoc]; simp only [s0, m0, hx0, hv0] ·rw [e1, Qb _ _ _ ht, ← add_assoc]; simp only [s0, m0, hx1, hv0] ·rw [e2, Qb _ _ _ ht, ← add_assoc]; simp only [s1, m1, hx0, hv1] ·rw [e3, Qb _ _ _ ht, ← add_assoc]; simp only [s1, m1, hx1, hv1] ·rw [e4, Qb _ _ _ ht, ← add_assoc]; simp only [s2, m2, hx0, hv2] ·rw [e5, Qb _ _ _ ht, ← add_assoc]; simp only [s2, m2, hx1, hv2] ·rw [e6, Qb _ _ _ ht, ← add_assoc]; simp only [s3, m3, hx0, hv3] ·rw [e7, Qb _ _ _ ht, ← add_assoc]; simp only [s3, m3, hx1, hv3] ·intro hc obtain ⟨hc1, hc2⟩ := ec hc simp only [Qcw] at hc1 obtain ⟨⟨⟨⟨hq, hq0⟩, hq1⟩, hq2⟩, hq3⟩ := hc1 refine ⟨hq, fun s hs1 hs2 => ?_⟩ rcases ZBp s (t.toNat + 1) with hs | hs ·have : s = t.toNat := by omega subst this rw [← hv0, ← hv1, ← hv2, ← hv3]; exact ⟨hq0, hq1, hq2, hq3⟩ ·exact hc2 s hs hs2 | case2 t a0 b0 a1 b1 a2 b2 a3 b3 chk h => unfold QaR simp only [dite_cond_eq_false (eq_false h)] have : ¬ t.toNat < n.toNat := fun h' => h (ZAz h') have he : ZAb t.toNat n.toNat = ∅ := ZBu (by omega) simp only [he, ZDi, add_zero, true_and] intro hc; exact ⟨hc, fun s h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega)⟩ lemma QcC (IX X0 X1 X2 W : Array UInt32) (o : USize) (ho : o.toNat ≤ 65280) (w0 w1 w2 w3 n : USize) (hI : n.toNat ≤ IX.size) (h0 : n.toNat ≤ X0.size) (h1 : n.toNat ≤ X1.size) (h2 : n.toNat ≤ X2.size) (hW : QaL IX W n.toNat w0 w1 w2 w3) (hWs : W.size < 2 ^ 32) (t : USize) (a0 b0 c0 a1 b1 c1 a2 b2 c2 a3 b3 c3 chk : UInt64) : let r := QaW IX X0 X1 X2 W o ho w0 w1 w2 w3 n hI h0 h1 h2 hW hWs t a0 b0 c0 a1 b1 c1 a2 b2 c2 a3 b3 c3 chk let g := fun (P : Array UInt32) (wr : USize) (s : Nat) => sx P[s]! * sx (Qi (wAt W IX wr s) (Qf o ho (wAt W IX wr s))).toUInt32 r.a0 = a0 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w0 s ∧ r.b0 = b0 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w0 s ∧ r.c0 = c0 + ∑ s ∈ ZAb t.toNat n.toNat, g X2 w0 s ∧ r.a1 = a1 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w1 s ∧ r.b1 = b1 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w1 s ∧ r.c1 = c1 + ∑ s ∈ ZAb t.toNat n.toNat, g X2 w1 s ∧ r.a2 = a2 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w2 s ∧ r.b2 = b2 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w2 s ∧ r.c2 = c2 + ∑ s ∈ ZAb t.toNat n.toNat, g X2 w2 s ∧ r.a3 = a3 + ∑ s ∈ ZAb t.toNat n.toNat, g X0 w3 s ∧ r.b3 = b3 + ∑ s ∈ ZAb t.toNat n.toNat, g X1 w3 s ∧ r.c3 = c3 + ∑ s ∈ ZAb t.toNat n.toNat, g X2 w3 s ∧ (r.chk.toNat < 2 ^ 31 → chk.toNat < 2 ^ 31 ∧ ∀ s, t.toNat ≤ s → s < n.toNat → (Qf o ho (wAt W IX w0 s)).toNat < 2 ^ 31 ∧ (Qf o ho (wAt W IX w1 s)).toNat < 2 ^ 31 ∧ (Qf o ho (wAt W IX w2 s)).toNat < 2 ^ 31 ∧ (Qf o ho (wAt W IX w3 s)).toNat < 2 ^ 31) := by induction t, a0, b0, c0, a1, b1, c1, a2, b2, c2, a3, b3, c3, chk using QaW.induct IX X0 X1 X2 W o ho w0 w1 w2 w3 n hI h0 h1 h2 hW hWs with | case1 t a0 b0 c0 a1 b1 c1 a2 b2 c2 a3 b3 c3 chk h ht hti x0 x1 x2 v0 v1 v2 v3 m0 m1 m2 m3 s0 s1 s2 s3 ih => unfold QaW simp only [dite_cond_eq_true (eq_true h)] obtain ⟨e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, ec⟩ := ih have hsucc := Qd t n h have hx0 : x0 = sx X0[t.toNat]! := by simp only [x0, Qk] have hx1 : x1 = sx X1[t.toNat]! := by simp only [x1, Qk] have hx2 : x2 = sx X2[t.toNat]! := by simp only [x2, Qk] have hv0 : v0 = wAt W IX w0 t.toNat := by simp only [v0]; exact QC _ _ _ _ _ (hW _ ht w0 (by simp)) hWs _ have hv1 : v1 = wAt W IX w1 t.toNat := by simp only [v1]; exact QC _ _ _ _ _ (hW _ ht w1 (by simp)) hWs _ have hv2 : v2 = wAt W IX w2 t.toNat := by simp only [v2]; exact QC _ _ _ _ _ (hW _ ht w2 (by simp)) hWs _ have hv3 : v3 = wAt W IX w3 t.toNat := by simp only [v3]; exact QC _ _ _ _ _ (hW _ ht w3 (by simp)) hWs _ rw [hsucc] at e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11 ec refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ ·rw [e0, Qb _ _ _ ht, ← add_assoc]; simp only [s0, m0, hx0, hv0] ·rw [e1, Qb _ _ _ ht, ← add_assoc]; simp only [s0, m0, hx1, hv0] ·rw [e2, Qb _ _ _ ht, ← add_assoc]; simp only [s0, m0, hx2, hv0] ·rw [e3, Qb _ _ _ ht, ← add_assoc]; simp only [s1, m1, hx0, hv1] ·rw [e4, Qb _ _ _ ht, ← add_assoc]; simp only [s1, m1, hx1, hv1] ·rw [e5, Qb _ _ _ ht, ← add_assoc]; simp only [s1, m1, hx2, hv1] ·rw [e6, Qb _ _ _ ht, ← add_assoc]; simp only [s2, m2, hx0, hv2] ·rw [e7, Qb _ _ _ ht, ← add_assoc]; simp only [s2, m2, hx1, hv2] ·rw [e8, Qb _ _ _ ht, ← add_assoc]; simp only [s2, m2, hx2, hv2] ·rw [e9, Qb _ _ _ ht, ← add_assoc]; simp only [s3, m3, hx0, hv3] ·rw [e10, Qb _ _ _ ht, ← add_assoc]; simp only [s3, m3, hx1, hv3] ·rw [e11, Qb _ _ _ ht, ← add_assoc]; simp only [s3, m3, hx2, hv3] ·intro hc obtain ⟨hc1, hc2⟩ := ec hc simp only [Qcw] at hc1 obtain ⟨⟨⟨⟨hq, hq0⟩, hq1⟩, hq2⟩, hq3⟩ := hc1 refine ⟨hq, fun s hs1 hs2 => ?_⟩ rcases ZBp s (t.toNat + 1) with hs | hs ·have : s = t.toNat := by omega subst this rw [← hv0, ← hv1, ← hv2, ← hv3]; exact ⟨hq0, hq1, hq2, hq3⟩ ·exact hc2 s hs hs2 | case2 t a0 b0 c0 a1 b1 c1 a2 b2 c2 a3 b3 c3 chk h => unfold QaW simp only [dite_cond_eq_false (eq_false h)] have : ¬ t.toNat < n.toNat := fun h' => h (ZAz h') have he : ZAb t.toNat n.toNat = ∅ := ZBu (by omega) simp only [he, ZDi, add_zero, true_and] intro hc; exact ⟨hc, fun s h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega)⟩ def Qj (x : Q8) : Nat := x.1.toNat * 2 ^ 64 + x.2.toNat lemma Qdl (x : Q8) : Qj x < 2 ^ 128 := by have := x.1.toNat_lt; have := x.2.toNat_lt; unfold Qj; omega lemma QcB (x y : Q8) : Qj (Q3 x y) = (Qj x + Qj y) % 2 ^ 128 := by unfold Q3 Qj have hx1 := x.1.toNat_lt; have hx2 := x.2.toNat_lt; have hy1 := y.1.toNat_lt; have hy2 := y.2.toNat_lt simp only [ZAl, ZAr] split_ifs with hc <;> simp only [UInt64.toNat_one, ZBa] <;> omega lemma Qcs (v : UInt64) : (QbJ v).toNat = if v.toNat < 2 ^ 63 then 0 else 2 ^ 64 - 1 := by unfold QbJ have hv := v.toNat_lt have key : (v >>> 63 == 0) = true ↔ v.toNat < 2 ^ 63 := by rw [beq_iff_eq, ← ZBr] simp only [ZAv, ZBa, ZAo] norm_num <;> omega by_cases h : v.toNat < 2 ^ 63 ·rw [if_pos (key.mpr h), if_pos h]; rfl ·rw [if_neg (fun h' => h (key.mp h')), if_neg h]; rfl def Qa (v : UInt64) : Int := v.toBitVec.toInt lemma Qao (v : UInt64) : Qa v = if v.toNat < 2 ^ 63 then (v.toNat : Int) else (v.toNat : Int) - 2 ^ 64 := by unfold Qa rw [BitVec.toInt_eq_toNat_cond] simp only [UInt64.toNat_toBitVec] split_ifs with h1 h2 h2 <;> push_cast <;> omega lemma Qae (v : UInt64) (d : Nat) (hd : d ≤ 4) : (Qj (Q0 v d) : Int) = (Qa v * 2 ^ (21 * d)) % 2 ^ 128 := by have hv := v.toNat_lt rw [Qao] interval_cases d <;> simp only [Q0, Qj, Qcs, ZCz, ZAi, ZAv] <;> norm_num [ZAe, ZAo] all_goals (split_ifs <;> (try simp only [Nat.or_zero]) <;> (try (first | rw [QH _ _ 21 (by omega) (by norm_num)] | rw [QH _ _ 42 (by omega) (by norm_num)] | rw [QH _ _ 63 (by omega) (by norm_num)])) <;> push_cast <;> omega) section open FloatLib.Numerics FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats lemma Qa3 (s : Bool) (m : Nat) (e : Int) (j : Nat) (h : j + 25 ≤ m.log2) : Model.roundDyadic Fmt ⟨s, shiftRightJam m j, e + j⟩ = Model.roundDyadic Fmt ⟨s, m, e⟩ := by have hm0 : m ≠ 0 := by rintro rfl; simp at h have hpow : 2 ^ m.log2 ≤ m := ZCk hm0 have hm : 2 ^ (j + 1) ≤ m := le_trans (ZAm (by norm_num) (by omega)) hpow have hlog : (shiftRightJam m j).log2 = m.log2 - j := log2_shiftRightJam m j hm have hne : shiftRightJam m j ≠ 0 := shiftRightJam_ne_zero m j (le_trans (ZAm (by norm_num) (by omega)) hm) rw [← Model.roundDyadicGeneral_eq_roundDyadic, ← Model.roundDyadicGeneral_eq_roundDyadic] unfold Model.roundDyadicGeneral simp only [hne, hm0, beq_iff_eq, ite_false, hlog] have htot : ((m.log2 - j : Nat) : Int) + (e + j) = (m.log2 : Int) + e := by omega rw [htot] have hfw : Fmt.fracWidth = 23 := rfl have hsub : Fmt.minSubnormalExponent = -149 := rfl have hmin : Fmt.minNormalExponent = -126 := rfl rw [hfw, hsub, hmin] split_ifs with h1 h2 h3 h4 <;> try omega ·rfl ·congr 1 obtain ⟨a, ha⟩ : ∃ a : Nat, e - -149 = Int.negSucc a := ⟨(-(e + 149) - 1).toNat, by omega⟩ have hb : e + j - -149 = Int.negSucc (a - j) := by omega rw [ha, hb] dsimp only rw [show a - j + 1 = (a + 1) - j by omega] exact roundShiftRightEven_shiftRightJam m j (a + 1) (by omega) ·congr 1 rw [show m.log2 - j - 23 = (m.log2 - 23) - j by omega] exact roundShiftRightEven_shiftRightJam m j _ (by omega) lemma Qdq (h l : UInt64) (hne : Qj ⟨h, l⟩ ≠ 0) : Qj ⟨~~~h + (if l == 0 then 1 else 0), 0 - l⟩ = 2 ^ 128 - Qj ⟨h, l⟩ := by unfold Qj at * have hh := h.toNat_lt; have hl := l.toNat_lt have hs : UInt64.size = 2 ^ 64 := rfl simp only [ZAl, UInt64.toNat_not, ZDg, ZBa, hs] at * by_cases hl0 : l = 0 ·subst hl0 simp only [beq_self_eq_true, ite_true, UInt64.toNat_one, ZBa] at * omega ·have hl0' : l.toNat ≠ 0 := fun h' => hl0 (ZBf (by simpa using h')) simp only [show (l == 0) = false from by simp [hl0], ZAp, ite_false, ZBa] omega lemma Qc9 (x y k : Nat) (hx : x % 2 ^ k = 0) (hy : y < 2 ^ k) : x ||| y = x + y := by rw [Nat.lor_comm, QH y x k hy hx, ZDo] lemma QbQ (x : UInt64) : (x != 0) = (x.toNat != 0) := by by_cases h : x = 0 ·subst h; rfl ·have : x.toNat ≠ 0 := fun h' => h (ZBf (by simpa using h')) rw [show (x != 0) = true from bne_iff_ne.mpr h, show (x.toNat != 0) = true from bne_iff_ne.mpr this] lemma QcL (q : Nat) (b : Bool) : q ||| (if b then 1 else 0) = if b then q ||| 1 else q := by cases b <;> simp lemma QcD (mh ml : UInt64) (hne : Qj ⟨mh, ml⟩ ≠ 0) : (QR mh ml).1.toNat = shiftRightJam (Qj ⟨mh, ml⟩) (QR mh ml).2 ∧ ((QR mh ml).2 = 0 ∨ (QR mh ml).2 + 25 ≤ (Qj ⟨mh, ml⟩).log2) := by unfold QR Qj at * have hh := mh.toNat_lt; have hl := ml.toNat_lt by_cases h0 : mh = 0 ·subst h0 simp only [beq_self_eq_true, ite_true, ZBa, zero_mul, zero_add, true_or, and_true] simp [shiftRightJam, Nat.mod_one] ·have h0' : mh.toNat ≠ 0 := fun h' => h0 (ZBf (by simpa using h')) have hne0 : mh.toNat * 2 ^ 64 + ml.toNat ≠ 0 := by positivity simp only [show (mh == 0) = false from by simp [h0], ZAp, ite_false] by_cases h32 : mh < 0x100000000 ·have h32' : mh.toNat < 2 ^ 32 := by simpa [ZAr] using h32 simp only [h32, ite_true] refine ⟨?_, Or.inr ?_⟩ ·have e1 : (mh <<< 32).toNat = mh.toNat * 2 ^ 32 := by rw [ZAi] simp only [show (32 : UInt64).toNat % 64 = 32 from rfl, ZAe] exact ZAa (by omega) have e2 : (ml >>> 32).toNat = ml.toNat / 2 ^ 32 := by rw [ZAv] simp only [show (32 : UInt64).toNat % 64 = 32 from rfl, ZAo] have e3 : (ml &&& 0xFFFFFFFF).toNat = ml.toNat % 2 ^ 32 := by rw [ZCu]; exact ZBd _ 32 have e4 : ((if ml &&& 0xFFFFFFFF != 0 then (1 : UInt64) else 0)).toNat = if ml.toNat % 2 ^ 32 != 0 then 1 else 0 := by have : (ml &&& 0xFFFFFFFF != 0) = (ml.toNat % 2 ^ 32 != 0) := by rw [← e3, QbQ] rw [this]; split <;> rfl have hQ : mh.toNat * 2 ^ 32 ||| ml.toNat / 2 ^ 32 = mh.toNat * 2 ^ 32 + ml.toNat / 2 ^ 32 := Qc9 _ _ 32 (by simp) (by omega) rw [ZCz, ZCz, e1, e2, e4, hQ, QcL] have q2 : (mh.toNat * 2 ^ 64 + ml.toNat) / 2 ^ 32 = mh.toNat * 2 ^ 32 + ml.toNat / 2 ^ 32 := by omega have q3 : (mh.toNat * 2 ^ 64 + ml.toNat) % 2 ^ 32 = ml.toNat % 2 ^ 32 := by omega simp only [shiftRightJam, q2, q3] by_cases hs : ml.toNat % 2 ^ 32 = 0 <;> simp [hs] ·rw [ZBt hne0] calc 2 ^ (32 + 25) ≤ 1 * 2 ^ 64 := by norm_num _ ≤ mh.toNat * 2 ^ 64 := ZAj _ (by omega) _ ≤ _ := by omega ·have h32' : 2 ^ 32 ≤ mh.toNat := by have : ¬ mh.toNat < 4294967296 := by simpa [ZAr] using h32 omega simp only [h32, ite_false] refine ⟨?_, Or.inr ?_⟩ ·have e4 : ((if ml != 0 then (1 : UInt64) else 0)).toNat = if ml.toNat != 0 then 1 else 0 := by rw [QbQ]; split <;> rfl rw [ZCz, e4, QcL] have q2 : (mh.toNat * 2 ^ 64 + ml.toNat) / 2 ^ 64 = mh.toNat := by omega have q3 : (mh.toNat * 2 ^ 64 + ml.toNat) % 2 ^ 64 = ml.toNat := by omega simp only [shiftRightJam, q2, q3] by_cases hs : ml.toNat = 0 <;> simp [hs] ·rw [ZBt hne0] calc 2 ^ (64 + 25) ≤ 2 ^ 32 * 2 ^ 64 := by norm_num _ ≤ mh.toNat * 2 ^ 64 := ZAj _ h32' _ ≤ _ := by omega lemma Qbb (x : UInt64) (h : x.toNat < 2 ^ 63) : Qa x = x.toNat := by rw [Qao, if_pos h] lemma Qb0 (x : UInt64) (h : x.toNat < 2 ^ 63) (h0 : x.toNat ≠ 0) : Qa (0 - x) = -(x.toNat : Int) := by have hx := x.toNat_lt rw [Qao] have e : (0 - x).toNat = 2 ^ 64 - x.toNat := by rw [ZDg, ZBa]; have : UInt64.size = 2 ^ 64 := rfl; omega rw [e, if_neg (by omega)]; push_cast; omega lemma Qda (bw : UInt32) (sb : Nat) (hsb : sb ≤ 100) (he0 : expOf bw ≠ 0) : let bm : UInt64 := ((bw &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (sb % 21).toUInt64 let bs : UInt64 := if signOf bw then 0 - bm else bm Qa bs * 2 ^ (21 * (sb / 21)) = sv bw * 2 ^ sb := by intro bm bs have hf := Q1 bw have hmant : mantOf bw = 2 ^ 23 + (bw &&& 0x7FFFFF).toNat := by unfold mantOf; simp [he0]; rfl have hor : ((bw &&& 0x7FFFFF) ||| 0x800000).toUInt64.toNat = mantOf bw := by rw [ZAw, ZBn, hmant] rw [QH _ _ 23 hf (by norm_num)]; norm_num; omega have hr : sb % 21 < 21 := ZCe _ (by norm_num) have hm24 := mantOf_lt_24 bw have hbm : bm.toNat = mantOf bw * 2 ^ (sb % 21) := by simp only [bm, ZAi, hor] have : ((sb % 21).toUInt64.toNat % 64) = sb % 21 := by simp only [Nat.toUInt64, UInt64.toNat_ofNat']; omega rw [this, ZAe] apply ZAa calc mantOf bw * 2 ^ (sb % 21) < 2 ^ 24 * 2 ^ 21 := ZAg hm24 (ZAm (by norm_num) (by omega)) (by positivity) _ ≤ 2 ^ 64 := by norm_num have hsmall : bm.toNat < 2 ^ 63 := by rw [hbm] calc mantOf bw * 2 ^ (sb % 21) < 2 ^ 24 * 2 ^ 21 := ZAg hm24 (ZAm (by norm_num) (by omega)) (by positivity) _ ≤ 2 ^ 63 := by norm_num have hne : bm.toNat ≠ 0 := by rw [hbm, hmant]; positivity have hpow : (2 : Int) ^ (sb % 21) * 2 ^ (21 * (sb / 21)) = 2 ^ sb := by rw [← pow_add]; congr 1; omega simp only [bs] unfold sv split_ifs with hsg ·rw [Qb0 _ hsmall hne, hbm]; push_cast; rw [← hpow]; ring ·rw [Qbb _ hsmall, hbm]; push_cast; rw [← hpow]; ring lemma Qc5 (a b c bs : UInt64) (d : Nat) (hd : d ≤ 4) : (Qj (Q3 (Q3 (Q3 (Q0 a 0) (Q0 b 1)) (Q0 c 2)) (Q0 bs d)) : Int) = (Qa a + Qa b * 2 ^ 21 + Qa c * 2 ^ 42 + Qa bs * 2 ^ (21 * d)) % 2 ^ 128 := by have ha := Qae a 0 (by norm_num) have hb := Qae b 1 (by norm_num) have hc := Qae c 2 (by norm_num) have hs := Qae bs d hd generalize Qa bs * 2 ^ (21 * d) = Bb at hs ⊢ simp only [QcB] push_cast rw [ha, hb, hc, hs] norm_num <;> omega lemma Qdj (t : Q8) : (t.1 >>> 63 == 1) = decide (2 ^ 127 ≤ Qj t) := by unfold Qj have h1 := t.1.toNat_lt; have h2 := t.2.toNat_lt rw [Bool.eq_iff_iff, beq_iff_eq, decide_eq_true_iff, ← ZBr] simp only [ZAv, UInt64.toNat_one, ZAo] norm_num omega lemma Qdo (t : Q8) (T : Int) (hT : (Qj t : Int) = T % 2 ^ 128) (hb1 : -2 ^ 127 < T) (hb2 : T < 2 ^ 127) : (t.1 >>> 63 == 1) = decide (T < 0) ∧ Qj ⟨if t.1 >>> 63 == 1 then ~~~t.1 + (if t.2 == 0 then 1 else 0) else t.1, if t.1 >>> 63 == 1 then 0 - t.2 else t.2⟩ = T.natAbs := by have hlt := Qdl t rw [Qdj] by_cases hneg : T < 0 ·have hv : (Qj t : Int) = T + 2 ^ 128 := by rw [hT]; omega have hge : 2 ^ 127 ≤ Qj t := by omega simp only [hneg, decide_true, hge, ite_true, and_true, true_and] have hne : Qj ⟨t.1, t.2⟩ ≠ 0 := by show Qj t ≠ 0; omega rw [Qdq t.1 t.2 hne] show 2 ^ 128 - Qj t = T.natAbs omega ·have hv : (Qj t : Int) = T := by rw [hT]; omega have hge : ¬ 2 ^ 127 ≤ Qj t := by omega simp only [hneg, decide_false, hge, ite_false, true_and] show Qj t = T.natAbs omega lemma Qcx : (QR 0 0).1 = 0 := by decide lemma Qcd (T : Int) (mh ml : UInt64) (hv : Qj ⟨mh, ml⟩ = T.natAbs) (base : Nat) (r : UInt32) (hm : (QR mh ml).1 ≠ 0) (hr : Bridge.Qaj (decide (T < 0)) (QR mh ml).1 (((QR mh ml).2 : Int) + base - 298) = some r) (nz : Bool) : T ≠ 0 ∧ r = finishWord T ((base : Int) - 298) nz := by have hT0 : T ≠ 0 := by intro h0 rw [h0] at hv have : mh = 0 ∧ ml = 0 := by unfold Qj at hv; simp at hv exact ⟨ZBf (by simpa using hv.1), ZBf (by simpa using hv.2)⟩ rw [this.1, this.2] at hm; exact hm Qcx have hne : Qj ⟨mh, ml⟩ ≠ 0 := by rw [hv]; omega obtain ⟨hj1, hj2⟩ := QcD mh ml hne refine ⟨hT0, ?_⟩ rw [Bridge.Qb2 _ _ _ _ hm hr, hj1, hv] unfold finishWord rw [if_neg hT0] refine congrArg toWord ?_ simp only [ofIntDyadic] rcases hj2 with h0 | hj ·rw [h0]; simp [shiftRightJam, Nat.mod_one] ·rw [hv] at hj have := Qa3 (decide (T < 0)) T.natAbs ((base : Int) - 298) (QR mh ml).2 hj rw [← this]; congr 2; ring lemma Qak (x : UInt64) : -2 ^ 63 ≤ Qa x ∧ Qa x < 2 ^ 63 := by have := x.toNat_lt; rw [Qao]; split_ifs <;> omega lemma Qdu (w : UInt32) : -(2 ^ 24 : Int) < sv w ∧ sv w < 2 ^ 24 := by have := mantOf_lt_24 w unfold sv; split_ifs <;> omega lemma QG (w : UInt32) (he : expOf w = 0) (hf : fracOf w = 0) : sv w = 0 := by unfold sv mantOf; simp [he, hf] lemma Qc0 (relu : Bool) (bw : UInt32) (base : Nat) (a b c : UInt64) (w : Word) (nz : Bool) (h : Qbw relu bw base a b c = some w) : expOf bw ≠ 255 ∧ (expOf bw = 0 → fracOf bw = 0) ∧ (expOf bw ≠ 0 → base ≤ 148 + (expOf bw).toNat) ∧ (Qa a + Qa b * 2 ^ 21 + Qa c * 2 ^ 42 + sv bw * 2 ^ (148 + (expOf bw).toNat - base)) ≠ 0 ∧ w = act relu (finishWord (Qa a + Qa b * 2 ^ 21 + Qa c * 2 ^ 42 + sv bw * 2 ^ (148 + (expOf bw).toNat - base)) ((base : Int) - 298) nz) := by unfold Qbw at h split at h ·simp at h rename_i hc1 split at h ·simp at h rename_i hc2 have h255 : expOf bw ≠ 255 := by intro h'; simp [h'] at hc1 have hz : expOf bw = 0 → fracOf bw = 0 := by intro h0; by_contra hf; simp [h0, hf] at hc1 have hsb : expOf bw ≠ 0 → 0 ≤ (148 : Int) + (expOf bw).toNat - base ∧ (148 : Int) + (expOf bw).toNat - base ≤ 100 := by intro h0; by_contra hb; apply hc2 simp only [ZAx, bne_iff_ne, ne_eq, h0, not_false_eq_true, true_and, ZCd, decide_eq_true_eq] omega suffices hsuff : (Qa a + Qa b * 2 ^ 21 + Qa c * 2 ^ 42 + sv bw * 2 ^ (148 + (expOf bw).toNat - base)) ≠ 0 ∧ w = act relu (finishWord (Qa a + Qa b * 2 ^ 21 + Qa c * 2 ^ 42 + sv bw * 2 ^ (148 + (expOf bw).toNat - base)) ((base : Int) - 298) nz) from ⟨h255, hz, fun h0 => by have := hsb h0; omega, hsuff⟩ dsimp only at h split at h ·simp at h rename_i hm0 split at h ·rename_i r hr injection h with h rw [← h] set sb : Int := (148 : Int) + (expOf bw).toNat - base with hsbdef set d := min (sb.toNat / 21) 4 with hd have hbias : Qa (Qp bw sb) * 2 ^ (21 * d) = sv bw * 2 ^ (148 + (expOf bw).toNat - base) := by by_cases h0 : expOf bw = 0 ·have hbs0 : Qp bw sb = 0 := by unfold Qp; simp [h0] rw [hbs0, QG bw h0 (hz h0)]; simp [Qa] ·obtain ⟨s1, s2⟩ := hsb h0 have hsbn : sb.toNat = 148 + (expOf bw).toNat - base := by omega have hd' : d = sb.toNat / 21 := by omega have := Qda bw sb.toNat (by omega) h0 simp only at this rw [hd', ← hsbn] have hbw : Qp bw sb = (if signOf bw then 0 - (((bw &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (sb.toNat % 21).toUInt64) else ((bw &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (sb.toNat % 21).toUInt64) := by unfold Qp; simp [h0]; rfl rw [hbw]; exact this have hT := Qc5 a b c (Qp bw sb) d (by omega) rw [hbias] at hT set T := Qa a + Qa b * 2 ^ 21 + Qa c * 2 ^ 42 + sv bw * 2 ^ (148 + (expOf bw).toNat - base) with hTdef have hBi : -(2 : Int) ^ 124 < sv bw * 2 ^ (148 + (expOf bw).toNat - base) ∧ sv bw * 2 ^ (148 + (expOf bw).toNat - base) < 2 ^ 124 := by by_cases h0 : expOf bw = 0 ·rw [QG bw h0 (hz h0)]; norm_num ·have := hsb h0 have hp : (2 : Int) ^ (148 + (expOf bw).toNat - base) ≤ 2 ^ 100 := pow_le_pow_right₀ (by norm_num) (by omega) have hp0 : (0 : Int) < 2 ^ (148 + (expOf bw).toNat - base) := by positivity obtain ⟨v1, v2⟩ := Qdu bw constructor <;> nlinarith have ha := Qak a; have hb := Qak b; have hc := Qak c have hT' : (Qj (QaK a b c (Qp bw sb) d) : Int) = T % 2 ^ 128 := hT obtain ⟨sg, mg⟩ := Qdo _ T hT' (by omega) (by omega) have hq1 : (QaU (QaK a b c (Qp bw sb) d)).1 = decide (T < 0) := by unfold QaU; exact sg have hq2 : Qj ⟨(QaU (QaK a b c (Qp bw sb) d)).2.1, (QaU (QaK a b c (Qp bw sb) d)).2.2⟩ = T.natAbs := by unfold QaU; exact mg rw [hq1] at hr obtain ⟨hT0, hrt⟩ := Qcd T _ _ hq2 base r (by simpa using hm0) hr nz exact ⟨hT0, by rw [hrt]⟩ ·simp at h def v32 (v : UInt32) : Int := v.toBitVec.toInt lemma QcP (v : UInt32) : v32 v = if v.toNat < 2 ^ 31 then (v.toNat : Int) else (v.toNat : Int) - 2 ^ 32 := by unfold v32 rw [BitVec.toInt_eq_toNat_cond] simp only [UInt32.toNat_toBitVec] split_ifs <;> push_cast <;> omega lemma QU (p : UInt64) (hp : p.toNat < 2 ^ 21) (neg : Bool) : v32 ((if neg then 0 - p else p).toUInt32) = if neg then -(p.toNat : Int) else p.toNat := by rw [QcP] have hs : UInt64.size = 2 ^ 64 := rfl cases neg ·simp only [ZAp, ite_false, ZBc] rw [ZAa (by omega), if_pos (by omega)] ·simp only [ite_true, ZBc, ZDg, ZBa, hs] by_cases h0 : p.toNat = 0 ·simp [h0] ·have : (2 ^ 64 - p.toNat + 0) % 2 ^ 64 % 2 ^ 32 = 2 ^ 32 - p.toNat := by omega rw [this, if_neg (by omega)]; push_cast; omega def wv (w : UInt32) (lx : Nat) : Int := sv w * 2 ^ ((expOf w).toNat - lx) def pv (P0 P1 P2 : Array UInt32) (t : Nat) : Int := v32 P0[t]! + v32 P1[t]! * 2 ^ 21 + v32 P2[t]! * 2 ^ 42 def Qa4 (a b c : UInt32) : Prop := (v32 a).natAbs < 2 ^ 21 ∧ (v32 b).natAbs < 2 ^ 21 ∧ (v32 c).natAbs < 2 ^ 21 def QV (P0 P1 P2 : Array UInt32) (t : Nat) : Prop := Qa4 P0[t]! P1[t]! P2[t]! def XOk (X : Array UInt32) (o : Nat) (lx lim : Nat) (k : Nat) : Prop := (expOf X[o + k]!).toNat ≠ 255 ∧ ((expOf X[o + k]!).toNat = 0 → (fracOf X[o + k]!).toNat = 0) ∧ ((expOf X[o + k]!).toNat ≠ 0 → lx ≤ (expOf X[o + k]!).toNat ∧ (expOf X[o + k]!).toNat ≤ lx + lim) lemma Qb7 (w : UInt32) (lx lim : UInt32) (hlim : lim ≤ 39) (he0 : (expOf w).toNat ≠ 0) (hlx : lx ≤ (w >>> 23) &&& 0xFF) (hd : ((w >>> 23) &&& 0xFF) - lx ≤ lim) : let mag := ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (((w >>> 23) &&& 0xFF) - lx).toUInt64 let p0 := mag &&& 0x1FFFFF let p1 := (mag >>> 21) &&& 0x1FFFFF let p2 := mag >>> 42 p0.toNat < 2 ^ 21 ∧ p1.toNat < 2 ^ 21 ∧ p2.toNat < 2 ^ 21 ∧ (if signOf w then -(p0.toNat : Int) else p0.toNat) + (if signOf w then -(p1.toNat : Int) else p1.toNat) * 2 ^ 21 + (if signOf w then -(p2.toNat : Int) else p2.toNat) * 2 ^ 42 = wv w lx.toNat := by intro mag p0 p1 p2 have he : (w >>> 23) &&& 0xFF = expOf w := rfl rw [he] at hlx hd have hlim' : lim.toNat ≤ 39 := hlim have hlx' : lx.toNat ≤ (expOf w).toNat := hlx have hd' : ((expOf w) - lx).toNat = (expOf w).toNat - lx.toNat := by rw [ZBw _ _ hlx] have hdl : (expOf w).toNat - lx.toNat ≤ 39 := by have : ((expOf w) - lx).toNat ≤ lim.toNat := hd omega have hfr : (fracOf w).toNat = (w &&& 0x7FFFFF).toNat := rfl have hf := Q1 w have hmant : mantOf w = 2 ^ 23 + (fracOf w).toNat := by have : expOf w ≠ 0 := fun h' => he0 (by simp [h']) simp [mantOf, this] have hm23 : ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64.toNat = mantOf w := by rw [ZAw, ZBn, hmant, hfr] rw [QH _ _ 23 hf (by norm_num)]; norm_num; omega have hml := mantOf_lt_24 w set d := (expOf w).toNat - lx.toNat with hddef have hmag : mag.toNat = mantOf w * 2 ^ d := by simp only [mag, he, ZAi, hm23] have : ((expOf w - lx).toUInt64.toNat % 64) = d := by simp only [ZAw, hd']; omega rw [this, ZAe] apply ZAa calc mantOf w * 2 ^ d < 2 ^ 24 * 2 ^ 39 := ZAg hml (ZAm (by norm_num) (by omega)) (by positivity) _ ≤ 2 ^ 64 := by norm_num have hmag63 : mag.toNat < 2 ^ 63 := by rw [hmag] calc mantOf w * 2 ^ d < 2 ^ 24 * 2 ^ 39 := ZAg hml (ZAm (by norm_num) (by omega)) (by positivity) _ = 2 ^ 63 := by norm_num have h0 : p0.toNat = mag.toNat % 2 ^ 21 := by simp only [p0, ZCu]; exact ZBd _ 21 have h1 : p1.toNat = mag.toNat / 2 ^ 21 % 2 ^ 21 := by simp only [p1, ZCu, ZAv] rw [show (21 : UInt64).toNat % 64 = 21 from rfl, ZAo] exact ZBd _ 21 have h2 : p2.toNat = mag.toNat / 2 ^ 42 := by simp only [p2, ZAv] rw [show (42 : UInt64).toNat % 64 = 42 from rfl, ZAo] refine ⟨by omega, by omega, by omega, ?_⟩ have hsum : (p0.toNat : Int) + p1.toNat * 2 ^ 21 + p2.toNat * 2 ^ 42 = mag.toNat := by rw [h0, h1, h2]; omega unfold wv sv rw [← hddef] have hm : ((mantOf w : Nat) : Int) * 2 ^ d = (mag.toNat : Int) := by rw [hmag]; push_cast; ring split_ifs with hs ·push_cast at hsum ⊢; linarith ·push_cast at hsum ⊢; linarith lemma QcR (w lx lim : UInt32) (hlim : lim ≤ 39) (he0 : (expOf w).toNat ≠ 0) (hlx : lx ≤ (w >>> 23) &&& 0xFF) (hd : ((w >>> 23) &&& 0xFF) - lx ≤ lim) (mag p0 p1 p2 : UInt64) (neg : Bool) (hmag : mag = ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (((w >>> 23) &&& 0xFF) - lx).toUInt64) (h0 : p0 = mag &&& 0x1FFFFF) (h1 : p1 = (mag >>> 21) &&& 0x1FFFFF) (h2 : p2 = mag >>> 42) (hn : neg = signOf w) : Qa4 (if _h : neg = true then 0 - p0 else p0).toUInt32 (if _h : neg = true then 0 - p1 else p1).toUInt32 (if _h : neg = true then 0 - p2 else p2).toUInt32 ∧ (lim ≤ 18 → v32 (if _h : neg = true then 0 - p2 else p2).toUInt32 = 0) ∧ v32 (if _h : neg = true then 0 - p0 else p0).toUInt32 + v32 (if _h : neg = true then 0 - p1 else p1).toUInt32 * 2 ^ 21 + v32 (if _h : neg = true then 0 - p2 else p2).toUInt32 * 2 ^ 42 = wv w lx.toNat := by subst hmag h0 h1 h2 hn obtain ⟨q0, q1, q2, hval⟩ := Qb7 w lx lim hlim he0 hlx hd simp only [dite_eq_ite] rw [QU _ q0, QU _ q1, QU _ q2] refine ⟨?_, ?_, hval⟩ rotate_left ·intro h18 have he : (w >>> 23) &&& 0xFF = expOf w := rfl have hlx' : lx.toNat ≤ (expOf w).toNat := by rw [he] at hlx; exact hlx have hdn : ((expOf w) - lx).toNat = (expOf w).toNat - lx.toNat := ZBw _ _ (by rw [he] at hlx; exact hlx) have hd18 : (expOf w).toNat - lx.toNat ≤ 18 := by have : ((expOf w) - lx).toNat ≤ lim.toNat := by rw [he] at hd; exact hd have : lim.toNat ≤ 18 := h18 omega have hml := mantOf_lt_24 w have hmant : mantOf w = 2 ^ 23 + (fracOf w).toNat := by have : expOf w ≠ 0 := fun h' => he0 (by simp [h']) simp [mantOf, this] have hfr : (fracOf w).toNat = (w &&& 0x7FFFFF).toNat := rfl have hf := Q1 w have hm23 : ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64.toNat = mantOf w := by rw [ZAw, ZBn, hmant, hfr] rw [QH _ _ 23 hf (by norm_num)]; norm_num; omega have hp2 : ((((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (((w >>> 23) &&& 0xFF) - lx).toUInt64) >>> 42).toNat = 0 := by rw [ZAv, ZAi, hm23, he] have : ((expOf w - lx).toUInt64.toNat % 64) = (expOf w).toNat - lx.toNat := by simp only [ZAw, hdn]; omega rw [this, ZAe, show (42 : UInt64).toNat % 64 = 42 from rfl, ZAo] have hlt : mantOf w * 2 ^ ((expOf w).toNat - lx.toNat) < 2 ^ 42 := by calc mantOf w * 2 ^ ((expOf w).toNat - lx.toNat) < 2 ^ 24 * 2 ^ 18 := ZAg hml (ZAm (by norm_num) hd18) (by positivity) _ = 2 ^ 42 := by norm_num rw [ZAa (by omega)] exact ZDh hlt rw [hp2]; split <;> simp rotate_right unfold Qa4 clear hval rw [QU _ q0, QU _ q1, QU _ q2] refine ⟨?_, ?_, ?_⟩ <;> split <;> simp only [ZDf, ZCr] <;> omega lemma Qc4 (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (hlim : lim ≤ 39) (k c : USize) (IX P0 P1 P2 : Array UInt32) (hck : c.toNat ≤ k.toNat) (hs : n.toNat ≤ IX.size ∧ n.toNat ≤ P0.size ∧ n.toNat ≤ P1.size ∧ n.toNat ≤ P2.size) (ok : Bool) (hkn : k.toNat ≤ n.toNat) : let r := Qz X o n lx lim hX hXs k c IX P0 P1 P2 hck hs ok c.toNat ≤ r.2.2.2.2.1.toNat ∧ (r.2.2.2.2.2 = true → ok = true ∧ (∀ k', k.toNat ≤ k' → k' < n.toNat → XOk X o.toNat lx.toNat lim.toNat k') ∧ (∀ t, t < c.toNat → r.1[t]! = IX[t]! ∧ r.2.1[t]! = P0[t]! ∧ r.2.2.1[t]! = P1[t]! ∧ r.2.2.2.1[t]! = P2[t]!) ∧ (∀ t, c.toNat ≤ t → t < r.2.2.2.2.1.toNat → QV r.2.1 r.2.2.1 r.2.2.2.1 t ∧ (lim ≤ 18 → v32 r.2.2.2.1[t]! = 0) ∧ pv r.2.1 r.2.2.1 r.2.2.2.1 t = wv X[o.toNat + (r.1[t]!).toNat]! lx.toNat) ∧ (∀ G : Nat → Int, ∑ t ∈ ZAb c.toNat r.2.2.2.2.1.toNat, G (r.1[t]!).toNat = ∑ k' ∈ ZAb k.toNat n.toNat, if (expOf X[o.toNat + k']!).toNat ≠ 0 then G k' else 0)) := by induction k, c, IX, P0, P1, P2, hck, hs, ok using Qz.induct X o n lx lim hX hXs with | case1 k c IX P0 P1 P2 hck hs ok h hk hk1 w e he ih => have hw : w = X[o.toNat + k.toNat]! := by simp only [w]; rw [Qk, Qe _ _ (by omega)] have he0 : expOf w = 0 := by have := he; simp only [beq_iff_eq] at this; exact this have heq : Qz X o n lx lim hX hXs k c IX P0 P1 P2 hck hs ok = Qz X o n lx lim hX hXs (k + 1) c IX P0 P1 P2 (by omega) hs (ok && (w &&& 0x7FFFFF) == 0) := by conv_lhs => unfold Qz simp only [dite_cond_eq_true (eq_true h)] exact if_pos he rw [heq] obtain ⟨hmono, ih2⟩ := ih (by omega) refine ⟨hmono, fun hfin => ?_⟩ obtain ⟨hok', hxk, hold, hnew, hsum⟩ := ih2 hfin simp only [ZAx, beq_iff_eq] at hok' refine ⟨hok'.1, ?_, hold, hnew, ?_⟩ ·intro k' hk1' hk2' rcases ZBp k' (k.toNat + 1) with hlt | hge ·have hk' : k' = k.toNat := by omega subst hk' unfold XOk rw [← hw] have hf0 : (fracOf w).toNat = 0 := by have : fracOf w = 0 := hok'.2 simp [this] refine ⟨by rw [he0]; decide, fun _ => hf0, fun h' => absurd (by simp [he0]) h'⟩ ·exact hxk k' (by omega) hk2' ·intro G rw [hsum G, hk1, ZAs hk] rw [← hw, he0]; simp | case2 k c IX P0 P1 P2 hck hs ok h hk hk1 w e he hc1 d mag p0 p1 p2 neg ih => have hw : w = X[o.toNat + k.toNat]! := by simp only [w]; rw [Qk, Qe _ _ (by omega)] have he0 : (expOf w).toNat ≠ 0 := by intro h0; apply he; have : expOf w = 0 := ZAk (by simpa using h0) simp only [beq_iff_eq]; exact this have heq : Qz X o n lx lim hX hXs k c IX P0 P1 P2 hck hs ok = Qz X o n lx lim hX hXs (k + 1) (c + 1) (IX.uset c k.toUInt32 (by omega)) (P0.uset c (if _h : neg = true then 0 - p0 else p0).toUInt32 (by omega)) (P1.uset c (if _h : neg = true then 0 - p1 else p1).toUInt32 (by omega)) (P2.uset c (if _h : neg = true then 0 - p2 else p2).toUInt32 (by omega)) (by omega) (by simp only [ZBz]; exact hs) (ok && e != 255 && lx ≤ e && d ≤ lim) := by conv_lhs => unfold Qz simp only [dite_cond_eq_true (eq_true h)] exact if_neg he rw [heq] obtain ⟨hmono, ih2⟩ := ih (by omega) refine ⟨by omega, fun hfin => ?_⟩ obtain ⟨hok', hxk, hold, hnew, hsum⟩ := ih2 hfin simp only [ZAx, bne_iff_ne, ne_eq, decide_eq_true_eq] at hok' obtain ⟨⟨⟨hok, h255⟩, hlx⟩, hdl⟩ := hok' have hlx' : lx.toNat ≤ (expOf w).toNat := hlx have hdn : ((expOf w) - lx).toNat = (expOf w).toNat - lx.toNat := ZBw _ _ hlx obtain ⟨hpo, h2z, hval⟩ := QcR w lx lim hlim he0 hlx hdl mag p0 p1 p2 neg rfl rfl rfl rfl rfl have hc_lt : c.toNat < (c + 1).toNat := by omega refine ⟨hok, ?_, ?_, ?_, ?_⟩ ·intro k' hk1' hk2' rcases ZBp k' (k.toNat + 1) with hlt | hge ·have hk' : k' = k.toNat := by omega subst hk' unfold XOk rw [← hw] have hdl' : ((expOf w) - lx).toNat ≤ lim.toNat := hdl refine ⟨fun h' => h255 (by have : expOf w = 255 := ZAk (by simpa using h'); exact this), fun h' => absurd h' he0, fun _ => ⟨hlx', by omega⟩⟩ ·exact hxk k' (by omega) hk2' ·intro t ht obtain ⟨o1, o2, o3, o4⟩ := hold t (by omega) refine ⟨by rw [o1, Qg, if_neg (by omega)], by rw [o2, Qg, if_neg (by omega)], by rw [o3, Qg, if_neg (by omega)], by rw [o4, Qg, if_neg (by omega)]⟩ ·intro t ht1 ht2 rcases ZBp t (c.toNat + 1) with hlt | hge ·have ht : t = c.toNat := by omega subst ht obtain ⟨o1, o2, o3, o4⟩ := hold c.toNat hc_lt refine ⟨?_, ?_, ?_⟩ ·unfold QV; rw [o2, o3, o4, Qg, Qg, Qg, if_pos rfl, if_pos rfl, if_pos rfl] exact hpo ·intro h18; rw [o4, Qg, if_pos rfl]; exact h2z h18 ·unfold pv; rw [o1, o2, o3, o4] rw [Qg, Qg, Qg, Qg, if_pos rfl, if_pos rfl, if_pos rfl, if_pos rfl, hval] simp only [ZDp] have : k.toNat < 2 ^ 32 := by omega rw [ZAa this, ← hw] ·exact hnew t (by omega) ht2 ·intro G have hs2 := hsum G rw [hc1, hk1] at hs2 rw [ZAs (by omega), hs2, ZAs hk, ← hw, if_pos he0] congr 1 obtain ⟨o1, -, -, -⟩ := hold c.toNat hc_lt rw [o1, Qg, if_pos rfl] simp only [ZDp] have : k.toNat < 2 ^ 32 := by omega rw [ZAa this] | case3 k c IX P0 P1 P2 hck hs ok h => unfold Qz; simp only [dite_cond_eq_false (eq_false h)] have hkn' : ¬ k.toNat < n.toNat := fun h' => h (ZAz h') refine ⟨le_rfl, fun hfin => ⟨hfin, fun k' h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega), fun t _ => ⟨by simp, by simp, by simp, by simp⟩, fun t h1 h2 => absurd (lt_of_le_of_lt h1 h2) (lt_irrefl _), ?_⟩⟩ intro G rw [Finset.Ico_self, ZBu (by omega)] simp lemma Qde (v : UInt32) : (sx v).toBitVec = ZBe 64 (v32 v) := by simp [sx, v32, BitVec.signExtend] lemma Qb5 (x : UInt64) (h : -2 ^ 31 ≤ Qa x ∧ Qa x < 2 ^ 31) : v32 x.toUInt32 = Qa x := by have hx := x.toNat_lt rw [QcP, Qao] at * simp only [ZBc] split_ifs at h ⊢ <;> push_cast <;> omega lemma Qcl (x : UInt64) (h : -2 ^ 31 ≤ Qa x ∧ Qa x < 2 ^ 31) : sx x.toUInt32 = x := by apply UInt64.toBitVec_inj.mp rw [Qde, Qb5 x h] unfold Qa exact BitVec.ofInt_toInt lemma Qdn (a : Nat) (h : a < 256) : a ||| 255 = 255 := by interval_cases a <;> rfl lemma QaC (x y : UInt32) (h : expOf y = 255) : expOf (x ||| y) = 255 := by apply ZAk have hy : (expOf y).toNat = 255 := by rw [h]; rfl unfold expOf at hy ⊢ simp only [ZCj, UInt32.toNat_shiftRight, ZBn] at hy ⊢ norm_num at hy ⊢ rw [Nat.shiftRight_or_distrib, Nat.and_or_distrib_right, hy] exact Qdn _ (ZCq Nat.and_le_right (by norm_num)) lemma Qcz (W : Array UInt32) (n : USize) (hW : n.toNat ≤ W.size) (k : USize) (c : UInt32) (hkn : k.toNat ≤ n.toNat) : expOf (Qah W n hW k c) ≠ 255 → expOf c ≠ 255 ∧ ∀ i, k.toNat ≤ i → i < n.toNat → expOf W[i]! ≠ 255 := by induction k, c using Qah.induct W n hW with | case1 k c h hk ih => have heq : Qah W n hW k c = Qah W n hW (k + 1) (c ||| W.uget k (by omega)) := by conv_lhs => unfold Qah simp only [dite_cond_eq_true (eq_true h)] rw [heq] intro hne have hk1 := Qd k n h obtain ⟨h1, h2⟩ := ih (by omega) hne have hwk : W.uget k (by omega) = W[k.toNat]! := Qk _ _ _ refine ⟨fun hc => h1 ?_, fun i hi1 hi2 => ?_⟩ ·have hcomm : (c ||| W.uget k (by omega)) = (W.uget k (by omega) ||| c) := by apply ZAk; rw [ZBn, ZBn, Nat.lor_comm] rw [hcomm]; exact QaC _ _ hc rcases ZBp i (k.toNat + 1) with hlt | hge ·have : i = k.toNat := by omega subst this intro h255; apply h1; rw [hwk]; exact QaC _ _ h255 ·exact h2 i (by omega) hi2 | case2 k c h => unfold Qah; simp only [dite_cond_eq_false (eq_false h)] have : ¬ k.toNat < n.toNat := fun h' => h (ZAz h') exact fun hc => ⟨hc, fun i h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega)⟩ lemma Qdi (a b : Array UInt32) (st c : Nat) : dsum a b st c = ∑ k ∈ ZAd c, sv a[st + k]! * sv b[st + k]! * 2 ^ (idxOf a[st + k]! + idxOf b[st + k]!) := by induction c generalizing st with | zero => simp [dsum] | succ c ih => rw [dsum, ih (st + 1), Finset.sum_range_succ'] simp only [Nat.add_zero, Nat.add_assoc, ZDo 1] ring lemma QaY (A B : Array UInt32) (hs : A.size = B.size) (hfin : ∀ k, k < A.size → expOf A[k]! ≠ 255 ∧ expOf B[k]! ≠ 255) (hS0 : dsum A B 0 A.size ≠ 0) (nz : Bool) : dotSpec A B = finishWord (dsum A B 0 A.size) (-298) nz := by set L := A.map (Model.ofUInt32 (fmt := Fmt)) with hL set R := B.map (Model.ofUInt32 (fmt := Fmt)) with hR have hLR : L.size = R.size := by simp [hL, hR, hs] have hLsize : L.size = A.size := by simp [hL] have hLfin : ∀ k (hk : k < L.size), Model.isFinite L[k] = true := by intro k hk have hk' : k < A.size := by simpa [hL] using hk have := (hfin k hk').1 rw [getElem!_pos A k hk'] at this simp [hL, isFinite_ofUInt32, this] have hRfin : ∀ k (hk : k < R.size), Model.isFinite R[k] = true := by intro k hk have hk' : k < B.size := by simpa [hR] using hk have := (hfin k (by omega)).2 rw [getElem!_pos B k hk'] at this simp [hR, isFinite_ofUInt32, this] have hslice : Model.Reduction.Semantics.finiteDotSlice L R 0 L.size (by simp) (by simp [hLR]) = (dsum A B 0 A.size : ℚ) * 2 ^ (-298 : ℤ) := by have := finiteDotSlice_eq A B 0 L.size (by simp [hL]) (by simp [hL, hR, hs]) (by intro k k1 k2; exact hfin k (by omega)) exact this.trans (by rw [hLsize]) have hexact := Model.Reduction.Internal.dotState_exact_toRat (destination := Fmt) L R hLR hLfin hRfin unfold dotSpec Model.dot have hnz : Model.Reduction.Semantics.finiteDot L.toList R.toList ≠ .ok 0 := by rw [Model.Reduction.Semantics.finiteDot_toList_eq_slice L R hLR] intro h injection h with h rw [hslice] at h simp at h; exact hS0 h rw [Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L R .nearestEven hLR hLfin hRfin hnz] simp only [Except.map] exact (finishWord_of_ne _ _ _ _ hS0 (by rw [hexact, hslice])).symm lemma Qcm (x : UInt32) (lx : Nat) (hlx : 1 ≤ lx) (h : (expOf x = 0 ∧ fracOf x = 0) ∨ (lx ≤ (expOf x).toNat)) : sv x * 2 ^ (idxOf x) = wv x lx * 2 ^ (lx - 1) := by rcases h with ⟨he, hf⟩ | hle ·rw [QG x he hf]; unfold wv; rw [QG x he hf]; ring ·have hne : expOf x ≠ 0 := by intro h0; rw [h0] at hle; simp at hle; omega have hidx : idxOf x = (expOf x).toNat - 1 := by simp [idxOf, hne] unfold wv; rw [hidx, mul_assoc, ← pow_add]; congr 2; omega lemma Qas (n : Nat) (f : Nat → UInt32) (k : Nat) (hk : k < n) : (Array.ofFn (n := n) fun i => f i.val)[k]! = f k := by rw [getElem!_pos _ k (by simpa using hk), Array.getElem_ofFn] lemma Qbp : expOf oneW = 127 ∧ sv oneW = 2 ^ 23 ∧ idxOf oneW = 126 := by decide lemma Qb3 (inW : Nat) (relu : Bool) (X W b : Array Word) (i jj : Nat) (lx lw : Nat) (hlx : 1 ≤ lx) (hlw : 1 ≤ lw) (hx : ∀ k, k < inW → expOf X[i * inW + k]! ≠ 255 ∧ ((expOf X[i * inW + k]! = 0 ∧ fracOf X[i * inW + k]! = 0) ∨ lx ≤ (expOf X[i * inW + k]!).toNat)) (hw : ∀ k, k < inW → expOf W[jj * inW + k]! ≠ 255) (hwx : ∀ k, k < inW → expOf X[i * inW + k]! ≠ 0 → ((expOf W[jj * inW + k]! = 0 ∧ fracOf W[jj * inW + k]! = 0) ∨ lw ≤ (expOf W[jj * inW + k]!).toNat)) (a bb c : UInt64) (hlanes : Qa a + Qa bb * 2 ^ 21 + Qa c * 2 ^ 42 = ∑ k ∈ ZAd inW, wv X[i * inW + k]! lx * wv W[jj * inW + k]! lw) (w : Word) (h : Qbw relu b[jj]! (lx + lw - 2) a bb c = some w) : w = act relu (dotOf (inW + 1) (fun t => if t < inW then X[i * inW + t]! else oneW) (fun t => if t < inW then W[jj * inW + t]! else b[jj]!)) := by obtain ⟨h255, hzb, hbase, hT0, hw'⟩ := Qc0 relu b[jj]! (lx + lw - 2) a bb c w false h rw [hw'] congr 1 set base := lx + lw - 2 with hbd set S := ∑ k ∈ ZAd inW, wv X[i * inW + k]! lx * wv W[jj * inW + k]! lw with hSdef rw [hlanes] at hT0 ⊢ set fa := fun t => if t < inW then X[i * inW + t]! else oneW with hfa set fb := fun t => if t < inW then W[jj * inW + t]! else b[jj]! with hfb set A := Array.ofFn (n := inW + 1) fun t => fa t.val with hA set B := Array.ofFn (n := inW + 1) fun t => fb t.val with hB have hAs : A.size = inW + 1 := by simp [hA] have hBs : B.size = inW + 1 := by simp [hB] have hAk : ∀ k, k < inW + 1 → A[k]! = fa k := fun k hk => Qas _ _ _ hk have hBk : ∀ k, k < inW + 1 → B[k]! = fb k := fun k hk => Qas _ _ _ hk have hdsum : dsum A B 0 A.size = (S + sv b[jj]! * 2 ^ (148 + (expOf b[jj]!).toNat - base)) * 2 ^ base := by rw [Qdi, hAs, ZBl] have hlast : sv A[0 + inW]! * sv B[0 + inW]! * 2 ^ (idxOf A[0 + inW]! + idxOf B[0 + inW]!) = sv b[jj]! * 2 ^ (148 + (expOf b[jj]!).toNat - base) * 2 ^ base := by rw [ZDl, hAk _ (by omega), hBk _ (by omega)] simp only [hfa, hfb, lt_irrefl, if_false] obtain ⟨_, hsv1, hidx1⟩ := Qbp rw [hsv1, hidx1] by_cases heb : expOf b[jj]! = 0 ·rw [QG _ heb (hzb heb)]; ring ·have hidx : idxOf b[jj]! = (expOf b[jj]!).toNat - 1 := by simp [idxOf, heb] have hb0 : (expOf b[jj]!).toNat ≠ 0 := fun h' => heb (ZAk (by simpa using h')) have := hbase heb rw [hidx] have e1 : (2 : Int) ^ 23 * 2 ^ (126 + ((expOf b[jj]!).toNat - 1)) = 2 ^ (148 + (expOf b[jj]!).toNat) := by rw [← pow_add]; congr 1; omega have e2 : (2 : Int) ^ (148 + (expOf b[jj]!).toNat - base) * 2 ^ base = 2 ^ (148 + (expOf b[jj]!).toNat) := by rw [← pow_add]; congr 1; omega calc (2 : Int) ^ 23 * sv b[jj]! * 2 ^ (126 + ((expOf b[jj]!).toNat - 1)) = sv b[jj]! * ((2 : Int) ^ 23 * 2 ^ (126 + ((expOf b[jj]!).toNat - 1))) := by ring _ = sv b[jj]! * ((2 : Int) ^ (148 + (expOf b[jj]!).toNat - base) * 2 ^ base) := by rw [e1, e2] _ = _ := by ring have hbody : ∑ k ∈ ZAd inW, sv A[0 + k]! * sv B[0 + k]! * 2 ^ (idxOf A[0 + k]! + idxOf B[0 + k]!) = S * 2 ^ base := by rw [hSdef, ZBm] apply ZAy rfl intro k hk have hk' := ZAu hk rw [ZDl, hAk _ (by omega), hBk _ (by omega)] simp only [hfa, hfb, hk', if_true] obtain ⟨_, hxk⟩ := hx k hk' by_cases hxe : expOf X[i * inW + k]! = 0 ·have hxf : fracOf X[i * inW + k]! = 0 := by rcases hxk with ⟨_, hf⟩ | hle ·exact hf ·rw [hxe] at hle; simp at hle; omega rw [QG _ hxe hxf]; unfold wv; rw [QG _ hxe hxf]; ring ·have tx := Qcm X[i * inW + k]! lx hlx hxk have tw := Qcm W[jj * inW + k]! lw hlw (hwx k hk' hxe) rw [pow_add, show sv X[i * inW + k]! * sv W[jj * inW + k]! * (2 ^ idxOf X[i * inW + k]! * 2 ^ idxOf W[jj * inW + k]!) = (sv X[i * inW + k]! * 2 ^ idxOf X[i * inW + k]!) * (sv W[jj * inW + k]! * 2 ^ idxOf W[jj * inW + k]!) by ring, tx, tw, show base = (lx - 1) + (lw - 1) by omega, pow_add] ring rw [hbody, hlast]; ring have hfin : ∀ k, k < A.size → expOf A[k]! ≠ 255 ∧ expOf B[k]! ≠ 255 := by intro k hk rw [hAs] at hk rw [hAk k hk, hBk k hk] simp only [hfa, hfb] split_ifs with hk' ·exact ⟨(hx k hk').1, hw k hk'⟩ ·exact ⟨by rw [Qbp.1]; decide, h255⟩ have hne : dsum A B 0 A.size ≠ 0 := by rw [hdsum]; exact mul_ne_zero hT0 (pow_ne_zero _ (by norm_num)) unfold dotOf rw [← hA, ← hB, QaY A B (by rw [hAs, hBs]) hfin hne false, hdsum, ← finishWord_scale] congr 1 lemma Qbc (N : Nat) (f : Nat → UInt64) : (∑ s ∈ ZAd N, f s).toBitVec = ∑ s ∈ ZAd N, (f s).toBitVec := by induction N with | zero => simp | succ N ih => rw [ZBl, ZBl, UInt64.toBitVec_add, ih] lemma Qag (N : Nat) (f : Nat → Int) : ZBe 64 (∑ s ∈ ZAd N, f s) = ∑ s ∈ ZAd N, ZBe 64 (f s) := by induction N with | zero => simp | succ N ih => rw [ZBl, ZBl, BitVec.ofInt_add, ih] lemma Qaz (N : Nat) (f : Nat → Int) : (∑ s ∈ ZAd N, f s).natAbs ≤ ∑ s ∈ ZAd N, (f s).natAbs := by induction N with | zero => simp | succ N ih => rw [ZBl, ZBl] exact le_trans (Int.natAbs_add_le _ _) (by omega) lemma Qay (N : Nat) (hN : N < 2048) (P : Array UInt32) (S : Nat → UInt64) (hP : ∀ s, s < N → (v32 P[s]!).natAbs < 2 ^ 21) (hS : ∀ s, s < N → (Qa (S s)).natAbs < 2 ^ 31) : Qa (0 + ∑ s ∈ ZAb 0 N, sx P[s]! * S s) = ∑ s ∈ ZAd N, v32 P[s]! * Qa (S s) := by rw [zero_add, ← ZCa] have hterm : ∀ s, s < N → (sx P[s]! * S s).toBitVec = ZBe 64 (v32 P[s]! * Qa (S s)) := by intro s _ rw [ZCl, Qde, ZCy] congr 1 unfold Qa; exact BitVec.ofInt_toInt.symm have hsum : (∑ s ∈ ZAd N, sx P[s]! * S s).toBitVec = ZBe 64 (∑ s ∈ ZAd N, v32 P[s]! * Qa (S s)) := by rw [Qbc, Qag] exact ZAy rfl fun s hs => hterm s (ZAu hs) have hb : (∑ s ∈ ZAd N, v32 P[s]! * Qa (S s)).natAbs < 2 ^ 63 := by calc (∑ s ∈ ZAd N, v32 P[s]! * Qa (S s)).natAbs ≤ ∑ s ∈ ZAd N, (v32 P[s]! * Qa (S s)).natAbs := Qaz _ _ _ ≤ ∑ _s ∈ ZAd N, (2 ^ 52 : Nat) := by apply ZCf intro s hs have h1 := hP s (ZAu hs) have h2 := hS s (ZAu hs) rw [Int.natAbs_mul] calc (v32 P[s]!).natAbs * (Qa (S s)).natAbs ≤ 2 ^ 21 * 2 ^ 31 := Nat.mul_le_mul (by omega) (by omega) _ = 2 ^ 52 := by norm_num _ = N * 2 ^ 52 := by simp _ < 2 ^ 63 := by calc N * 2 ^ 52 < 2048 * 2 ^ 52 := ZAn hN (by positivity) _ = 2 ^ 63 := by norm_num unfold Qa rw [hsum, BitVec.toInt_ofInt] apply Int.bmod_eq_of_le <;> omega lemma Qcn (w : UInt32) (m : UInt64) (hm : m.toNat < 2 ^ 31) : Qa (Qi w m) = if signOf w then -(m.toNat : Int) else m.toNat := by unfold Qi split ·by_cases h0 : m.toNat = 0 ·have : m = 0 := ZBf (by simpa using h0) subst this; simp [Qa] ·exact Qb0 m (by omega) h0 ·exact Qbb m (by omega) lemma Qcj (lw : Nat) (w : UInt32) (M : UInt64) (hm : M.toNat < 2 ^ 31) (hmag : M.toNat = mantOf w * 2 ^ ((expOf w).toNat - lw)) : Qa (Qi w M) = wv w lw ∧ (Qa (Qi w M)).natAbs < 2 ^ 31 := by rw [Qcn w _ hm] refine ⟨?_, ?_⟩ ·unfold wv sv; rw [hmag]; split <;> push_cast <;> ring ·split <;> simp only [ZDf, ZCr] <;> omega lemma QbL (lw : Nat) (hlw : lw ≤ 254) (o : USize) (hoe : o.toNat = lw * 256) (ho : o.toNat ≤ 65280) (w : UInt32) (hm : (Qf o ho w).toNat < 2 ^ 31) : Qa (Qi w (Qf o ho w)) = wv w lw ∧ (Qa (Qi w (Qf o ho w))).natAbs < 2 ^ 31 := Qcj lw w (Qf o ho w) hm (QaF lw hlw o hoe ho w hm).1 lemma QbN (n nz : Nat) (hnz : nz < 2048) (IX X0 X1 X2 : Array UInt32) (S : Nat → UInt64) (xw wrow : Nat → UInt32) (lx lw : Nat) (hparts : ∀ t, t < nz → QV X0 X1 X2 t ∧ pv X0 X1 X2 t = wv (xw (IX[t]!).toNat) lx) (hS : ∀ t, t < nz → Qa (S t) = wv (wrow (IX[t]!).toNat) lw ∧ (Qa (S t)).natAbs < 2 ^ 31) (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 n, if (expOf (xw k)).toNat ≠ 0 then G k else 0) (hzero : ∀ k, k < n → (expOf (xw k)).toNat = 0 → wv (xw k) lx = 0) : Qa (0 + ∑ s ∈ ZAb 0 nz, sx X0[s]! * S s) + Qa (0 + ∑ s ∈ ZAb 0 nz, sx X1[s]! * S s) * 2 ^ 21 + Qa (0 + ∑ s ∈ ZAb 0 nz, sx X2[s]! * S s) * 2 ^ 42 = ∑ k ∈ ZAd n, wv (xw k) lx * wv (wrow k) lw := by have hb := fun t (ht : t < nz) => (hparts t ht).1 have hs := fun t (ht : t < nz) => (hS t ht).2 rw [Qay nz hnz X0 S (fun t ht => (hb t ht).1) hs, Qay nz hnz X1 S (fun t ht => (hb t ht).2.1) hs, Qay nz hnz X2 S (fun t ht => (hb t ht).2.2) hs] have hpv : ∑ s ∈ ZAd nz, v32 X0[s]! * Qa (S s) + (∑ s ∈ ZAd nz, v32 X1[s]! * Qa (S s)) * 2 ^ 21 + (∑ s ∈ ZAd nz, v32 X2[s]! * Qa (S s)) * 2 ^ 42 = ∑ s ∈ ZAd nz, pv X0 X1 X2 s * Qa (S s) := by rw [ZBm, ZBm, ← ZBi, ← ZBi] apply Finset.sum_congr rfl; intro s _; unfold pv; ring rw [hpv] have hterm : ∑ s ∈ ZAd nz, pv X0 X1 X2 s * Qa (S s) = ∑ t ∈ ZAb 0 nz, (fun k => wv (xw k) lx * wv (wrow k) lw) (IX[t]!).toNat := by rw [← ZCa] apply ZAy rfl; intro t ht have ht' := ZAu ht rw [(hparts t ht').2, (hS t ht').1] rw [hterm, hG (fun k => wv (xw k) lx * wv (wrow k) lw), ← ZCa] apply ZAy rfl; intro k hk have hk' := ZAu hk split_ifs with he ·rfl ·push_neg at he; rw [hzero k hk' he]; ring lemma Qcu (n nz : Nat) (hnz : nz < 2048) (IX X0 X1 X2 : Array UInt32) (S : Nat → UInt64) (xw wrow : Nat → UInt32) (lx lw : Nat) (hparts : ∀ t, t < nz → QV X0 X1 X2 t ∧ pv X0 X1 X2 t = wv (xw (IX[t]!).toNat) lx) (h2z : ∀ t, t < nz → v32 X2[t]! = 0) (hS : ∀ t, t < nz → Qa (S t) = wv (wrow (IX[t]!).toNat) lw ∧ (Qa (S t)).natAbs < 2 ^ 31) (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 n, if (expOf (xw k)).toNat ≠ 0 then G k else 0) (hzero : ∀ k, k < n → (expOf (xw k)).toNat = 0 → wv (xw k) lx = 0) : Qa (0 + ∑ s ∈ ZAb 0 nz, sx X0[s]! * S s) + Qa (0 + ∑ s ∈ ZAb 0 nz, sx X1[s]! * S s) * 2 ^ 21 + Qa 0 * 2 ^ 42 = ∑ k ∈ ZAd n, wv (xw k) lx * wv (wrow k) lw := by rw [← QbN n nz hnz IX X0 X1 X2 S xw wrow lx lw hparts hS hG hzero] have hb := fun t (ht : t < nz) => (hparts t ht).1 rw [Qay nz hnz X2 S (fun t ht => (hb t ht).2.2) (fun t ht => (hS t ht).2)] have : ∑ s ∈ ZAd nz, v32 X2[s]! * Qa (S s) = 0 := by apply Finset.sum_eq_zero; intro s hs; rw [h2z s (ZAu hs)]; ring rw [this]; simp [Qa] lemma Qba : QbD = dotOf := rfl def QN (inW : Nat) (relu : Bool) (X W b : Array Word) (i j : Nat) : Word := act relu (dotOf (inW + 1) (fun t => if t < inW then X[i * inW + t]! else oneW) (fun t => if t < inW then W[j * inW + t]! else b[j]!)) lemma Qa7 (inW : Nat) (relu : Bool) (X W b : Array Word) (i j : Nat) : QaT inW relu X W b i j = QN inW relu X W b i j := by unfold QaT QN; rw [Qba] def Qq (inW outW : Nat) (relu : Bool) (X W b : Array Word) (out : Array Word) (k : Nat) : Prop := out.size = k ∧ ∀ q, q < k → out[q]! = QN inW relu X W b (q / outW) (q % outW) lemma Q4 (inW outW : Nat) (relu : Bool) (X W b : Array Word) (out : Array Word) (i j : Nat) (hj : j < outW) (h : Qq inW outW relu X W b out (i * outW + j)) (v : Word) (hv : v = QN inW relu X W b i j) : Qq inW outW relu X W b (out.push v) (i * outW + j + 1) := by obtain ⟨hs, hq⟩ := h refine ⟨by simp [hs], fun q hq' => ?_⟩ rcases ZBp q (i * outW + j) with hlt | hge ·rw [Qaa _ _ _ (by omega)]; exact hq q hlt ·have : q = out.size := by omega subst this rw [Qac, hv, hs] congr 1 ·rw [ZDo, ZDn _ _ (by omega), ZDh hj, ZDl] ·rw [ZDo, ZDb, ZAa hj] lemma QaJ (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i j : Nat) (out : Array Word) (hj : j ≤ outW) (h : Qq inW outW relu X W b out (i * outW + j)) : Qq inW outW relu X W b (QT inW outW relu X W b i j out) ((i + 1) * outW) := by induction j, out using QT.induct inW outW relu X W b i with | case1 j out hj' ih => unfold QT; rw [if_pos hj'] apply ih (by omega) exact Q4 inW outW relu X W b out i j hj' h _ (Qa7 _ _ _ _ _ _ _) | case2 j out hj' => unfold QT; rw [if_neg hj'] have : j = outW := by omega subst this rw [show (i + 1) * j = i * j + j by ring]; exact h def QB (inW : Nat) (relu : Bool) (X W b : Array Word) (i jj base : Nat) (ok : Bool) (a bb c : UInt64) : Prop := ok = true → ∀ w, Qbw relu b[jj]! base a bb c = some w → w = QN inW relu X W b i jj lemma QaO (inW : Nat) (relu : Bool) (X W b : Array Word) (i jj base : Nat) (ok : Bool) (a bb c : UInt64) (h : QB inW relu X W b i jj base ok a bb c) : Qdb inW relu X W b i jj (if ok then Qbw relu b[jj]! base a bb c else none) = QN inW relu X W b i jj := by unfold Qdb split ·rename_i w hw split at hw ·exact h ‹_› w hw ·simp at hw ·exact Qa7 _ _ _ _ _ _ _ lemma QI (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i j base : Nat) (r : Qbf) (ok : Nat → Bool) (out : Array Word) (hj : j < outW) (h : Qq inW outW relu X W b out (i * outW + j)) (g0 : QB inW relu X W b i j base (ok j) r.a0 r.b0 r.c0) (g1 : j + 1 < outW → QB inW relu X W b i (j + 1) base (ok (j + 1)) r.a1 r.b1 r.c1) (g2 : j + 2 < outW → QB inW relu X W b i (j + 2) base (ok (j + 2)) r.a2 r.b2 r.c2) (g3 : j + 3 < outW → QB inW relu X W b i (j + 3) base (ok (j + 3)) r.a3 r.b3 r.c3) : Qq inW outW relu X W b (QP inW outW relu X W b i j base r ok out) (i * outW + min (j + 4) outW) := by unfold QP dsimp only have p0 := Q4 inW outW relu X W b out i j hj h _ (QaO _ _ _ _ _ _ _ _ _ _ _ _ g0) by_cases h1 : j + 1 < outW ·have p1 := Q4 inW outW relu X W b _ i (j + 1) h1 p0 _ (QaO _ _ _ _ _ _ _ _ _ _ _ _ (g1 h1)) rw [if_pos h1] by_cases h2 : j + 2 < outW ·have p2 := Q4 inW outW relu X W b _ i (j + 2) h2 (by rw [← Nat.add_assoc]; exact p1) _ (QaO _ _ _ _ _ _ _ _ _ _ _ _ (g2 h2)) rw [if_pos h2] by_cases h3 : j + 3 < outW ·have p3 := Q4 inW outW relu X W b _ i (j + 3) h3 (by rw [← Nat.add_assoc]; exact p2) _ (QaO _ _ _ _ _ _ _ _ _ _ _ _ (g3 h3)) rw [if_pos h3, show min (j + 4) outW = j + 4 by omega] rw [show i * outW + (j + 4) = i * outW + (j + 3) + 1 by ring]; exact p3 ·rw [if_neg h3, show min (j + 4) outW = j + 3 by omega] rw [show i * outW + (j + 3) = i * outW + (j + 2) + 1 by ring]; exact p2 ·rw [if_neg h2, if_neg (by omega), show min (j + 4) outW = j + 2 by omega] rw [show i * outW + (j + 2) = i * outW + (j + 1) + 1 by ring]; exact p1 ·rw [if_neg h1, if_neg (by omega), if_neg (by omega), show min (j + 4) outW = j + 1 by omega] exact p0 lemma Qc8 (nz n : Nat) (IX : Array UInt32) (p : Nat → Prop) [DecidablePred p] (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 n, if p k then G k else 0) (k : Nat) (hk : k < n) (hp : p k) : ∃ t, t < nz ∧ (IX[t]!).toNat = k := by by_contra hno push_neg at hno have h := hG (fun k' => if k' = k then 1 else 0) have hl : ∑ t ∈ ZAb 0 nz, (fun k' => if k' = k then (1 : Int) else 0) (IX[t]!).toNat = 0 := by apply Finset.sum_eq_zero; intro t ht have := hno t (ZCg ht).2 simp [this] have hr : ∑ k' ∈ ZAb 0 n, (if p k' then (fun k'' => if k'' = k then (1 : Int) else 0) k' else 0) = 1 := by rw [Finset.sum_eq_single k] ·simp [hp] ·intro b _ hb; simp [hb] ·intro hk'; exact absurd (Finset.mem_Ico.mpr ⟨ZAt _, hk⟩) hk' rw [hl, hr] at h; exact absurd h (by norm_num) lemma QbH (inW : Nat) (relu : Bool) (X W b : Array Word) (i jj : Nat) (IX X0 X1 X2 : Array UInt32) (nz : Nat) (hnz : nz < 2048) (lx lw lim : Nat) (hlx : 1 ≤ lx) (hlw : 1 ≤ lw) (S : Nat → UInt64) (hS : ∀ t, t < nz → Qa (S t) = wv W[jj * inW + (IX[t]!).toNat]! lw ∧ (Qa (S t)).natAbs < 2 ^ 31) (hparts : ∀ t, t < nz → QV X0 X1 X2 t ∧ (lim ≤ 18 → v32 X2[t]! = 0) ∧ pv X0 X1 X2 t = wv X[i * inW + (IX[t]!).toNat]! lx) (hxok : ∀ k, k < inW → XOk X (i * inW) lx lim k) (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 inW, if (expOf X[i * inW + k]!).toNat ≠ 0 then G k else 0) (hwfin : ∀ k, k < inW → expOf W[jj * inW + k]! ≠ 255) (hwwin : ∀ k, k < inW → expOf X[i * inW + k]! ≠ 0 → ((expOf W[jj * inW + k]! = 0 ∧ fracOf W[jj * inW + k]! = 0) ∨ lw ≤ (expOf W[jj * inW + k]!).toNat)) (a bb c : UInt64) (ok : Bool) (ha : a = 0 + ∑ s ∈ ZAb 0 nz, sx X0[s]! * S s) (hb : bb = 0 + ∑ s ∈ ZAb 0 nz, sx X1[s]! * S s) (hc : c = 0 + ∑ s ∈ ZAb 0 nz, sx X2[s]! * S s ∨ (lim ≤ 18 ∧ c = 0)) : QB inW relu X W b i jj (lx + lw - 2) ok a bb c := by intro _ w hw have hzero : ∀ k, k < inW → (expOf X[i * inW + k]!).toNat = 0 → wv X[i * inW + k]! lx = 0 := by intro k hk he have hx := hxok k hk unfold XOk at hx have hf := hx.2.1 he have he' : expOf X[i * inW + k]! = 0 := ZAk (by simpa using he) have hf' : fracOf X[i * inW + k]! = 0 := ZAk (by simpa using hf) unfold wv; rw [QG _ he' hf']; ring have hlanes : Qa a + Qa bb * 2 ^ 21 + Qa c * 2 ^ 42 = ∑ k ∈ ZAd inW, wv X[i * inW + k]! lx * wv W[jj * inW + k]! lw := by rcases hc with hc | ⟨h18, hc⟩ ·rw [ha, hb, hc] exact QbN inW nz hnz IX X0 X1 X2 S (fun k => X[i * inW + k]!) (fun k => W[jj * inW + k]!) lx lw (fun t ht => ⟨(hparts t ht).1, (hparts t ht).2.2⟩) hS hG hzero ·rw [ha, hb, hc] exact Qcu inW nz hnz IX X0 X1 X2 S (fun k => X[i * inW + k]!) (fun k => W[jj * inW + k]!) lx lw (fun t ht => ⟨(hparts t ht).1, (hparts t ht).2.2⟩) (fun t ht => (hparts t ht).2.1 h18) hS hG hzero unfold QN rw [Qb3 inW relu X W b i jj lx lw hlx hlw ?_ hwfin hwwin a bb c hlanes w hw] intro k hk have hx := hxok k hk unfold XOk at hx refine ⟨fun h' => hx.1 (by rw [h']; rfl), ?_⟩ by_cases he : (expOf X[i * inW + k]!).toNat = 0 ·left exact ⟨ZAk (by simpa using he), ZAk (by simpa using hx.2.1 he)⟩ ·right; exact (hx.2.2 he).1 lemma QbK (nz n : Nat) (IX : Array UInt32) (p : Nat → Prop) [DecidablePred p] (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 n, if p k then G k else 0) (hfull : nz = n) (k : Nat) (hk : k < n) : p k := by by_contra hp have h := hG (fun _ => 1) simp only [ZCx, Nat.card_Ico, Nat.sub_zero, nsmul_eq_mul, mul_one] at h have hle : ∑ k' ∈ ZAb 0 n, (if p k' then (1 : Int) else 0) ≤ ((n - 1 : Nat) : Int) := by have hsplit : ∑ k' ∈ ZAb 0 n, (if p k' then (1 : Int) else 0) = ∑ k' ∈ (ZAb 0 n).erase k, (if p k' then (1 : Int) else 0) := by rw [← Finset.add_sum_erase _ _ (Finset.mem_Ico.mpr ⟨ZAt _, hk⟩), if_neg hp, zero_add] rw [hsplit] calc ∑ k' ∈ (ZAb 0 n).erase k, (if p k' then (1 : Int) else 0) ≤ ∑ _k' ∈ (ZAb 0 n).erase k, (1 : Int) := ZCf fun _ _ => by split <;> norm_num _ = ((n - 1 : Nat) : Int) := by rw [ZCx, Finset.card_erase_of_mem (Finset.mem_Ico.mpr ⟨ZAt _, hk⟩), Nat.card_Ico] simp have : (nz : Int) ≤ ((n - 1 : Nat) : Int) := by rw [← h] at hle; exact_mod_cast hle omega lemma QbT (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i jj : Nat) (hjj : jj < outW) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (IX X0 X1 X2 : Array UInt32) (nz : Nat) (hnz : nz < 2048) (hnzle : nz ≤ inW) (lx lw lim : Nat) (hlx : 1 ≤ lx) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (o : USize) (hoe : o.toNat = lw * 256) (ho : o.toNat ≤ 65280) (hparts : ∀ t, t < nz → QV X0 X1 X2 t ∧ (lim ≤ 18 → v32 X2[t]! = 0) ∧ pv X0 X1 X2 t = wv X[i * inW + (IX[t]!).toNat]! lx) (hxok : ∀ k, k < inW → XOk X (i * inW) lx lim k) (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 inW, if (expOf X[i * inW + k]!).toNat ≠ 0 then G k else 0) (hguard : nz = inW ∨ ∀ k, k < inW → expOf W[jj * inW + k]! ≠ 255) (wr : USize) (hwrd : wr = (jj * inW).toUSize) (a bb c chk : UInt64) (ha : a = 0 + ∑ s ∈ ZAb 0 nz, sx X0[s]! * sx (Qi (wAt W IX wr s) (Qf o ho (wAt W IX wr s))).toUInt32) (hb : bb = 0 + ∑ s ∈ ZAb 0 nz, sx X1[s]! * sx (Qi (wAt W IX wr s) (Qf o ho (wAt W IX wr s))).toUInt32) (hc : c = 0 + ∑ s ∈ ZAb 0 nz, sx X2[s]! * sx (Qi (wAt W IX wr s) (Qf o ho (wAt W IX wr s))).toUInt32 ∨ (lim ≤ 18 ∧ c = 0)) (hchk : chk.toNat < 2 ^ 31 → ∀ s, s < nz → (Qf o ho (wAt W IX wr s)).toNat < 2 ^ 31) : QB inW relu X W b i jj (lx + lw - 2) (decide (chk < 0x80000000)) a bb c := by intro hok have hc31 : chk.toNat < 2 ^ 31 := by simpa [ZAr] using hok have hm := hchk hc31 have hwr : ∀ s, wAt W IX wr s = W[jj * inW + (IX[s]!).toNat]! := by intro s; unfold wAt; rw [hwrd, Qc _ (ZZa hjj hWsz hWs).1] have hmk : ∀ k, k < inW → (expOf X[i * inW + k]!).toNat ≠ 0 → (Qf o ho W[jj * inW + k]!).toNat < 2 ^ 31 := by intro k hk hne obtain ⟨t, ht, hIt⟩ := Qc8 nz inW IX _ hG k hk hne have := hm t ht; rw [hwr, hIt] at this; exact this have hwspec := fun k hk hne => QaF lw hlw o hoe ho W[jj * inW + k]! (hmk k hk hne) apply QbH inW relu X W b i jj IX X0 X1 X2 nz hnz lx lw lim hlx hlw1 (fun s => sx (Qi (wAt W IX wr s) (Qf o ho (wAt W IX wr s))).toUInt32) _ hparts hxok hG _ _ a bb c true ha hb hc rfl ·intro t ht have hb31 := (QbL lw hlw o hoe ho _ (hm t ht)).2 show Qa (sx (Qi (wAt W IX wr t) (Qf o ho (wAt W IX wr t))).toUInt32) = _ ∧ _ rw [Qcl _ (by omega)] rw [hwr]; exact QbL lw hlw o hoe ho _ (by rw [← hwr]; exact hm t ht) ·intro k hk rcases hguard with hfull | hg ·have hne := QbK nz inW IX _ hG hfull k hk obtain ⟨_, hm2⟩ := hwspec k hk hne rcases hm2 with hm0 | ⟨_, h255, _⟩ ·intro h'; unfold mantOf at hm0; rw [h'] at hm0; simp at hm0 ·exact fun h' => h255 (by rw [h']; rfl) ·exact hg k hk ·intro k hk hne have hne' : (expOf X[i * inW + k]!).toNat ≠ 0 := fun h' => hne (ZAk (by simpa using h')) obtain ⟨_, hm2⟩ := hwspec k hk hne' rcases hm2 with hm0 | ⟨_, _, hle, _⟩ ·left unfold mantOf at hm0 by_cases he : expOf W[jj * inW + k]! = 0 ·rw [if_pos he] at hm0 exact ⟨he, ZAk (by simpa using hm0)⟩ ·rw [if_neg he] at hm0; omega ·right; exact hle lemma Qbx (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (IX X0 X1 X2 : Array UInt32) (nz : USize) (wide : Bool) (o : USize) (ho : o.toNat ≤ 65280) (base : Nat) (hI : nz.toNat ≤ IX.size) (h0 : nz.toNat ≤ X0.size) (h1 : nz.toNat ≤ X1.size) (h2 : nz.toNat ≤ X2.size) (hIX : ∀ s, s < nz.toNat → (IX[s]!).toNat < inW) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (hnz : nz.toNat < 2048) (hnzle : nz.toNat ≤ inW) (lx lw : Nat) (hlx : 1 ≤ lx) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hoe : o.toNat = lw * 256) (hbase : base = lx + lw - 2) (lim : Nat) (hwl : wide = false → lim ≤ 18) (hparts : ∀ t, t < nz.toNat → QV X0 X1 X2 t ∧ (lim ≤ 18 → v32 X2[t]! = 0) ∧ pv X0 X1 X2 t = wv X[i * inW + (IX[t]!).toNat]! lx) (hxok : ∀ k, k < inW → XOk X (i * inW) lx lim k) (hG : ∀ G : Nat → Int, ∑ t ∈ ZAb 0 nz.toNat, G (IX[t]!).toNat = ∑ k ∈ ZAb 0 inW, if (expOf X[i * inW + k]!).toNat ≠ 0 then G k else 0) (hguard : nz.toNat = inW ∨ ∀ jj, jj < outW → ∀ k, k < inW → expOf W[jj * inW + k]! ≠ 255) (j : Nat) (out : Array Word) (h : Qq inW outW relu X W b out (i * outW + min j outW)) : Qq inW outW relu X W b (Qu inW outW relu X W b i IX X0 X1 X2 nz wide o ho base hI h0 h1 h2 hIX hWsz hWs j out) ((i + 1) * outW) := by induction j, out using Qu.induct inW outW relu X W b i IX X0 X1 X2 nz wide o ho base hI h0 h1 h2 hIX hWsz hWs with | case1 j out hj w0 w1 w2 w3 hr r ok ih => have heq : Qu inW outW relu X W b i IX X0 X1 X2 nz wide o ho base hI h0 h1 h2 hIX hWsz hWs j out = Qu inW outW relu X W b i IX X0 X1 X2 nz wide o ho base hI h0 h1 h2 hIX hWsz hWs (j + 4) (QP inW outW relu X W b i j base r (fun _ => ok) out) := by conv_lhs => unfold Qu simp only [dite_cond_eq_true (eq_true hj)] rfl rw [heq] apply ih rw [show min j outW = j by omega] at h have hg : ∀ jj, jj < outW → (nz.toNat = inW ∨ ∀ k, k < inW → expOf W[jj * inW + k]! ≠ 255) := by intro jj hjj; rcases hguard with hf | hg ·exact Or.inl hf ·exact Or.inr (hg jj hjj) have L := fun (jj : Nat) (hjj : jj < outW) (wr : USize) (hwr : wr = (jj * inW).toUSize) (a bb c chk : UInt64) => QbT inW outW relu X W b i jj hjj hWsz hWs IX X0 X1 X2 nz.toNat hnz hnzle lx lw lim hlx hlw1 hlw o hoe ho hparts hxok hG (hg jj hjj) wr hwr a bb c chk rw [hbase] at * have hw0 : w0 = (j * inW).toUSize := rfl have hw1 : j + 1 < outW → w1 = ((j + 1) * inW).toUSize := fun h' => by show ((if j + 1 < outW then j + 1 else j) * inW).toUSize = _; rw [if_pos h'] have hw2 : j + 2 < outW → w2 = ((j + 2) * inW).toUSize := fun h' => by show ((if j + 2 < outW then j + 2 else j) * inW).toUSize = _; rw [if_pos h'] have hw3 : j + 3 < outW → w3 = ((j + 3) * inW).toUSize := fun h' => by show ((if j + 3 < outW then j + 3 else j) * inW).toUSize = _; rw [if_pos h'] have z : ∀ s : Nat, (0 : USize).toNat ≤ s := fun s => ZAt _ simp only [ok, r] by_cases hw : wide = true <;> simp only [hw, ite_true, ite_false, dite_true, dite_false, ZAp] · obtain ⟨e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, ec⟩ := QcC IX X0 X1 X2 W o ho w0 w1 w2 w3 nz hI h0 h1 h2 hr hWs 0 0 0 0 0 0 0 0 0 0 0 0 0 0 simp only [ZCb] at e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11 apply QI inW outW relu X W b i j (lx + lw - 2) _ _ out hj h ·exact L j hj w0 hw0 _ _ _ _ e0 e1 (Or.inl e2) (fun hc s hs => ((ec hc).2 s (z s) hs).1) ·intro h1' exact L (j + 1) h1' w1 (hw1 h1') _ _ _ _ e3 e4 (Or.inl e5) (fun hc s hs => ((ec hc).2 s (z s) hs).2.1) ·intro h2' exact L (j + 2) h2' w2 (hw2 h2') _ _ _ _ e6 e7 (Or.inl e8) (fun hc s hs => ((ec hc).2 s (z s) hs).2.2.1) ·intro h3' exact L (j + 3) h3' w3 (hw3 h3') _ _ _ _ e9 e10 (Or.inl e11) (fun hc s hs => ((ec hc).2 s (z s) hs).2.2.2) · obtain ⟨e0, e1, e2, e3, e4, e5, e6, e7, ec⟩ := QcH IX X0 X1 W o ho w0 w1 w2 w3 nz hI h0 h1 hr hWs 0 0 0 0 0 0 0 0 0 0 simp only [ZCb] at e0 e1 e2 e3 e4 e5 e6 e7 have h18 : lim ≤ 18 := hwl (by simpa using hw) apply QI inW outW relu X W b i j (lx + lw - 2) _ _ out hj h ·exact L j hj w0 hw0 _ _ _ _ e0 e1 (Or.inr ⟨h18, rfl⟩) (fun hc s hs => ((ec hc).2 s (z s) hs).1) ·intro h1' exact L (j + 1) h1' w1 (hw1 h1') _ _ _ _ e2 e3 (Or.inr ⟨h18, rfl⟩) (fun hc s hs => ((ec hc).2 s (z s) hs).2.1) ·intro h2' exact L (j + 2) h2' w2 (hw2 h2') _ _ _ _ e4 e5 (Or.inr ⟨h18, rfl⟩) (fun hc s hs => ((ec hc).2 s (z s) hs).2.2.1) ·intro h3' exact L (j + 3) h3' w3 (hw3 h3') _ _ _ _ e6 e7 (Or.inr ⟨h18, rfl⟩) (fun hc s hs => ((ec hc).2 s (z s) hs).2.2.2) | case2 j out hj => unfold Qu; simp only [dite_cond_eq_false (eq_false hj)] rw [show min j outW = outW by omega] at h rw [show (i + 1) * outW = i * outW + outW by ring]; exact h lemma QcT (wide : Bool) : (if wide then 39 else 18 : UInt32) ≤ 39 := by cases wide <;> decide lemma QcS (wide : Bool) : wide = false → (if wide then 39 else 18 : UInt32).toNat ≤ 18 := by intro h; subst h; decide lemma Qbk (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (o : USize) (ho : o.toNat ≤ 65280) (lw : Nat) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hoe : o.toNat = lw * 256) (lx lim : UInt32) (wide : Bool) (hlim : lim ≤ 39) (hwl : wide = false → lim.toNat ≤ 18) (hXsz : (i + 1) * inW ≤ X.size) (hWsz : outW * inW ≤ W.size) (hXs : X.size < 2 ^ 32) (hWs : W.size < 2 ^ 32) (hin : inW < 2048) (out : Array Word) (h : Qq inW outW relu X W b out (i * outW)) : Qq inW outW relu X W b (Qax inW outW relu X W b i o ho lw lx lim wide hXsz hWsz hXs hWs hin out) ((i + 1) * outW) := by unfold Qax dsimp only split ·rename_i hcond simp only [ZAx, decide_eq_true_eq, ZCd, beq_iff_eq, bne_iff_ne, ne_eq] at hcond obtain ⟨⟨hok, hlx⟩, hguard⟩ := hcond have hn : inW.toUSize.toNat = inW := Qc _ (by omega) have hxo : (i * inW).toUSize.toNat = i * inW := Qc _ (ZZb hXsz hXs).1 have hz : inW.toUSize.toNat ≤ (ZBv inW (0 : UInt32)).size := by simp [hn] have hXb : (i * inW).toUSize.toNat + inW.toUSize.toNat ≤ X.size := by rw [hn, hxo]; exact (ZZb hXsz hXs).2 obtain ⟨-, hcnt, -⟩ := Qbn X (i * inW).toUSize inW.toUSize lx lim hXb hXs _ hz obtain ⟨_, hsem⟩ := Qc4 X (i * inW).toUSize inW.toUSize lx lim hXb hXs hlim 0 0 (ZBv inW 0) (ZBv inW 0) (ZBv inW 0) (ZBv inW 0) (by simp) ⟨hz, hz, hz, hz⟩ true (by simp) obtain ⟨-, hxok, -, hnew, hG⟩ := hsem hok simp only [ZCb, hxo] at hxok hnew hG have hcnt' := le_of_le_of_eq hcnt hn have hlx1 : 1 ≤ lx.toNat := hlx apply Qbx inW outW relu X W b i _ _ _ _ _ wide o ho _ _ _ _ _ _ hWsz hWs (by omega) hcnt' lx.toNat lw hlx1 hlw1 hlw hoe rfl lim.toNat hwl ·intro t ht obtain ⟨p1, p2, p3⟩ := hnew t (ZAt _) ht exact ⟨p1, fun h18 => p2 h18, p3⟩ ·intro k hk; exact hxok k (ZAt _) (by rw [hn]; exact hk) ·intro G; exact (hG G).trans (by rw [hn]) ·rcases hguard with hfull | hor ·left; omega ·right intro jj hjj k hk have hsz : (outW * inW).toUSize.toNat = outW * inW := Qc _ (by omega) have hlt : jj * inW + k < outW * inW := by have := ZZc inW hjj omega exact (Qcz W (outW * inW).toUSize (by rw [hsz]; omega) 0 0 (by simp) hor).2 (jj * inW + k) (by simp) (by rw [hsz]; exact hlt) ·simpa using h ·exact QaJ inW outW relu X W b i 0 out (ZAt _) (by simpa using h) lemma Qci (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (o : USize) (ho : o.toNat ≤ 65280) (lw : Nat) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hoe : o.toNat = lw * 256) (hXsz : (i + 1) * inW ≤ X.size) (hWsz : outW * inW ≤ W.size) (hXs : X.size < 2 ^ 32) (hWs : W.size < 2 ^ 32) (hin : inW < 2048) (out : Array Word) (h : Qq inW outW relu X W b out (i * outW)) : Qq inW outW relu X W b (QbX inW outW relu X W b i o ho lw hXsz hWsz hXs hWs hin out) ((i + 1) * outW) := by unfold QbX exact Qbk inW outW relu X W b i o ho lw hlw1 hlw hoe _ _ _ (QcT _) (QcS _) hXsz hWsz hXs hWs hin out h lemma Qb4 (rows inW outW : Nat) (relu : Bool) (X W b : Array Word) (o : USize) (ho : o.toNat ≤ 65280) (lw : Nat) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hoe : o.toNat = lw * 256) (hXsz : rows * inW ≤ X.size) (hWsz : outW * inW ≤ W.size) (hXs : X.size < 2 ^ 32) (hWs : W.size < 2 ^ 32) (hin : inW < 2048) (i : Nat) (out : Array Word) (hi : i ≤ rows) (h : Qq inW outW relu X W b out (i * outW)) : Qq inW outW relu X W b (Q6 rows inW outW relu X W b o ho lw hXsz hWsz hXs hWs hin i out) (rows * outW) := by induction i, out using Q6.induct rows inW outW relu X W b o ho lw hXsz hWsz hXs hWs hin with | case1 i out hi' ih => unfold Q6; simp only [dite_cond_eq_true (eq_true hi')] exact ih (by omega) (Qci inW outW relu X W b i o ho lw hlw1 hlw hoe _ hWsz hXs hWs hin out h) | case2 i out hi' => unfold Q6; simp only [dite_cond_eq_false (eq_false hi')] have : i = rows := by omega subst this; exact h lemma QM (D : Array UInt32) (w t : USize) (n : Nat) (ht : t.toNat < n) (hw : w.toNat + n ≤ D.size) (hDs : D.size < 2 ^ 32) : (D.uget (w + t) (QE D w t n ht hw hDs)).toUInt64 = (D[w.toNat + t.toNat]!).toUInt64 := by rw [Qk, Qe _ _ (by omega)] lemma Qcq (U0 U1 D : Array UInt32) (w0 w1 w2 w3 n : USize) (h0 : n.toNat ≤ U0.size) (h1 : n.toNat ≤ U1.size) (hW : Qx D n.toNat w0 w1 w2 w3) (hDs : D.size < 2 ^ 32) (t : USize) (a0 b0 a1 b1 a2 b2 a3 b3 : UInt64) : let r := QaS U0 U1 D w0 w1 w2 w3 n h0 h1 hW hDs t a0 b0 a1 b1 a2 b2 a3 b3 r.a0 = a0 + ∑ s ∈ ZAb t.toNat n.toNat, (U0[s]!).toUInt64 * (D[w0.toNat + s]!).toUInt64 ∧ r.b0 = b0 + ∑ s ∈ ZAb t.toNat n.toNat, (U1[s]!).toUInt64 * (D[w0.toNat + s]!).toUInt64 ∧ r.a1 = a1 + ∑ s ∈ ZAb t.toNat n.toNat, (U0[s]!).toUInt64 * (D[w1.toNat + s]!).toUInt64 ∧ r.b1 = b1 + ∑ s ∈ ZAb t.toNat n.toNat, (U1[s]!).toUInt64 * (D[w1.toNat + s]!).toUInt64 ∧ r.a2 = a2 + ∑ s ∈ ZAb t.toNat n.toNat, (U0[s]!).toUInt64 * (D[w2.toNat + s]!).toUInt64 ∧ r.b2 = b2 + ∑ s ∈ ZAb t.toNat n.toNat, (U1[s]!).toUInt64 * (D[w2.toNat + s]!).toUInt64 ∧ r.a3 = a3 + ∑ s ∈ ZAb t.toNat n.toNat, (U0[s]!).toUInt64 * (D[w3.toNat + s]!).toUInt64 ∧ r.b3 = b3 + ∑ s ∈ ZAb t.toNat n.toNat, (U1[s]!).toUInt64 * (D[w3.toNat + s]!).toUInt64 := by induction t, a0, b0, a1, b1, a2, b2, a3, b3 using QaS.induct U0 U1 D w0 w1 w2 w3 n h0 h1 hW hDs with | case1 t a0 b0 a1 b1 a2 b2 a3 b3 h ht x0 x1 d0 d1 d2 d3 ih => unfold QaS simp only [dite_cond_eq_true (eq_true h)] obtain ⟨e0, e1, e2, e3, e4, e5, e6, e7⟩ := ih have hsucc := Qd t n h have hx0 : x0 = (U0[t.toNat]!).toUInt64 := by simp only [x0, Qk] have hx1 : x1 = (U1[t.toNat]!).toUInt64 := by simp only [x1, Qk] have hd0 : d0 = (D[w0.toNat + t.toNat]!).toUInt64 := QM D w0 t _ ht hW.1 hDs have hd1 : d1 = (D[w1.toNat + t.toNat]!).toUInt64 := QM D w1 t _ ht hW.2.1 hDs have hd2 : d2 = (D[w2.toNat + t.toNat]!).toUInt64 := QM D w2 t _ ht hW.2.2.1 hDs have hd3 : d3 = (D[w3.toNat + t.toNat]!).toUInt64 := QM D w3 t _ ht hW.2.2.2 hDs rw [hsucc] at e0 e1 e2 e3 e4 e5 e6 e7 refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ ·rw [e0, Qb _ _ _ ht, ← add_assoc]; simp only [hx0, hd0] ·rw [e1, Qb _ _ _ ht, ← add_assoc]; simp only [hx1, hd0] ·rw [e2, Qb _ _ _ ht, ← add_assoc]; simp only [hx0, hd1] ·rw [e3, Qb _ _ _ ht, ← add_assoc]; simp only [hx1, hd1] ·rw [e4, Qb _ _ _ ht, ← add_assoc]; simp only [hx0, hd2] ·rw [e5, Qb _ _ _ ht, ← add_assoc]; simp only [hx1, hd2] ·rw [e6, Qb _ _ _ ht, ← add_assoc]; simp only [hx0, hd3] ·rw [e7, Qb _ _ _ ht, ← add_assoc]; simp only [hx1, hd3] | case2 t a0 b0 a1 b1 a2 b2 a3 b3 h => unfold QaS simp only [dite_cond_eq_false (eq_false h)] have : ¬ t.toNat < n.toNat := fun h' => h (ZAz h') have he : ZAb t.toNat n.toNat = ∅ := ZBu (by omega) simp only [he, ZDi, add_zero, and_self] lemma Qa1 (U0 U1 U2 D : Array UInt32) (w0 w1 n : USize) (h0 : n.toNat ≤ U0.size) (h1 : n.toNat ≤ U1.size) (h2 : n.toNat ≤ U2.size) (hW : Qx D n.toNat w0 w1 w0 w1) (hDs : D.size < 2 ^ 32) (t : USize) (a0 b0 c0 a1 b1 c1 : UInt64) : let r := Qad U0 U1 U2 D w0 w1 n h0 h1 h2 hW hDs t a0 b0 c0 a1 b1 c1 r.a0 = a0 + ∑ s ∈ ZAb t.toNat n.toNat, (U0[s]!).toUInt64 * (D[w0.toNat + s]!).toUInt64 ∧ r.b0 = b0 + ∑ s ∈ ZAb t.toNat n.toNat, (U1[s]!).toUInt64 * (D[w0.toNat + s]!).toUInt64 ∧ r.c0 = c0 + ∑ s ∈ ZAb t.toNat n.toNat, (U2[s]!).toUInt64 * (D[w0.toNat + s]!).toUInt64 ∧ r.a1 = a1 + ∑ s ∈ ZAb t.toNat n.toNat, (U0[s]!).toUInt64 * (D[w1.toNat + s]!).toUInt64 ∧ r.b1 = b1 + ∑ s ∈ ZAb t.toNat n.toNat, (U1[s]!).toUInt64 * (D[w1.toNat + s]!).toUInt64 ∧ r.c1 = c1 + ∑ s ∈ ZAb t.toNat n.toNat, (U2[s]!).toUInt64 * (D[w1.toNat + s]!).toUInt64 := by induction t, a0, b0, c0, a1, b1, c1 using Qad.induct U0 U1 U2 D w0 w1 n h0 h1 h2 hW hDs with | case1 t a0 b0 c0 a1 b1 c1 h ht x0 x1 x2 d0 d1 ih => unfold Qad simp only [dite_cond_eq_true (eq_true h)] obtain ⟨e0, e1, e2, e3, e4, e5⟩ := ih have hsucc := Qd t n h have hx0 : x0 = (U0[t.toNat]!).toUInt64 := by simp only [x0, Qk] have hx1 : x1 = (U1[t.toNat]!).toUInt64 := by simp only [x1, Qk] have hx2 : x2 = (U2[t.toNat]!).toUInt64 := by simp only [x2, Qk] have hd0 : d0 = (D[w0.toNat + t.toNat]!).toUInt64 := QM D w0 t _ ht hW.1 hDs have hd1 : d1 = (D[w1.toNat + t.toNat]!).toUInt64 := QM D w1 t _ ht hW.2.1 hDs rw [hsucc] at e0 e1 e2 e3 e4 e5 refine ⟨?_, ?_, ?_, ?_, ?_, ?_⟩ ·rw [e0, Qb _ _ _ ht, ← add_assoc]; simp only [hx0, hd0] ·rw [e1, Qb _ _ _ ht, ← add_assoc]; simp only [hx1, hd0] ·rw [e2, Qb _ _ _ ht, ← add_assoc]; simp only [hx2, hd0] ·rw [e3, Qb _ _ _ ht, ← add_assoc]; simp only [hx0, hd1] ·rw [e4, Qb _ _ _ ht, ← add_assoc]; simp only [hx1, hd1] ·rw [e5, Qb _ _ _ ht, ← add_assoc]; simp only [hx2, hd1] | case2 t a0 b0 c0 a1 b1 c1 h => unfold Qad simp only [dite_cond_eq_false (eq_false h)] have : ¬ t.toNat < n.toNat := fun h' => h (ZAz h') have he : ZAb t.toNat n.toNat = ∅ := ZBu (by omega) simp only [he, ZDi, add_zero, and_self] def uv (u : UInt32) : Int := (u.toNat : Int) - 2 ^ 21 def pvD (U0 U1 U2 : Array UInt32) (t : Nat) : Int := uv U0[t]! + uv U1[t]! * 2 ^ 21 + uv U2[t]! * 2 ^ 42 def Qaw (U0 U1 U2 : Array UInt32) (t : Nat) : Prop := (uv U0[t]!).natAbs < 2 ^ 21 ∧ (uv U1[t]!).natAbs < 2 ^ 21 ∧ (uv U2[t]!).natAbs < 2 ^ 21 lemma QW (neg : Bool) (p : UInt64) (hp : p.toNat < 2 ^ 21) : uv (Qb8 neg p).toUInt32 = if neg then -(p.toNat : Int) else p.toNat := by unfold uv Qb8 have c : (0x200000 : UInt64).toNat = 2 ^ 21 := rfl cases neg ·simp only [ZAp, ite_false, ZBc, ZAl, c] rw [ZAa (by omega), ZAa (by omega)]; push_cast; ring ·have hle : p ≤ (0x200000 : UInt64) := ZCh (by rw [c]; omega) simp only [ite_true, ZBc] rw [ZAf _ _ hle, c, ZAa (by omega)] omega lemma Qcg (w lx lim : UInt32) (he0 : (expOf w).toNat ≠ 0) (hlx : lx ≤ (w >>> 23) &&& 0xFF) (hd : ((w >>> 23) &&& 0xFF) - lx ≤ lim) (h18 : lim.toNat ≤ 18) : ((((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< (((w >>> 23) &&& 0xFF) - lx).toUInt64) >>> 42).toNat = 0 := by have he : (w >>> 23) &&& 0xFF = expOf w := rfl have hdn : ((expOf w) - lx).toNat = (expOf w).toNat - lx.toNat := ZBw _ _ (by rw [he] at hlx; exact hlx) have hd18 : (expOf w).toNat - lx.toNat ≤ 18 := by have : ((expOf w) - lx).toNat ≤ lim.toNat := by rw [he] at hd; exact hd omega have hml := mantOf_lt_24 w have hmant : mantOf w = 2 ^ 23 + (fracOf w).toNat := by have : expOf w ≠ 0 := fun h' => he0 (by simp [h']) simp [mantOf, this] have hfr : (fracOf w).toNat = (w &&& 0x7FFFFF).toNat := rfl have hf := Q1 w have hm23 : ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64.toNat = mantOf w := by rw [ZAw, ZBn, hmant, hfr] rw [QH _ _ 23 hf (by norm_num)]; norm_num; omega rw [ZAv, ZAi, hm23, he] have : ((expOf w - lx).toUInt64.toNat % 64) = (expOf w).toNat - lx.toNat := by simp only [ZAw, hdn]; omega rw [this, ZAe, show (42 : UInt64).toNat % 64 = 42 from rfl, ZAo] have hlt : mantOf w * 2 ^ ((expOf w).toNat - lx.toNat) < 2 ^ 42 := by calc mantOf w * 2 ^ ((expOf w).toNat - lx.toNat) < 2 ^ 24 * 2 ^ 18 := ZAg hml (ZAm (by norm_num) hd18) (by positivity) _ = 2 ^ 42 := by norm_num rw [ZAa (by omega)] exact ZDh hlt lemma QcU (X : Array UInt32) (o n : USize) (lx lim : UInt32) (hX : o.toNat + n.toNat ≤ X.size) (hXs : X.size < 2 ^ 32) (hlim : lim ≤ 39) (k : USize) (U0 U1 U2 : Array UInt32) (hs : n.toNat ≤ U0.size ∧ n.toNat ≤ U1.size ∧ n.toNat ≤ U2.size) (s0 s1 s2 : UInt64) (ok : Bool) (hkn : k.toNat ≤ n.toNat) : let r := Qv X o n lx lim hX hXs k U0 U1 U2 hs s0 s1 s2 ok (∀ t, t < k.toNat → r.1[t]! = U0[t]! ∧ r.2.1[t]! = U1[t]! ∧ r.2.2.1[t]! = U2[t]!) ∧ r.2.2.2.1 = s0 + ∑ t ∈ ZAb k.toNat n.toNat, (r.1[t]!).toUInt64 ∧ r.2.2.2.2.1 = s1 + ∑ t ∈ ZAb k.toNat n.toNat, (r.2.1[t]!).toUInt64 ∧ r.2.2.2.2.2.1 = s2 + ∑ t ∈ ZAb k.toNat n.toNat, (r.2.2.1[t]!).toUInt64 ∧ (r.2.2.2.2.2.2 = true → ok = true ∧ ∀ k', k.toNat ≤ k' → k' < n.toNat → XOk X o.toNat lx.toNat lim.toNat k' ∧ Qaw r.1 r.2.1 r.2.2.1 k' ∧ (lim.toNat ≤ 18 → uv r.2.2.1[k']! = 0) ∧ pvD r.1 r.2.1 r.2.2.1 k' = wv X[o.toNat + k']! lx.toNat) := by induction k, U0, U1, U2, hs, s0, s1, s2, ok using Qv.induct X o n lx lim hX hXs with | case1 k U0 U1 U2 hs s0 s1 s2 ok h hk w e d mag neg q0 q1 q2 ih => have hw : w = X[o.toNat + k.toNat]! := by simp only [w]; rw [Qk, Qe _ _ (by omega)] have heq : Qv X o n lx lim hX hXs k U0 U1 U2 hs s0 s1 s2 ok = Qv X o n lx lim hX hXs (k + 1) (U0.uset k q0 (by omega)) (U1.uset k q1 (by omega)) (U2.uset k q2 (by omega)) (by simp only [ZBz]; exact hs) (s0 + q0.toUInt64) (s1 + q1.toUInt64) (s2 + q2.toUInt64) (ok && if _h : (e == 0) = true then (w &&& 0x7FFFFF) == 0 else e != 255 && decide (lx ≤ e) && decide (d ≤ lim)) := by conv_lhs => unfold Qv simp only [dite_cond_eq_true (eq_true h)] rfl rw [heq] have hk1 := Qd k n h obtain ⟨kept, sum0, sum1, sum2, sem⟩ := ih (by omega) rw [hk1] at kept sum0 sum1 sum2 sem have hat : ∀ (A : Array UInt32) (q : UInt32) (hA : k.toNat < A.size) (R : Array UInt32), (∀ t, t < k.toNat + 1 → R[t]! = (A.uset k q hA)[t]!) → R[k.toNat]! = q := by intro A q hA R hR; rw [hR _ (by omega), Qg, if_pos rfl] have r0 := hat U0 q0 (by omega) _ (fun t ht => (kept t ht).1) have r1 := hat U1 q1 (by omega) _ (fun t ht => (kept t ht).2.1) have r2 := hat U2 q2 (by omega) _ (fun t ht => (kept t ht).2.2) refine ⟨?_, ?_, ?_, ?_, ?_⟩ ·intro t ht obtain ⟨o1, o2, o3⟩ := kept t (by omega) rw [o1, o2, o3, Qg, Qg, Qg, if_neg (by omega), if_neg (by omega), if_neg (by omega)] exact ⟨rfl, rfl, rfl⟩ ·rw [sum0, Qb _ _ _ hk]; simp only [r0, add_assoc] ·rw [sum1, Qb _ _ _ hk]; simp only [r1, add_assoc] ·rw [sum2, Qb _ _ _ hk]; simp only [r2, add_assoc] ·intro hfin obtain ⟨hok', hrest⟩ := sem hfin simp only [ZAx] at hok' obtain ⟨hok, hcond⟩ := hok' refine ⟨hok, fun k' hk1' hk2' => ?_⟩ rcases ZBp k' (k.toNat + 1) with hlt | hge ·have hk' : k' = k.toNat := by omega subst hk' unfold XOk Qaw pvD rw [r0, r1, r2, ← hw] by_cases he0 : e = 0 · have he' : expOf w = 0 := he0 have hcz : (w &&& 0x7FFFFF) = 0 := by have := hcond; simp only [he0, beq_self_eq_true, dite_true, beq_iff_eq] at this; exact this have hmag : mag = 0 := by simp only [mag, he0, beq_self_eq_true, dite_true] have z0 : uv q0 = 0 := by simp only [q0, hmag, UInt64.zero_and]; rw [QW _ _ (by decide)]; split <;> simp have z1 : uv q1 = 0 := by simp only [q1, hmag, UInt64.zero_shiftRight, UInt64.zero_and]; rw [QW _ _ (by decide)]; split <;> simp have z2 : uv q2 = 0 := by simp only [q2, hmag, UInt64.zero_shiftRight]; rw [QW _ _ (by decide)]; split <;> simp have hfz : fracOf w = 0 := hcz refine ⟨⟨by rw [he']; decide, fun _ => by rw [hfz]; rfl, fun h' => absurd (by rw [he']; rfl) h'⟩, ⟨by rw [z0]; decide, by rw [z1]; decide, by rw [z2]; decide⟩, fun _ => z2, ?_⟩ rw [z0, z1, z2]; unfold wv; rw [QG w he' hfz]; ring · have hne : (e == 0) = false := by simpa using he0 have hmag : mag = ((w &&& 0x7FFFFF) ||| 0x800000).toUInt64 <<< d.toUInt64 := by simp only [mag, hne, ZAp, dite_false] have hc' : (e != 255 && decide (lx ≤ e) && decide (d ≤ lim)) = true := by have := hcond; simp only [hne, ZAp, dite_false] at this; exact this simp only [ZAx, bne_iff_ne, ne_eq, decide_eq_true_eq] at hc' obtain ⟨⟨h255, hlx⟩, hdl⟩ := hc' have he0' : (expOf w).toNat ≠ 0 := by intro h0; apply he0 have : expOf w = 0 := ZAk (by simpa using h0) exact this obtain ⟨p0lt, p1lt, p2lt, hval⟩ := Qb7 w lx lim hlim he0' hlx hdl have p0lt' : (mag &&& 0x1FFFFF).toNat < 2 ^ 21 := by rw [hmag]; exact p0lt have p1lt' : ((mag >>> 21) &&& 0x1FFFFF).toNat < 2 ^ 21 := by rw [hmag]; exact p1lt have p2lt' : (mag >>> 42).toNat < 2 ^ 21 := by rw [hmag]; exact p2lt have v0 : uv q0 = if signOf w then -((mag &&& 0x1FFFFF).toNat : Int) else (mag &&& 0x1FFFFF).toNat := by simp only [q0]; rw [QW _ _ p0lt'] have v1 : uv q1 = if signOf w then -(((mag >>> 21) &&& 0x1FFFFF).toNat : Int) else ((mag >>> 21) &&& 0x1FFFFF).toNat := by simp only [q1]; rw [QW _ _ p1lt'] have v2 : uv q2 = if signOf w then -((mag >>> 42).toNat : Int) else (mag >>> 42).toNat := by simp only [q2]; rw [QW _ _ p2lt'] have hlx' : lx.toNat ≤ (expOf w).toNat := hlx have hdl' : ((expOf w) - lx).toNat ≤ lim.toNat := hdl have hdn : ((expOf w) - lx).toNat = (expOf w).toNat - lx.toNat := ZBw _ _ hlx refine ⟨⟨fun h' => h255 (by have : expOf w = 255 := ZAk (by simpa using h'); exact this), fun h' => absurd h' he0', fun _ => ⟨hlx', by omega⟩⟩, ⟨?_, ?_, ?_⟩, ?_, ?_⟩ ·rw [v0]; split <;> simp only [ZDf, ZCr] <;> omega ·rw [v1]; split <;> simp only [ZDf, ZCr] <;> omega ·rw [v2]; split <;> simp only [ZDf, ZCr] <;> omega ·intro h18 have hz : (mag >>> 42).toNat = 0 := by rw [hmag]; exact Qcg w lx lim he0' hlx hdl h18 rw [v2, hz]; split <;> simp ·rw [v0, v1, v2, hmag]; exact hval ·exact hrest k' (by omega) hk2' | case2 k U0 U1 U2 hs s0 s1 s2 ok h => have heq : Qv X o n lx lim hX hXs k U0 U1 U2 hs s0 s1 s2 ok = (U0, U1, U2, s0, s1, s2, ok) := by unfold Qv; simp only [dite_cond_eq_false (eq_false h)] rw [heq] have hkn' : ¬ k.toNat < n.toNat := fun h' => h (ZAz h') have he : ZAb k.toNat n.toNat = ∅ := ZBu (by omega) refine ⟨fun t _ => ⟨rfl, rfl, rfl⟩, by simp [he], by simp [he], by simp [he], fun hfin => ⟨hfin, ?_⟩⟩ intro k' h1 h2; omega lemma Qb1 (W : Array UInt32) (wo : USize) (hwo : wo.toNat ≤ 65280) (o n : USize) (hW : o.toNat + n.toNat ≤ W.size) (hWs : W.size < 2 ^ 32) (k : USize) (D : Array UInt32) (hD : W.size ≤ D.size) (c sd : UInt64) (hkn : k.toNat ≤ n.toNat) : let r := Ql W wo hwo o n hW hWs k D hD c sd (∀ i, ¬(o.toNat + k.toNat ≤ i ∧ i < o.toNat + n.toNat) → r.1[i]! = D[i]!) ∧ (∀ i, o.toNat + k.toNat ≤ i → i < o.toNat + n.toNat → r.1[i]! = (Qi W[i]! (Qf wo hwo W[i]!) + 0x80000000).toUInt32) ∧ r.2.2 = sd + ∑ t ∈ ZAb k.toNat n.toNat, (r.1[o.toNat + t]!).toUInt64 ∧ (r.2.1.toNat < 2 ^ 31 → c.toNat < 2 ^ 31 ∧ ∀ i, o.toNat + k.toNat ≤ i → i < o.toNat + n.toNat → (Qf wo hwo W[i]!).toNat < 2 ^ 31) := by induction k, D, hD, c, sd using Ql.induct W wo hwo o n hW hWs with | case1 k D hD c sd h hk hok v m u ih => have hv : v = W[o.toNat + k.toNat]! := by simp only [v]; rw [Qk, hok] have heq : Ql W wo hwo o n hW hWs k D hD c sd = Ql W wo hwo o n hW hWs (k + 1) (D.uset (o + k) u (by omega)) (by simp only [ZBz]; exact hD) (c ||| m) (sd + u.toUInt64) := by conv_lhs => unfold Ql simp only [dite_cond_eq_true (eq_true h)] rfl rw [heq] have hk1 := Qd k n h obtain ⟨i1, i2, i3, i4⟩ := ih (by omega) rw [hk1] at i1 i2 i3 i4 have hat : (Ql W wo hwo o n hW hWs (k + 1) (D.uset (o + k) u (by omega)) (by simp only [ZBz]; exact hD) (c ||| m) (sd + u.toUInt64)).1[o.toNat + k.toNat]! = u := by rw [i1 _ (by omega), Qg, if_pos hok.symm] refine ⟨?_, ?_, ?_, ?_⟩ ·intro i hi rw [i1 i (by omega), Qg, if_neg (by omega)] ·intro i h1 h2 rcases ZBp i (o.toNat + k.toNat + 1) with hlt | hge ·have : i = o.toNat + k.toNat := by omega subst this rw [hat]; simp only [u, m]; rw [hv] ·exact i2 i (by omega) h2 ·rw [i3, Qb _ _ _ hk]; simp only [hat, add_assoc] ·intro hc obtain ⟨hc1, hc2⟩ := i4 hc rw [Qcw] at hc1 refine ⟨hc1.1, fun i h1 h2 => ?_⟩ rcases ZBp i (o.toNat + k.toNat + 1) with hlt | hge ·have : i = o.toNat + k.toNat := by omega subst this; rw [← hv]; exact hc1.2 ·exact hc2 i (by omega) h2 | case2 k D hD c sd h => unfold Ql; simp only [dite_cond_eq_false (eq_false h)] have : ¬ k.toNat < n.toNat := fun h' => h (ZAz h') have he : ZAb k.toNat n.toNat = ∅ := ZBu (by omega) exact ⟨fun _ _ => by simp, fun i h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega), by simp [he], fun hc => ⟨hc, fun i h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega)⟩⟩ lemma QbI (W : Array UInt32) (wo : USize) (hwo : wo.toNat ≤ 65280) (inW outW : Nat) (hWsz : outW * inW ≤ W.size) (hWs : W.size < 2 ^ 32) (j : Nat) (D : Array UInt32) (hD : W.size ≤ D.size) (oks : Array Bool) (sds : Array UInt64) : let r := Qh W wo hwo inW outW hWsz hWs j D hD oks sds (∀ i, i < j * inW → r.1[i]! = D[i]!) ∧ (∀ j', j ≤ j' → j' < outW → ∀ k, k < inW → r.1[j' * inW + k]! = (Qi W[j' * inW + k]! (Qf wo hwo W[j' * inW + k]!) + 0x80000000).toUInt32) ∧ (∀ j', j' < oks.size → r.2.1[j']! = oks[j']!) ∧ (∀ j', j ≤ j' → j' < outW → r.2.1[oks.size + (j' - j)]! = true → ∀ k, k < inW → (Qf wo hwo W[j' * inW + k]!).toNat < 2 ^ 31) ∧ (∀ j', j' < sds.size → r.2.2[j']! = sds[j']!) ∧ (∀ j', j ≤ j' → j' < outW → r.2.2[sds.size + (j' - j)]! = 0 + ∑ t ∈ ZAb 0 inW, (r.1[j' * inW + t]!).toUInt64) := by induction j, D, hD, oks, sds using Qh.induct W wo hwo inW outW hWsz hWs with | case1 j D hD oks sds hj h1 r ih => have heq : Qh W wo hwo inW outW hWsz hWs j D hD oks sds = Qh W wo hwo inW outW hWsz hWs (j + 1) r.1 (by rw [QL]; exact hD) (oks.push (r.2.1 < 0x80000000)) (sds.push r.2.2) := by conv_lhs => unfold Qh simp only [dite_cond_eq_true (eq_true hj)] rfl rw [heq] obtain ⟨p1, p2, p3, p4, p5, p6⟩ := ih obtain ⟨hz1, hz2⟩ := ZZa hj hWsz hWs have hj1 : (j + 1) * inW = j * inW + inW := by rw [Nat.add_mul, Nat.one_mul] have hji : (j * inW).toUSize.toNat = j * inW := Qc _ hz1 have hni : inW.toUSize.toNat = inW := Qc _ (by omega) obtain ⟨d1, d2, d3, d4⟩ := Qb1 W wo hwo (j * inW).toUSize inW.toUSize h1 hWs 0 D hD 0 0 (by simp) simp only [ZCb, Nat.add_zero, hji, hni] at d1 d2 d3 d4 refine ⟨?_, ?_, ?_, ?_, ?_, ?_⟩ ·intro i hi rw [p1 i (by omega), d1 i (by omega)] ·intro j' hj1 hj2 k hk rcases ZBp j' (j + 1) with hlt | hge ·have : j' = j := by omega subst this rw [p1 _ (by omega), d2 _ (by omega) (by omega)] ·exact p2 j' hge hj2 k hk ·intro j' hj' rw [p3 j' (by simp; omega), Qaa _ _ _ hj'] ·intro j' hj1 hj2 hok k hk rcases ZBp j' (j + 1) with hlt | hge ·have hjj : j' = j := by omega have h3 := p3 oks.size (by simp) rw [Qac] at h3 have hidx : oks.size + (j' - j) = oks.size := by omega rw [hidx, h3] at hok have hc' : r.2.1.toNat < 2 ^ 31 := by simpa [ZAr] using hok rw [hjj] exact (d4 hc').2 _ (by omega) (by omega) ·have := p4 j' hge hj2 (by rw [show (oks.push (r.2.1 < 0x80000000)).size + (j' - (j + 1)) = oks.size + (j' - j) by simp; omega] exact hok) exact this k hk ·intro j' hj' rw [p5 j' (by simp; omega), Qaa _ _ _ hj'] ·intro j' hj1 hj2 rcases ZBp j' (j + 1) with hlt | hge ·have hjj : j' = j := by omega have h5 := p5 sds.size (by simp) rw [Qac] at h5 have hsum : r.2.2 = 0 + ∑ t ∈ ZAb 0 inW, ((Qh W wo hwo inW outW hWsz hWs (j + 1) r.1 (by rw [QL]; exact hD) (oks.push (r.2.1 < 0x80000000)) (sds.push r.2.2)).1[j * inW + t]!).toUInt64 := by conv_lhs => rw [d3] congr 1 apply ZAy rfl intro t ht rw [p1 _ (by have := (ZCg ht).2; omega)] rw [show sds.size + (j' - j) = sds.size by omega, h5, hjj] exact hsum ·rw [show sds.size + (j' - j) = (sds.push r.2.2).size + (j' - (j + 1)) by simp; omega] exact p6 j' hge hj2 | case2 j D hD oks sds hj => unfold Qh; simp only [dite_cond_eq_false (eq_false hj)] exact ⟨fun _ _ => by simp, fun j' h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega), fun _ _ => by simp, fun j' h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega), fun _ _ => by simp, fun j' h1 h2 => absurd (lt_of_le_of_lt h1 h2) (by omega)⟩ lemma QaB (x y : Int) : ZBe 64 (x - y) = ZBe 64 x - ZBe 64 y := by rw [sub_eq_add_neg, BitVec.ofInt_add, BitVec.ofInt_neg, ← sub_eq_add_neg] lemma Qy (x : UInt64) (z : Int) (h : (x.toNat : Int) = z) : x.toBitVec = ZBe 64 z := by rw [← h, BitVec.ofInt_natCast] apply BitVec.eq_of_toNat_eq simp lemma Qc6 (N : Nat) (hN : N < 2048) (A B : Nat → UInt64) (v d : Nat → Int) (hA : ∀ t, t < N → ((A t).toNat : Int) = 2 ^ 21 + v t) (hB : ∀ t, t < N → ((B t).toNat : Int) = 2 ^ 31 + d t) (hv : ∀ t, t < N → (v t).natAbs < 2 ^ 21) (hd : ∀ t, t < N → (d t).natAbs < 2 ^ 31) : Qa (Qm N.toUInt64 (0 + ∑ s ∈ ZAb 0 N, A s * B s) (0 + ∑ s ∈ ZAb 0 N, A s) (0 + ∑ s ∈ ZAb 0 N, B s)) = ∑ t ∈ ZAd N, v t * d t := by have eA : ∀ t ∈ ZAd N, (A t).toBitVec = ZBe 64 (2 ^ 21 + v t) := fun t ht => Qy _ _ (hA t (ZAu ht)) have eB : ∀ t ∈ ZAd N, (B t).toBitVec = ZBe 64 (2 ^ 31 + d t) := fun t ht => Qy _ _ (hB t (ZAu ht)) have eN : (N.toUInt64).toBitVec = ZBe 64 (N : Int) := Qy _ _ (by simp; omega) have c31 : (2147483648 : UInt64).toBitVec = ZBe 64 (2 ^ 31) := Qy _ _ (by norm_num) have c21 : (2097152 : UInt64).toBitVec = ZBe 64 (2 ^ 21) := Qy _ _ (by norm_num) have c52 : (4503599627370496 : UInt64).toBitVec = ZBe 64 (2 ^ 52) := Qy _ _ (by norm_num) have hSAB : (∑ s ∈ ZAd N, A s * B s).toBitVec = ZBe 64 (∑ t ∈ ZAd N, (2 ^ 21 + v t) * (2 ^ 31 + d t)) := by rw [Qbc, Qag] apply ZAy rfl intro t ht rw [ZCl, eA t ht, eB t ht, ZCy] have hSA : (∑ s ∈ ZAd N, A s).toBitVec = ZBe 64 (∑ t ∈ ZAd N, (2 ^ 21 + v t)) := by rw [Qbc, Qag]; exact ZAy rfl eA have hSB : (∑ s ∈ ZAd N, B s).toBitVec = ZBe 64 (∑ t ∈ ZAd N, (2 ^ 31 + d t)) := by rw [Qbc, Qag]; exact ZAy rfl eB have key : ∑ t ∈ ZAd N, (2 ^ 21 + v t) * (2 ^ 31 + d t) - (∑ t ∈ ZAd N, (2 ^ 21 + v t)) * 2 ^ 31 - (∑ t ∈ ZAd N, (2 ^ 31 + d t)) * 2 ^ 21 + (N : Int) * 2 ^ 52 = ∑ t ∈ ZAd N, v t * d t := by have e1 : ∑ t ∈ ZAd N, (2 ^ 21 + v t) * (2 ^ 31 + d t) = ∑ t ∈ ZAd N, (v t * d t + (2 ^ 21 + v t) * 2 ^ 31 + (2 ^ 31 + d t) * 2 ^ 21 - 2 ^ 52) := ZAy rfl (fun t _ => by ring) rw [e1, ZDk, ZBi, ZBi, ← ZBm, ← ZBm, ZCx, Finset.card_range] simp only [nsmul_eq_mul]; ring have hbv : (Qm N.toUInt64 (0 + ∑ s ∈ ZAb 0 N, A s * B s) (0 + ∑ s ∈ ZAb 0 N, A s) (0 + ∑ s ∈ ZAb 0 N, B s)).toBitVec = ZBe 64 (∑ t ∈ ZAd N, v t * d t) := by unfold Qm rw [← ZCa, zero_add, zero_add, zero_add, UInt64.toBitVec_add, UInt64.toBitVec_sub, UInt64.toBitVec_sub, ZCl, ZCl, ZCl, hSAB, hSA, hSB, eN, c31, c21, c52, ← ZCy, ← ZCy, ← ZCy, ← QaB, ← QaB, ← BitVec.ofInt_add, key] have hb : (∑ t ∈ ZAd N, v t * d t).natAbs < 2 ^ 63 := by calc (∑ t ∈ ZAd N, v t * d t).natAbs ≤ ∑ t ∈ ZAd N, (v t * d t).natAbs := Qaz _ _ _ ≤ ∑ _t ∈ ZAd N, (2 ^ 52 : Nat) := by apply ZCf intro t ht have h1 := hv t (ZAu ht) have h2 := hd t (ZAu ht) rw [Int.natAbs_mul] calc (v t).natAbs * (d t).natAbs ≤ 2 ^ 21 * 2 ^ 31 := Nat.mul_le_mul (by omega) (by omega) _ = 2 ^ 52 := by norm_num _ = N * 2 ^ 52 := by simp _ < 2 ^ 63 := by calc N * 2 ^ 52 < 2048 * 2 ^ 52 := ZAn hN (by positivity) _ = 2 ^ 63 := by norm_num unfold Qa rw [hbv, BitVec.toInt_ofInt] apply Int.bmod_eq_of_le <;> omega lemma QdA (w : UInt32) (m : UInt64) (hm : m.toNat < 2 ^ 31) : (((Qi w m + 0x80000000).toUInt32).toNat : Int) = 2 ^ 31 + Qa (Qi w m) := by rw [Qcn w m hm] unfold Qi have c : (0x80000000 : UInt64).toNat = 2147483648 := rfl have hm' : m.toNat < 2147483648 := by omega have h64 : (2 : Nat) ^ 64 = 18446744073709551616 := by norm_num have h32 : (2 : Nat) ^ 32 = 4294967296 := by norm_num by_cases hs : signOf w = true ·rw [if_pos hs, if_pos hs] have e1 : (0 - m + 0x80000000 : UInt64).toNat = 2147483648 - m.toNat := by rw [ZAl, ZDg, c, ZBa, h64]; omega rw [ZBc, e1, h32, ZAa (by omega)] omega ·rw [if_neg hs, if_neg hs] have e1 : (m + 0x80000000 : UInt64).toNat = m.toNat + 2147483648 := by rw [ZAl, c, h64]; omega rw [ZBc, e1, h32, ZAa (by omega)] push_cast; ring lemma Qbm (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i jj : Nat) (hjj : jj < outW) (hin : inW < 2048) (D : Array UInt32) (oks : Array Bool) (sds : Array UInt64) (wo : USize) (hwo : wo.toNat ≤ 65280) (U0 U1 U2 : Array UInt32) (s0 s1 s2 : UInt64) (lx lw lim : Nat) (hlx : 1 ≤ lx) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hwoe : wo.toNat = lw * 256) (hparts : ∀ k, k < inW → Qaw U0 U1 U2 k ∧ (lim ≤ 18 → uv U2[k]! = 0) ∧ pvD U0 U1 U2 k = wv X[i * inW + k]! lx) (hxok : ∀ k, k < inW → XOk X (i * inW) lx lim k) (hs0 : s0 = 0 + ∑ t ∈ ZAb 0 inW, (U0[t]!).toUInt64) (hs1 : s1 = 0 + ∑ t ∈ ZAb 0 inW, (U1[t]!).toUInt64) (hs2 : s2 = 0 + ∑ t ∈ ZAb 0 inW, (U2[t]!).toUInt64) (hD : ∀ k, k < inW → D[jj * inW + k]! = (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!) + 0x80000000).toUInt32) (hok : oks[jj]! = true → ∀ k, k < inW → (Qf wo hwo W[jj * inW + k]!).toNat < 2 ^ 31) (hsd : sds[jj]! = 0 + ∑ t ∈ ZAb 0 inW, (D[jj * inW + t]!).toUInt64) (wr : USize) (hwrd : wr = (jj * inW).toUSize) (hWj : (jj + 1) * inW < 2 ^ 32) (a bb c : UInt64) (ha : a = Qm inW.toUInt64 (0 + ∑ s ∈ ZAb 0 inW, (U0[s]!).toUInt64 * (D[wr.toNat + s]!).toUInt64) s0 sds[jj]!) (hb : bb = Qm inW.toUInt64 (0 + ∑ s ∈ ZAb 0 inW, (U1[s]!).toUInt64 * (D[wr.toNat + s]!).toUInt64) s1 sds[jj]!) (hc : c = Qm inW.toUInt64 (0 + ∑ s ∈ ZAb 0 inW, (U2[s]!).toUInt64 * (D[wr.toNat + s]!).toUInt64) s2 sds[jj]! ∨ (lim ≤ 18 ∧ c = 0)) : QB inW relu X W b i jj (lx + lw - 2) (oks[jj]!) a bb c := by intro hk w hw have hm := hok hk have hspec := fun k hk' => QaF lw hlw wo hwoe hwo W[jj * inW + k]! (hm k hk') have hwv := fun k hk' => QbL lw hlw wo hwoe hwo W[jj * inW + k]! (hm k hk') have hwr : wr.toNat = jj * inW := by rw [hwrd, Qc _ (lt_of_le_of_lt (ZAj _ (Nat.le_add_right _ 1)) hWj)] have hB : ∀ k, k < inW → (((D[wr.toNat + k]!).toUInt64).toNat : Int) = 2 ^ 31 + Qa (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!)) := by intro k hk' rw [hwr, hD k hk', ZAw] exact QdA _ _ (hm k hk') have hlane : ∀ (U : Array UInt32) (su : UInt64), su = 0 + ∑ t ∈ ZAb 0 inW, (U[t]!).toUInt64 → (∀ k, k < inW → (uv U[k]!).natAbs < 2 ^ 21) → Qa (Qm inW.toUInt64 (0 + ∑ s ∈ ZAb 0 inW, (U[s]!).toUInt64 * (D[wr.toNat + s]!).toUInt64) su sds[jj]!) = ∑ k ∈ ZAd inW, uv U[k]! * Qa (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!)) := by intro U su hsu hU conv_lhs => rw [hsu, hsd, ← hwr] exact Qc6 inW hin (fun s => (U[s]!).toUInt64) (fun s => (D[wr.toNat + s]!).toUInt64) (fun s => uv U[s]!) (fun k => Qa (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!))) (fun t _ => by simp only [uv, ZAw]; ring) hB hU (fun k hk' => (hwv k hk').2) have hlanes : Qa a + Qa bb * 2 ^ 21 + Qa c * 2 ^ 42 = ∑ k ∈ ZAd inW, wv X[i * inW + k]! lx * wv W[jj * inW + k]! lw := by have e0 := hlane U0 s0 hs0 (fun k hk' => (hparts k hk').1.1) have e1 := hlane U1 s1 hs1 (fun k hk' => (hparts k hk').1.2.1) have hc' : Qa c = ∑ k ∈ ZAd inW, uv U2[k]! * Qa (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!)) := by rcases hc with hc | ⟨h18, hc⟩ ·rw [hc]; exact hlane U2 s2 hs2 (fun k hk' => (hparts k hk').1.2.2) ·rw [hc] have : Qa 0 = 0 := by simp [Qa] rw [this]; symm apply Finset.sum_eq_zero; intro k hk'; rw [(hparts k (ZAu hk')).2.1 h18]; ring rw [ha, hb, e0, e1, hc', ZBm, ZBm, ← ZBi, ← ZBi] apply ZAy rfl intro k hk' have hk'' := ZAu hk' have hp := (hparts k hk'').2.2 unfold pvD at hp rw [(hwv k hk'').1, ← hp]; ring unfold QN rw [Qb3 inW relu X W b i jj lx lw hlx hlw1 ?_ ?_ ?_ a bb c hlanes w hw] ·intro k hk' have hx := hxok k hk' unfold XOk at hx refine ⟨fun h' => hx.1 (by rw [h']; rfl), ?_⟩ by_cases he : (expOf X[i * inW + k]!).toNat = 0 ·left exact ⟨ZAk (by simpa using he), ZAk (by simpa using hx.2.1 he)⟩ ·right; exact (hx.2.2 he).1 ·intro k hk' obtain ⟨_, hm2⟩ := hspec k hk' rcases hm2 with hm0 | ⟨_, h255, _⟩ ·intro h'; unfold mantOf at hm0; rw [h'] at hm0; simp at hm0 ·exact fun h' => h255 (by rw [h']; rfl) ·intro k hk' _ obtain ⟨_, hm2⟩ := hspec k hk' rcases hm2 with hm0 | ⟨_, _, hle, _⟩ ·left unfold mantOf at hm0 by_cases he : expOf W[jj * inW + k]! = 0 ·rw [if_pos he] at hm0 exact ⟨he, ZAk (by simpa using hm0)⟩ ·rw [if_neg he] at hm0; omega ·right; exact hle lemma Qa5 (inW outW : Nat) (relu : Bool) (X W b : Array Word) (i : Nat) (U0 U1 U2 D : Array UInt32) (oks : Array Bool) (sds : Array UInt64) (s0 s1 s2 : UInt64) (wide : Bool) (base : Nat) (h0 : inW ≤ U0.size) (h1 : inW ≤ U1.size) (h2 : inW ≤ U2.size) (hin : inW < 2048) (hDsz : outW * inW ≤ D.size) (hDs : D.size < 2 ^ 32) (wo : USize) (hwo : wo.toNat ≤ 65280) (lx lw : Nat) (hlx : 1 ≤ lx) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hwoe : wo.toNat = lw * 256) (hbase : base = lx + lw - 2) (lim : Nat) (hwl : wide = false → lim ≤ 18) (hparts : ∀ k, k < inW → Qaw U0 U1 U2 k ∧ (lim ≤ 18 → uv U2[k]! = 0) ∧ pvD U0 U1 U2 k = wv X[i * inW + k]! lx) (hxok : ∀ k, k < inW → XOk X (i * inW) lx lim k) (hs0 : s0 = 0 + ∑ t ∈ ZAb 0 inW, (U0[t]!).toUInt64) (hs1 : s1 = 0 + ∑ t ∈ ZAb 0 inW, (U1[t]!).toUInt64) (hs2 : s2 = 0 + ∑ t ∈ ZAb 0 inW, (U2[t]!).toUInt64) (hD : ∀ jj, jj < outW → ∀ k, k < inW → D[jj * inW + k]! = (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!) + 0x80000000).toUInt32) (hok : ∀ jj, jj < outW → oks[jj]! = true → ∀ k, k < inW → (Qf wo hwo W[jj * inW + k]!).toNat < 2 ^ 31) (hsd : ∀ jj, jj < outW → sds[jj]! = 0 + ∑ t ∈ ZAb 0 inW, (D[jj * inW + t]!).toUInt64) (j : Nat) (out : Array Word) (h : Qq inW outW relu X W b out (i * outW + min j outW)) : Qq inW outW relu X W b (Qn inW outW relu X W b i U0 U1 U2 D oks sds s0 s1 s2 wide base h0 h1 h2 hin hDsz hDs j out) ((i + 1) * outW) := by induction j, out using Qn.induct inW outW relu X W b i U0 U1 U2 D oks sds s0 s1 s2 wide base h0 h1 h2 hin hDsz hDs with | case1 j out hj n hn w0 w1 w2 w3 hr nn e0 e1 e2 e3 r ih => have heq : Qn inW outW relu X W b i U0 U1 U2 D oks sds s0 s1 s2 wide base h0 h1 h2 hin hDsz hDs j out = Qn inW outW relu X W b i U0 U1 U2 D oks sds s0 s1 s2 wide base h0 h1 h2 hin hDsz hDs (j + 4) (QP inW outW relu X W b i j base r (fun jj => oks[jj]!) out) := by conv_lhs => unfold Qn simp only [dite_cond_eq_true (eq_true hj)] rfl rw [heq] apply ih rw [show min j outW = j by omega] at h have L := fun (jj : Nat) (hjj : jj < outW) (wr : USize) (hwr : wr = (jj * inW).toUSize) (a bb c : UInt64) => Qbm inW outW relu X W b i jj hjj hin D oks sds wo hwo U0 U1 U2 s0 s1 s2 lx lw lim hlx hlw1 hlw hwoe hparts hxok hs0 hs1 hs2 (hD jj hjj) (hok jj hjj) (hsd jj hjj) wr hwr (by have : (jj + 1) * inW ≤ outW * inW := ZAj _ hjj; omega) a bb c rw [hbase] at * have hw0 : w0 = (j * inW).toUSize := rfl have hw1 : j + 1 < outW → w1 = ((j + 1) * inW).toUSize := fun h' => by show ((if j + 1 < outW then j + 1 else j) * inW).toUSize = _; rw [if_pos h'] have hw2 : j + 2 < outW → w2 = ((j + 2) * inW).toUSize := fun h' => by show ((if j + 2 < outW then j + 2 else j) * inW).toUSize = _; rw [if_pos h'] have hw3 : j + 3 < outW → w3 = ((j + 3) * inW).toUSize := fun h' => by show ((if j + 3 < outW then j + 3 else j) * inW).toUSize = _; rw [if_pos h'] have he1 : j + 1 < outW → e1 = sds[j + 1]! := fun h' => by show sds[if j + 1 < outW then j + 1 else j]! = _; rw [if_pos h'] have he2 : j + 2 < outW → e2 = sds[j + 2]! := fun h' => by show sds[if j + 2 < outW then j + 2 else j]! = _; rw [if_pos h'] have he3 : j + 3 < outW → e3 = sds[j + 3]! := fun h' => by show sds[if j + 3 < outW then j + 3 else j]! = _; rw [if_pos h'] have hnn : n.toNat = inW := hn simp only [r] by_cases hw : wide = true <;> simp only [hw, ite_true, ite_false, dite_true, dite_false, ZAp] ·obtain ⟨p0, p1, p2, p3, p4, p5⟩ := Qa1 U0 U1 U2 D w0 w1 n (by omega) (by omega) (by omega) (Qbo _ _ _ _ _ _ hr) hDs 0 0 0 0 0 0 0 obtain ⟨q0, q1, q2, q3, q4, q5⟩ := Qa1 U0 U1 U2 D w2 w3 n (by omega) (by omega) (by omega) (Qbj _ _ _ _ _ _ hr) hDs 0 0 0 0 0 0 0 simp only [ZCb, hnn] at p0 p1 p2 p3 p4 p5 q0 q1 q2 q3 q4 q5 apply QI inW outW relu X W b i j (lx + lw - 2) _ _ out hj h ·exact L j hj w0 hw0 _ _ _ (by rw [p0] <;> rfl) (by rw [p1] <;> rfl) (Or.inl (by rw [p2] <;> rfl)) ·intro h1' exact L (j + 1) h1' w1 (hw1 h1') _ _ _ (by rw [p3, he1 h1'] <;> rfl) (by rw [p4, he1 h1'] <;> rfl) (Or.inl (by rw [p5, he1 h1'] <;> rfl)) ·intro h2' exact L (j + 2) h2' w2 (hw2 h2') _ _ _ (by rw [q0, he2 h2'] <;> rfl) (by rw [q1, he2 h2'] <;> rfl) (Or.inl (by rw [q2, he2 h2'] <;> rfl)) ·intro h3' exact L (j + 3) h3' w3 (hw3 h3') _ _ _ (by rw [q3, he3 h3'] <;> rfl) (by rw [q4, he3 h3'] <;> rfl) (Or.inl (by rw [q5, he3 h3'] <;> rfl)) ·obtain ⟨e0', e1', e2', e3', e4', e5', e6', e7'⟩ := Qcq U0 U1 D w0 w1 w2 w3 n (by omega) (by omega) hr hDs 0 0 0 0 0 0 0 0 0 simp only [ZCb, hnn] at e0' e1' e2' e3' e4' e5' e6' e7' have h18 : lim ≤ 18 := hwl (by simpa using hw) apply QI inW outW relu X W b i j (lx + lw - 2) _ _ out hj h ·exact L j hj w0 hw0 _ _ _ (by rw [e0'] <;> rfl) (by rw [e1'] <;> rfl) (Or.inr ⟨h18, rfl⟩) ·intro h1' exact L (j + 1) h1' w1 (hw1 h1') _ _ _ (by rw [e2', he1 h1'] <;> rfl) (by rw [e3', he1 h1'] <;> rfl) (Or.inr ⟨h18, rfl⟩) ·intro h2' exact L (j + 2) h2' w2 (hw2 h2') _ _ _ (by rw [e4', he2 h2'] <;> rfl) (by rw [e5', he2 h2'] <;> rfl) (Or.inr ⟨h18, rfl⟩) ·intro h3' exact L (j + 3) h3' w3 (hw3 h3') _ _ _ (by rw [e6', he3 h3'] <;> rfl) (by rw [e7', he3 h3'] <;> rfl) (Or.inr ⟨h18, rfl⟩) | case2 j out hj => unfold Qn; simp only [dite_cond_eq_false (eq_false hj)] rw [show min j outW = outW by omega] at h rw [show (i + 1) * outW = i * outW + outW by ring]; exact h lemma QbG (rows inW outW : Nat) (relu : Bool) (X W b : Array Word) (D : Array UInt32) (oks : Array Bool) (sds : Array UInt64) (wo : USize) (hwo : wo.toNat ≤ 65280) (lw : Nat) (hlw1 : 1 ≤ lw) (hlw : lw ≤ 254) (hwoe : wo.toNat = lw * 256) (hD : ∀ jj, jj < outW → ∀ k, k < inW → D[jj * inW + k]! = (Qi W[jj * inW + k]! (Qf wo hwo W[jj * inW + k]!) + 0x80000000).toUInt32) (hok : ∀ jj, jj < outW → oks[jj]! = true → ∀ k, k < inW → (Qf wo hwo W[jj * inW + k]!).toNat < 2 ^ 31) (hsd : ∀ jj, jj < outW → sds[jj]! = 0 + ∑ t ∈ ZAb 0 inW, (D[jj * inW + t]!).toUInt64) (hXsz : rows * inW ≤ X.size) (hDsz : outW * inW ≤ D.size) (hXs : X.size < 2 ^ 32) (hDs : D.size < 2 ^ 32) (hin : inW < 2048) (U0 U1 U2 : Array UInt32) (hU : inW ≤ U0.size ∧ inW ≤ U1.size ∧ inW ≤ U2.size) (i : Nat) (out : Array Word) (hi : i ≤ rows) (h : Qq inW outW relu X W b out (i * outW)) : Qq inW outW relu X W b (Qt rows inW outW relu X W b D oks sds lw hXsz hDsz hXs hDs hin U0 U1 U2 hU i out) (rows * outW) := by induction U0, U1, U2, hU, i, out using Qt.induct rows inW outW relu X W b D oks sds lw hXsz hDsz hXs hDs hin with | case1 U0 U1 U2 hU i out hi' xo n hn hX lh wide r hr out' ih => have heq : Qt rows inW outW relu X W b D oks sds lw hXsz hDsz hXs hDs hin U0 U1 U2 hU i out = Qt rows inW outW relu X W b D oks sds lw hXsz hDsz hXs hDs hin r.1 r.2.1 r.2.2.1 hr (i + 1) out' := by conv_lhs => unfold Qt simp only [dite_cond_eq_true (eq_true hi')] rfl rw [heq] apply ih (by omega) simp only [out'] split ·rename_i hcond simp only [ZAx, decide_eq_true_eq] at hcond obtain ⟨hok', hlx⟩ := hcond have hni : n.toNat = inW := hn have hxo : xo.toNat = i * inW := Qc _ (ZZa hi' hXsz hXs).1 obtain ⟨-, hsum0, hsum1, hsum2, hsem⟩ := QcU X xo n lh.1 (if wide then 39 else 18) hX hXs (QcT _) 0 U0 U1 U2 (by rw [hni]; exact hU) 0 0 0 true (by simp) obtain ⟨-, hrest⟩ := hsem hok' simp only [ZCb, hxo, hni] at hsum0 hsum1 hsum2 hrest have hlx1 : 1 ≤ lh.1.toNat := hlx apply Qa5 inW outW relu X W b i _ _ _ D oks sds _ _ _ wide _ _ _ _ hin hDsz hDs wo hwo lh.1.toNat lw hlx1 hlw1 hlw hwoe rfl (if wide then 39 else 18 : UInt32).toNat (QcS wide) ·intro k hk obtain ⟨_, p2, p3, p4⟩ := hrest k (ZAt _) hk exact ⟨p2, p3, p4⟩ ·intro k hk; exact (hrest k (ZAt _) hk).1 ·exact hsum0 ·exact hsum1 ·exact hsum2 ·exact hD ·exact hok ·exact hsd ·simpa using h ·exact QaJ inW outW relu X W b i 0 out (ZAt _) (by simpa using h) | case2 U0 U1 U2 hU i out hi' => unfold Qt; simp only [dite_cond_eq_false (eq_false hi')] have : i = rows := by omega subst this; exact h lemma QcN (lw : UInt32) (h : lw ≤ 254) : (lw.toUSize * 256).toNat = lw.toNat * 256 := by have h1 : lw.toNat ≤ 254 := h have h2 : (lw.toUSize).toNat = lw.toNat := ZCi lw rw [USize.toNat_mul, h2] have : 2 ^ 32 ≤ ZCn := USize.le_size have h3 : ZCn = 2 ^ ZBo := rfl simp only [USize.toNat_ofNat] rw [ZAa (by omega : 256 < 2 ^ ZBo), ZAa (by omega)] lemma QbS (rows inW outW : Nat) (relu : Bool) (X W b : Array Word) (out : Array Word) (h : Qq inW outW relu X W b out (rows * outW)) : out = linearWith dotOf rows inW outW relu X W b := by obtain ⟨hs, hq⟩ := h apply Array.ext ·simp [linearWith, hs] ·intro q h1 h2 rw [← getElem!_pos out q h1, hq q (by omega)] simp only [linearWith, Array.getElem_ofFn] rfl lemma Qdc (lw0 : UInt32) : let lw : UInt32 := if lw0 == 0 || lw0 > 254 then 1 else lw0 1 ≤ lw.toNat ∧ lw ≤ 254 := by intro lw simp only [lw] split ·exact ⟨by decide, by decide⟩ ·rename_i h simp only [ZCd, beq_iff_eq, decide_eq_true_eq, not_or, not_lt] at h obtain ⟨h1, h2⟩ := h have h2' : ¬ (254 : UInt32).toNat < lw0.toNat := fun h' => h2 (UInt32.lt_iff_toNat_lt.mpr h') refine ⟨?_, UInt32.le_iff_toNat_le.mpr (by simp at h2' ⊢; omega)⟩ have : lw0.toNat ≠ 0 := fun h' => h1 (ZAk (by simpa using h')) omega lemma QcG : Qbv = linearWith dotOf := by funext rows inW outW relu X W b unfold Qbv split ·rename_i hg obtain ⟨hlw1, hlw⟩ := Qdc ((Q7 W inW outW hg.2.1 hg.2.2.2.2.2 0 4 0 - 7)) dsimp only split · apply QbS set lw : UInt32 := if (Q7 W inW outW hg.2.1 hg.2.2.2.2.2 0 4 0 - 7) == 0 || (Q7 W inW outW hg.2.1 hg.2.2.2.2.2 0 4 0 - 7) > 254 then 1 else (Q7 W inW outW hg.2.1 hg.2.2.2.2.2 0 4 0 - 7) with hlwd have hwoe : (lw.toUSize * 256).toNat = lw.toNat * 256 := QcN lw hlw obtain ⟨-, d2, -, d4, -, d6⟩ := QbI W (lw.toUSize * 256) (QaM lw hlw) inW outW hg.2.1 hg.2.2.2.2.2 0 (ZBv W.size 0) (by simp) #[] #[] apply QbG rows inW outW relu X W b _ _ _ (lw.toUSize * 256) (QaM lw hlw) lw.toNat hlw1 hlw hwoe ·intro jj hjj k hk; exact d2 jj (ZAt _) hjj k hk ·intro jj hjj hok k hk exact d4 jj (ZAt _) hjj (by rw [show (#[] : Array Bool).size + (jj - 0) = jj by simp]; exact hok) k hk ·intro jj hjj have := d6 jj (ZAt _) hjj rwa [show (#[] : Array UInt64).size + (jj - 0) = jj by simp] at this ·exact ZAt _ ·simp [Qq] · apply QbS apply Qb4 rows inW outW relu X W b _ (QaM _ hlw) _ hlw1 hlw (QcN _ hlw) ·exact ZAt _ ·simp [Qq] ·rw [Qba] end section open Float.Model Float.Model.UnpackedFloat lemma Qap (fmt : FloatFormat) (sign : Bool) (exponent fraction : Nat) (he : exponent < 2 ^ fmt.expWidth) (hf : fraction < 2 ^ fmt.fracWidth) : (Model.ofFields fmt sign exponent fraction).toNatBits = (if sign then 1 <<< (fmt.expWidth + fmt.fracWidth) else 0) ||| (exponent <<< fmt.fracWidth) ||| fraction := by rw [Model.ofFields_eq_ofFieldsImpl] simp only [Model.ofFieldsImpl, Model.mkBitsImpl, Model.ofBits, Model.toNatBits, BitVec.toNat_ofNatLT, FloatFormat.expAllOnesNat, FloatFormat.fracMaskNat, Nat.and_two_pow_sub_one_of_lt_two_pow he, Nat.and_two_pow_sub_one_of_lt_two_pow hf] rfl lemma QcO : Fmt.expWidth = 8 := rfl lemma QcX : Fmt.fracWidth = 23 := rfl lemma Qaf (sign : Bool) (e f : Nat) (he : e < 2 ^ 8) (hf : f < 2 ^ 23) : toWord (Model.ofFields Fmt sign e f) = ZCs ((if sign then 2 ^ 31 else 0) + e * 2 ^ 23 + f) := by unfold toWord rw [Qap Fmt sign e f (by rw [QcO]; exact he) (by rw [QcX]; exact hf), QcO, QcX] congr 1 have h1 : e <<< 23 < 2 ^ 31 := by rw [ZAe]; omega cases sign ·simp only [ZAp, ite_false, Nat.zero_or, ZDl] rw [← ZAq hf, ZAe] ·simp only [ite_true] rw [show (1 : Nat) <<< (8 + 23) = 1 <<< 31 from rfl, ← ZAq h1, show 1 <<< 31 + e <<< 23 = (2 ^ 8 + e) <<< 23 by simp [ZAe]; ring, ← ZAq hf, ZAe] ring lemma Qcc (w : Word) (he : expOf w ≠ 0) : mantOf w = (fracOf w ||| 0x800000).toNat := by have hf := fracOf_toNat_lt w simp only [mantOf, he, ite_false, ZBn] rw [show (0x800000 : UInt32).toNat = 1 <<< 23 from rfl, Nat.or_comm, ← ZAq hf] simp [ZAe] lemma QaQ (w : Word) : rationalWord w = (sv w : ℚ) * 2 ^ ((idxOf w : ℤ) - 149) := by unfold rationalWord; rw [decodeD_toRat] lemma Qdg (w : Word) (he : expOf w = 0) (hf : fracOf w = 0) : rationalWord w = 0 := by rw [QaQ]; simp [sv, mantOf, he, hf] lemma QaI : roundRational 0 = 0 := by simp [roundRational, Model.roundRat, toWord] lemma Qbt (e : Int) : Model.bpow e = (2 : ℝ) ^ e := by simp [Model.bpow, FloatLib.Floats.Formats.Flocq.bpow, FloatLib.Numerics.binaryRadix, FloatLib.Numerics.Radix.toReal] lemma QbA (k : Nat) : Model.pow2 k = 2 ^ k := by simp [Model.pow2, ZAe] lemma Qbe (q : ℚ) (P D : Nat) (E : Int) (L : Nat) (n d m : Nat) (hq0 : q ≠ 0) (hq : ((|q| : ℚ) : ℝ) = (P : ℝ) / D * (2 : ℝ) ^ E) (hD : 0 < D) (hL1 : D * 2 ^ L ≤ P) (hL2 : P < D * 2 ^ (L + 1)) (hd : d ≠ 0) (hnd : (n : ℝ) / d = (P : ℝ) / D * (2 : ℝ) ^ ((23 : Int) - L)) (hm : m = ZBj n d) (hT1 : -126 ≤ (L : Int) + E) (hT2 : (L : Int) + E + (if m = 2 ^ 24 then 1 else 0) ≤ 127) : roundRational q = ZCs ((if q < 0 then 2 ^ 31 else 0) + ((L : Int) + E + 127 + (if m = 2 ^ 24 then 1 else 0)).toNat * 2 ^ 23 + (if m = 2 ^ 24 then 0 else m - 2 ^ 23)) := by set a := q.num.natAbs with ha_def set b := q.den with hb_def have ha : a ≠ 0 := by simp [ha_def, hq0] have hb : b ≠ 0 := q.den_nz have hab : (a : ℝ) / b = (P : ℝ) / D * (2 : ℝ) ^ E := by rw [← hq] have : ((|q| : ℚ) : ℝ) = ((q.num.natAbs : ℚ) / q.den : ℚ) := by congr 1 rw [Rat.abs_def, Rat.divInt_eq_div]; push_cast congr 1 first | exact (Nat.cast_natAbs q.num).symm | simp [Nat.cast_natAbs, Int.cast_abs] rw [this]; push_cast; rfl have hDR : (0 : ℝ) < D := by exact_mod_cast hD have hpL : (2 : ℝ) ^ (L : Int) ≤ (P : ℝ) / D := by rw [le_div_iff₀ hDR, zpow_natCast]; exact_mod_cast (by linarith [hL1] : 2 ^ L * D ≤ P) have hpU : (P : ℝ) / D < (2 : ℝ) ^ ((L : Int) + 1) := by rw [div_lt_iff₀ hDR, show ((L : Int) + 1) = ((L + 1 : Nat) : Int) by push_cast; ring, zpow_natCast] exact_mod_cast (by linarith [hL2] : P < 2 ^ (L + 1) * D) have hfl : FloatLib.Numerics.RationalBinary.floorLog2 a b = L + E := by apply Model.floorLog2_eq_of_bounds a b (L + E) ha hb ·rw [hab, Qbt, zpow_add₀ (by norm_num)] exact mul_le_mul_of_nonneg_right hpL (by positivity) ·rw [hab, Qbt, show (L : Int) + E + 1 = (L + 1) + E by ring, zpow_add₀ (by norm_num)] exact mul_lt_mul_of_pos_right hpU (by positivity) have hsc : ZBj (FloatLib.Numerics.RationalBinary.scaleByPowerOfTwo a b (Int.ofNat 23 - (L + E))).1 (FloatLib.Numerics.RationalBinary.scaleByPowerOfTwo a b (Int.ofNat 23 - (L + E))).2 = m := by rw [hm] apply Model.roundQuotientEven_eq_of_rat_eq ·exact FloatLib.Numerics.RationalBinary.scaleByPowerOfTwo_snd_ne_zero a b _ hb ·exact hd ·rw [Model.scaleByPowerOfTwo_real, Model.scaledRatToReal, hab, hnd, Qbt, mul_assoc, ← zpow_add₀ (by norm_num)] congr 2; push_cast; ring have hz : (0 : ℝ) < (2 : ℝ) ^ ((23 : Int) - L) := zpow_pos (by norm_num) _ have hnd1 : (2 : ℝ) ^ (23 : Int) ≤ (n : ℝ) / d := by rw [hnd] calc (2 : ℝ) ^ (23 : Int) = (2 : ℝ) ^ (L : Int) * (2 : ℝ) ^ ((23 : Int) - L) := by rw [← zpow_add₀ (by norm_num)]; congr 1; ring _ ≤ (P : ℝ) / D * (2 : ℝ) ^ ((23 : Int) - L) := mul_le_mul_of_nonneg_right hpL hz.le have hnd2 : (n : ℝ) / d < (2 : ℝ) ^ (24 : Int) := by rw [hnd] calc (P : ℝ) / D * (2 : ℝ) ^ ((23 : Int) - L) < (2 : ℝ) ^ ((L : Int) + 1) * (2 : ℝ) ^ ((23 : Int) - L) := mul_lt_mul_of_pos_right hpU hz _ = (2 : ℝ) ^ (24 : Int) := by rw [← zpow_add₀ (by norm_num)]; congr 1; ring have hdR : (0 : ℝ) < d := by exact_mod_cast ZCp hd have hn1 : 8388608 * d ≤ n := by have h := (le_div_iff₀ hdR).mp hnd1; norm_num at h; exact_mod_cast h have hn2 : n < 16777216 * d := by have h := (div_lt_iff₀ hdR).mp hnd2; norm_num at h; exact_mod_cast h have hq1 : 2 ^ 23 ≤ n / d := (ZBy (ZCp hd)).mpr (by linarith) have hq2 : n / d < 2 ^ 24 := (ZBk (ZCp hd)).mpr (by linarith) have hmr := FloatLib.Numerics.roundQuotientEven_eq_quotient_add n d have hm1 : 2 ^ 23 ≤ m := by rw [hm, hmr]; split <;> omega have hm2 : m ≤ 2 ^ 24 := by rw [hm, hmr]; split <;> omega have hfw : FloatFormat.fracWidth Fmt = 23 := by decide have hbias : FloatFormat.exponentBias Fmt = 127 := by decide have hmin : FloatFormat.minNormalExponent Fmt = -126 := by decide have hmax : FloatFormat.maxNormalExponent Fmt = 127 := by decide have hieee : Fmt.isIEEE = true := by decide have hsz : FloatFormat.supportsSignedZero Fmt = true := by decide have hpos : Model.roundRatScaled Fmt false a b 0 = Model.ofFields Fmt false ((L : Int) + E + 127 + (if m = 2 ^ 24 then 1 else 0)).toNat (if m = 2 ^ 24 then 0 else m - 2 ^ 23) := by by_cases hc : m = 2 ^ 24 ·rw [Model.roundRatScaled_false_eq_normal_of_carry Fmt a b 0 hieee ha hb (by rw [hfl, hmin]; omega) (by simp only [hfw, hfl, QbA]; rw [hsc, hc]) (by rw [hfl, hmax]; simp [hc] at hT2; omega)] rw [hbias, hfl]; simp only [hc, ite_true, Int.add_zero] congr 2; push_cast; ring ·rw [Model.roundRatScaled_false_eq_normal_of_ne_carry Fmt a b 0 hieee ha hb (by rw [hfl, hmin]; omega) (by rw [hfl, hmax]; simp [hc] at hT2; omega) (by simp only [hfw, hfl, QbA]; rw [hsc]; exact hc)] simp only [hc, ite_false, hfl, hbias, hfw, QbA, Int.add_zero] rw [hsc] congr 1 unfold roundRational rw [Model.roundRat] by_cases hneg : q < 0 ·simp only [hneg, decide_true, ite_true] rw [Model.roundRatScaled_true_eq_neg_false Fmt a b 0 hieee hb, hpos, Model.neg_ofFields_of_supportsSignedZero Fmt hsz, Bool.not_false, Qaf true _ _ (by split <;> omega) (by split <;> omega)] simp ·simp only [hneg, decide_false, ite_false] rw [hpos, Qaf false _ _ (by split <;> omega) (by split <;> omega)] simp lemma Qce (w : Word) (he : expOf w ≠ 0) : 2 ^ 23 ≤ mantOf w ∧ mantOf w < 2 ^ 24 := by have := mantOf_lt_24 w constructor ·simp [mantOf, he] ·exact this lemma QcY (s : Bool) (E F : UInt32) (hE : E.toNat < 2 ^ 8) (hF : F.toNat < 2 ^ 23) : ((if s then (0x80000000 : UInt32) else 0) ||| (E <<< 23) ||| F) = ZCs ((if s then 2 ^ 31 else 0) + E.toNat * 2 ^ 23 + F.toNat) := by apply ZAk rw [UInt32.toNat_ofNat', ZBn, ZBn, UInt32.toNat_shiftLeft, show (23 : UInt32).toNat % 32 = 23 from rfl] have h1 : E.toNat <<< 23 % 2 ^ 32 = E.toNat <<< 23 := ZAa (by rw [ZAe]; omega) rw [h1] have hlt : (if s then 2 ^ 31 else 0) + E.toNat * 2 ^ 23 + F.toNat < 2 ^ 32 := by split <;> omega rw [ZAa hlt] have hEs : E.toNat <<< 23 < 2 ^ 31 := by rw [ZAe]; omega cases s ·simp only [ZAp, ite_false, UInt32.toNat_zero, Nat.zero_or, ZDl] rw [← ZAq hF, ZAe] ·simp only [ite_true, show (0x80000000 : UInt32).toNat = 1 <<< 31 from rfl] rw [← ZAq hEs, show 1 <<< 31 + E.toNat <<< 23 = (2 ^ 8 + E.toNat) <<< 23 by simp [ZAe]; ring, ← ZAq hF, ZAe] ring @[inline] def QJ (Q R : UInt64) : UInt64 := let r := Q.log2 - 23 let q := Q >>> r let low := Q &&& ((1 <<< r) - 1) let half := (1 : UInt64) <<< (r - 1) if low < half then q else if half < low then q + 1 else if R != 0 then q + 1 else if q % 2 == 0 then q else q + 1 lemma QbO (Q R D r : Nat) (hR : R < D) (hr : 1 ≤ r) : ZBj (Q * D + R) (D * 2 ^ r) = if Q % 2 ^ r < 2 ^ (r - 1) then Q / 2 ^ r else if 2 ^ (r - 1) < Q % 2 ^ r then Q / 2 ^ r + 1 else if R ≠ 0 then Q / 2 ^ r + 1 else if Q / 2 ^ r % 2 = 0 then Q / 2 ^ r else Q / 2 ^ r + 1 := by have hD : 0 < D := by omega have hp : 0 < 2 ^ r := by positivity have hhalf : 2 ^ r = 2 * 2 ^ (r - 1) := by rw [← pow_succ']; congr 1; omega have hQ : Q = Q / 2 ^ r * 2 ^ r + Q % 2 ^ r := (ZCc Q (2 ^ r)).symm have hlow : Q % 2 ^ r < 2 ^ r := ZCe _ hp generalize hq : Q / 2 ^ r = q at hQ ⊢ generalize hl : Q % 2 ^ r = low at hQ hlow ⊢ generalize hH : 2 ^ (r - 1) = H at hhalf ⊢ generalize hP : 2 ^ r = P at hhalf hp hlow hQ ⊢ subst hhalf have hrem : low * D + R < D * (2 * H) := by have : low * D ≤ (2 * H - 1) * D := ZAj _ (by omega) have e : (2 * H - 1) * D + D = D * (2 * H) := by have : 1 ≤ 2 * H := by omega zify [this]; ring omega have hnum : Q * D + R = (low * D + R) + q * (D * (2 * H)) := by rw [hQ]; ring have hdiv : (Q * D + R) / (D * (2 * H)) = q := by rw [hnum, ZDn _ _ (by positivity), ZDh hrem, zero_add] have hmod : (Q * D + R) % (D * (2 * H)) = low * D + R := by rw [hnum, ZDb, ZAa hrem] unfold FloatLib.Numerics.roundQuotientEven simp only [hdiv, hmod] by_cases h1 : low < H ·have : 2 * (low * D + R) < D * (2 * H) := by have := ZZc D h1 rw [Nat.mul_left_comm D 2 H, Nat.mul_comm D H]; omega simp [h1, this] ·by_cases h2 : H < low ·have : D * (2 * H) < 2 * (low * D + R) := by have := ZZc D h2; rw [Nat.mul_left_comm D 2 H, Nat.mul_comm D H]; omega have h3 : ¬ 2 * (low * D + R) < D * (2 * H) := by omega simp [h1, h2, this, h3] ·have hlh : low = H := by omega subst hlh by_cases hR0 : R = 0 ·subst hR0 have e : 2 * (low * D) = D * (2 * low) := by ring simp [h1, h2, e] ·have : D * (2 * low) < 2 * (low * D + R) := by have : 0 < R := ZCp hR0 rw [Nat.mul_left_comm D 2 low, Nat.mul_comm D low]; omega have h3 : ¬ 2 * (low * D + R) < D * (2 * low) := by omega simp [h1, h2, hR0, this, h3] lemma QaV (Q : UInt64) : (Q.log2).toNat = Q.toNat.log2 := rfl lemma Qa8 (Q R : UInt64) (D : Nat) (hQ : 2 ^ 25 ≤ Q.toNat) (hR : R.toNat < D) : (QJ Q R).toNat = ZBj (Q.toNat * D + R.toNat) (D * 2 ^ (Q.toNat.log2 - 23)) := by have hQ0 : Q.toNat ≠ 0 := by omega have hl1 : 25 ≤ Q.toNat.log2 := (ZBt hQ0).mpr hQ have hl2 : Q.toNat.log2 < 64 := (ZDa hQ0).mpr Q.toNat_lt rw [QbO _ _ _ _ hR (by omega)] unfold QJ generalize hrN : Q.toNat.log2 - 23 = rN have hr : (Q.log2 - 23).toNat = rN := by rw [ZAf _ _ (by rw [ZAh, QaV]; simp; omega), QaV]; simp; omega have hq : (Q >>> (Q.log2 - 23)).toNat = Q.toNat / 2 ^ rN := by rw [ZAv, hr, ZAa (by omega), ZAo] have hpow : ((1 : UInt64) <<< (Q.log2 - 23)).toNat = 2 ^ rN := by rw [ZAi, hr, ZAa (show rN < 64 by omega), ZAe, show (1 : UInt64).toNat = 1 from rfl, one_mul] exact ZAa (ZDq (by norm_num) (by omega)) have hlow : (Q &&& ((1 <<< (Q.log2 - 23)) - 1)).toNat = Q.toNat % 2 ^ rN := by rw [ZCu, ZAf _ _ (by rw [ZAh, hpow]; simp; exact Nat.one_le_two_pow), hpow, show (1 : UInt64).toNat = 1 from rfl] exact ZBd _ _ have hhalf : ((1 : UInt64) <<< (Q.log2 - 23 - 1)).toNat = 2 ^ (rN - 1) := by have hr1 : (Q.log2 - 23 - 1).toNat = rN - 1 := by rw [ZAf _ _ (by rw [ZAh, hr]; simp; omega), hr]; rfl rw [ZAi, hr1, ZAa (show rN - 1 < 64 by omega), ZAe, show (1 : UInt64).toNat = 1 from rfl, one_mul] exact ZAa (ZDq (by norm_num) (by omega)) have hqlt : Q.toNat / 2 ^ rN < 2 ^ 63 := by have : Q.toNat / 2 ^ rN ≤ Q.toNat / 2 := Nat.div_le_div_left (by calc 2 = 2 ^ 1 := by norm_num _ ≤ 2 ^ rN := ZAm (by norm_num) (by omega)) (by norm_num) have := Q.toNat_lt; omega have hq1 : (Q >>> (Q.log2 - 23) + 1).toNat = Q.toNat / 2 ^ rN + 1 := by rw [ZAl, hq]; simp; omega simp only [ZAr, hlow, hhalf, hq, hq1, bne_iff_ne, ne_eq, beq_iff_eq] have hm2 : (Q >>> (Q.log2 - 23)) % 2 = 0 ↔ Q.toNat / 2 ^ rN % 2 = 0 := by rw [← ZBr, UInt64.toNat_mod, hq]; simp have hR0 : R = 0 ↔ R.toNat = 0 := by rw [← ZBr]; simp simp only [hm2, hR0] split_ifs <;> simp_all def Qr : Accuracy → Bool | .exact => false | _ => true lemma Qdt (m : Nat) (a : Accuracy) (k : Nat) : (ZAc m a >>> (k + 1)) = ⟨m / 2 ^ (k + 1), m / 2 ^ k % 2 != 0, m % 2 ^ k != 0 || Qr a⟩ := by induction k with | zero => show Nat.repeat ZBb 1 _ = _ cases a with | exact => simp [Nat.repeat, ExtendedMantissa.shiftRightOne, ExtendedMantissa.ofMantissaAndAccuracy, Qr, Nat.mod_one] | inexact o => cases o <;> simp [Nat.repeat, ExtendedMantissa.shiftRightOne, ExtendedMantissa.ofMantissaAndAccuracy, Qr] | succ k ih => show Nat.repeat ZBb (k + 2) _ = _ rw [Nat.repeat] change ZBb (ZAc m a >>> (k + 1)) = _ rw [ih] simp only [ExtendedMantissa.shiftRightOne] have e1 : m / 2 ^ (k + 1) / 2 = m / 2 ^ (k + 1 + 1) := by rw [Nat.div_div_eq_div_mul, ← pow_succ] have e2 : m % 2 ^ (k + 1) = m % 2 ^ k + 2 ^ k * (m / 2 ^ k % 2) := Nat.mod_pow_succ rw [e1] congr 1 rw [e2] cases h1 : (m / 2 ^ k % 2 != 0) <;> cases h2 : (m % 2 ^ k != 0) <;> cases Qr a <;> simp_all [bne_iff_ne] <;> omega lemma Qc3 (Q R' : UInt64) (a : Accuracy) (hQ : 2 ^ 25 ≤ Q.toNat) (hR' : R'.toNat < 2) (hix : R'.toNat ≠ 0 ↔ Qr a = true) : (ZAc Q.toNat a >>> (Q.toNat.log2 - 23)).roundedMantissa = (QJ Q R').toNat := by have hQ0 : Q.toNat ≠ 0 := by omega have hl1 : 25 ≤ Q.toNat.log2 := (ZBt hQ0).mpr hQ rw [Qa8 Q R' 2 hQ hR', QbO _ _ _ _ hR' (by omega)] obtain ⟨k, hk⟩ : ∃ k, Q.toNat.log2 - 23 = k + 1 := ⟨Q.toNat.log2 - 24, by omega⟩ rw [hk, Qdt, show k + 1 - 1 = k from rfl] have e2 : Q.toNat % 2 ^ (k + 1) = Q.toNat % 2 ^ k + 2 ^ k * (Q.toNat / 2 ^ k % 2) := Nat.mod_pow_succ have hlt : Q.toNat % 2 ^ k < 2 ^ k := ZCe _ (by positivity) generalize Q.toNat / 2 ^ (k + 1) = q unfold ExtendedMantissa.roundedMantissa ExtendedMantissa.accuracy rcases (show Q.toNat / 2 ^ k % 2 = 0 ∨ Q.toNat / 2 ^ k % 2 = 1 by omega) with hbit | hbit ·have h1 : Q.toNat % 2 ^ (k + 1) < 2 ^ k := by rw [e2, hbit]; simpa rw [if_pos h1] cases h2 : (Q.toNat % 2 ^ k != 0 || Qr a) <;> simp [hbit, Accuracy.roundToNearestEven] ·have h1 : ¬ Q.toNat % 2 ^ (k + 1) < 2 ^ k := by rw [e2, hbit]; simp rw [if_neg h1] by_cases hz : Q.toNat % 2 ^ k = 0 ·have h3 : ¬ 2 ^ k < Q.toNat % 2 ^ (k + 1) := by rw [e2, hbit, hz]; simp rw [if_neg h3] by_cases hr : R'.toNat ≠ 0 ·have := hix.mp hr rw [if_pos hr]; simp [hbit, hz, this, Accuracy.roundToNearestEven] ·have : Qr a = false := by cases h : Qr a ·rfl ·exact absurd (hix.mpr h) hr rw [if_neg hr]; simp [hbit, hz, this, Accuracy.roundToNearestEven] split <;> omega ·have h3 : 2 ^ k < Q.toNat % 2 ^ (k + 1) := by rw [e2, hbit]; omega have hs : (Q.toNat % 2 ^ k != 0) = true := by simpa using hz rw [if_pos h3]; simp [hs, hbit, Accuracy.roundToNearestEven] lemma S1a (R : Nat) (e : Int) (a : Accuracy) (hl : 23 ≤ R.log2) (hT : -149 ≤ (R.log2 : Int) + e - 23) : shiftToTargetExponent Format.binary32 R e a = (ZAc R a >>> (R.log2 - 23), e + ((R.log2 - 23 : Nat) : Int)) := by unfold shiftToTargetExponent shiftToExponent have htot : totalExponent R e = (R.log2 : Int) + 1 + e := rfl rw [htot, Bridge.tgt _ (by omega)] have hs : ((R.log2 : Int) + 1 + e - 24 - e).toNat = R.log2 - 23 := by omega dsimp only rw [hs] lemma QbE (u : UnpackedFloat) : toWord (Model.ofModel Fmt u) = ZCs (UnpackedFloat.pack Format.binary32 u).toNat := rfl lemma Qco (m : Nat) (a : Accuracy) : (ZAc m a).mantissa = m := by cases a with | exact => rfl | inexact o => cases o <;> rfl lemma Qb6 (R : Nat) (a : Accuracy) (hR : 2 ^ 25 ≤ R) : 2 ^ 23 ≤ (ZAc R a >>> (R.log2 - 23)).roundedMantissa ∧ (ZAc R a >>> (R.log2 - 23)).roundedMantissa ≤ 2 ^ 24 := by have hR0 : R ≠ 0 := by omega have hl : 25 ≤ R.log2 := (ZBt hR0).mpr hR have hq1 : 2 ^ 23 ≤ R / 2 ^ (R.log2 - 23) := by rw [ZBy (by positivity), ← pow_add] exact le_trans (ZAm (by norm_num) (by omega)) (ZCk hR0) have hq2 : R / 2 ^ (R.log2 - 23) < 2 ^ 24 := by rw [ZBk (by positivity), ← pow_add] exact lt_of_lt_of_le ZCw (ZAm (by norm_num) (by omega)) have hmant : (ZAc R a >>> (R.log2 - 23)).mantissa = R / 2 ^ (R.log2 - 23) := by rw [Bridge.QY, Qco] constructor ·exact le_trans hq1 (by rw [← hmant]; exact Bridge.Qdf _) ·have := Bridge.QcQ (ZAc R a >>> (R.log2 - 23)).mantissa (ZAc R a >>> (R.log2 - 23)).accuracy rw [hmant] at this unfold ExtendedMantissa.roundedMantissa rw [hmant]; omega lemma Qcr (R : Nat) (e : Int) (a : Accuracy) (M : Nat) (hR : 2 ^ 25 ≤ R) (hM : (ZAc R a >>> (R.log2 - 23)).roundedMantissa = M) (hT1 : -149 ≤ (R.log2 : Int) + e - 23) (hT2 : (R.log2 : Int) + e - 23 + (if M = 2 ^ 24 then 1 else 0) ≤ 104) : toWord (Model.ofModel Fmt (roundWithAccuracy (ZBg Fmt) .positive R e a)) = ZCs ((((R.log2 : Int) + e - 23 + (if M = 2 ^ 24 then 1 else 0) + 150).toNat) * 2 ^ 23 + (if M = 2 ^ 24 then 0 else M - 2 ^ 23)) := by have hR0 : R ≠ 0 := by omega have hl : 25 ≤ R.log2 := (ZBt hR0).mpr hR have hMb : 2 ^ 23 ≤ M ∧ M ≤ 2 ^ 24 := hM ▸ Qb6 R a hR have hM0 : M ≠ 0 := by omega have hl2 : 23 ≤ M.log2 := (ZBt hM0).mpr hMb.1 have hl3 : M.log2 ≤ 24 := by have := (ZDa hM0).mpr (show M < 2 ^ 25 by omega); omega show toWord (Model.ofModel Fmt (roundWithAccuracy Format.binary32 .positive R e a)) = _ unfold roundWithAccuracy rw [S1a R e a (by omega) hT1] dsimp only rw [hM, S1a M (e + ((R.log2 - 23 : Nat) : Int)) .exact hl2 (by push_cast; omega)] dsimp only rw [QbE] congr 1 have hfm : (ZAc M .exact >>> (M.log2 - 23)).mantissa = M / 2 ^ (M.log2 - 23) := by rw [Bridge.QY, Qco] by_cases hc : M = 2 ^ 24 ·have hlg : M.log2 = 24 := by apply le_antisymm hl3 exact (ZBt hM0).mpr (by omega) have hfin : M / 2 ^ (M.log2 - 23) = 2 ^ 23 := by rw [hlg, hc]; norm_num rw [dif_neg (by rw [hfm, hfin]; norm_num)] simp only [hfm, hfin, if_pos hc] rw [QZ .positive (2 ^ 23) _ (by norm_num) le_rfl (by norm_num) (by rw [hlg]; push_cast; omega) (by rw [hlg]; push_cast; omega)] simp only [show (Sign.positive = Sign.negative) = False by decide, if_false, zero_add] rw [hlg] congr 2 push_cast; omega ·have hlg : M.log2 = 23 := by apply le_antisymm _ hl2 have := (ZDa hM0).mpr (show M < 2 ^ 24 by omega); omega have hfin : M / 2 ^ (M.log2 - 23) = M := by rw [hlg]; simp rw [dif_neg (by rw [hfm, hfin]; exact hM0)] simp only [hfm, hfin, if_neg hc] rw [QZ .positive M _ (by omega) hMb.1 (by omega) (by rw [hlg]; push_cast; omega) (by rw [hlg]; push_cast; omega)] simp only [show (Sign.positive = Sign.negative) = False by decide, if_false, zero_add] rw [hlg] have : M % 2 ^ 23 = M - 2 ^ 23 := by omega rw [this] congr 2 push_cast; omega @[inline] def Qab (R : Nat) (s : Int) (ix : Bool) : UInt32 := if R < 2 ^ 25 || 2 ^ 64 ≤ R then 0xFFFFFFFF else let Q := R.toUInt64 let m := QJ Q (if ix then 1 else 0) let k : Int := ((Q.log2 - 23).toNat : Int) let cy : Int := if m == 0x1000000 then 1 else 0 if k - s + 150 < 1 || 254 < k - s + 150 + cy then 0xFFFFFFFF else ((k - s + 150 + cy).toNat.toUInt32 <<< 23) ||| ((if m == 0x1000000 then 0 else m.toUInt32) &&& 0x7FFFFF) lemma Qcf (R : Nat) (s : Int) (a : Accuracy) (h : Qab R s (Qr a) ≠ 0xFFFFFFFF) : Qab R s (Qr a) = toWord (Model.ofModel Fmt (roundWithAccuracy (ZBg Fmt) .positive R (-s) a)) := by unfold Qab at h ⊢ split at h ·exact absurd rfl h rename_i hR rw [if_neg hR] simp only [ZCd, decide_eq_true_eq, not_or, not_lt, not_le] at hR obtain ⟨hR1, hR2⟩ := hR dsimp only at h ⊢ have hQ : R.toUInt64.toNat = R := by simp; omega have hR0 : R ≠ 0 := by omega have hl : 25 ≤ R.log2 := (ZBt hR0).mpr hR1 have hm := Qc3 R.toUInt64 (if Qr a = true then 1 else 0) a (by rw [hQ]; exact hR1) (by split <;> simp) (by split <;> simp_all) rw [hQ] at hm have hk : (((R.toUInt64.log2 - 23).toNat : Nat) : Int) = (R.log2 : Int) - 23 := by rw [ZAf _ _ (by rw [ZAh, QaV, hQ]; simp; omega), QaV, hQ] simp; omega rw [hk] at h ⊢ generalize hMd : QJ R.toUInt64 (if Qr a = true then 1 else 0) = m at hm h ⊢ have hc : (m == 0x1000000) = true ↔ m.toNat = 2 ^ 24 := by rw [beq_iff_eq, ← ZBr]; rfl generalize hcyd : (if (m == 0x1000000) = true then (1 : Int) else 0) = cy at h ⊢ by_cases hrng : (decide ((R.log2 : Int) - 23 - s + 150 < 1) || decide (254 < (R.log2 : Int) - 23 - s + 150 + cy)) = true ·rw [if_pos hrng] at h; exact absurd rfl h rw [if_neg hrng] set cN : Int := if m.toNat = 2 ^ 24 then 1 else 0 with hcN have hcc : cy = cN := by rw [← hcyd, hcN]; by_cases h' : m.toNat = 2 ^ 24 ·rw [if_pos (hc.mpr h'), if_pos h'] ·rw [if_neg (fun h'' => h' (hc.mp h'')), if_neg h'] simp only [ZCd, decide_eq_true_eq, not_or, not_lt, not_le] at hrng obtain ⟨hr1, hr2⟩ := hrng rw [hcc] at hr2 ⊢ have hcN01 : cN = 0 ∨ cN = 1 := by rw [hcN]; split <;> simp rw [Qcr R (-s) a m.toNat hR1 hm (by omega) (by rw [← hcN]; omega)] have hMb : 2 ^ 23 ≤ m.toNat ∧ m.toNat ≤ 2 ^ 24 := hm ▸ Qb6 R a hR1 have hE : ((((R.log2 : Int) - 23) - s + 150 + cN).toNat.toUInt32).toNat = ((R.log2 : Int) - 23 - s + 150 + cN).toNat := by rw [Nat.toUInt32, UInt32.toNat_ofNat']; exact ZAa (by omega) have hF : ((if (m == 0x1000000) = true then 0 else m.toUInt32) &&& 0x7FFFFF).toNat = if m.toNat = 2 ^ 24 then 0 else m.toNat - 2 ^ 23 := by by_cases h' : m.toNat = 2 ^ 24 ·rw [if_pos (hc.mpr h'), if_pos h']; rfl ·rw [if_neg (fun h'' => h' (hc.mp h'')), if_neg h', ZCj, ZBc, show (0x7FFFFF : UInt32).toNat = 2 ^ 23 - 1 from rfl, ZBd] omega have hp := QcY false (((R.log2 : Int) - 23 - s + 150 + cN).toNat.toUInt32) ((if (m == 0x1000000) = true then 0 else m.toUInt32) &&& 0x7FFFFF) (by rw [hE]; omega) (by rw [hF]; split <;> omega) simp only [ZAp, ite_false, UInt32.zero_or] at hp rw [hp, hE, hF] congr 2 omega @[inline] def QD (num den root : Nat) : Float.Model.UnpackedFloat.Accuracy := if num = root * root * den then .exact else .inexact (if 4 * num < den * ((2 * root + 1) * (2 * root + 1)) then .lt else if 4 * num = den * ((2 * root + 1) * (2 * root + 1)) then .eq else .gt) lemma Qbs (N D R : Nat) : Qr (QD N D R) = (N != R * R * D) := by unfold QD by_cases h : N = R * R * D ·simp [h, Qr] ·rw [if_neg h]; simp [h, Qr] lemma Qcb (num den : Nat) : QD num den (sqrtLower num den) = sqrtAccuracy num den := by simp only [QD, sqrtAccuracy, pow_two] @[inline] def Qav (A t0 n : Nat) : Word := let L : Int := (A.log2 : Int) + t0 - 298 - n.log2 - 1 let s : Int := (55 - L) / 2 + 1 let v : Int := t0 - 298 + 2 * s let N := if v ≥ 0 then A <<< v.toNat else A let D := if v ≥ 0 then n else n <<< (-v).toNat let R := sqrtLower N D let w := Qab R s (N != R * R * D) if w != 0xFFFFFFFF then w else toWord (Model.ofModel Fmt (roundWithAccuracy (ZBg Fmt) .positive R (-s) (QD N D R))) lemma QcW (q : ℚ) (hq : 0 < q) (N D : Nat) (s : Int) (hD : 0 < D) (hroot : sqrtLower N D ≠ 0) (hstep : -s ≤ (ZBg Fmt).targetExponent (Float.Model.totalExponent (sqrtLower N D) (-s))) (hscale : Real.sqrt ((N : ℝ) / D) * ZBx ZBs (-s) = Real.sqrt (q : ℝ)) : toWord (Model.ofModel Fmt (roundWithAccuracy (ZBg Fmt) .positive (sqrtLower N D) (-s) (sqrtAccuracy N D))) = sqrtRational q := by rw [sqrtRational_eq_math] have hacc : Model.accuracyRepresents (sqrtLower N D) (sqrtAccuracy N D) (Real.sqrt ((N : ℝ) / D)) := sqrtAccuracy_correct N D hD have he := Model.cexp_accuracy_mul_bpow_eq_targetExponent Fmt (sqrtLower N D) (-s) (sqrtAccuracy N D) (Real.sqrt ((N : ℝ) / D)) (by decide) hroot hacc have hs := Model.scaledMantissa_accuracy_mul_bpow Fmt (sqrtLower N D) (-s) (sqrtAccuracy N D) (Real.sqrt ((N : ℝ) / D)) (by decide) hroot hacc have hn := Model.roundedMantissa_shiftToTargetExponent_eq_nearestEven Fmt (sqrtLower N D) (-s) (sqrtAccuracy N D) (Real.sqrt ((N : ℝ) / D)) hacc hstep rw [hscale] at he hs have hround : (FloatLib.Floats.Formats.Flocq.nearestEven (FloatLib.Floats.Formats.Flocq.scaledMantissa ZBs (Model.fexpOf Fmt) (Real.sqrt (q : ℝ)))).toNat = (shiftToTargetExponent (ZBg Fmt) (sqrtLower N D) (-s) (sqrtAccuracy N D)).1.roundedMantissa := by rw [hs, ← hn] simp have htarget : (shiftToTargetExponent (ZBg Fmt) (sqrtLower N D) (-s) (sqrtAccuracy N D)).2 = (ZBg Fmt).targetExponent (Float.Model.totalExponent (sqrtLower N D) (-s)) := by rw [Model.shiftToTargetExponent_eq_of_le_targetExponent Fmt (sqrtLower N D) (-s) (sqrtAccuracy N D) hstep] simp only [sqrtMathWord, not_le.mpr hq, ite_false, he, hround] rw [Model.roundWithAccuracy_eq_finishRoundedMantissa] change toWord (Model.ofModel Fmt (Model.finishRoundedMantissa (ZBg Fmt) .positive (_, (shiftToTargetExponent (ZBg Fmt) (sqrtLower N D) (-s) (sqrtAccuracy N D)).2))) = _ rw [htarget] lemma QcE (e : Int) : ZBx ZBs e = (2 : ℝ) ^ e := by simp [FloatLib.Floats.Formats.Flocq.bpow, FloatLib.Numerics.binaryRadix, FloatLib.Numerics.Radix.toReal] lemma QbU (A t0 n : Nat) (hA : 0 < A) (hn : 0 < n) : Qav A t0 n = sqrtRational ((A : ℚ) * 2 ^ ((t0 : ℤ) - 298) / n) := by have hq : (0 : ℚ) < (A : ℚ) * 2 ^ ((t0 : ℤ) - 298) / n := by positivity unfold Qav lift_lets intro L s v N D R w have hw : (if (w != 0xFFFFFFFF) = true then w else toWord (Model.ofModel Fmt (roundWithAccuracy (ZBg Fmt) .positive R (-s) (QD N D R)))) = toWord (Model.ofModel Fmt (roundWithAccuracy (ZBg Fmt) .positive R (-s) (QD N D R))) := by split ·rename_i h have hwd : w = Qab R s (Qr (QD N D R)) := by rw [Qbs] rw [hwd] at h ⊢ exact Qcf R s _ (by simpa using h) ·rfl rw [hw] clear hw have hRd : R = sqrtLower N D := rfl rw [hRd, Qcb] clear hRd have hLd : L = (A.log2 : Int) + t0 - 298 - n.log2 - 1 := rfl have hsd : s = (55 - L) / 2 + 1 := rfl have hvd : v = t0 - 298 + 2 * s := rfl have hA2 : 2 ^ A.log2 ≤ A := ZCk (by omega) have hn2 : n < 2 ^ (n.log2 + 1) := ZCw have h2v : (2 : ℝ) ^ ((t0 : ℤ) - 298) * (2 : ℝ) ^ (2 * s) = (2 : ℝ) ^ v := by rw [← zpow_add₀ (by norm_num), hvd] have hND : 2 ^ 56 * D ≤ N ∧ 0 < D ∧ (N : ℝ) / D = (((A : ℚ) * 2 ^ ((t0 : ℤ) - 298) / n : ℚ) : ℝ) * (2 : ℝ) ^ (2 * s) := by by_cases hv : v ≥ 0 ·have hN : N = A * 2 ^ v.toNat := by show (if v ≥ 0 then A <<< v.toNat else A) = _; rw [if_pos hv, ZAe] have hD : D = n := by show (if v ≥ 0 then n else n <<< (-v).toNat) = _; rw [if_pos hv] have hk : 57 + n.log2 ≤ A.log2 + v.toNat := by omega refine ⟨?_, by omega, ?_⟩ ·rw [hN, hD] calc 2 ^ 56 * n ≤ 2 ^ 56 * 2 ^ (n.log2 + 1) := ZCm _ hn2.le _ = 2 ^ (57 + n.log2) := by rw [← pow_add]; congr 1; omega _ ≤ 2 ^ (A.log2 + v.toNat) := ZAm (by norm_num) hk _ = 2 ^ A.log2 * 2 ^ v.toNat := pow_add _ _ _ _ ≤ A * 2 ^ v.toNat := ZAj _ hA2 ·rw [hN, hD]; push_cast have : (2 : ℝ) ^ v.toNat = (2 : ℝ) ^ v := by rw [← zpow_natCast, Int.toNat_of_nonneg hv] rw [this, ← h2v]; ring ·have hN : N = A := by show (if v ≥ 0 then A <<< v.toNat else A) = _; rw [if_neg hv] have hD : D = n * 2 ^ (-v).toNat := by show (if v ≥ 0 then n else n <<< (-v).toNat) = _; rw [if_neg hv, ZAe] have hk : 57 + n.log2 + (-v).toNat ≤ A.log2 := by omega refine ⟨?_, by rw [hD]; positivity, ?_⟩ ·rw [hN, hD] calc 2 ^ 56 * (n * 2 ^ (-v).toNat) ≤ 2 ^ 56 * (2 ^ (n.log2 + 1) * 2 ^ (-v).toNat) := ZCm _ (ZAj _ hn2.le) _ = 2 ^ (57 + n.log2 + (-v).toNat) := by rw [← pow_add, ← pow_add]; congr 1; omega _ ≤ 2 ^ A.log2 := ZAm (by norm_num) hk _ ≤ A := hA2 ·rw [hN, hD]; push_cast have : (2 : ℝ) ^ v = ((2 : ℝ) ^ (-v).toNat)⁻¹ := by rw [← zpow_natCast, Int.toNat_of_nonneg (by omega), zpow_neg, inv_inv] rw [show (A : ℝ) * 2 ^ ((t0 : ℤ) - 298) / n * 2 ^ (2 * s) = A * (2 ^ ((t0 : ℤ) - 298) * 2 ^ (2 * s)) / n by ring, h2v, this] field_simp <;> ring obtain ⟨hND1, hD0, hND2⟩ := hND have hroot : 2 ^ 23 ≤ sqrtLower N D := by unfold sqrtLower apply Nat.le_sqrt.mpr have : 2 ^ 56 ≤ N / D := (ZBy hD0).mpr hND1 calc 2 ^ 23 * 2 ^ 23 ≤ 2 ^ 56 := by norm_num _ ≤ N / D := this have hroot0 : sqrtLower N D ≠ 0 := by omega apply QcW _ hq N D s hD0 hroot0 ·have hlog : 23 ≤ (sqrtLower N D).log2 := (ZBt hroot0).mpr hroot unfold Float.Model.Format.targetExponent Float.Model.totalExponent apply le_max_of_le_left have : (ZBg Fmt).mantissaBits = 24 := rfl rw [this]; push_cast; omega ·rw [hND2, QcE, Real.sqrt_mul (by positivity), show (2 : ℝ) ^ (2 * s) = ((2 : ℝ) ^ s) ^ 2 by rw [← zpow_natCast, ← zpow_mul]; congr 1; push_cast; ring, Real.sqrt_sq (by positivity), mul_assoc, ← zpow_add₀ (by norm_num), add_neg_cancel, zpow_zero, mul_one] def Qo (x : Array Word) (b n j lo hi : Nat) : Nat × Nat := if j < n then let w := x[b + j]! Qo x b n (j + 1) (if mantOf w != 0 && idxOf w < lo then idxOf w else lo) (max hi (idxOf w)) else (lo, hi) termination_by n - j def QK (x : Array Word) (b n lo hi j : Nat) (h l : UInt64) (tiny : Nat) : UInt64 × UInt64 × Nat := if j < n then let w := x[b + j]! let m := mantOf w if idxOf w + 34 < hi then QK x b n lo hi (j + 1) h l (tiny + (m * m) <<< (2 * (idxOf w - lo))) else let t := (m * m).toUInt64 let sh := (2 * (idxOf w + 34 - hi)).toUInt64 let tl := if sh < 64 then t <<< sh else 0 let th := if sh == 0 then 0 else if sh < 64 then t >>> (64 - sh) else t <<< (sh - 64) let l' := l + tl QK x b n lo hi (j + 1) (h + th + (if l' < l then 1 else 0)) l' tiny else (h, l, tiny) termination_by n - j lemma QaA (x : Array Word) (b n : Nat) : ∀ d j lo hi, n - j = d → hi ≤ (Qo x b n j lo hi).2 ∧ (Qo x b n j lo hi).1 ≤ lo ∧ (∀ k, j ≤ k → k < n → idxOf x[b + k]! ≤ (Qo x b n j lo hi).2) ∧ (∀ k, j ≤ k → k < n → mantOf x[b + k]! ≠ 0 → (Qo x b n j lo hi).1 ≤ idxOf x[b + k]!) := by intro d induction d with | zero => intro j lo hi hd rw [Qo, if_neg (by omega)] exact ⟨le_refl _, le_refl _, fun k h1 h2 => by omega, fun k h1 h2 => by omega⟩ | succ d ih => intro j lo hi hd rw [Qo, if_pos (by omega)] dsimp only obtain ⟨i1, i2, i3, i4⟩ := ih (j + 1) (if (mantOf x[b + j]! != 0 && decide (idxOf x[b + j]! < lo)) = true then idxOf x[b + j]! else lo) (max hi (idxOf x[b + j]!)) (by omega) refine ⟨le_trans (le_max_left _ _) i1, le_trans i2 (by split <;> simp_all; omega), ?_, ?_⟩ ·intro k h1 h2 rcases Nat.eq_or_lt_of_le h1 with h' | h' ·subst h'; exact le_trans (le_max_right _ _) i1 ·exact i3 k (by omega) h2 ·intro k h1 h2 hm rcases Nat.eq_or_lt_of_le h1 with h' | h' ·subst h' refine le_trans i2 ?_ split ·exact le_refl _ ·rename_i hc simp only [ZAx, bne_iff_ne, ne_eq, decide_eq_true_eq, not_and, not_lt] at hc exact hc hm ·exact i4 k (by omega) h2 hm lemma QcV (h l : UInt64) (M S : Nat) (hM : M < 2 ^ 48) (hS : S ≤ 68) (hb : h.toNat * 2 ^ 64 + l.toNat + M * 2 ^ S < 2 ^ 128) : (h + (if S.toUInt64 == 0 then 0 else if S.toUInt64 < 64 then M.toUInt64 >>> (64 - S.toUInt64) else M.toUInt64 <<< (S.toUInt64 - 64)) + (if l + (if S.toUInt64 < 64 then M.toUInt64 <<< S.toUInt64 else 0) < l then 1 else 0)).toNat * 2 ^ 64 + (l + (if S.toUInt64 < 64 then M.toUInt64 <<< S.toUInt64 else 0)).toNat = h.toNat * 2 ^ 64 + l.toNat + M * 2 ^ S := by have ht : M.toUInt64.toNat = M := by simp; omega have hs : S.toUInt64.toNat = S := by simp; omega have hsplit : ∃ th tl : Nat, th < 2 ^ 64 ∧ tl < 2 ^ 64 ∧ th * 2 ^ 64 + tl = M * 2 ^ S ∧ (if S.toUInt64 == 0 then 0 else if S.toUInt64 < 64 then M.toUInt64 >>> (64 - S.toUInt64) else M.toUInt64 <<< (S.toUInt64 - 64)).toNat = th ∧ (if S.toUInt64 < 64 then M.toUInt64 <<< S.toUInt64 else 0).toNat = tl := by by_cases h0 : S = 0 ·have e1 : (S.toUInt64 == 0) = true := by rw [beq_iff_eq, ← ZBr, hs, h0]; rfl have e2 : S.toUInt64 < 64 := by rw [ZAr, hs]; simp; omega refine ⟨0, M, by norm_num, by omega, by rw [h0]; simp, ?_, ?_⟩ ·rw [if_pos e1]; rfl ·rw [if_pos e2, ZAi, ht, hs, h0]; simp; omega by_cases h64 : S < 64 ·have e1 : (S.toUInt64 == 0) = false := by rw [beq_eq_false_iff_ne, ne_eq, ← ZBr, hs]; simp; omega have e2 : S.toUInt64 < 64 := by rw [ZAr, hs]; simp; omega have e3 : (64 - S.toUInt64).toNat = 64 - S := by rw [ZAf _ _ (by rw [ZAh, hs]; simp; omega), hs]; rfl have hpow : 2 ^ 64 = 2 ^ S * 2 ^ (64 - S) := by rw [← pow_add]; congr 1; omega refine ⟨M / 2 ^ (64 - S), M * 2 ^ S % 2 ^ 64, ?_, ZCe _ (by positivity), ?_, ?_, ?_⟩ ·exact lt_of_le_of_lt (Nat.div_le_self _ _) (by omega) ·have : M * 2 ^ S / 2 ^ 64 = M / 2 ^ (64 - S) := by rw [hpow, show M * 2 ^ S = (M * 2 ^ S) from rfl, mul_comm (2 ^ S) _, Nat.mul_div_mul_right _ _ (by positivity)] rw [← this]; exact ZCc _ _ ·rw [if_neg (by simp [e1]), if_pos e2, ZAv, ht, e3, ZAa (by omega), ZAo] ·rw [if_pos e2, ZAi, ht, hs, ZAa h64, ZAe] ·have e1 : (S.toUInt64 == 0) = false := by rw [beq_eq_false_iff_ne, ne_eq, ← ZBr, hs]; simp; omega have e2 : ¬ S.toUInt64 < 64 := by rw [ZAr, hs]; simp; omega have e3 : (S.toUInt64 - 64).toNat = S - 64 := by rw [ZAf _ _ (by rw [ZAh, hs]; simp; omega), hs]; rfl have hlt : M * 2 ^ (S - 64) < 2 ^ 64 := by calc M * 2 ^ (S - 64) < 2 ^ 48 * 2 ^ 4 := by apply ZAg hM (ZAm (by norm_num) (by omega)) (by positivity) _ ≤ 2 ^ 64 := by norm_num refine ⟨M * 2 ^ (S - 64), 0, hlt, by norm_num, ?_, ?_, ?_⟩ ·rw [add_zero, mul_assoc, ← pow_add]; congr 2; omega ·rw [if_neg (by simp [e1]), if_neg e2, ZAi, ht, e3, ZAa (show S - 64 < 64 by omega), ZAe, ZAa hlt] ·rw [if_neg e2]; rfl obtain ⟨th, tl, hth, htl, hsum, hthe, htle⟩ := hsplit generalize hTH : (if S.toUInt64 == 0 then 0 else if S.toUInt64 < 64 then M.toUInt64 >>> (64 - S.toUInt64) else M.toUInt64 <<< (S.toUInt64 - 64)) = TH at hthe ⊢ generalize hTL : (if S.toUInt64 < 64 then M.toUInt64 <<< S.toUInt64 else 0) = TL at htle ⊢ have hl' : (l + TL).toNat = (l.toNat + tl) % 2 ^ 64 := by rw [ZAl, htle] have hc : (if l + TL < l then (1 : UInt64) else 0).toNat = (l.toNat + tl) / 2 ^ 64 := by have hl := l.toNat_lt by_cases hcl : l + TL < l ·rw [if_pos hcl]; rw [ZAr, hl'] at hcl; simp; omega ·rw [if_neg hcl]; rw [ZAr, hl'] at hcl; simp; omega rw [ZAl, ZAl, hthe, hc, hl'] have hl := l.toNat_lt have hh := h.toNat_lt have e128 : (2 : Nat) ^ 128 = 2 ^ 64 * 2 ^ 64 := by norm_num rw [e128] at hb generalize hP : M * 2 ^ S = P at hb hsum ⊢ generalize hB : (2 : Nat) ^ 64 = B at hb hsum hh hl hth htl ⊢ have hmod := Nat.mod_add_div (l.toNat + tl) B have hcB : (l.toNat + tl) / B * B ≤ l.toNat + tl := Nat.div_mul_le_self _ _ have hlt : h.toNat + th + (l.toNat + tl) / B < B := by by_contra hcon push_neg at hcon have h1 : B * B ≤ (h.toNat + th + (l.toNat + tl) / B) * B := ZAj B hcon rw [Nat.add_mul, Nat.add_mul] at h1; omega rw [ZAa (lt_of_le_of_lt (Nat.le_add_right _ _) hlt), ZAa hlt, Nat.add_mul, Nat.add_mul] have := ZCc (l.toNat + tl) B omega def QS (w : Word) (hi : Nat) : Nat := if idxOf w + 34 < hi then 0 else mantOf w * mantOf w * 2 ^ (2 * (idxOf w + 34 - hi)) def Qai (w : Word) (lo hi : Nat) : Nat := if idxOf w + 34 < hi then mantOf w * mantOf w * 2 ^ (2 * (idxOf w - lo)) else 0 lemma Qct (x : Array Word) (b n lo hi : Nat) (hhi : ∀ k, k < n → idxOf x[b + k]! ≤ hi) : ∀ d j h l tiny, n - j = d → h.toNat * 2 ^ 64 + l.toNat + ∑ k ∈ ZAb j n, QS x[b + k]! hi < 2 ^ 128 → (QK x b n lo hi j h l tiny).1.toNat * 2 ^ 64 + (QK x b n lo hi j h l tiny).2.1.toNat = h.toNat * 2 ^ 64 + l.toNat + ∑ k ∈ ZAb j n, QS x[b + k]! hi ∧ (QK x b n lo hi j h l tiny).2.2 = tiny + ∑ k ∈ ZAb j n, Qai x[b + k]! lo hi := by intro d induction d with | zero => intro j h l tiny hd _ rw [QK, if_neg (by omega), Finset.Ico_eq_empty_of_le (by omega)] simp | succ d ih => intro j h l tiny hd hb have hj : j < n := by omega rw [ZAs hj] at hb rw [ZAs hj, ZAs hj] rw [QK, if_pos hj] dsimp only by_cases hsm : idxOf x[b + j]! + 34 < hi ·rw [if_pos hsm] have hbig : QS x[b + j]! hi = 0 := by simp [QS, hsm] have htiny : Qai x[b + j]! lo hi = mantOf x[b + j]! * mantOf x[b + j]! * 2 ^ (2 * (idxOf x[b + j]! - lo)) := by simp [Qai, hsm] rw [hbig, zero_add] at hb ⊢ obtain ⟨i1, i2⟩ := ih (j + 1) h l _ (by omega) hb refine ⟨i1, ?_⟩ rw [i2, htiny, ZAe]; ring ·rw [if_neg hsm] have hi_le := hhi j hj have hm := mantOf_lt_24 x[b + j]! have hbig : QS x[b + j]! hi = mantOf x[b + j]! * mantOf x[b + j]! * 2 ^ (2 * (idxOf x[b + j]! + 34 - hi)) := by simp [QS, hsm] have htiny : Qai x[b + j]! lo hi = 0 := by simp [Qai, hsm] rw [htiny, zero_add] have hadd := QcV h l (mantOf x[b + j]! * mantOf x[b + j]!) (2 * (idxOf x[b + j]! + 34 - hi)) (lt_of_lt_of_le (ZAg hm hm.le (by norm_num)) (by norm_num)) (by omega) (by rw [← hbig]; exact lt_of_le_of_lt (Nat.add_le_add_left (Nat.le_add_right _ _) _) hb) obtain ⟨i1, i2⟩ := ih (j + 1) _ _ tiny (by omega) (by rw [hadd]; rw [hbig] at hb; exact lt_of_eq_of_lt (by ring) hb) refine ⟨?_, i2⟩ rw [i1, hadd, hbig]; ring lemma QA (f : Nat → ℚ) (n : Nat) (a : ℚ) : (List.range n).foldl (fun t j => t + f j) a = a + ∑ j ∈ ZAd n, f j := by induction n generalizing a with | zero => simp | succ n ih => rw [List.range_succ, List.foldl_append, ih, ZBl]; simp; ring lemma Qa6 (n : Nat) (x : Array Word) (r : Nat) : rowVariance n x r 0 = ((∑ k ∈ ZAd n, mantOf x[r * n + k]! * mantOf x[r * n + k]! * 2 ^ (2 * idxOf x[r * n + k]!) : Nat) : ℚ) * 2 ^ (-298 : ℤ) / n := by unfold rowVariance rw [QA, zero_add] congr 1 push_cast rw [ZBm] refine ZAy rfl (fun k _ => ?_) rw [sub_zero, QaQ] have hsv : (sv x[r * n + k]! : ℚ) ^ 2 = (mantOf x[r * n + k]! : ℚ) ^ 2 := by unfold sv; split <;> push_cast <;> ring have hz : ((2 : ℚ) ^ ((idxOf x[r * n + k]! : ℤ) - 149)) ^ 2 = (2 : ℚ) ^ (2 * idxOf x[r * n + k]!) * 2 ^ (-298 : ℤ) := by rw [← zpow_natCast (2 : ℚ) (2 * idxOf _), ← zpow_add₀ (by norm_num), ← zpow_natCast, ← zpow_mul] congr 1; push_cast; ring rw [mul_pow, hsv, hz]; ring lemma QcA (w : Word) (lo hi : Nat) (h34 : 34 ≤ hi) (hi' : idxOf w ≤ hi) (hlo : mantOf w ≠ 0 → lo ≤ idxOf w) : mantOf w * mantOf w * 2 ^ (2 * idxOf w) = QS w hi * 2 ^ (2 * (hi - 34)) + Qai w lo hi * 2 ^ (2 * lo) := by by_cases hs : idxOf w + 34 < hi ·simp only [QS, Qai, if_pos hs] by_cases hm : mantOf w = 0 ·simp [hm] ·have := hlo hm have e : 2 * idxOf w = 2 * (idxOf w - lo) + 2 * lo := by omega rw [e, pow_add]; ring ·simp only [QS, Qai, if_neg hs] have e : 2 * idxOf w = 2 * (idxOf w + 34 - hi) + 2 * (hi - 34) := by omega rw [e, pow_add]; ring lemma Qdk (w : Word) (hi : Nat) (hi' : idxOf w ≤ hi) : QS w hi ≤ 2 ^ 116 := by unfold QS split ·exact ZAt _ ·have hm := mantOf_lt_24 w have h1 : mantOf w * mantOf w ≤ 2 ^ 48 := by nlinarith have h2 : 2 ^ (2 * (idxOf w + 34 - hi)) ≤ 2 ^ 68 := ZAm (by norm_num) (by omega) calc mantOf w * mantOf w * 2 ^ (2 * (idxOf w + 34 - hi)) ≤ 2 ^ 48 * 2 ^ 68 := Nat.mul_le_mul h1 h2 _ = 2 ^ 116 := by norm_num lemma QaE (rows n : Nat) (eps : Word) (x g : Array Word) (h : stableNormDomain rows n eps x g = true) : 0 < n ∧ 0 < rationalWord eps := by simp only [stableNormDomain, ZAx, decide_eq_true_eq] at h exact ⟨h.1.1.1.1.1.1.2, h.2⟩ @[inline] def QQ (w : Word) : UInt64 := (if expOf w == 0 then fracOf w else fracOf w ||| 0x800000).toUInt64 @[inline] def ixU (w : Word) : UInt64 := (if expOf w == 0 then 0 else expOf w - 1).toUInt64 def Q5 (x : Array Word) (b n : Nat) (lo : UInt64) (j : Nat) (p q : UInt64) : UInt64 × UInt64 := if j < n then let w := x[b + j]! let v := QQ w <<< (ixU w - lo) if signOf w then Q5 x b n lo (j + 1) p (q + v) else Q5 x b n lo (j + 1) (p + v) q else (p, q) termination_by n - j @[inline] def QaP (x : Array Word) (o n lo hi : Nat) (tp tn : UInt64) (eps : Word) : Word := let acc := QK x o n lo hi 0 0 0 0 let c := min lo (hi - 34) let S2 := (acc.1.toNat <<< 64 + acc.2.1.toNat) <<< (2 * (hi - 34 - c)) + acc.2.2 <<< (2 * (lo - c)) let Tm := (if tn ≤ tp then tp - tn else tn - tp).toNat <<< (lo - c) let V := n * S2 - Tm * Tm let t2 := idxOf eps + 149 let t0 := min (2 * c) t2 Qav (V <<< (2 * c - t0) + (n * n * mantOf eps) <<< (t2 - t0)) t0 (n * n) @[inline] def QaX (n lo : Nat) (tp tn : UInt64) (dw : Word) : Qau := ⟨expOf dw != 0 && expOf dw != 255, lo.toUInt64, n.toUInt64, tp, tn, n.toUInt64 * QQ dw, lo.toUInt64 + 875 - ixU dw, signOf dw, dw⟩ @[inline] def QaN (x : Array Word) (o n : Nat) (eps : Word) : Qau := let lh := Qo x o n 0 255 34 if n < 512 && lh.2 ≤ lh.1 + 29 then let t := Q5 x o n lh.1.toUInt64 0 0 0 QaX n lh.1 t.1 t.2 (QaP x o n lh.1 lh.2 t.1 t.2 eps) else default @[inline] def Qaq (x : Array Word) (o n : Nat) (eps : Word) : Qau := let lh := Qo x o n 0 255 34 if n < 512 && lh.2 ≤ lh.1 + 29 then QaX n lh.1 0 0 (QaP x o n lh.1 lh.2 0 0 eps) else default @[inline] def Qat (a g d : UInt64) : UInt64 × UInt64 := let c1 := (a >>> 30) * g let c2 := ((c1 % d) <<< 30) + (a &&& 0x3FFFFFFF) * g ((c1 / d) <<< 30 + c2 / d, c2 % d) @[inline] def Qar (st : Qau) (xw gw bw : Word) : UInt32 := if !st.ok then 0xFFFFFFFF else let nX := st.nn * (QQ xw <<< (ixU xw - st.lo)) let ap := (if signOf xw then 0 else nX) + st.tn let an := (if signOf xw then nX else 0) + st.tp let sA := ap < an let aM := if sA then an - ap else ap - an let G := QQ gw let Bm := QQ bw let e1 := st.b1 + ixU gw let e2 := ixU bw + 875 let u := (if Bm == 0 then e1 else if aM == 0 || G == 0 then e2 else min e1 e2) - 8 let k := e1 - u let j := e2 - u if !(aM == 0 || G == 0 || (k < 62 && aM < (1 : UInt64) <<< (62 - k))) || !(Bm == 0 || j < 38) then 0xFFFFFFFF else let qr := Qat (aM <<< k) G st.D let T2 := Bm <<< j let s1 := sA ^^ signOf gw ^^ st.sd let same := s1 == signOf bw let ge := T2 ≤ qr.1 let Q := if same then qr.1 + T2 else if ge then qr.1 - T2 else if qr.2 == 0 then T2 - qr.1 else T2 - qr.1 - 1 let R := if same || ge then qr.2 else if qr.2 == 0 then 0 else st.D - qr.2 let neg := if same || ge then s1 else signOf bw if Q == 0 && R == 0 then 0 else if Q < 0x2000000 then 0xFFFFFFFF else let r := Q.log2 - 23 let m := QJ Q R let cy : UInt64 := if m == 0x1000000 then 1 else 0 let E := u + r if E < 875 || E + cy > 1128 then 0xFFFFFFFF else (if neg then (0x80000000 : UInt32) else 0) ||| ((E + cy - 874).toUInt32 <<< 23) ||| ((if cy == 1 then 0 else m.toUInt32) &&& 0x7FFFFF) def QX (rows n : Nat) (eps : Word) (x g b : Array Word) : Array Word := if stableNormDomain rows n eps x g && b.size == n && b.all finiteWord then let st := Array.ofFn (n := rows) fun r => QaN x (r.val * n) n eps if st.all (·.ok) then Array.ofFn (n := rows * n) fun q => let w := Qar st[q.val / n]! x[q.val]! g[q.val % n]! b[q.val % n]! if w != 0xFFFFFFFF then w else roundRational ((rationalWord x[q.val]! - rowMean n x (q.val / n)) * rationalWord g[q.val % n]! / rationalWord (sqrtRational (rowVariance n x (q.val / n) (rowMean n x (q.val / n)) + rationalWord eps)) + rationalWord b[q.val % n]!) else layernormStable rows n eps x g b else layernormLegacyWith dotOf rows n eps x g b def Qal (rows n : Nat) (eps : Word) (x g : Array Word) : Array Word := if stableNormDomain rows n eps x g then let st := Array.ofFn (n := rows) fun r => Qaq x (r.val * n) n eps if st.all (·.ok) then Array.ofFn (n := rows * n) fun q => let w := Qar st[q.val / n]! x[q.val]! g[q.val % n]! 0 if w != 0xFFFFFFFF then w else roundRational (rationalWord x[q.val]! * rationalWord g[q.val % n]! / rationalWord (sqrtRational (rowVariance n x (q.val / n) 0 + rationalWord eps))) else rmsnormStable rows n eps x g else rmsnormLegacyWith dotOf rows n eps x g lemma QF (w : Word) : (QQ w).toNat = mantOf w := by unfold QQ by_cases h : expOf w = 0 ·simp [h, mantOf] ·simp only [beq_iff_eq, h, ite_false, ZAw]; exact (Qcc w h).symm lemma Qs (w : Word) : (ixU w).toNat = idxOf w := by unfold ixU idxOf by_cases h : expOf w = 0 ·simp [h] ·have h1 : (expOf w).toNat ≠ 0 := fun h' => h (ZAk (by simpa using h')) simp only [beq_iff_eq, h, ite_false, ZAw] rw [ZBw _ _ (by rw [UInt32.le_iff_toNat_le]; simp; omega)] simp lemma Q9 (w : Word) : idxOf w ≤ 254 := by have := expOf_toNat_lt w unfold idxOf; split <;> omega def Qan (w : Word) (lo : Nat) : Nat := if signOf w then 0 else mantOf w * 2 ^ (idxOf w - lo) def Qam (w : Word) (lo : Nat) : Nat := if signOf w then mantOf w * 2 ^ (idxOf w - lo) else 0 lemma QaH (w : Word) (lo : Nat) (hlo : lo ≤ 255) (h : mantOf w ≠ 0 → lo ≤ idxOf w ∧ idxOf w ≤ lo + 29) : (QQ w <<< (ixU w - lo.toUInt64)).toNat = mantOf w * 2 ^ (idxOf w - lo) ∧ mantOf w * 2 ^ (idxOf w - lo) < 2 ^ 53 := by have hm24 := mantOf_lt_24 w by_cases hm : mantOf w = 0 ·have : QQ w = 0 := ZBf (by rw [QF, hm]; rfl) rw [this, hm]; simp ·obtain ⟨h1, h2⟩ := h hm have hlt : mantOf w * 2 ^ (idxOf w - lo) < 2 ^ 53 := calc mantOf w * 2 ^ (idxOf w - lo) < 2 ^ 24 * 2 ^ 29 := ZAg hm24 (ZAm (by norm_num) (by omega)) (by positivity) _ = 2 ^ 53 := by norm_num have hl64 : lo.toUInt64.toNat = lo := by simp; omega have hs : (ixU w - lo.toUInt64).toNat = idxOf w - lo := by rw [ZAf _ _ (by rw [ZAh, Qs, hl64]; omega), Qs, hl64] refine ⟨?_, hlt⟩ rw [ZAi, QF, hs, ZAa (show idxOf w - lo < 64 by omega), ZAe] exact ZAa (by omega) lemma QcF (x : Array Word) (b n lo : Nat) (hlo : lo ≤ 255) (hn : n < 512) (hr : ∀ k, k < n → mantOf x[b + k]! ≠ 0 → lo ≤ idxOf x[b + k]! ∧ idxOf x[b + k]! ≤ lo + 29) : ∀ d j p q, n - j = d → j ≤ n → p.toNat ≤ j * 2 ^ 53 → q.toNat ≤ j * 2 ^ 53 → (Q5 x b n lo.toUInt64 j p q).1.toNat = p.toNat + ∑ k ∈ ZAb j n, Qan x[b + k]! lo ∧ (Q5 x b n lo.toUInt64 j p q).2.toNat = q.toNat + ∑ k ∈ ZAb j n, Qam x[b + k]! lo := by intro d induction d with | zero => intro j p q hd hj _ _ rw [Q5, if_neg (by omega), Finset.Ico_eq_empty_of_le (by omega)] simp | succ d ih => intro j p q hd hj hp hq have hjn : j < n := by omega rw [Q5, if_pos hjn, ZAs hjn, ZAs hjn] obtain ⟨hv, hvlt⟩ := QaH x[b + j]! lo hlo (hr j hjn) have h62 : (j + 1) * 2 ^ 53 ≤ 2 ^ 62 := by calc (j + 1) * 2 ^ 53 ≤ 512 * 2 ^ 53 := ZAj _ (by omega) _ = 2 ^ 62 := by norm_num dsimp only split ·rename_i hs have hq' : (q + QQ x[b + j]! <<< (ixU x[b + j]! - lo.toUInt64)).toNat = q.toNat + mantOf x[b + j]! * 2 ^ (idxOf x[b + j]! - lo) := by rw [ZAl, hv]; exact ZAa (by omega) obtain ⟨i1, i2⟩ := ih (j + 1) p _ (by omega) (by omega) (le_trans hp (ZAj _ (Nat.le_add_right _ 1))) (by rw [hq', Nat.add_one_mul]; exact Nat.add_le_add hq hvlt.le) refine ⟨by rw [i1]; simp [Qan, hs], by rw [i2, hq']; simp [Qam, hs]; ring⟩ ·rename_i hs have hp' : (p + QQ x[b + j]! <<< (ixU x[b + j]! - lo.toUInt64)).toNat = p.toNat + mantOf x[b + j]! * 2 ^ (idxOf x[b + j]! - lo) := by rw [ZAl, hv]; exact ZAa (by omega) obtain ⟨i1, i2⟩ := ih (j + 1) _ q (by omega) (by omega) (by rw [hp', Nat.add_one_mul]; exact Nat.add_le_add hp hvlt.le) (le_trans hq (ZAj _ (Nat.le_add_right _ 1))) refine ⟨by rw [i1, hp']; simp [Qan, hs]; ring, by rw [i2]; simp [Qam, hs]⟩ lemma QbY (w : Word) (lo : Nat) (h : mantOf w ≠ 0 → lo ≤ idxOf w) : rationalWord w = (((Qan w lo : ℤ) - Qam w lo : ℤ) : ℚ) * 2 ^ ((lo : ℤ) - 149) := by rw [QaQ] by_cases hm : mantOf w = 0 ·simp [sv, Qan, Qam, hm] ·have hl := h hm have e : (2 : ℚ) ^ ((idxOf w : ℤ) - 149) = (2 : ℚ) ^ (idxOf w - lo) * 2 ^ ((lo : ℤ) - 149) := by rw [← zpow_natCast, ← zpow_add₀ (by norm_num)]; congr 1; push_cast [hl]; ring unfold sv Qan Qam rw [e] split <;> push_cast <;> ring lemma Qdw (w : Word) : rationalWord w ^ 2 = ((mantOf w * mantOf w * 2 ^ (2 * idxOf w) : ℕ) : ℚ) * 2 ^ (-298 : ℤ) := by rw [QaQ] have hsv : (sv w : ℚ) ^ 2 = (mantOf w : ℚ) ^ 2 := by unfold sv; split <;> push_cast <;> ring have hz : ((2 : ℚ) ^ ((idxOf w : ℤ) - 149)) ^ 2 = (2 : ℚ) ^ (2 * idxOf w) * 2 ^ (-298 : ℤ) := by rw [← zpow_natCast (2 : ℚ) (2 * idxOf _), ← zpow_add₀ (by norm_num), ← zpow_natCast, ← zpow_mul] congr 1; push_cast; ring rw [mul_pow, hsv, hz]; push_cast; ring lemma QbZ (n : Nat) (hn : 0 < n) (a : Nat → ℚ) : ∑ k ∈ ZAd n, (a k - (∑ j ∈ ZAd n, a j) / n) ^ 2 = ∑ k ∈ ZAd n, a k ^ 2 - (∑ k ∈ ZAd n, a k) ^ 2 / n := by have hn' : (n : ℚ) ≠ 0 := by exact_mod_cast hn.ne' have e : ∀ k, (a k - (∑ j ∈ ZAd n, a j) / n) ^ 2 = a k ^ 2 - 2 * ((∑ j ∈ ZAd n, a j) / n) * a k + ((∑ j ∈ ZAd n, a j) / n) ^ 2 := by intro k; ring simp only [e, ZBi, ZDk, ← Finset.mul_sum, ZCx, Finset.card_range, nsmul_eq_mul] field_simp ring lemma Qa9 (n : Nat) (x : Array Word) (r : Nat) : rowMean n x r = (∑ k ∈ ZAd n, rationalWord x[r * n + k]!) / n := by unfold rowMean; rw [QA, zero_add] lemma Qa2 (n : Nat) (hn : 0 < n) (x : Array Word) (r : Nat) : rowVariance n x r (rowMean n x r) = ((∑ k ∈ ZAd n, mantOf x[r * n + k]! * mantOf x[r * n + k]! * 2 ^ (2 * idxOf x[r * n + k]!) : ℕ) * 2 ^ (-298 : ℤ) - (∑ k ∈ ZAd n, rationalWord x[r * n + k]!) ^ 2 / n) / n := by unfold rowVariance rw [QA, zero_add, Qa9, QbZ n hn (fun k => rationalWord x[r * n + k]!)] congr 2 push_cast rw [ZBm] refine ZAy rfl (fun k _ => ?_) rw [Qdw]; push_cast; ring lemma Qdd (eps : Word) (heps : 0 < rationalWord eps) : rationalWord eps = (mantOf eps : ℚ) * 2 ^ ((idxOf eps : ℤ) - 149) ∧ 0 < mantOf eps := by rw [QaQ] at heps ⊢ unfold sv at heps ⊢ split at heps ·exfalso push_cast at heps have h2 : (0 : ℚ) < 2 ^ ((idxOf eps : ℤ) - 149) := by positivity have h3 : (0 : ℚ) ≤ mantOf eps := ZDm _ nlinarith ·rename_i hs rw [if_neg hs] refine ⟨by push_cast; ring, ?_⟩ rcases Nat.eq_zero_or_pos (mantOf eps) with h0 | h0 ·rw [h0] at heps; simp at heps ·exact h0 lemma QcJ (x : Array Word) (b n lo hi : Nat) (h34 : 34 ≤ hi) (hn4 : n < 4096) (hidx : ∀ k, k < n → idxOf x[b + k]! ≤ hi) (hlo : ∀ k, k < n → mantOf x[b + k]! ≠ 0 → lo ≤ idxOf x[b + k]!) : ∑ k ∈ ZAd n, mantOf x[b + k]! * mantOf x[b + k]! * 2 ^ (2 * idxOf x[b + k]!) = ((QK x b n lo hi 0 0 0 0).1.toNat * 2 ^ 64 + (QK x b n lo hi 0 0 0 0).2.1.toNat) * 2 ^ (2 * (hi - 34)) + (QK x b n lo hi 0 0 0 0).2.2 * 2 ^ (2 * lo) := by have hbound : (0 : UInt64).toNat * 2 ^ 64 + (0 : UInt64).toNat + ∑ k ∈ ZAb 0 n, QS x[b + k]! hi < 2 ^ 128 := by have : ∑ k ∈ ZAb 0 n, QS x[b + k]! hi ≤ ∑ k ∈ ZAb 0 n, 2 ^ 116 := ZCf (fun k hk => Qdk _ _ (hidx k (ZCg hk).2)) rw [ZCx, Nat.card_Ico, smul_eq_mul] at this simp only [ZBa, zero_mul, zero_add] calc _ ≤ (n - 0) * 2 ^ 116 := this _ < 2 ^ 128 := by have : (n - 0) * 2 ^ 116 < 4096 * 2 ^ 116 := ZAn (by omega) (by positivity) exact lt_of_lt_of_le this (by norm_num) obtain ⟨a1, a2⟩ := Qct x b n lo hi hidx (n - 0) 0 0 0 0 rfl hbound rw [ZCa] at * simp only [ZBa, zero_mul, zero_add] at a1 a2 rw [a1, a2, ZBm, ZBm, ← ZBi] exact ZAy rfl (fun k hk => QcA _ lo hi h34 (hidx k (ZCg hk).2) (hlo k (ZCg hk).2)) def Qcp (st : Qau) (n : Nat) (x : Array Word) (r : Nat) (μ : ℚ) : Prop := 0 < n ∧ n < 512 ∧ st.lo.toNat ≤ 255 ∧ (∀ k, k < n → mantOf x[r * n + k]! ≠ 0 → st.lo.toNat ≤ idxOf x[r * n + k]! ∧ idxOf x[r * n + k]! ≤ st.lo.toNat + 29) ∧ st.nn.toNat = n ∧ st.tp.toNat ≤ n * 2 ^ 53 ∧ st.tn.toNat ≤ n * 2 ^ 53 ∧ μ = (((st.tp.toNat : ℤ) - st.tn.toNat : ℤ) : ℚ) * 2 ^ ((st.lo.toNat : ℤ) - 149) / n ∧ expOf st.den ≠ 0 ∧ expOf st.den ≠ 255 ∧ st.D.toNat = n * mantOf st.den ∧ st.b1.toNat = st.lo.toNat + 875 - idxOf st.den ∧ st.sd = signOf st.den lemma QaG (n : Nat) (x : Array Word) (r : Nat) (m : ℚ) : 0 ≤ rowVariance n x r m := by unfold rowVariance rw [QA, zero_add] exact div_nonneg (Finset.sum_nonneg (fun _ _ => sq_nonneg _)) (ZDm _) lemma QbR (x : Array Word) (n r lo hi : Nat) (tp tn : UInt64) (eps : Word) (hn : 0 < n) (hn4 : n < 4096) (heps : 0 < rationalWord eps) (h34 : 34 ≤ hi) (hidx : ∀ k, k < n → idxOf x[r * n + k]! ≤ hi) (hlo : ∀ k, k < n → mantOf x[r * n + k]! ≠ 0 → lo ≤ idxOf x[r * n + k]!) (μ : ℚ) (hvar : rowVariance n x r μ = (((∑ k ∈ ZAd n, mantOf x[r * n + k]! * mantOf x[r * n + k]! * 2 ^ (2 * idxOf x[r * n + k]!) : ℕ) : ℚ) * 2 ^ (-298 : ℤ) - ((((tp.toNat : ℤ) - tn.toNat : ℤ) : ℚ) * 2 ^ ((lo : ℤ) - 149)) ^ 2 / n) / n) : QaP x (r * n) n lo hi tp tn eps = sqrtRational (rowVariance n x r μ + rationalWord eps) := by unfold QaP lift_lets intro acc c S2 Tm V t2 t0 have hacc : acc = QK x (r * n) n lo hi 0 0 0 0 := rfl have hc : c = min lo (hi - 34) := rfl have hS2 : S2 = (acc.1.toNat <<< 64 + acc.2.1.toNat) <<< (2 * (hi - 34 - c)) + acc.2.2 <<< (2 * (lo - c)) := rfl have hTm : Tm = (if tn ≤ tp then tp - tn else tn - tp).toNat <<< (lo - c) := rfl have hV : V = n * S2 - Tm * Tm := rfl have ht2 : t2 = idxOf eps + 149 := rfl have ht0 : t0 = min (2 * c) t2 := rfl have hSS := QcJ x (r * n) n lo hi h34 hn4 hidx hlo rw [← hacc] at hSS clear_value acc c S2 Tm V t2 t0 have hc1 : c ≤ lo := by omega have hc2 : c ≤ hi - 34 := by omega have hS2c : ∑ k ∈ ZAd n, mantOf x[r * n + k]! * mantOf x[r * n + k]! * 2 ^ (2 * idxOf x[r * n + k]!) = S2 * 2 ^ (2 * c) := by rw [hSS, hS2] simp only [ZAe] have e1 : 2 ^ (2 * (hi - 34)) = 2 ^ (2 * (hi - 34 - c)) * 2 ^ (2 * c) := by rw [← pow_add]; congr 1; omega have e2 : 2 ^ (2 * lo) = 2 ^ (2 * (lo - c)) * 2 ^ (2 * c) := by rw [← pow_add]; congr 1; omega rw [e1, e2]; ring have hTa : ((if tn ≤ tp then tp - tn else tn - tp).toNat : ℚ) ^ 2 = (((tp.toNat : ℤ) - tn.toNat : ℤ) : ℚ) ^ 2 := by split ·rename_i h; rw [ZAf _ _ h] have := ZDe h push_cast [this]; ring ·rename_i h have h' : tp ≤ tn := by rw [ZAh] at h ⊢; omega rw [ZAf _ _ h'] have := ZDe h' push_cast [this]; ring have hsum2 : ((((tp.toNat : ℤ) - tn.toNat : ℤ) : ℚ) * 2 ^ ((lo : ℤ) - 149)) ^ 2 = ((Tm * Tm : ℕ) : ℚ) * 2 ^ (2 * c) * 2 ^ (-298 : ℤ) := by rw [hTm, ZAe] generalize (if tn ≤ tp then tp - tn else tn - tp).toNat = a at hTa ⊢ push_cast at hTa ⊢ have e : ((2 : ℚ) ^ ((lo : ℤ) - 149)) ^ 2 = (2 : ℚ) ^ (lo - c) * (2 : ℚ) ^ (lo - c) * 2 ^ (2 * c) * 2 ^ (-298 : ℤ) := by rw [← pow_add, ← pow_add, ← zpow_natCast (2 : ℚ), ← zpow_add₀ (by norm_num), ← zpow_natCast, ← zpow_mul] congr 1; push_cast [hc1]; ring rw [mul_pow, e] linear_combination (-(2 ^ (lo - c) * 2 ^ (lo - c) * 2 ^ (2 * c) * 2 ^ (-298 : ℤ) : ℚ)) * hTa have hnq : (n : ℚ) ≠ 0 := by exact_mod_cast hn.ne' have hvar' : rowVariance n x r μ = (((n * S2 : ℕ) : ℚ) - ((Tm * Tm : ℕ) : ℚ)) * 2 ^ (2 * c) * 2 ^ (-298 : ℤ) / ((n * n : ℕ) : ℚ) := by rw [hvar, hS2c, hsum2]; push_cast; field_simp <;> ring have hle : Tm * Tm ≤ n * S2 := by have h0 := QaG n x r μ rw [hvar'] at h0 have hpos : (0 : ℚ) < 2 ^ (2 * c) * 2 ^ (-298 : ℤ) / ((n * n : ℕ) : ℚ) := by positivity have e : (((n * S2 : ℕ) : ℚ) - ((Tm * Tm : ℕ) : ℚ)) * 2 ^ (2 * c) * 2 ^ (-298 : ℤ) / ((n * n : ℕ) : ℚ) = (((n * S2 : ℕ) : ℚ) - ((Tm * Tm : ℕ) : ℚ)) * (2 ^ (2 * c) * 2 ^ (-298 : ℤ) / ((n * n : ℕ) : ℚ)) := by ring rw [e] at h0 have h1 : (0 : ℚ) ≤ ((n * S2 : ℕ) : ℚ) - ((Tm * Tm : ℕ) : ℚ) := by exact nonneg_of_mul_nonneg_left h0 hpos have h2 : ((Tm * Tm : ℕ) : ℚ) ≤ ((n * S2 : ℕ) : ℚ) := by linarith exact_mod_cast h2 have hVq : (V : ℚ) = ((n * S2 : ℕ) : ℚ) - ((Tm * Tm : ℕ) : ℚ) := by rw [hV, ZDc hle] obtain ⟨heq, hmpos⟩ := Qdd eps heps have hle1 : t0 ≤ 2 * c := by omega have hle3 : t0 ≤ t2 := by omega set A := V <<< (2 * c - t0) + (n * n * mantOf eps) <<< (t2 - t0) with hA have hNat : A * 2 ^ t0 = V * 2 ^ (2 * c) + n * n * mantOf eps * 2 ^ t2 := by rw [hA]; simp only [ZAe] have e1 : 2 ^ (2 * c) = 2 ^ (2 * c - t0) * 2 ^ t0 := by rw [← pow_add]; congr 1; omega have e3 : 2 ^ t2 = 2 ^ (t2 - t0) * 2 ^ t0 := by rw [← pow_add]; congr 1; omega rw [e1, e3]; ring have hApos : 0 < A := by have : 0 < (n * n * mantOf eps) <<< (t2 - t0) := by rw [ZAe]; positivity rw [hA]; exact lt_of_lt_of_le this (Nat.le_add_left _ _) rw [QbU A t0 (n * n) hApos (by positivity)] congr 1 rw [hvar', heq, ← hVq] have hNatQ : (A : ℚ) * (2 : ℚ) ^ t0 = (V : ℚ) * 2 ^ (2 * c) + (n : ℚ) * n * mantOf eps * (2 : ℚ) ^ t2 := by exact_mod_cast hNat have z1 : (2 : ℚ) ^ ((t0 : ℤ) - 298) = (2 : ℚ) ^ t0 * 2 ^ (-298 : ℤ) := by rw [sub_eq_add_neg, zpow_add₀ (by norm_num : (2 : ℚ) ≠ 0), zpow_natCast] have z2 : (2 : ℚ) ^ ((idxOf eps : ℤ) - 149) = (2 : ℚ) ^ t2 * 2 ^ (-298 : ℤ) := by have e : ((idxOf eps : ℤ) - 149) = ((t2 : ℕ) : ℤ) + (-298) := by rw [ht2]; push_cast; ring rw [e, zpow_add₀ (by norm_num : (2 : ℚ) ≠ 0), zpow_natCast] rw [z1, z2, show (A : ℚ) * ((2 : ℚ) ^ t0 * 2 ^ (-298 : ℤ)) = ((A : ℚ) * 2 ^ t0) * 2 ^ (-298 : ℤ) by ring, hNatQ] push_cast field_simp <;> ring lemma Qck (x : Array Word) (b n lo : Nat) (hlo : lo ≤ 255) (hr : ∀ k, k < n → mantOf x[b + k]! ≠ 0 → lo ≤ idxOf x[b + k]! ∧ idxOf x[b + k]! ≤ lo + 29) : ∑ k ∈ ZAb 0 n, Qan x[b + k]! lo ≤ n * 2 ^ 53 ∧ ∑ k ∈ ZAb 0 n, Qam x[b + k]! lo ≤ n * 2 ^ 53 := by have hb : ∀ k ∈ ZAb 0 n, mantOf x[b + k]! * 2 ^ (idxOf x[b + k]! - lo) ≤ 2 ^ 53 := fun k hk => le_of_lt (QaH x[b + k]! lo hlo (hr k (ZCg hk).2)).2 constructor ·calc ∑ k ∈ ZAb 0 n, Qan x[b + k]! lo ≤ ∑ k ∈ ZAb 0 n, 2 ^ 53 := Finset.sum_le_sum (fun k hk => by unfold Qan; split <;> first | exact Nat.zero_le _ | exact hb k hk) _ = n * 2 ^ 53 := by simp ·calc ∑ k ∈ ZAb 0 n, Qam x[b + k]! lo ≤ ∑ k ∈ ZAb 0 n, 2 ^ 53 := Finset.sum_le_sum (fun k hk => by unfold Qam; split <;> first | exact Nat.zero_le _ | exact hb k hk) _ = n * 2 ^ 53 := by simp lemma QcZ (x : Array Word) (n : Nat) (eps : Word) (r : Nat) (hn : 0 < n) (heps : 0 < rationalWord eps) (hok : (QaN x (r * n) n eps).ok = true) : Qcp (QaN x (r * n) n eps) n x r (rowMean n x r) ∧ (QaN x (r * n) n eps).den = sqrtRational (rowVariance n x r (rowMean n x r) + rationalWord eps) := by unfold QaN at hok ⊢ obtain ⟨i1, i2, i3, i4⟩ := QaA x (r * n) n (n - 0) 0 255 34 rfl generalize hlh : Qo x (r * n) n 0 255 34 = lh at hok i1 i2 i3 i4 ⊢ dsimp only at hok ⊢ split at hok ·rename_i hc rw [if_pos hc] simp only [ZAx, decide_eq_true_eq] at hc obtain ⟨hn512, hspread⟩ := hc have hr : ∀ k, k < n → mantOf x[r * n + k]! ≠ 0 → lh.1 ≤ idxOf x[r * n + k]! ∧ idxOf x[r * n + k]! ≤ lh.1 + 29 := fun k hk hm => ⟨i4 k (ZAt _) hk hm, le_trans (i3 k (ZAt _) hk) hspread⟩ obtain ⟨t1, t2⟩ := QcF x (r * n) n lh.1 i2 hn512 hr (n - 0) 0 0 0 rfl (ZAt _) (by simp) (by simp) obtain ⟨s1, s2⟩ := Qck x (r * n) n lh.1 i2 hr simp only [ZBa, zero_add] at t1 t2 generalize htp : (Q5 x (r * n) n lh.1.toUInt64 0 0 0).1 = tp at t1 hok ⊢ generalize htn : (Q5 x (r * n) n lh.1.toUInt64 0 0 0).2 = tn at t2 hok ⊢ have hT : (∑ k ∈ ZAd n, rationalWord x[r * n + k]!) = (((tp.toNat : ℤ) - tn.toNat : ℤ) : ℚ) * 2 ^ ((lh.1 : ℤ) - 149) := by rw [t1, t2, ← ZCa] push_cast rw [← ZDk, ZBm] refine ZAy rfl (fun k hk => ?_) rw [QbY _ lh.1 (fun hm => (hr k (ZAu hk) hm).1)] push_cast; ring have hden := QbR x n r lh.1 lh.2 tp tn eps hn (by omega) heps i1 (fun k hk => i3 k (ZAt _) hk) (fun k hk hm => i4 k (ZAt _) hk hm) (rowMean n x r) (by rw [Qa2 n hn x r, hT]) generalize hdw : QaP x (r * n) n lh.1 lh.2 tp tn eps = dw at hden hok ⊢ simp only [QaX, ZAx, bne_iff_ne, ne_eq] at hok ⊢ have hlo64 : lh.1.toUInt64.toNat = lh.1 := by simp; omega have hn64 : n.toUInt64.toNat = n := by simp; omega have hm24 := mantOf_lt_24 dw have hix := Q9 dw refine ⟨⟨hn, hn512, by rw [hlo64]; exact i2, by rw [hlo64]; exact hr, hn64, by rw [t1]; exact s1, by rw [t2]; exact s2, by rw [hlo64, Qa9, hT], hok.1, hok.2, ?_, ?_, rfl⟩, hden⟩ ·rw [ZCt, hn64, QF] apply ZAa calc n * mantOf dw < 512 * 2 ^ 24 := ZAg hn512 hm24.le (by omega) _ ≤ 2 ^ 64 := by norm_num ·rw [ZAf _ _ ?_, ZAl, hlo64, Qs] ·simp; omega ·rw [ZAh, ZAl, hlo64, Qs]; simp; omega ·exact absurd hok (by decide) lemma Qcy (x : Array Word) (n : Nat) (eps : Word) (r : Nat) (hn : 0 < n) (heps : 0 < rationalWord eps) (hok : (Qaq x (r * n) n eps).ok = true) : Qcp (Qaq x (r * n) n eps) n x r 0 ∧ (Qaq x (r * n) n eps).den = sqrtRational (rowVariance n x r 0 + rationalWord eps) := by unfold Qaq at hok ⊢ obtain ⟨i1, i2, i3, i4⟩ := QaA x (r * n) n (n - 0) 0 255 34 rfl generalize hlh : Qo x (r * n) n 0 255 34 = lh at hok i1 i2 i3 i4 ⊢ dsimp only at hok ⊢ split at hok ·rename_i hc rw [if_pos hc] simp only [ZAx, decide_eq_true_eq] at hc obtain ⟨hn512, hspread⟩ := hc have hr : ∀ k, k < n → mantOf x[r * n + k]! ≠ 0 → lh.1 ≤ idxOf x[r * n + k]! ∧ idxOf x[r * n + k]! ≤ lh.1 + 29 := fun k hk hm => ⟨i4 k (ZAt _) hk hm, le_trans (i3 k (ZAt _) hk) hspread⟩ have hden := QbR x n r lh.1 lh.2 0 0 eps hn (by omega) heps i1 (fun k hk => i3 k (ZAt _) hk) (fun k hk hm => i4 k (ZAt _) hk hm) 0 (by rw [Qa6]; simp) generalize hdw : QaP x (r * n) n lh.1 lh.2 0 0 eps = dw at hden hok ⊢ simp only [QaX, ZAx, bne_iff_ne, ne_eq] at hok ⊢ have hlo64 : lh.1.toUInt64.toNat = lh.1 := by simp; omega have hn64 : n.toUInt64.toNat = n := by simp; omega have hm24 := mantOf_lt_24 dw have hix := Q9 dw refine ⟨⟨hn, hn512, by rw [hlo64]; exact i2, by rw [hlo64]; exact hr, hn64, by simp, by simp, by simp, hok.1, hok.2, ?_, ?_, rfl⟩, hden⟩ ·rw [ZCt, hn64, QF] apply ZAa calc n * mantOf dw < 512 * 2 ^ 24 := ZAg hn512 hm24.le (by omega) _ ≤ 2 ^ 64 := by norm_num ·rw [ZAf _ _ ?_, ZAl, hlo64, Qs] ·simp; omega ·rw [ZAh, ZAl, hlo64, Qs]; simp; omega ·exact absurd hok (by decide) lemma Qbl (a g d : UInt64) (ha : a.toNat < 2 ^ 62) (hg : g.toNat < 2 ^ 24) (hd1 : 2 ^ 23 ≤ d.toNat) (hd2 : d.toNat < 2 ^ 33) : (Qat a g d).1.toNat = a.toNat * g.toNat / d.toNat ∧ (Qat a g d).2.toNat = a.toNat * g.toNat % d.toNat := by unfold Qat dsimp only have hD : 0 < d.toNat := by omega have p30 : (30 : UInt64).toNat % 64 = 30 := rfl have e63 : (2 : ℕ) ^ 33 * 2 ^ 30 = 2 ^ 63 := by norm_num have e56 : (2 : ℕ) ^ 32 * 2 ^ 24 = 2 ^ 56 := by norm_num have e54 : (2 : ℕ) ^ 30 * 2 ^ 24 = 2 ^ 54 := by norm_num have ha1 : (a >>> 30).toNat = a.toNat / 2 ^ 30 := by rw [ZAv]; simp [ZAo] have ha0 : (a &&& 0x3FFFFFFF).toNat = a.toNat % 2 ^ 30 := by rw [ZCu, show (0x3FFFFFFF : UInt64).toNat = 2 ^ 30 - 1 from rfl] exact ZBd _ 30 have hA1 : a.toNat / 2 ^ 30 < 2 ^ 32 := by omega have hA0 : a.toNat % 2 ^ 30 < 2 ^ 30 := ZCe _ (by positivity) have hc1lt : a.toNat / 2 ^ 30 * g.toNat < 2 ^ 56 := e56 ▸ ZAg hA1 hg.le (by omega) have hlowlt : a.toNat % 2 ^ 30 * g.toNat < 2 ^ 54 := e54 ▸ ZAg hA0 hg.le (by omega) have hc1 : ((a >>> 30) * g).toNat = a.toNat / 2 ^ 30 * g.toNat := by rw [ZCt, ha1]; exact ZAa (by omega) have hlow : ((a &&& 0x3FFFFFFF) * g).toNat = a.toNat % 2 ^ 30 * g.toNat := by rw [ZCt, ha0]; exact ZAa (by omega) generalize hC1 : a.toNat / 2 ^ 30 * g.toNat = c1 at hc1 hc1lt generalize hL : a.toNat % 2 ^ 30 * g.toNat = lw at hlow hlowlt have hr1lt : c1 % d.toNat < 2 ^ 33 := lt_trans (ZCe _ hD) hd2 have hshlt : c1 % d.toNat * 2 ^ 30 < 2 ^ 63 := e63 ▸ ZAn hr1lt (by positivity) have hsh : (((a >>> 30) * g % d) <<< 30).toNat = c1 % d.toNat * 2 ^ 30 := by rw [ZAi, UInt64.toNat_mod, hc1, p30, ZAe] exact ZAa (by omega) have hc2 : (((a >>> 30) * g % d) <<< 30 + (a &&& 0x3FFFFFFF) * g).toNat = c1 % d.toNat * 2 ^ 30 + lw := by rw [ZAl, hsh, hlow] exact ZAa (lt_of_lt_of_le (Nat.add_lt_add hshlt hlowlt) (by norm_num)) generalize hC2 : c1 % d.toNat * 2 ^ 30 + lw = c2 at hc2 have hc2lt : c2 < 2 ^ 64 := by rw [← hC2]; exact lt_of_lt_of_le (Nat.add_lt_add hshlt hlowlt) (by norm_num) have hag : a.toNat * g.toNat = c2 + c1 / d.toNat * 2 ^ 30 * d.toNat := by have e1 : a.toNat = a.toNat / 2 ^ 30 * 2 ^ 30 + a.toNat % 2 ^ 30 := (ZCc _ _).symm have e2 : c1 = c1 / d.toNat * d.toNat + c1 % d.toNat := (ZCc _ _).symm rw [← hC2] calc a.toNat * g.toNat = (a.toNat / 2 ^ 30 * 2 ^ 30 + a.toNat % 2 ^ 30) * g.toNat := by rw [← e1] _ = c1 * 2 ^ 30 + lw := by rw [← hC1, ← hL]; ring _ = (c1 / d.toNat * d.toNat + c1 % d.toNat) * 2 ^ 30 + lw := by rw [← e2] _ = (c1 % d.toNat * 2 ^ 30 + lw) + c1 / d.toNat * 2 ^ 30 * d.toNat := by ring have hq1lt : c1 / d.toNat < 2 ^ 33 := by rw [ZBk hD] calc c1 < 2 ^ 56 := hc1lt _ = 2 ^ 33 * 2 ^ 23 := by norm_num _ ≤ 2 ^ 33 * d.toNat := ZCm _ hd1 have hq1sh : c1 / d.toNat * 2 ^ 30 < 2 ^ 63 := e63 ▸ ZAn hq1lt (by positivity) have hq2lt : c2 / d.toNat < 2 ^ 41 := by rw [ZBk hD] calc c2 < 2 ^ 64 := hc2lt _ = 2 ^ 41 * 2 ^ 23 := by norm_num _ ≤ 2 ^ 41 * d.toNat := ZCm _ hd1 have hq1u : (((a >>> 30) * g / d) <<< 30).toNat = c1 / d.toNat * 2 ^ 30 := by rw [ZAi, UInt64.toNat_div, hc1, p30, ZAe] exact ZAa (lt_trans hq1sh (by norm_num)) have hq2u : ((((a >>> 30) * g % d) <<< 30 + (a &&& 0x3FFFFFFF) * g) / d).toNat = c2 / d.toNat := by rw [UInt64.toNat_div, hc2] constructor ·rw [ZAl, hq1u, hq2u, ZAa (lt_of_lt_of_le (Nat.add_lt_add hq1sh hq2lt) (by norm_num)), hag, ZDn _ _ hD, ZDo] ·rw [UInt64.toNat_mod, hc2, hag, ZDb] lemma QcI (a d : UInt64) : Qat a 0 d = (0, 0) := by simp [Qat] lemma Qcv (q0 r0 T2 Dw : UInt64) (s1 s2 : Bool) (hr : r0.toNat < Dw.toNat) (hq0 : q0.toNat < 2 ^ 63) (hT2 : T2.toNat < 2 ^ 62) : (if s1 == s2 || T2 ≤ q0 then r0 else if r0 == 0 then 0 else Dw - r0).toNat < Dw.toNat ∧ (if s1 then -1 else 1) * ((q0.toNat : ℚ) + r0.toNat / Dw.toNat) + (if s2 then -1 else 1) * (T2.toNat : ℚ) = (if (if s1 == s2 || T2 ≤ q0 then s1 else s2) then -1 else 1) * (((if s1 == s2 then q0 + T2 else if T2 ≤ q0 then q0 - T2 else if r0 == 0 then T2 - q0 else T2 - q0 - 1).toNat : ℚ) + (if s1 == s2 || T2 ≤ q0 then r0 else if r0 == 0 then 0 else Dw - r0).toNat / Dw.toNat) := by have hD : (0 : ℚ) < Dw.toNat := by exact_mod_cast (show 0 < Dw.toNat by omega) by_cases hs : (s1 == s2) = true ·have hs' : s2 = s1 := by cases s1 <;> cases s2 <;> simp_all subst hs' have hadd : (q0 + T2).toNat = q0.toNat + T2.toNat := by rw [ZAl]; exact ZAa (by omega) simp only [hs, Bool.true_or, ite_true, hadd] refine ⟨hr, ?_⟩ push_cast; ring ·simp only [hs, Bool.false_or, ZAp, ite_false] have hs2 : s2 = !s1 := by cases s1 <;> cases s2 <;> simp_all subst hs2 by_cases hge : T2 ≤ q0 ·have hsub : (q0 - T2).toNat = q0.toNat - T2.toNat := ZAf _ _ hge have hle := ZDe hge simp only [hge, decide_true, ite_true, hsub] refine ⟨hr, ?_⟩ rw [ZDc hle] cases s1 <;> simp <;> ring ·have hlt : q0.toNat < T2.toNat := by rw [ZAh] at hge; omega simp only [hge, decide_false, ZAp, ite_false] by_cases hr0 : r0 = 0 ·have hr0' : r0.toNat = 0 := by rw [hr0]; rfl have hsub : (T2 - q0).toNat = T2.toNat - q0.toNat := ZAf _ _ (by rw [ZAh]; omega) simp only [hr0, beq_self_eq_true, ite_true, hsub, ZBa] refine ⟨by omega, ?_⟩ rw [ZDc hlt.le] cases s1 <;> simp [hr0'] <;> ring ·have hr0' : r0.toNat ≠ 0 := fun h => hr0 (ZBf (by rw [h]; rfl)) have hb : (r0 == 0) = false := by simpa using hr0 have hsub : (T2 - q0 - 1).toNat = T2.toNat - q0.toNat - 1 := by rw [ZAf _ _ ?_, ZAf _ _ (by rw [ZAh]; omega)] ·rfl ·rw [ZAh, ZAf _ _ (by rw [ZAh]; omega)] simp; omega have hsub2 : (Dw - r0).toNat = Dw.toNat - r0.toNat := ZAf _ _ (by rw [ZAh]; omega) simp only [hb, ZAp, ite_false, hsub, hsub2] refine ⟨by omega, ?_⟩ rw [ZDc (show 1 ≤ T2.toNat - q0.toNat by omega), ZDc hlt.le, ZDc hr.le] field_simp cases s1 <;> simp <;> ring lemma QcK (Q R u : UInt64) (D : Nat) (neg : Bool) (v : ℚ) (hQ : 2 ^ 25 ≤ Q.toNat) (hR : R.toNat < D) (hu : u.toNat < 2 ^ 20) (hv : v = (if neg then -1 else 1) * ((Q.toNat : ℚ) + R.toNat / D) * 2 ^ ((u.toNat : ℤ) - 1024)) (hE : ¬((decide (u + (Q.log2 - 23) < 875) || decide (u + (Q.log2 - 23) + (if QJ Q R == 0x1000000 then (1 : UInt64) else 0) > 1128)) = true)) : ((if neg then (0x80000000 : UInt32) else 0) ||| ((u + (Q.log2 - 23) + (if QJ Q R == 0x1000000 then (1 : UInt64) else 0) - 874).toUInt32 <<< 23) ||| ((if (if QJ Q R == 0x1000000 then (1 : UInt64) else 0) == 1 then 0 else (QJ Q R).toUInt32) &&& 0x7FFFFF)) = roundRational v := by have hD : 0 < D := by omega have hQ0 : Q.toNat ≠ 0 := by omega have hl1 : 25 ≤ Q.toNat.log2 := (ZBt hQ0).mpr hQ have hl2 : Q.toNat.log2 < 64 := (ZDa hQ0).mpr Q.toNat_lt have hm := Qa8 Q R D hQ hR have hr : (Q.log2 - 23).toNat = Q.toNat.log2 - 23 := by rw [ZAf _ _ (by rw [ZAh, QaV]; simp; omega), QaV]; simp generalize hrN : Q.toNat.log2 - 23 = rN at hm hr generalize hM : QJ Q R = M at hm hE ⊢ have hQlo : 2 ^ (rN + 23) ≤ Q.toNat := by have := ZCk hQ0; rw [show rN + 23 = Q.toNat.log2 by omega]; exact this have hQhi : Q.toNat < 2 ^ (rN + 24) := by have := Nat.lt_log2_self (n := Q.toNat); rw [show rN + 24 = Q.toNat.log2 + 1 by omega]; exact this have hL1 : D * 2 ^ rN * 2 ^ 23 ≤ Q.toNat * D + R.toNat := by have : D * 2 ^ rN * 2 ^ 23 = 2 ^ (rN + 23) * D := by rw [pow_add]; ring rw [this] calc 2 ^ (rN + 23) * D ≤ Q.toNat * D := ZAj _ hQlo _ ≤ Q.toNat * D + R.toNat := Nat.le_add_right _ _ have hL2 : Q.toNat * D + R.toNat < D * 2 ^ rN * 2 ^ (23 + 1) := by have : D * 2 ^ rN * 2 ^ (23 + 1) = 2 ^ (rN + 24) * D := by rw [show (2 : ℕ) ^ (rN + 24) = 2 ^ rN * 2 ^ 24 from pow_add 2 rN 24]; ring rw [this] calc Q.toNat * D + R.toNat < Q.toNat * D + D := by omega _ = (Q.toNat + 1) * D := by ring _ ≤ 2 ^ (rN + 24) * D := ZAj _ hQhi have hDd : 0 < D * 2 ^ rN := by positivity have hM1 : 2 ^ 23 ≤ M.toNat ∧ M.toNat ≤ 2 ^ 24 := by have hmr := FloatLib.Numerics.roundQuotientEven_eq_quotient_add (Q.toNat * D + R.toNat) (D * 2 ^ rN) rw [hm, hmr] have hq1 : 2 ^ 23 ≤ (Q.toNat * D + R.toNat) / (D * 2 ^ rN) := (ZBy hDd).mpr (by rw [mul_comm]; exact hL1) have hq2 : (Q.toNat * D + R.toNat) / (D * 2 ^ rN) < 2 ^ 24 := (ZBk hDd).mpr (by have h2 := hL2 rw [show D * 2 ^ rN * 2 ^ (23 + 1) = 2 ^ 24 * (D * 2 ^ rN) by ring] at h2 exact h2) constructor <;> split <;> omega have hc : (M == 0x1000000) = true ↔ M.toNat = 2 ^ 24 := by rw [beq_iff_eq, ← ZBr]; rfl set cN : Nat := if M.toNat = 2 ^ 24 then 1 else 0 with hcN have hcu : (if (M == 0x1000000) = true then (1 : UInt64) else 0).toNat = cN := by by_cases h' : M.toNat = 2 ^ 24 ·rw [if_pos (hc.mpr h'), hcN, if_pos h']; rfl ·rw [if_neg (fun h'' => h' (hc.mp h'')), hcN, if_neg h']; rfl have hcN1 : cN ≤ 1 := by rw [hcN]; split <;> omega have he1 : (u + (Q.log2 - 23)).toNat = u.toNat + rN := by rw [ZAl, hr]; exact ZAa (by omega) have he2 : (u + (Q.log2 - 23) + (if (M == 0x1000000) = true then (1 : UInt64) else 0)).toNat = u.toNat + rN + cN := by rw [ZAl, he1, hcu]; exact ZAa (by omega) simp only [ZCd, decide_eq_true_eq, not_or, not_lt, ZAr, gt_iff_lt] at hE obtain ⟨hE1, hE2⟩ := hE rw [he1] at hE1 rw [he2] at hE2 simp only [show (875 : UInt64).toNat = 875 from rfl, show (1128 : UInt64).toNat = 1128 from rfl] at hE1 hE2 have hEf : ((u + (Q.log2 - 23) + (if (M == 0x1000000) = true then (1 : UInt64) else 0) - 874).toUInt32).toNat = u.toNat + rN + cN - 874 := by rw [ZBc, ZAf _ _ (by rw [ZAh, he2]; simp; omega), he2] simp; omega have hF : ((if (if (M == 0x1000000) = true then (1 : UInt64) else 0) == 1 then 0 else M.toUInt32) &&& 0x7FFFFF).toNat = if M.toNat = 2 ^ 24 then 0 else M.toNat - 2 ^ 23 := by by_cases h' : M.toNat = 2 ^ 24 ·rw [if_pos (hc.mpr h'), if_pos h']; simp ·rw [if_neg (fun h'' => h' (hc.mp h'')), if_neg h'] simp only [show ((0 : UInt64) == 1) = false from rfl, ZAp, ite_false] rw [ZCj, ZBc, show (0x7FFFFF : UInt32).toNat = 2 ^ 23 - 1 from rfl, ZBd] omega rw [QcY _ _ _ (by rw [hEf]; omega) (by rw [hF]; split <;> omega), hEf, hF] have hQq : (0 : ℚ) < Q.toNat := by exact_mod_cast (show 0 < Q.toNat by omega) have hRq : (0 : ℚ) ≤ R.toNat / D := div_nonneg (ZDm _) (ZDm _) have hpos : (0 : ℚ) < (Q.toNat : ℚ) + R.toNat / D := add_pos_of_pos_of_nonneg hQq hRq have h2p : (0 : ℚ) < 2 ^ ((u.toNat : ℤ) - 1024) := zpow_pos (by norm_num) _ have hX : (0 : ℚ) < ((Q.toNat : ℚ) + R.toNat / D) * 2 ^ ((u.toNat : ℤ) - 1024) := mul_pos hpos h2p have hv' : v = (if neg then -1 else 1) * (((Q.toNat : ℚ) + R.toNat / D) * 2 ^ ((u.toNat : ℤ) - 1024)) := by rw [hv]; ring have hv0 : v ≠ 0 := by rw [hv']; cases neg <;> simp <;> exact ⟨hpos.ne', h2p.ne'⟩ have hneg : v < 0 ↔ neg = true := by rw [hv']; cases neg ·simp; exact hX.le ·simp; exact hX have habs : ((|v| : ℚ) : ℝ) = ((Q.toNat * D + R.toNat : ℕ) : ℝ) / ((D * 2 ^ rN : ℕ) : ℝ) * (2 : ℝ) ^ (((u.toNat : ℤ) - 1024 + rN)) := by have : |v| = ((Q.toNat : ℚ) + R.toNat / D) * 2 ^ ((u.toNat : ℤ) - 1024) := by rw [hv, abs_mul, abs_mul] cases neg <;> simp [abs_of_pos hpos, abs_of_pos (zpow_pos (by norm_num : (0 : ℚ) < 2) _)] rw [this] have hDq : (D : ℝ) ≠ 0 := by exact_mod_cast hD.ne' push_cast rw [zpow_add₀ (by norm_num : (2 : ℝ) ≠ 0), zpow_natCast] field_simp have hT2 : ((23 : ℕ) : ℤ) + ((u.toNat : ℤ) - 1024 + rN) + (if M.toNat = 2 ^ 24 then 1 else 0) ≤ 127 := by by_cases hm' : M.toNat = 2 ^ 24 ·have : cN = 1 := by rw [hcN, if_pos hm'] rw [if_pos hm']; omega ·have : cN = 0 := by rw [hcN, if_neg hm'] rw [if_neg hm']; omega rw [Qbe v (Q.toNat * D + R.toNat) (D * 2 ^ rN) ((u.toNat : ℤ) - 1024 + rN) 23 (Q.toNat * D + R.toNat) (D * 2 ^ rN) M.toNat hv0 habs hDd hL1 hL2 hDd.ne' (by norm_num) hm (by omega) hT2] clear_value cN apply congrArg ZCs have hs : (if neg = true then 2 ^ 31 else 0 : ℕ) = (if v < 0 then 2 ^ 31 else 0) := by by_cases h' : neg = true ·rw [if_pos h', if_pos (hneg.mpr h')] ·rw [if_neg h', if_neg (fun h'' => h' (hneg.mp h''))] rw [hs] by_cases hm' : M.toNat = 2 ^ 24 ·have : cN = 1 := by rw [hcN, if_pos hm'] simp only [if_pos hm']; omega ·have : cN = 0 := by rw [hcN, if_neg hm'] simp only [if_neg hm']; omega lemma Qbz (w : Word) : rationalWord w = (if signOf w then -1 else 1) * (mantOf w : ℚ) * 2 ^ ((idxOf w : ℤ) - 149) := by rw [QaQ]; unfold sv; split <;> push_cast <;> ring lemma Qdz (a b c : Bool) : ((if (a ^^ b ^^ c) then -1 else 1 : ℚ)) = (if a then -1 else 1) * (if b then -1 else 1) * (if c then -1 else 1) := by cases a <;> cases b <;> cases c <;> norm_num set_option maxRecDepth 8192 in lemma Qa0 (st : Qau) (n : Nat) (x : Array Word) (r : Nat) (μ : ℚ) (hrow : Qcp st n x r μ) (kk : Nat) (hk : kk < n) (gw bw : Word) (h : Qar st x[r * n + kk]! gw bw ≠ 0xFFFFFFFF) : Qar st x[r * n + kk]! gw bw = roundRational ((rationalWord x[r * n + kk]! - μ) * rationalWord gw / rationalWord st.den + rationalWord bw) := by obtain ⟨hn, hn512, hlo, hrr, hnn, htp, htn, hmean, hd0, hd255, hD, hb1, hsd⟩ := hrow have hrx := hrr kk hk clear hrr generalize hxw : x[r * n + kk]! = xw at hrx h ⊢ rw [hmean] clear hmean generalize hres : Qar st xw gw bw = res at h ⊢ unfold Qar at hres lift_lets at hres extract_lets nX ap an sA aM G Bm e1 e2 u k j qr T2 s1 same ge Q R neg r m cy E at hres have dnX : nX = st.nn * (QQ xw <<< (ixU xw - st.lo)) := rfl have dap : ap = (if signOf xw = true then 0 else nX) + st.tn := rfl have dan : an = (if signOf xw = true then nX else 0) + st.tp := rfl have dsA : sA = (ap < an) := rfl have daM : aM = if sA then an - ap else ap - an := rfl have dG : G = QQ gw := rfl have dBm : Bm = QQ bw := rfl have de1 : e1 = st.b1 + ixU gw := rfl have de2 : e2 = ixU bw + 875 := rfl have du : u = (if (Bm == 0) = true then e1 else if (aM == 0 || G == 0) = true then e2 else min e1 e2) - 8 := rfl have dk : k = e1 - u := rfl have dj : j = e2 - u := rfl have dqr : qr = Qat (aM <<< k) G st.D := rfl have dT2 : T2 = Bm <<< j := rfl have ds1 : s1 = (decide sA ^^ signOf gw ^^ st.sd) := rfl have dsame : same = (s1 == signOf bw) := rfl have dge : ge = (T2 ≤ qr.1) := rfl have dQ : Q = if same = true then qr.1 + T2 else if ge then qr.1 - T2 else if (qr.2 == 0) = true then T2 - qr.1 else T2 - qr.1 - 1 := rfl have dR : R = if (same || decide ge) = true then qr.2 else if (qr.2 == 0) = true then 0 else st.D - qr.2 := rfl have dneg : neg = if (same || decide ge) = true then s1 else signOf bw := rfl have dr : r = Q.log2 - 23 := rfl have dm : m = QJ Q R := rfl have dcy : cy = if (m == 16777216) = true then 1 else 0 := rfl have dE : E = u + r := rfl clear_value nX ap an aM G Bm e1 e2 u k j qr T2 s1 same Q R neg r m cy E have hlo64 : st.lo = (st.lo.toNat).toUInt64 := by apply ZBf; simp obtain ⟨hsh, hshlt⟩ := QaH xw st.lo.toNat hlo hrx rw [← hlo64] at hsh have hnX : nX.toNat = n * (mantOf xw * 2 ^ (idxOf xw - st.lo.toNat)) := by rw [dnX, ZCt, hnn, hsh] apply ZAa calc n * (mantOf xw * 2 ^ (idxOf xw - st.lo.toNat)) < 512 * 2 ^ 53 := ZAg hn512 hshlt.le (by omega) _ ≤ 2 ^ 64 := by norm_num have hnXlt : nX.toNat < 2 ^ 62 := by rw [hnX] calc n * (mantOf xw * 2 ^ (idxOf xw - st.lo.toNat)) < 512 * 2 ^ 53 := ZAg hn512 hshlt.le (by omega) _ = 2 ^ 62 := by norm_num have htp62 : st.tp.toNat < 2 ^ 62 := lt_of_le_of_lt htp (by calc n * 2 ^ 53 < 512 * 2 ^ 53 := ZAn hn512 (by positivity) _ = 2 ^ 62 := by norm_num) have htn62 : st.tn.toNat < 2 ^ 62 := lt_of_le_of_lt htn (by calc n * 2 ^ 53 < 512 * 2 ^ 53 := ZAn hn512 (by positivity) _ = 2 ^ 62 := by norm_num) have hap : ap.toNat = (if signOf xw = true then 0 else nX.toNat) + st.tn.toNat := by rw [dap, ZAl]; split <;> simp <;> omega have han : an.toNat = (if signOf xw = true then nX.toNat else 0) + st.tp.toNat := by rw [dan, ZAl]; split <;> simp <;> omega have hap63 : ap.toNat < 2 ^ 63 := by rw [hap]; split <;> omega have han63 : an.toNat < 2 ^ 63 := by rw [han]; split <;> omega have hsA : sA ↔ ap.toNat < an.toNat := by rw [dsA, ZAr] have haM : (aM.toNat : ℤ) = |(ap.toNat : ℤ) - an.toNat| := by rw [daM] split ·rename_i h'; rw [ZAf _ _ (by rw [ZAh]; have := hsA.mp h'; omega)] have := hsA.mp h'; rw [abs_of_neg (by omega)]; omega ·rename_i h'; rw [ZAf _ _ (by rw [ZAh]; have := mt hsA.mpr h'; omega)] have := mt hsA.mpr h'; rw [abs_of_nonneg (by omega)]; omega have haM63 : aM.toNat < 2 ^ 63 := by have : |(ap.toNat : ℤ) - an.toNat| < 2 ^ 63 := abs_sub_lt_iff.mpr ⟨by omega, by omega⟩ omega have hG : G.toNat = mantOf gw := by rw [dG, QF] have hBm : Bm.toNat = mantOf bw := by rw [dBm, QF] have hixg := Qs gw have hixb := Qs bw have hig := Q9 gw have hib := Q9 bw have hid := Q9 st.den have he1 : e1.toNat = st.lo.toNat + 875 - idxOf st.den + idxOf gw := by rw [de1, ZAl, hb1, hixg]; exact ZAa (by omega) have he2 : e2.toNat = idxOf bw + 875 := by rw [de2, ZAl, hixb]; exact ZAa (by simp; omega) split at hres ·exact absurd hres.symm h split at hres ·exact absurd hres.symm h rename_i hcond simp only [Bool.not_or, Bool.not_not, ZCd, ZAx, Bool.not_eq_true', not_or, Bool.not_eq_false, beq_iff_eq, decide_eq_true_eq] at hcond obtain ⟨hc1, hc2⟩ := hcond have hU : ∀ U : UInt64, U.toNat ≥ 600 → (U - 8).toNat = U.toNat - 8 := fun U hU => ZAf _ _ (by rw [ZAh]; simp; omega) have hmin : (min e1 e2).toNat = min e1.toNat e2.toNat := UInt64.toNat_min e1 e2 have hu : u.toNat = (if Bm = 0 then e1.toNat else if aM = 0 ∨ G = 0 then e2.toNat else min e1.toNat e2.toNat) - 8 := by rw [du] by_cases hb0 : Bm = 0 ·simp only [hb0, beq_self_eq_true, ite_true]; exact hU _ (by omega) ·have : (Bm == 0) = false := by simpa using hb0 simp only [this, ZAp, ite_false, hb0] by_cases ha0 : aM = 0 ∨ G = 0 ·have : (aM == 0 || G == 0) = true := by rcases ha0 with h' | h' <;> simp [h'] simp only [this, ite_true, ha0]; exact hU _ (by omega) ·have : (aM == 0 || G == 0) = false := by push_neg at ha0; simp [ha0.1, ha0.2] simp only [this, ZAp, ite_false, ha0]; rw [hU _ (by rw [hmin]; omega), hmin] have hk : aM ≠ 0 → G ≠ 0 → k.toNat = e1.toNat - u.toNat ∧ u.toNat ≤ e1.toNat := by intro ha hg have hle : u.toNat ≤ e1.toNat := by rw [hu]; split ·omega ·rw [if_neg (fun h' => h'.elim ha hg)]; omega exact ⟨by rw [dk, ZAf _ _ (ZCh hle)], hle⟩ have hj : Bm ≠ 0 → j.toNat = e2.toNat - u.toNat ∧ u.toNat ≤ e2.toNat := by intro hb have hle : u.toNat ≤ e2.toNat := by rw [hu, if_neg hb]; split ·omega ·omega exact ⟨by rw [dj, ZAf _ _ (ZCh hle)], hle⟩ have hu20 : u.toNat < 2 ^ 20 := by rw [hu]; split <;> (try split) <;> omega have hc1' : aM ≠ 0 → G ≠ 0 → k.toNat < 62 ∧ aM.toNat < 2 ^ (62 - k.toNat) := by intro ha hg have ha' : (aM == 0) = false := by simpa using ha have hg' : (G == 0) = false := by simpa using hg have h3 : ¬((decide (k < 62) && decide (aM < 1 <<< (62 - k))) = false) := fun h3 => hc1 ⟨⟨ha', hg'⟩, h3⟩ simp only [Bool.and_eq_false_iff, decide_eq_false_iff_not, not_or, not_not] at h3 obtain ⟨h4, h5⟩ := h3 have hk62 : k.toNat < 62 := ZDd h4 refine ⟨hk62, ?_⟩ have hs : ((1 : UInt64) <<< (62 - k)).toNat = 2 ^ (62 - k.toNat) := by have e : (62 - k).toNat = 62 - k.toNat := by rw [ZAf _ _ (ZCh (by simp; omega))]; rfl rw [ZAi, e, ZAa (show 62 - k.toNat < 64 by omega), ZAe, show (1 : UInt64).toNat = 1 from rfl, one_mul] exact ZAa (ZDq (by norm_num) (by omega)) rw [← hs]; exact ZDd h5 have hc2' : Bm ≠ 0 → j.toNat < 38 := by intro hb have hb' : (Bm == 0) = false := by simpa using hb have h3 : ¬(decide (j < 38) = false) := fun h3 => hc2 ⟨hb', h3⟩ simp only [decide_eq_false_iff_not, not_not] at h3 exact ZDd h3 have hmd := Qce st.den hd0 have hDw1 : 2 ^ 23 ≤ st.D.toNat := by rw [hD]; exact le_trans hmd.1 (ZDj _ hn) have hDw2 : st.D.toNat < 2 ^ 33 := by rw [hD] calc n * mantOf st.den < 512 * 2 ^ 24 := ZAg hn512 hmd.2.le (by omega) _ = 2 ^ 33 := by norm_num have hGlt : G.toNat < 2 ^ 24 := by rw [hG]; exact mantOf_lt_24 gw have hBlt : Bm.toNat < 2 ^ 24 := by rw [hBm]; exact mantOf_lt_24 bw have hqr : qr.1.toNat * st.D.toNat + qr.2.toNat = (if aM = 0 ∨ G = 0 then 0 else aM.toNat * 2 ^ k.toNat * G.toNat) ∧ qr.2.toNat < st.D.toNat ∧ qr.1.toNat < 2 ^ 63 := by rw [dqr] have hDpos : 0 < st.D.toNat := by omega by_cases hz : aM = 0 ∨ G = 0 ·rw [if_pos hz] rcases hz with ha | hg ·have h0 : aM <<< k = 0 := by rw [ha]; apply ZBf; rw [ZAi]; simp obtain ⟨q1, q2⟩ := Qbl 0 G st.D (by simp) hGlt hDw1 hDw2 rw [h0, q1, q2]; simp; omega ·rw [hg, QcI]; simp; omega ·rw [if_neg hz] push_neg at hz obtain ⟨hk62, haM2⟩ := hc1' hz.1 hz.2 have hsh2 : (aM <<< k).toNat = aM.toNat * 2 ^ k.toNat := by rw [ZAi, ZAa (show k.toNat < 64 by omega), ZAe] apply ZAa calc aM.toNat * 2 ^ k.toNat < 2 ^ (62 - k.toNat) * 2 ^ k.toNat := ZAn haM2 (by positivity) _ = 2 ^ 62 := by rw [← pow_add]; congr 1; omega _ < 2 ^ 64 := by norm_num have ha62 : (aM <<< k).toNat < 2 ^ 62 := by rw [hsh2] calc aM.toNat * 2 ^ k.toNat < 2 ^ (62 - k.toNat) * 2 ^ k.toNat := ZAn haM2 (by positivity) _ = 2 ^ 62 := by rw [← pow_add]; congr 1; omega obtain ⟨q1, q2⟩ := Qbl (aM <<< k) G st.D ha62 hGlt hDw1 hDw2 rw [q1, q2, hsh2] refine ⟨ZCc _ _, ZCe _ hDpos, ?_⟩ rw [ZBk hDpos] have hlt := ha62; rw [hsh2] at hlt calc aM.toNat * 2 ^ k.toNat * G.toNat < 2 ^ 62 * 2 ^ 24 := ZAg hlt hGlt.le (by norm_num) _ = 2 ^ 63 * 2 ^ 23 := by norm_num _ ≤ 2 ^ 63 * st.D.toNat := ZCm _ hDw1 have hT2 : T2.toNat = (if Bm = 0 then 0 else Bm.toNat * 2 ^ j.toNat) ∧ T2.toNat < 2 ^ 62 := by rw [dT2] by_cases hb : Bm = 0 ·rw [if_pos hb, hb]; simp ·rw [if_neg hb] have hj38 := hc2' hb have hlt : Bm.toNat * 2 ^ j.toNat < 2 ^ 62 := calc Bm.toNat * 2 ^ j.toNat < 2 ^ 24 * 2 ^ 38 := ZAg hBlt (ZAm (by norm_num) hj38.le) (by positivity) _ = 2 ^ 62 := by norm_num have e : (Bm <<< j).toNat = Bm.toNat * 2 ^ j.toNat := by rw [ZAi, ZAa (show j.toNat < 64 by omega), ZAe] exact ZAa (by omega) exact ⟨e, by rw [e]; exact hlt⟩ obtain ⟨hqr1, hqr2, hqr3⟩ := hqr obtain ⟨hT2v, hT2lt⟩ := hT2 have hcomb : R.toNat < st.D.toNat ∧ (if s1 then -1 else 1) * ((qr.1.toNat : ℚ) + qr.2.toNat / st.D.toNat) + (if signOf bw then -1 else 1) * (T2.toNat : ℚ) = (if neg then -1 else 1) * ((Q.toNat : ℚ) + R.toNat / st.D.toNat) := by rw [dQ, dR, dneg, dsame] exact Qcv qr.1 qr.2 T2 st.D s1 (signOf bw) hqr2 hqr3 hT2lt obtain ⟨hRD, hcomb⟩ := hcomb have hDq : (st.D.toNat : ℚ) = n * mantOf st.den := by rw [hD]; push_cast; ring have hnq : (n : ℚ) ≠ 0 := by exact_mod_cast hn.ne' have hmdq : (mantOf st.den : ℚ) ≠ 0 := by exact_mod_cast (show mantOf st.den ≠ 0 by omega) have hAz : rationalWord xw - (((st.tp.toNat : ℤ) - st.tn.toNat : ℤ) : ℚ) * 2 ^ ((st.lo.toNat : ℤ) - 149) / n = (if sA then -1 else 1) * (aM.toNat : ℚ) * 2 ^ ((st.lo.toNat : ℤ) - 149) / n := by rw [QbY xw st.lo.toNat (fun hm => (hrx hm).1)] have hsgn : ((if sA then -1 else 1) * (aM.toNat : ℚ)) = ((ap.toNat : ℤ) - an.toNat : ℤ) := by by_cases hs : sA ·have := hsA.mp hs rw [if_pos hs]; have e : (aM.toNat : ℤ) = an.toNat - ap.toNat := by rw [haM, abs_of_neg (by omega)]; ring have e' : (aM.toNat : ℚ) = ((an.toNat : ℤ) - ap.toNat : ℤ) := by exact_mod_cast e rw [e']; push_cast; ring ·have := mt hsA.mpr hs rw [if_neg hs]; have e : (aM.toNat : ℤ) = ap.toNat - an.toNat := by rw [haM, abs_of_nonneg (by omega)] have e' : (aM.toNat : ℚ) = ((ap.toNat : ℤ) - an.toNat : ℤ) := by exact_mod_cast e rw [e', one_mul] rw [hsgn, hap, han, hnX] unfold Qan Qam split <;> push_cast <;> field_simp <;> ring have hterm1 : (if sA then -1 else 1) * (aM.toNat : ℚ) * 2 ^ ((st.lo.toNat : ℤ) - 149) / n * rationalWord gw / rationalWord st.den = (if s1 then -1 else 1) * ((qr.1.toNat : ℚ) + qr.2.toNat / st.D.toNat) * 2 ^ ((u.toNat : ℤ) - 1024) := by rw [Qbz gw, Qbz st.den, ds1, Qdz, ← hsd] by_cases hz : aM = 0 ∨ G = 0 ·rw [if_pos hz] at hqr1 have hq0 : qr.1.toNat = 0 := by rcases Nat.eq_zero_or_pos qr.1.toNat with h' | h' ·exact h' ·exfalso; have : 2 ^ 23 ≤ qr.1.toNat * st.D.toNat := le_trans hDw1 (ZDj _ h'); omega have hr0 : qr.2.toNat = 0 := by rw [hq0] at hqr1; omega rcases hz with ha | hg ·have : aM.toNat = 0 := by rw [ha]; rfl simp [this, hq0, hr0] ·have : mantOf gw = 0 := by rw [← hG, hg]; rfl simp [this, hq0, hr0] ·rw [if_neg hz] at hqr1 push_neg at hz obtain ⟨hkk, hle⟩ := hk hz.1 hz.2 have hqv : ((qr.1.toNat : ℚ) + qr.2.toNat / st.D.toNat) = (aM.toNat : ℚ) * 2 ^ k.toNat * G.toNat / st.D.toNat := by have : ((qr.1.toNat * st.D.toNat + qr.2.toNat : ℕ) : ℚ) = ((aM.toNat * 2 ^ k.toNat * G.toNat : ℕ) : ℚ) := by rw [hqr1] push_cast at this have hD0 : (st.D.toNat : ℚ) ≠ 0 := by exact_mod_cast (show st.D.toNat ≠ 0 by omega) field_simp linarith rw [hqv, hG, hDq] have h2a : (2 : ℚ) ^ ((st.lo.toNat : ℤ) - 149) = 2 ^ ((k.toNat : ℤ) + ((u.toNat : ℤ) - 1024) + ((idxOf st.den : ℤ) - 149) - ((idxOf gw : ℤ) - 149)) := by congr 1; omega rw [h2a, zpow_sub₀ two_ne_zero, zpow_add₀ two_ne_zero, zpow_add₀ two_ne_zero, zpow_natCast] by_cases hs : sA <;> by_cases hg' : signOf gw = true <;> by_cases hd' : st.sd = true <;> simp [hs, hg', hd'] <;> field_simp <;> ring have hterm2 : rationalWord bw = (if signOf bw then -1 else 1) * (T2.toNat : ℚ) * 2 ^ ((u.toNat : ℤ) - 1024) := by rw [Qbz bw, hT2v] by_cases hb : Bm = 0 ·have : mantOf bw = 0 := by rw [← hBm, hb]; rfl rw [if_pos hb, this]; simp ·rw [if_neg hb] obtain ⟨hjj, hle⟩ := hj hb have e : (idxOf bw : ℤ) - 149 = (j.toNat : ℤ) + ((u.toNat : ℤ) - 1024) := by omega rw [e, zpow_add₀ two_ne_zero, zpow_natCast, hBm]; push_cast; ring have hv : (rationalWord xw - (((st.tp.toNat : ℤ) - st.tn.toNat : ℤ) : ℚ) * 2 ^ ((st.lo.toNat : ℤ) - 149) / n) * rationalWord gw / rationalWord st.den + rationalWord bw = (if neg then -1 else 1) * ((Q.toNat : ℚ) + R.toNat / st.D.toNat) * 2 ^ ((u.toNat : ℤ) - 1024) := by rw [hAz, hterm1, hterm2, ← hcomb]; ring rw [hv] split at hres ·rename_i hz simp only [ZAx, beq_iff_eq] at hz obtain ⟨hQ0, hR0⟩ := hz rw [← hres, hQ0, hR0]; simp [QaI] split at hres ·exact absurd hres.symm h rename_i hQ25 split at hres ·exact absurd hres.symm h rename_i hErng have hQ : 2 ^ 25 ≤ Q.toNat := by have := mt UInt64.lt_iff_toNat_lt.mpr hQ25; simp at this; omega rw [← hres] rw [dE, dr, dcy, dm] at hErng ⊢ exact QcK Q R u st.D.toNat neg _ hQ hRD hu20 rfl hErng lemma QbP {α : Type} [Inhabited α] (m : Nat) (f : Fin m → α) (i : Nat) (h : i < m) : (ZCo f)[i]! = f ⟨i, h⟩ := by rw [getElem!_pos (ZCo f) i (by simpa using h)] simp lemma Qb9 (m : Nat) (f : Fin m → Qau) (h : (ZCo f).all (·.ok) = true) (i : Nat) (hi : i < m) : (f ⟨i, hi⟩).ok = true := by have := (Array.all_eq_true.mp h) i (by simpa using hi) simpa using this lemma QaZ : QX = layernormSpec := by funext rows n eps x g b unfold QX layernormSpec layernormWith split ·rename_i hdom simp only [ZAx] at hdom obtain ⟨⟨hst, _⟩, _⟩ := hdom obtain ⟨hn, heps⟩ := QaE rows n eps x g hst dsimp only split ·rename_i hall unfold layernormStable simp only [] congr 1; funext q have hqr : q.val / n < rows := Nat.div_lt_of_lt_mul (lt_of_lt_of_eq q.isLt (Nat.mul_comm _ _)) have hkk : q.val % n < n := ZCe _ hn have hx : x[q.val]! = x[q.val / n * n + q.val % n]! := by rw [ZCc] have hok := Qb9 rows _ hall _ hqr simp only [QbP rows _ _ hqr] split ·rename_i hw obtain ⟨hrow, hden⟩ := QcZ x n eps (q.val / n) hn heps hok rw [hx] at hw ⊢ rw [Qa0 _ n x (q.val / n) _ hrow (q.val % n) hkk _ _ (by simpa using hw), hden] ·rfl ·rfl ·rfl lemma Qby : Qal = rmsnormSpec := by funext rows n eps x g unfold Qal rmsnormSpec rmsnormWith split ·rename_i hst obtain ⟨hn, heps⟩ := QaE rows n eps x g hst dsimp only split ·rename_i hall unfold rmsnormStable simp only [] congr 1; funext q have hqr : q.val / n < rows := Nat.div_lt_of_lt_mul (lt_of_lt_of_eq q.isLt (Nat.mul_comm _ _)) have hkk : q.val % n < n := ZCe _ hn have hx : x[q.val]! = x[q.val / n * n + q.val % n]! := by rw [ZCc] have hok := Qb9 rows _ hall _ hqr simp only [QbP rows _ _ hqr] split ·rename_i hw obtain ⟨hrow, hden⟩ := Qcy x n eps (q.val / n) hn heps hok rw [hx] at hw ⊢ rw [Qa0 _ n x (q.val / n) _ hrow (q.val % n) hkk _ _ (by simpa using hw), hden, Qdg 0 rfl rfl] ring_nf ·rfl ·rfl ·rfl end def kernels : Kernels where core := specCore dense := ⟨Qbv, gemmSpec⟩ conv := specConv elem := specElem norm := ⟨Qal, QX⟩ lemma correct : Obligation kernels := by unfold Obligation kernels specKernels specDense specNorm rw [QcG, Qby, QaZ] rfl end Submission