import ContractExact namespace Submission open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats section open FloatLib.Numerics def roundDyadic_jam (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 := Nat.log2_self_le hm0 have hm : 2 ^ (j + 1) ≤ m := le_trans (Nat.pow_le_pow_right (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 (Nat.pow_le_pow_right (by norm_num) (by clear*-;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 clear*-h hne;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 clear*-h h2;omega⟩ have hb : e + j - -149 = Int.negSucc (a - j) := by clear*-h h2 ha;omega rw [ha, hb] dsimp only rw [show a - j + 1 = (a + 1) - j by clear*-ha hb;omega] exact roundShiftRightEven_shiftRightJam m j (a + 1) (by clear*-h h2 ha;omega) ·congr 1 rw [show m.log2 - j - 23 = (m.log2 - 23) - j by clear*-;omega] exact roundShiftRightEven_shiftRightJam m j _ (by clear*-h h4;omega) end def getElem!_ofFn (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] namespace Core def tm (a b : Word) : Int := sv a * sv b * 2 ^ (idxOf a + idxOf b) def tsum (n : Nat) (fa fb : Nat → Word) : Int := ∑ k ∈ Finset.range n, tm (fa k) (fb k) def finAll (n : Nat) (fa fb : Nat → Word) : Prop := ∀ k, k < n → expOf (fa k) ≠ 255 ∧ expOf (fb k) ≠ 255 def tsum_succ (n : Nat) (fa fb : Nat → Word) : tsum (n + 1) fa fb = tsum n fa fb + tm (fa n) (fb n) := Finset.sum_range_succ _ _ def dotOf_val (n : Nat) (fa fb : Nat → Word) (hfin : finAll n fa fb) : dotOf n fa fb = finishWord (tsum n fa fb) (-298) (decide (n ≠ 0) && dallNZ (Array.ofFn (n := n) fun i => fa i.val) (Array.ofFn (n := n) fun i => fb i.val) 0 n) := by unfold dotOf dotSpec Model.dot set A := Array.ofFn (n := n) fun i => fa i.val set B := Array.ofFn (n := n) fun i => fb i.val set L := A.map (Model.ofUInt32 (fmt := Fmt)) set R := B.map (Model.ofUInt32 (fmt := Fmt)) have hLR : L.size = R.size := by simp [L, R, A, B] have hLfin : ∀ k (h : k < L.size), Model.isFinite L[k] = true := fun k h => by simp [L, A, isFinite_ofUInt32] at h ⊢; exact (hfin k h).1 have hRfin : ∀ k (h : k < R.size), Model.isFinite R[k] = true := fun k h => by simp [R, B, isFinite_ofUInt32] at h ⊢; exact (hfin k h).2 have hk : ∀ k, 0 ≤ k → k < 0 + L.size → expOf A[k]! ≠ 255 ∧ expOf B[k]! ≠ 255 := fun k _ h => by simp [L, A] at h; simp only [A, B, getElem!_ofFn n _ k h]; exact hfin k h have hd : ∀ i c, dsum A B i c = ∑ k ∈ Finset.range c, tm A[i + k]! B[i + k]! := fun i c => by induction c generalizing i with | zero => simp [dsum] | succ c ih => rw [dsum, ih (i + 1), Finset.sum_range_succ', add_comm] exact congrArg₂ _ (Finset.sum_congr rfl fun k _ => by rw [show i + 1 + k = i + (k + 1) by clear*-;omega]) rfl have hslice := (finiteDotSlice_eq A B 0 L.size (by simp [L]) (by simp [hLR, R]) hk).trans (c := (tsum n fa fb : ℚ) * 2 ^ (-298 : ℤ)) (by simp only [hd, tsum, L, A, B, Array.size_map, Array.size_ofFn]; congr 2; exact Finset.sum_congr rfl fun k hk => by simp at hk; simp [getElem!_ofFn n _ k hk]) have hx := Model.Reduction.Internal.dotState_exact_toRat (destination := Fmt) L R hLR hLfin hRfin by_cases hS : tsum n fa fb = 0 ·rw [hS, finishWord_zero, Model.Reduction.dotWithStatus_eq_zero_of_finite Fmt L R .nearestEven hLR hLfin hRfin ((FloatLib.Numerics.Dyadic.toRat_eq_zero_iff _).1 (by rw [hx, hslice, hS]; simp))] obtain ⟨h1, h2⟩ := dotStateLoop_flags A B {} 0 L.size (by simp [L]) (by simp [hLR, R]) hk unfold Model.Reduction.Internal.dotState; rw [h1, h2] simp [L, A]; rfl ·rw [Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L R .nearestEven hLR hLfin hRfin (by rw [Model.Reduction.Semantics.finiteDot_toList_eq_slice L R hLR, Ne, Except.ok.injEq, hslice]; simpa)] exact (finishWord_of_ne _ (tsum n fa fb) (-298) _ hS (by rw [hx, hslice])).symm def dotOf_round (n : Nat) (fa fb : Nat → Word) (hfin : finAll n fa fb) (hS : tsum n fa fb ≠ 0) : dotOf n fa fb = finishWord (tsum n fa fb) (-298) false := by simp [dotOf_val n fa fb hfin, finishWord, hS] @[inline] def nzW (w : UInt32) : UInt64 := if (w >>> 23) &&& 0xFF != 0 then 1 else 0 @[inline] def mW (w : UInt32) : UInt64 := (w &&& 0x7FFFFF).toUInt64 ||| (nzW w <<< 23) @[inline] def iW (w : UInt32) : UInt64 := ((w >>> 23) &&& 0xFF).toUInt64 - nzW w def sval (x : UInt64) : Int := x.toBitVec.toInt def mW_toNat (w : UInt32) : (mW w).toNat = mantOf w := by have hf : (w &&& 0x7FFFFF).toNat < 2 ^ 23 := by rw [UInt32.toNat_and]; exact lt_of_le_of_lt Nat.and_le_right (by decide) unfold mW nzW mantOf expOf fracOf by_cases he : (w >>> 23) &&& 0xFF = 0 ·simp [he] ·simp only [show ((w >>> 23) &&& 0xFF != 0) = true by simpa using he, he, ite_true, ite_false] rw [UInt64.toNat_or, UInt32.toNat_toUInt64, show ((1 : UInt64) <<< 23).toNat = 2 ^ 23 * 1 from rfl, Nat.or_comm, ← Nat.two_pow_add_eq_or_of_lt hf, Nat.mul_one, Nat.add_comm] def iW_toNat (w : UInt32) : (iW w).toNat = idxOf w := by unfold iW nzW idxOf expOf have hlt := expOf_toNat_lt w unfold expOf at hlt by_cases he : (w >>> 23) &&& 0xFF = 0 ·simp [he] ·have hpos : 1 ≤ ((w >>> 23) &&& 0xFF).toNat := Nat.one_le_iff_ne_zero.2 fun h => he (UInt32.toNat_inj.mp (by simpa using h)) simp only [show ((w >>> 23) &&& 0xFF != 0) = true by simpa using he, he, ite_true, ite_false] rw [UInt64.toNat_sub_of_le _ _ (UInt64.le_iff_toNat_le.mpr (by rw [UInt32.toNat_toUInt64]; simpa using hpos)), UInt32.toNat_toUInt64] rfl def signOf_iff (w : UInt32) : signOf w = true ↔ 2 ^ 31 ≤ w.toNat := by have := w.toNat_lt rw [signOf, bne_iff_ne, ne_eq, ← UInt32.toNat_inj, UInt32.toNat_and, show (0x80000000 : UInt32).toNat = 2 ^ 31 from rfl, Nat.and_two_pow, Nat.testBit_eq_decide_div_mod_eq] by_cases h : w.toNat / 2 ^ 31 % 2 = 1 <;> simp [h] <;> (clear*-h this;omega) @[inline] def sx (k x : UInt64) : UInt64 := bif x >>> k == 0 then x else x >>> k @[inline] def sr (k x r : UInt64) : UInt64 := bif x >>> k == 0 then r else r + k @[inline] def fastLog2 (x0 : UInt64) : UInt64 := let x1 := sx 32 x0 let r1 := sr 32 x0 0 let x2 := sx 16 x1 let r2 := sr 16 x1 r1 let x3 := sx 8 x2 let r3 := sr 8 x2 r2 let x4 := sx 4 x3 let r4 := sr 4 x3 r3 let x5 := sx 2 x4 let r5 := sr 2 x4 r4 sr 1 x5 r5 @[inline] def rseB (value shift : UInt64) : UInt64 := let quotient := value >>> shift let remainder := value &&& ((1 <<< shift) - 1) let half := (1 : UInt64) <<< (shift - 1) quotient + (if remainder + (quotient &&& 1) > half then 1 else 0) @[inline] def rseAny (value shift : UInt64) : UInt64 := if shift == 0 then value else if shift < 64 then rseB value shift else if shift == 64 then (if value > 0x8000000000000000 then 1 else 0) else 0 @[inline] def mkW (sign : Bool) (e f : UInt32) : UInt32 := (if sign then (0x80000000 : UInt32) else 0) ||| ((e &&& 0xff) <<< 23) ||| (f &&& 0x007fffff) @[inline] def fracW (n : UInt64) : UInt32 := (if n < 0x800000 then 0 else n - 0x800000).toUInt32 @[inline] def rnd (sign : Bool) (product scale : UInt64) : UInt32 := if product == 0 then if sign then 0x80000000 else 0 else let leading := fastLog2 product let position := leading + scale if position < 172 then let fraction := if scale < 149 then rseAny product (149 - scale) else product <<< (scale - 149) if fraction == 0 then (if sign then 0x80000000 else 0) else if fraction == 0x800000 then mkW sign 1 0 else mkW sign 0 fraction.toUInt32 else let roundedMantissa := if leading < 23 then product <<< (23 - leading) else rseAny product (leading - 23) let carry := roundedMantissa == 0x1000000 let normalizedPosition := if carry then position + 1 else position if normalizedPosition > 425 then (if sign then 0xff800000 else 0x7f800000) else let normalizedMantissa := if carry then 0x800000 else roundedMantissa mkW sign (normalizedPosition - 171).toUInt32 (fracW normalizedMantissa) open Model.NativeBinary32 in def log2_shift (n k : Nat) (h : n >>> k ≠ 0) : n.log2 = k + (n >>> k).log2 := by rw [Nat.shiftRight_eq_div_pow] at * have := (Nat.le_log2 (by rintro rfl; simp at h)).2 (Nat.div_pos_iff.1 (Nat.pos_of_ne_zero h)).2 rw [Nat.log2_eq_log_two, Nat.log2_eq_log_two, Nat.log_div_base_pow] at *; omega def step (x0 r x k : UInt64) (hk : k.toNat ≤ 32) (hk0 : 0 < k.toNat) (hinv : x0.toNat.log2 = r.toNat + x.toNat.log2) (hb : x.toNat < 2 ^ (2 * k.toNat)) : x0.toNat.log2 = (sr k x r).toNat + (sx k x).toNat.log2 ∧ (sx k x).toNat < 2 ^ k.toNat := by have : x0.toNat.log2 < 64 := by by_cases h : x0.toNat = 0 <;> simp [h, Nat.log2_lt, x0.toNat_lt] have h6 : k.toNat % 64 = k.toNat := Nat.mod_eq_of_lt (by clear*-hk;omega) unfold sx sr by_cases hz : x >>> k = 0 <;> simp [hz, h6, hinv] ·simpa [h6, Nat.shiftRight_eq_div_pow, Nat.div_eq_zero_iff] using congrArg UInt64.toNat hz have := log2_shift x.toNat k.toNat (by simpa [← UInt64.toNat_inj, h6] using hz) refine ⟨by clear h6 hb hk hk0 hz;omega, ?_⟩ rw [Nat.shiftRight_eq_div_pow] exact Nat.div_lt_of_lt_mul (by rwa [← Nat.pow_add, show k.toNat + k.toNat = 2 * k.toNat by clear*-;omega]) def fastLog2_eq (x : UInt64) : fastLog2 x = x.log2 := by apply UInt64.toNat_inj.mp obtain ⟨e1, b1⟩ := step x 0 x 32 (by decide) (by decide) (by simp) x.toNat_lt obtain ⟨e2, b2⟩ := step x _ _ 16 (by decide) (by decide) e1 b1 obtain ⟨e3, b3⟩ := step x _ _ 8 (by decide) (by decide) e2 b2 obtain ⟨e4, b4⟩ := step x _ _ 4 (by decide) (by decide) e3 b3 obtain ⟨e5, b5⟩ := step x _ _ 2 (by decide) (by decide) e4 b4 obtain ⟨e6, b6⟩ := step x _ _ 1 (by decide) (by decide) e5 b5 rw [Nat.log2_def (sx 1 _).toNat, if_neg (by simpa using b6)] at e6 unfold fastLog2 exact e6.symm def rseAny_eq (value shift : UInt64) : rseAny value shift = FloatLib.Numerics.FixedWord.roundShiftRightEven value shift.toNat := by unfold rseAny FloatLib.Numerics.FixedWord.roundShiftRightEven by_cases h0 : shift = 0 ·subst h0; rfl have := shift.toNat_lt have h0' : shift.toNat ≠ 0 := by simpa [← UInt64.toNat_inj] using h0 simp only [h0, h0', beq_iff_eq, UInt64.ofNat_toNat, UInt64.lt_iff_toNat_lt, ↓reduceIte, show UInt64.ofNat (shift.toNat - 1) = shift - 1 from UInt64.toNat_inj.mp (by simp [UInt64.toNat_sub]; clear this;omega), show shift = 64 ↔ shift.toNat = 64 by rw [← UInt64.toNat_inj]; rfl] refine ite_congr rfl (fun hs => ?_) fun _ => rfl have : (value &&& ((1 <<< shift) - 1)).toNat < 2 ^ 63 := by have p2 : 2 ^ shift.toNat ≤ 2 ^ 63 := Nat.pow_le_pow_right two_pos (by clear this;omega) rw [UInt64.toNat_and, UInt64.toNat_sub_of_le, UInt64.toNat_shiftLeft] <;> simp [UInt64.le_iff_toNat_le, Nat.mod_eq_of_lt hs, Nat.one_shiftLeft, Nat.mod_eq_of_lt (by omega : 2 ^ shift.toNat < 18446744073709551616), Nat.one_le_two_pow] exact (Nat.mod_lt _ (Nat.two_pow_pos _)).trans_le p2 have : ((value >>> shift) &&& 1).toNat ≤ 1 := by simp [UInt64.toNat_and]; clear*-;omega have := (value >>> shift).toNat_lt simp only [rseB, gt_iff_lt, UInt64.lt_iff_toNat_lt, UInt64.toNat_add, beq_iff_eq, ← UInt64.toNat_inj, apply_ite UInt64.toNat, UInt64.toNat_one, UInt64.reduceToNat] generalize (value &&& ((1 <<< shift) - 1)).toNat = r at * generalize ((value >>> shift) &&& 1).toNat = b at * split_ifs <;> (clear h0 h0' hs;omega) def fracW_eq (n : UInt64) : fracW n = UInt32.ofNat (n.toNat - 0x800000) := by unfold fracW; split <;> simp_all [UInt64.toUInt32, Nat.toUInt32, UInt64.lt_iff_toNat_lt, UInt64.toNat_sub_of_le, UInt64.le_iff_toNat_le, Nat.sub_eq_zero_of_le, le_of_lt] open Model.NativeBinary32 in def toWord_native (w : UInt32) : toWord (ofUInt32 w) = w := by conv_rhs => rw [← toUInt32_ofUInt32 w] exact UInt32.toNat_inj.mp (Nat.mod_eq_of_lt (BitVec.isLt _)) open Model.NativeBinary32 in def rnd_eq (sign : Bool) (m scale : UInt64) (hs : scale.toNat ≤ 506) : rnd sign m scale = toWord (Model.roundDyadic Fmt ⟨sign, m.toNat, (scale.toNat : Int) - 298⟩) := by erw [← ofUInt32_roundDyadic, toWord_native, ← roundProduct_eq_roundDyadic _ _ _ hs] unfold rnd roundProduct mkW mkBits simp only [fastLog2_eq, rseAny_eq, fracW_eq, UInt64.toUInt32, Nat.toUInt32] rfl def val128 (hi lo : UInt64) : Int := sval hi * 2 ^ 64 + lo.toNat @[inline] def magLo (hi lo : UInt64) : UInt64 := if hi >>> 63 != 0 then (0 : UInt64) - lo else lo @[inline] def magHi (hi lo : UInt64) : UInt64 := if hi >>> 63 != 0 then (if lo == 0 then (0 : UInt64) - hi else ~~~hi) else hi def neg_iff (hi : UInt64) : (hi >>> 63 != 0) = decide (2 ^ 63 ≤ hi.toNat) := by have := hi.toNat_lt rw [Bool.eq_iff_iff]; simp [← UInt64.toNat_inj, Nat.shiftRight_eq_div_pow] def val128_eq (hi lo : UInt64) : val128 hi lo = (hi.toNat * 2 ^ 64 + lo.toNat : Int) - (if 2 ^ 63 ≤ hi.toNat then 2 ^ 128 else 0) := by unfold val128 sval rw [BitVec.toInt_eq_toNat_cond, UInt64.toNat_toBitVec] omega def mag_spec (hi lo : UInt64) : (val128 hi lo).natAbs = (magHi hi lo).toNat * 2 ^ 64 + (magLo hi lo).toNat ∧ decide (val128 hi lo < 0) = (hi >>> 63 != 0) := by have := hi.toNat_lt have := lo.toNat_lt unfold magHi magLo; rw [val128_eq, neg_iff] by_cases hn : 2 ^ 63 ≤ hi.toNat <;> simp only [hn, decide_true, decide_false, ite_true, ite_false, Bool.false_eq_true] ·split <;> simp_all [UInt64.size, UInt64.toNat_not, ← UInt64.toNat_inj] <;> omega ·simp; clear*-;omega @[inline] def fin128 (hi lo B : UInt64) : UInt64 := if hi == 0 && lo == 0 then 0x100000000 else if B > 442 then 0x100000000 else let neg := hi >>> 63 != 0 let mlo := magLo hi lo let mhi := magHi hi lo if mhi == 0 then (rnd neg mlo B).toUInt64 else if mhi >>> 32 == 0 then let q := (mhi <<< 32) + (mlo >>> 32) (rnd neg (if mlo &&& 0xFFFFFFFF == 0 then q else q ||| 1) (B + 32)).toUInt64 else (rnd neg (if mlo == 0 then mhi else mhi ||| 1) (B + 64)).toUInt64 def dotOf_of_fin128 (n : Nat) (fa fb : Nat → Word) (hi lo B : UInt64) (hfin : finAll n fa fb) (hval : tsum n fa fb = val128 hi lo * 2 ^ B.toNat) (h : fin128 hi lo B < 0x100000000) : dotOf n fa fb = (fin128 hi lo B).toUInt32 := by obtain ⟨hmag, hneg⟩ := mag_spec hi lo have := lo.toNat_lt have := hi.toNat_lt simp only [fin128] at h ⊢ have hz : ¬(hi == 0 && lo == 0) = true := fun c => by simp [c] at h have hB : ¬B > 442 := fun c => by simp [c] at h simp only [hz, hB, Bool.false_eq_true, ↓reduceIte] clear h have hS : tsum n fa fb ≠ 0 := by rw [hval]; refine mul_ne_zero (fun h0 => hz ?_) (by positivity) rw [val128_eq] at h0; simp only [Bool.and_eq_true, beq_iff_eq, ← UInt64.toNat_inj, UInt64.toNat_zero]; split at h0 <;> (clear hB hfin hmag hneg hval hz;omega) rw [dotOf_round n fa fb hfin hS, finishWord_of_ne (ofIntDyadic (val128 hi lo) ((B.toNat : Int) - 298)) _ _ _ hS (by rw [toRat_ofIntDyadic, hval]; push_cast; rw [zpow_sub₀ two_ne_zero, zpow_natCast]; field_simp), ofIntDyadic, hneg, hmag] symm simp only [apply_ite UInt64.toUInt32, UInt32.toUInt32_toUInt64] generalize magHi hi lo = mh at * generalize magLo hi lo = ml at * have := ml.toNat_lt simp only [UInt64.lt_iff_toNat_lt, gt_iff_lt, UInt64.reduceToNat, not_lt] at hB split <;> rename_i h0 <;> simp only [beq_iff_eq, ← UInt64.toNat_inj, UInt64.toNat_zero] at h0 ·simp [h0, rnd_eq _ _ B (by clear*-hB;omega)] split <;> rename_i h1 <;> simp [← UInt64.toNat_inj, Nat.shiftRight_eq_div_pow] at h1 ·rw [rnd_eq _ _ _ (by simp [UInt64.toNat_add]; clear*-hB;omega), ← roundDyadic_jam _ (mh.toNat * 2 ^ 64 + ml.toNat) _ 32 ((Nat.le_log2 (by clear*-h0;omega)).2 (by clear*-h0;omega))] congr 3 swap; · simp [UInt64.toNat_add]; clear*-hB;omega have e1 : (mh.toNat * 2 ^ 64 + ml.toNat) / 2 ^ 32 = (mh <<< 32 + ml >>> 32).toNat := by simp [Nat.shiftLeft_eq, Nat.shiftRight_eq_div_pow]; clear*-h1 this;omega have e2 : (mh.toNat * 2 ^ 64 + ml.toNat) % 2 ^ 32 = (ml &&& 4294967295).toNat := by rw [UInt64.toNat_and, show (4294967295 : UInt64).toNat = 2 ^ 32 - 1 from rfl, Nat.and_two_pow_sub_one_eq_mod]; clear*-;omega simp only [FloatLib.Numerics.shiftRightJam, UInt64.reduceToNat, e1, e2, apply_ite UInt64.toNat, UInt64.toNat_or, beq_iff_eq, ← UInt64.toNat_inj] ·rw [rnd_eq _ _ _ (by simp [UInt64.toNat_add]; clear*-hB;omega), ← roundDyadic_jam _ (mh.toNat * 2 ^ 64 + ml.toNat) _ 64 ((Nat.le_log2 (by clear*-h1;omega)).2 (by clear*-h1;omega))] congr 3 swap; · simp [UInt64.toNat_add]; clear*-hB;omega simp only [FloatLib.Numerics.shiftRightJam, UInt64.reduceToNat, show (mh.toNat * 2 ^ 64 + ml.toNat) / 2 ^ 64 = mh.toNat by clear*-this;omega, show (mh.toNat * 2 ^ 64 + ml.toNat) % 2 ^ 64 = ml.toNat by clear*-this;omega, apply_ite UInt64.toNat, UInt64.toNat_or, beq_iff_eq, ← UInt64.toNat_inj] @[inline] def rne39 (N : UInt64) : UInt64 := (N + (0x3FFFFFFFFF : UInt64) + ((N >>> 39) &&& 1)) >>> 39 def mkW_nat (n : Bool) (e f : UInt32) : (mkW n e f).toNat = (if n then 2 ^ 31 else 0) + e.toNat % 2 ^ 8 * 2 ^ 23 + f.toNat % 2 ^ 23 := by have h3 := Nat.mod_lt f.toNat (Nat.two_pow_pos 23) have := Nat.mod_lt e.toNat (Nat.two_pow_pos 8) have hx : ((e &&& 0xff) <<< 23 ||| (f &&& 0x007fffff)).toNat = 2 ^ 23 * (e.toNat % 2 ^ 8) + f.toNat % 2 ^ 23 := by rw [UInt32.toNat_or, UInt32.toNat_shiftLeft, UInt32.toNat_and, UInt32.toNat_and, show (0xff : UInt32).toNat = 2 ^ 8 - 1 from rfl, show (0x007fffff : UInt32).toNat = 2 ^ 23 - 1 from rfl, Nat.and_two_pow_sub_one_eq_mod, Nat.and_two_pow_sub_one_eq_mod, show (23 : UInt32).toNat % 32 = 23 from rfl, Nat.shiftLeft_eq, Nat.mul_comm, Nat.mod_eq_of_lt (by simp; clear*-;omega), ← Nat.two_pow_add_eq_or_of_lt h3] unfold mkW rw [UInt32.or_assoc] cases n <;> simp only [Bool.false_eq_true, ↓reduceIte, UInt32.zero_or, UInt32.toNat_or, hx] ·clear*-;omega ·rw [show (0x80000000 : UInt32).toNat = 2 ^ 31 * 1 from rfl, ← Nat.two_pow_add_eq_or_of_lt (by clear*-this;omega)]; clear*-;omega def rnd62n (n : Bool) (N sc : UInt64) (h1 : 2 ^ 62 ≤ N.toNat) (h2 : N.toNat < 2 ^ 63) (hs : 110 ≤ sc.toNat) (hs2 : sc.toNat < 363) : (rnd n N sc).toNat = (if n then 2 ^ 31 else 0) + ((sc.toNat - 110) * 2 ^ 23 + (rne39 N).toNat) ∧ 2 ^ 23 ≤ (rne39 N).toNat ∧ (rne39 N).toNat ≤ 2 ^ 24 := by have hq : (N >>> 39).toNat = N.toNat / 2 ^ 39 := by simp [Nat.shiftRight_eq_div_pow] have hb : ((N >>> 39) &&& 1).toNat = N.toNat / 2 ^ 39 % 2 := by simp [hq, Nat.and_one_is_mod] have hr : (rne39 N).toNat = N.toNat / 2 ^ 39 + if 2 ^ 38 < N.toNat % 2 ^ 39 + N.toNat / 2 ^ 39 % 2 then 1 else 0 := by unfold rne39; simp (disch := omega) only [UInt64.toNat_shiftRight, UInt64.toNat_add, hb, UInt64.reduceToNat, Nat.shiftRight_eq_div_pow, Nat.reducePow, Nat.mod_eq_of_lt] generalize N.toNat = x; clear * -; split <;> omega have hq1 : 2 ^ 23 ≤ N.toNat / 2 ^ 39 ∧ N.toNat / 2 ^ 39 < 2 ^ 24 := by clear * - h1 h2; omega have hR : (rseAny N (62 - 23)).toNat = (rne39 N).toNat ∧ 2 ^ 23 ≤ (rne39 N).toNat ∧ (rne39 N).toNat ≤ 2 ^ 24 := by have ha : (N &&& 0x7FFFFFFFFF).toNat = N.toNat % 2 ^ 39 := by rw [UInt64.toNat_and]; exact Nat.and_two_pow_sub_one_eq_mod _ 39 rw [hr]; show (rseB N 39).toNat = _ ∧ _; unfold rseB simp only [show ((1 : UInt64) <<< 39) - 1 = 0x7FFFFFFFFF from rfl, show (1 : UInt64) <<< (39 - 1) = 0x4000000000 from rfl, gt_iff_lt, UInt64.lt_iff_toNat_lt, UInt64.toNat_add, ha, hb, hq, apply_ite UInt64.toNat, UInt64.reduceToNat] clear * - hq1; split_ifs <;> omega refine ⟨?_, hR.2⟩ unfold rnd simp only [show fastLog2 N = 62 by rw [fastLog2_eq, ← UInt64.toNat_inj]; exact (Nat.log2_eq_iff (by clear*-h1;omega : N.toNat ≠ 0)).2 ⟨h1, h2⟩, show (N == 0) = false by simp [← UInt64.toNat_inj]; clear*-h1;omega, show ¬62 + sc < 172 by simp [UInt64.lt_iff_toNat_lt]; clear*-hs hs2;omega, show ¬(62 : UInt64) < 23 by decide, ite_false, Bool.false_eq_true] obtain ⟨hR, hb⟩ := hR generalize rseAny N (62 - 23) = R at hR ⊢ rw [← hR] at hb ⊢ clear * - hb hs hs2 by_cases hc : R.toNat = 16777216 <;> simp [hc, ← UInt64.toNat_inj, fracW_eq, UInt64.lt_iff_toNat_lt] <;> split <;> (try omega) <;> simp [mkW_nat, UInt32.toNat_sub, UInt32.toNat_add] <;> (clear*-hb hc hs hs2;omega) def rnd_fw (n : Bool) (M σ : UInt64) (hM : M.toNat ≠ 0) (hσ : σ.toNat ≤ 506) : rnd n M σ = finishWord ((if n then -(M.toNat : Int) else M.toNat) * 2 ^ σ.toNat) (-298) false := by rw [rnd_eq _ _ _ hσ] refine (finishWord_of_ne _ _ _ _ (mul_ne_zero (by split <;> (clear*-hM;omega)) (by positivity)) ?_).symm cases n <;> simp [FloatLib.Numerics.Dyadic.toRat, FloatLib.Numerics.Dyadic.signedSignificand, zpow_sub₀] <;> field_simp end Core namespace Dense def usucc {k n : USize} (h : k < n) : (k + 1).toNat = k.toNat + 1 := by have := USize.lt_iff_toNat_lt.mp h; have := n.toNat_lt_size; have := USize.size_eq_two_pow rw [USize.toNat_add, USize.toNat_one, Nat.mod_eq_of_lt (by omega)] def uadd {a b : USize} (h : a.toNat + b.toNat < USize.size) : (a + b).toNat = a.toNat + b.toNat := by rw [USize.toNat_add, Nat.mod_eq_of_lt h] def toUSize_toNat {n : Nat} (h : n < USize.size) : n.toUSize.toNat = n := by rw [Nat.toUSize_eq, USize.toNat_ofNat_of_lt' h] def u32_toUSize (x : UInt32) : x.toUSize.toNat = x.toNat := by simp [UInt32.toNat_toUSize] def uget_eq (A : Array UInt32) (u : USize) (h : u.toNat < A.size) : A.uget u h = A[u.toNat]! := by simp_all def sval_eq (p : UInt64) : Core.sval p = (p.toNat : Int) - (if 2 ^ 63 ≤ p.toNat then 2 ^ 64 else 0) := by unfold Core.sval; rw [BitVec.toInt_eq_toNat_cond, UInt64.toNat_toBitVec] split <;> split <;> push_cast <;> omega @[inline] def absW (x : UInt32) : UInt32 := x &&& 0x7FFFFFFF def absA (x : UInt32) : (absW x).toNat = x.toNat % 2 ^ 31 := by unfold absW; rw [UInt32.toNat_and]; exact Nat.and_two_pow_sub_one_eq_mod _ 31 def expA (x : UInt32) : (expOf x).toNat = (absW x).toNat / 2 ^ 23 := by have : (expOf x).toNat = x.toNat / 2 ^ 23 % 2 ^ 8 := by unfold expOf; rw [UInt32.toNat_and, UInt32.toNat_shiftRight] simp only [UInt32.reduceToNat, Nat.reduceMod, Nat.shiftRight_eq_div_pow] exact Nat.and_two_pow_sub_one_eq_mod _ 8 rw [this, absA, show 2 ^ 31 = 2 ^ 23 * 2 ^ 8 by norm_num, Nat.mod_mul_right_div_self] def exp0 (x : UInt32) : expOf x = 0 ↔ (absW x).toNat < 2 ^ 23 := by rw [← UInt32.toNat_inj, expA]; simp; try omega def idxA (x : UInt32) : idxOf x = (absW x).toNat / 2 ^ 23 - 1 := by have := expA x; unfold idxOf; split <;> rename_i h ·have := (exp0 x).mp h; clear*-this;omega ·have := mt (exp0 x).mpr h; omega def idxE (x : UInt32) : idxOf x = (expOf x).toNat - 1 := by rw [idxA, expA] def wdiv (w : UInt32) : w.toNat / 2 ^ 23 = (expOf w).toNat + 256 * (w.toNat / 2 ^ 31) := by rw [expA, absA]; have := w.toNat_lt; omega def expL (x : UInt32) : (expOf x).toNat < 256 := by rw [expA, absA]; omega def fr23 (w : UInt32) : (w &&& 0x7FFFFF).toNat = w.toNat % 2 ^ 23 := by rw [UInt32.toNat_and]; exact Nat.and_two_pow_sub_one_eq_mod _ 23 def sv_abs (w : UInt32) : |sv w| < 2 ^ 24 := by have := mantOf_lt_24 w; unfold sv; split <;> simp <;> omega def ulen {k : USize} {a : Array UInt32} (h : k < a.usize) : k.toNat < a.size := by have := USize.lt_iff_toNat_lt.mp h; rw [Array.usize, Nat.toUSize_eq, USize.toNat_ofNat'] at this exact lt_of_lt_of_le this (Nat.mod_le _ _) @[inline] def x2a (h l m s : UInt64) : UInt64 × UInt64 := let l' := l + (m <<< s) (h + (m >>> 1 >>> (63 - s)) + (if l' < l then 1 else 0), l') def x2a_spec (h l m s : UInt64) (hs : s.toNat ≤ 60) (hb : h.toNat * 2 ^ 64 + l.toNat + m.toNat * 2 ^ s.toNat < 2 ^ 128) : (x2a h l m s).1.toNat * 2 ^ 64 + (x2a h l m s).2.toNat = h.toNat * 2 ^ 64 + l.toNat + m.toNat * 2 ^ s.toNat := by have e1 : (63 - s).toNat = 63 - s.toNat := by rw [UInt64.toNat_sub_of_le _ _ (by simp [UInt64.le_iff_toNat_le]; omega)]; rfl have e2 : m.toNat / 2 / 2 ^ (63 - s.toNat) = m.toNat * 2 ^ s.toNat / 2 ^ 64 := by rw [Nat.div_div_eq_div_mul, show (2 : Nat) ^ 64 = 2 ^ 1 * 2 ^ (63 - s.toNat) * 2 ^ s.toNat by rw [← pow_add, ← pow_add]; congr 1; clear*-hs;omega, pow_one, Nat.mul_div_mul_right _ _ (by positivity : 0 < 2 ^ s.toNat)] have := h.toNat_lt; have := l.toNat_lt simp only [x2a, UInt64.lt_iff_toNat_lt, UInt64.toNat_add, UInt64.toNat_shiftLeft, UInt64.toNat_shiftRight, e1, Nat.shiftLeft_eq, Nat.shiftRight_eq_div_pow, Nat.mod_eq_of_lt (by clear*-hs;omega : s.toNat < 64), Nat.mod_eq_of_lt (by clear*-;omega : 63 - s.toNat < 64), UInt64.reduceToNat, Nat.reduceMod, pow_one, e2] split <;> simp only [UInt64.reduceToNat] <;> (clear e1 e2 hs;omega) @[specialize] def x2m (fa fb : Nat → Word) (n t : Nat) (B : UInt64) : UInt64 := if t < n then x2m fa fb n (t + 1) (if Core.mW (fa t) * Core.mW (fb t) == 0 then B else min B (Core.iW (fa t) + Core.iW (fb t))) else B termination_by n - t @[specialize] def x2l (fa fb : Nat → Word) (n : Nat) (B : UInt64) (t : Nat) (pH pL nH nL : UInt64) : UInt64 := if t < n then let a := fa t let b := fb t let m := Core.mW a * Core.mW b let e := Core.iW a + Core.iW b if expOf a == 255 || expOf b == 255 || m != 0 && (e < B || 60 < e - B) then 0x100000000 else if m == 0 then x2l fa fb n B (t + 1) pH pL nH nL else let g := signOf a == signOf b let q := x2a (if g then pH else nH) (if g then pL else nL) m (e - B) x2l fa fb n B (t + 1) (if g then q.1 else pH) (if g then q.2 else pL) (if g then nH else q.1) (if g then nL else q.2) else Core.fin128 (pH - nH - (if pL < nL then 1 else 0)) (pL - nL) B termination_by n - t def x2v (pH pL nH nL : UInt64) (hP : pH.toNat * 2 ^ 64 + pL.toNat < 2 ^ 126) (hN : nH.toNat * 2 ^ 64 + nL.toNat < 2 ^ 126) : Core.val128 (pH - nH - (if pL < nL then 1 else 0)) (pL - nL) = ((pH.toNat * 2 ^ 64 + pL.toNat : Nat) : Int) - ((nH.toNat * 2 ^ 64 + nL.toNat : Nat) : Int) := by have Z:(pH-nH-(if pL(clear hN hP;omega) have:=pL.toNat_lt;have:=nL.toNat_lt;have:=pH.toNat_lt;have:=nH.toNat_lt;have:=(pH-nH).toNat_lt;have:=(pH-nH-1).toNat_lt;have:=(pL-nL).toNat_lt have a:=F pL nL;have b:=F pH nH;have c:=F (pH-nH) 1;clear F hP hN;simp only[UInt64.lt_iff_toNat_lt,UInt64.toNat_one] at*;split_ifs at a b c⊢<;>(try simp only[UInt64.sub_zero])<;>omega rw[Core.val128_eq];have:=(pL-nL).toNat_lt;have:=(pH-nH-(if pLsplit at *<;>push_cast<;>omega def x2l_spec (fa fb : Nat → Word) (n : Nat) (B : UInt64) (hn : n < 2 ^ 18) : ∀ k t (pH pL nH nL : UInt64), n - t = k → t ≤ n → Core.finAll t fa fb → pH.toNat * 2 ^ 64 + pL.toNat ≤ t * 2 ^ 108 → nH.toNat * 2 ^ 64 + nL.toNat ≤ t * 2 ^ 108 → Core.tsum t fa fb = (((pH.toNat * 2 ^ 64 + pL.toNat : Nat) : Int) - ((nH.toNat * 2 ^ 64 + nL.toNat : Nat) : Int)) * 2 ^ B.toNat → x2l fa fb n B t pH pL nH nL < 0x100000000 → dotOf n fa fb = (x2l fa fb n B t pH pL nH nL).toUInt32 := by intro k; induction k <;> intro t pH pL nH nL hk ht hf hP hN hT hr ·obtain rfl : t = n := by clear*-hk ht;omega rw [x2l, if_neg (by clear*-;omega)] at hr ⊢ exact Core.dotOf_of_fin128 _ _ _ _ _ _ hf (by rw [hT, x2v _ _ _ _ (by clear*-hP hn;omega) (by clear*-hN hn;omega)]) hr rename_i k ih have htn : t < n := by clear*-hk;omega have hk' : n - (t + 1) = k := by clear*-hk htn;omega have ht' : t + 1 ≤ n := by clear*-htn;omega rw [x2l, if_pos htn] at hr ⊢; dsimp only at hr ⊢ split at hr; · exact absurd hr (by decide) rename_i hx rw [if_neg hx] simp only [Bool.or_eq_true, beq_iff_eq, Bool.and_eq_true, bne_iff_ne, ne_eq, decide_eq_true_eq, not_or, not_and, UInt64.lt_iff_toNat_lt, UInt64.reduceToNat] at hx obtain ⟨⟨hxa, hxb⟩, hw⟩ := hx have hf' : Core.finAll (t + 1) fa fb := fun s hs => (Nat.lt_succ_iff_lt_or_eq.mp hs).elim (hf s) fun e => e ▸ ⟨hxa, hxb⟩ have hm48 : mantOf (fa t) * mantOf (fb t) < 2 ^ 48 := (Nat.mul_lt_mul'' (mantOf_lt_24 _) (mantOf_lt_24 _)).trans_eq (by norm_num) have hm : (Core.mW (fa t) * Core.mW (fb t)).toNat = mantOf (fa t) * mantOf (fb t) := by rw [UInt64.toNat_mul, Core.mW_toNat, Core.mW_toNat, Nat.mod_eq_of_lt (hm48.trans (by norm_num))] have hts := Core.tsum_succ t fa fb have hle := Nat.mul_le_mul_right (2 ^ 108) t.le_succ split at hr ·rename_i h0 rw [if_pos h0] have h0' : mantOf (fa t) * mantOf (fb t) = 0 := by rw [← hm, beq_iff_eq.mp h0]; rfl refine ih (t + 1) pH pL nH nL hk' ht' hf' (hP.trans hle) (hN.trans hle) ?_ hr rw [hts, hT, add_eq_left]; unfold Core.tm sv; rcases Nat.mul_eq_zero.mp h0' with h | h <;> simp [h] rename_i h0 rw [if_neg h0] obtain ⟨hB, hDw⟩ := hw fun h => h0 (by simp [h]) have hia := idxOf_le _ hxa; have hib := idxOf_le _ hxb have he : (Core.iW (fa t) + Core.iW (fb t)).toNat = idxOf (fa t) + idxOf (fb t) := by rw [UInt64.toNat_add, Core.iW_toNat, Core.iW_toNat, Nat.mod_eq_of_lt (by clear*-hia hib;omega)] rw [he] at hB have hs : (Core.iW (fa t) + Core.iW (fb t) - B).toNat = idxOf (fa t) + idxOf (fb t) - B.toNat := by rw [UInt64.toNat_sub_of_le _ _ (by rw [UInt64.le_iff_toNat_le, he]; clear*-hB;omega), he] rw [hs] at hDw have hsc : (2 : Int) ^ (idxOf (fa t) + idxOf (fb t)) = 2 ^ (idxOf (fa t) + idxOf (fb t) - B.toNat) * 2 ^ B.toNat := by rw [← pow_add]; congr 1; clear*-hB;omega generalize hT0 : (mantOf (fa t) * mantOf (fb t)) * 2 ^ (idxOf (fa t) + idxOf (fb t) - B.toNat) = T have hpow : T ≤ 2 ^ 108 := hT0 ▸ (Nat.mul_le_mul hm48.le (Nat.pow_le_pow_right (by norm_num) (by clear*-hDw;omega : _ ≤ 60))).trans_eq (by norm_num) have htm : Core.tm (fa t) (fb t) = (if signOf (fa t) == signOf (fb t) then (T : Int) else -T) * 2 ^ B.toNat := by rw [← hT0]; unfold Core.tm sv; rw [hsc] cases signOf (fa t) <;> cases signOf (fb t) <;> simp <;> ring have hq := fun H L (hHL : H.toNat * 2 ^ 64 + L.toNat ≤ t * 2 ^ 108) => x2a_spec H L _ _ (by rw [hs]; clear*-hDw;omega) (by rw [hm, hs, hT0]; clear*-hHL hn hpow htn;omega) rw [hm, hs, hT0] at hq cases hg : (signOf (fa t) == signOf (fb t)) <;> simp only [hg, ite_true, ite_false, Bool.false_eq_true] at htm hr ⊢ ·have q := hq nH nL hN refine ih (t + 1) pH pL _ _ hk' ht' hf' (hP.trans hle) (by rw [q]; exact Nat.succ_mul t _ ▸ Nat.add_le_add hN hpow) ?_ hr rw [hts, hT, q, htm]; push_cast; ring ·have q := hq pH pL hP refine ih (t + 1) _ _ nH nL hk' ht' hf' (by rw [q]; exact Nat.succ_mul t _ ▸ Nat.add_le_add hP hpow) (hN.trans hle) ?_ hr rw [hts, hT, q, htm]; push_cast; ring @[inline] def x2d (n : Nat) (fa fb : Nat → Word) : Word := let r := if n < 262144 then x2l fa fb n (x2m fa fb n 0 1023) 0 0 0 0 0 else 0x100000000 if r < 0x100000000 then r.toUInt32 else dotOf n fa fb def x2d_eq (n : Nat) (fa fb : Nat → Word) : x2d n fa fb = dotOf n fa fb := by unfold x2d; dsimp only by_cases hn : n < 262144 ·rw [if_pos hn]; split ·exact (x2l_spec fa fb n _ (by omega) _ 0 0 0 0 0 rfl (by clear hn;omega) (fun _ h => absurd h (by omega)) (by simp) (by simp) (by simp [Core.tsum]) ‹_›).symm ·rfl ·rw [if_neg hn, if_neg (by decide)] @[noinline] def cellFB (n : Nat) (relu : Bool) (X W b : @& Array Word) (xo s j : Nat) : Word := act relu (x2d (n + 1) (fun t => if t < n then X[xo + t * s]! else oneW) (fun t => if t < n then W[j * n + t]! else b[j]!)) namespace F noncomputable def rv (v : Float) : ℝ := Model.toReal (Model.ofFloatModel v.toModel) def fv (v : Float) : Prop := Model.isFinite (Model.ofFloatModel v.toModel) = true def rvU (v : Float) : rv v = Model.unpackedToReal v.toModel.unpack := by unfold rv; rw [Model.toReal_eq_unpackedToReal_toModel (by decide), Model.toModel_ofFloatModel] def fvI (v : Float) : fv v ↔ v.toModel.unpack.isFinite = true := by unfold fv rw [← Model.toDyadic?_isSome_eq_isFinite, Model.toDyadic?_ieee_eq_model _ (by decide), Model.toModel_ofFloatModel] cases v.toModel.unpack <;> rfl def addM (x y : Float) (hx : fv x) (hy : fv y) : Model.ofFloatModel (x + y).toModel = Model.add (Model.ofFloatModel x.toModel) (Model.ofFloatModel y.toModel) := by change Model.ofFloatModel (Float.Model.add x.toModel y.toModel) = _ rw [Float.Model.add, Model.ofFloatModel_pack] have h := Model.add_eq_ofModel_add_of_isFinite (fmt := FloatFormat.binary64) (by decide) (Model.ofFloatModel x.toModel) (Model.ofFloatModel y.toModel) (by rw [Model.toModel_ofFloatModel]; exact (fvI x).1 hx) (by rw [Model.toModel_ofFloatModel]; exact (fvI y).1 hy) rw [Model.toModel_ofFloatModel, Model.toModel_ofFloatModel] at h exact h.symm def pm (E : Int) (he : E ≤ 971) : (2 : ℝ) ^ E ≤ Model.toReal (Model.posMaxFinite FloatFormat.binary64) := by have h971 : FloatFormat.binary64.maxNormalExponent - Int.ofNat FloatFormat.binary64.fracWidth = 971 := by decide have h := Model.abs_signed_mul_bpow_le_toReal_posMaxFinite FloatFormat.binary64 false 1 E (by decide) (by rw [h971]; exact he) simp only [Bool.false_eq_true, ite_false, Nat.cast_one, one_mul] at h change |(2 : ℝ) ^ E| ≤ _ at h simpa only [abs_of_pos (zpow_pos (by norm_num : (0 : ℝ) < 2) E)] using h open FloatLib.Floats.Formats.Flocq in def re (x : ℝ) (E : Int) (he : -1021 ≤ E) (hx : |x| < (2 : ℝ) ^ E) : |Model.roundAt FloatFormat.binary64 x - x| ≤ (2 : ℝ) ^ (E - 53) / 2 := by by_cases hz : x = 0 ·subst x; rw [Model.roundAt_zero]; simp only [sub_zero, abs_zero]; positivity have hm : magnitude FloatLib.Numerics.binaryRadix x ≤ E := magnitude_le_of_abs_lt_bpow _ x E hz hx apply (Model.abs_roundAt_sub_le FloatFormat.binary64 x).trans apply div_le_div_of_nonneg_right _ (by norm_num) change ulp FloatLib.Numerics.binaryRadix (Model.fexpOf FloatFormat.binary64) x ≤ (2 : ℝ) ^ (E - 53) rw [ulp.of_ne_zero _ _ x hz] change (2 : ℝ) ^ (max (magnitude FloatLib.Numerics.binaryRadix x - 53) (-1074)) ≤ (2 : ℝ) ^ (E - 53) apply zpow_le_zpow_right₀ (by norm_num) omega def faR (x y : Float) (hx : fv x) (hy : fv y) (hb : |rv x + rv y| ≤ Model.toReal (Model.posMaxFinite FloatFormat.binary64)) : fv (x + y) ∧ rv (x + y) = Model.roundAt FloatFormat.binary64 (rv x + rv y) := by have hm := addM x y hx hy have hf := Model.isFinite_add_of_abs_toReal_add_le_posMaxFinite (Model.ofFloatModel x.toModel) (Model.ofFloatModel y.toModel) (by decide) hx hy hb refine ⟨by unfold fv; rw [hm]; exact hf, ?_⟩ unfold rv; rw [hm]; exact Model.toReal_add_eq_roundAt _ _ (by decide) hx hy hf def fadd (x y : Float) (hx : fv x) (hy : fv y) (E : Int) (he : -1021 ≤ E) (he' : E ≤ 971) (hb : |rv x + rv y| < (2 : ℝ) ^ E) : fv (x + y) ∧ |rv (x + y) - (rv x + rv y)| ≤ (2 : ℝ) ^ (E - 53) / 2 := by obtain ⟨h1, h2⟩ := faR x y hx hy (hb.le.trans (pm E he')); exact ⟨h1, by rw [h2]; exact re _ E he hb⟩ def rx (d : FloatLib.Numerics.Dyadic) (hs : d.significand < 2 ^ 53) (he : -1074 ≤ d.exponent) (hb : |d.toReal| ≤ (2 : ℝ) ^ (971 : Int)) : Model.roundAt FloatFormat.binary64 d.toReal = d.toReal := by obtain ⟨hf, hr⟩ := Model.roundDyadic_of_representable FloatFormat.binary64 (by decide) d d.significand 0 (by simp) hs he (hb.trans (pm 971 le_rfl)) rw [← Model.toReal_roundDyadic_eq_roundAt _ (by decide) d hf, hr] def addX (x y : Float) (hx : fv x) (hy : fv y) (d : FloatLib.Numerics.Dyadic) (hd : d.toReal = rv x + rv y) (hs : d.significand < 2 ^ 53) (he : -1074 ≤ d.exponent) (hb : |d.toReal| ≤ (2 : ℝ) ^ (971 : Int)) : fv (x + y) ∧ rv (x + y) = rv x + rv y := by obtain ⟨h1, h2⟩ := faR x y hx hy (by rw [← hd]; exact hb.trans (pm 971 le_rfl)); exact ⟨h1, by rw [h2, ← hd]; exact rx d hs he hb⟩ def i64 (i : Int64) (hi : i.toInt.natAbs < 2 ^ 53) : fv i.toFloat ∧ rv i.toFloat = i.toInt := by have hm : Model.ofFloatModel i.toFloat.toModel = Model.roundDyadic FloatFormat.binary64 (FloatLib.Numerics.Dyadic.ofScaledInt i.toInt 0) := FloatLib.Floats.ExecFloat.Binary.toModel_ofFloat_int64ToFloat i have hd : (FloatLib.Numerics.Dyadic.ofScaledInt i.toInt 0).toReal = i.toInt := by rw [← FloatLib.Numerics.Dyadic.cast_toRat, FloatLib.Numerics.Dyadic.ofScaledInt_toRat]; simp obtain ⟨hf, hr⟩ := Model.roundDyadic_of_representable FloatFormat.binary64 (by decide) (FloatLib.Numerics.Dyadic.ofScaledInt i.toInt 0) i.toInt.natAbs 0 (Nat.mul_one _).symm hi (by change _ ≤ (0 : ℤ); decide) (by rw [hd, ← Int.cast_abs, Int.abs_eq_natAbs]; exact le_trans (by exact_mod_cast hi.le) (pm 53 (by norm_num))) exact ⟨by unfold fv; rw [hm]; exact hf, by unfold rv; rw [hm, hr, hd]⟩ def mulM (x y : Float) : Model.ofFloatModel (x * y).toModel = Model.ofModel FloatFormat.binary64 (Float.Model.UnpackedFloat.mul Float.Model.Format.binary64 x.toModel.unpack y.toModel.unpack) := by change Model.ofFloatModel (Float.Model.mul x.toModel y.toModel) = _ rw [Float.Model.mul, Model.ofFloatModel_pack] def unpN (b : BitVec 64) (s : Float.Model.UnpackedFloat.Sign) (m : Nat) (e : Int) (h : 0 < m) (hu : Float.Model.UnpackedFloat.unpack Float.Model.Format.binary64 b = .finite s m e h) : 2 ^ 52 ≤ m ∨ e = -1074 := by revert hu; unfold Float.Model.UnpackedFloat.unpack; dsimp only split ·split <;> intro hu <;> cases hu ·split ·split ·intro hu; cases hu ·rename_i hE _ intro hu; injection hu with _ _ h3 right; rw [← h3, hE]; decide ·intro hu; injection hu with _ h2 _ left; rw [← h2, BitVec.toNat_append] exact le_trans (by decide) Nat.left_le_or def fmR (x y : Float) (hx : fv x) (hy : fv y) (hb : |rv x * rv y| ≤ (2 : ℝ) ^ (971 : Int)) : fv (x * y) ∧ rv (x * y) = Model.roundAt FloatFormat.binary64 (rv x * rv y) := by simp only [fvI] at hx hy rw [rvU x, rvU y] at hb ⊢ unfold fv rv; rw [mulM] generalize ux : x.toModel.unpack = X at hx hb ⊢ generalize uy : y.toModel.unpack = Y at hy hb ⊢ cases X <;> cases Y <;> simp only [Float.Model.UnpackedFloat.isFinite, Bool.false_eq_true] at hx hy case finite.finite s1 m1 e1 h1 s2 m2 e2 h2 => have n1 := unpN _ s1 m1 e1 h1 ux have n2 := unpN _ s2 m2 e2 h2 uy have hpre : e1 + e2 ≤ Float.Model.Format.binary64.targetExponent (Float.Model.totalExponent (m1 * m2) (e1 + e2)) := by change e1 + e2 ≤ max ((Nat.log2 (m1 * m2) : Int) + 1 + (e1 + e2) - 53) (-1074) have := (Nat.le_log2 (n := m1 * m2) (k := 52) (by positivity)).2 have := Nat.le_mul_of_pos_right m1 h2; have := Nat.le_mul_of_pos_left m2 h1 clear h1 h2 hb hx hy ux uy;omega let d' : FloatLib.Numerics.Dyadic := ⟨xor (Model.modelSignBit s1) (Model.modelSignBit s2), m1 * m2, e1 + e2⟩ have hround : Model.ofModel FloatFormat.binary64 (Float.Model.UnpackedFloat.mul Float.Model.Format.binary64 (.finite s1 m1 e1 h1) (.finite s2 m2 e2 h2)) = Model.roundDyadic FloatFormat.binary64 d' := by rw [Float.Model.UnpackedFloat.mul, Model.roundWithAccuracy_exact_eq_round_of_le_targetExponent _ _ _ _ hpre] cases s1 <;> cases s2 <;> rfl have hreal : d'.toReal = Model.unpackedToReal (.finite s1 m1 e1 h1) * Model.unpackedToReal (.finite s2 m2 e2 h2) := Model.Dyadic.toReal_mul ⟨_, m1, e1⟩ ⟨_, m2, e2⟩ have hfin := Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite FloatFormat.binary64 (by decide) d' (by rw [hreal]; exact hb.trans (pm 971 le_rfl)) rw [hround] exact ⟨hfin, by rw [Model.toReal_roundDyadic_eq_roundAt _ (by decide) d' hfin, hreal]⟩ all_goals simp [Float.Model.UnpackedFloat.mul, Model.isFinite_ofModel_zero FloatFormat.binary64 (by decide), Model.toReal_ofModel_zero FloatFormat.binary64 (by decide)] def dyR (s : Bool) (m : Nat) (e : Int) : (⟨s, m, e⟩ : FloatLib.Numerics.Dyadic).toReal = (if s then -(m : ℝ) else m) * (2 : ℝ) ^ e := by simp only [FloatLib.Numerics.Dyadic.toReal, FloatLib.Numerics.Dyadic.cast_signedSignificand] split <;> simp def pw : Nat → Float | 0 => (1 : Int64).toFloat | k + 1 => let p := pw k; p + p def pwV (k : Nat) (hk : k ≤ 900) : fv (pw k) ∧ rv (pw k) = (2 : ℝ) ^ k := by induction k with | zero => have := i64 1 (by decide); simp only [pw]; exact ⟨this.1, by rw [this.2]; simp⟩ | succ k ih => obtain ⟨f, v⟩ := ih (by omega) have hd : (⟨false, 1, ((k + 1 : Nat) : Int)⟩ : FloatLib.Numerics.Dyadic).toReal = (2 : ℝ) ^ (k + 1) := by rw [dyR]; simp only [Bool.false_eq_true, ite_false, Nat.cast_one, one_mul]; exact zpow_natCast 2 (k + 1) have := addX (pw k) (pw k) f f _ (by rw [hd, v, pow_succ]; ring) (show (1 : Nat) < 2 ^ 53 by norm_num) (show (-1074 : Int) ≤ ((k + 1 : Nat) : Int) by clear hk;omega) (by rw [hd, abs_of_pos (by positivity), ← zpow_natCast] exact zpow_le_zpow_right₀ (by norm_num) (by omega)) simp only [pw]; exact ⟨this.1, by rw [this.2, v, pow_succ]; ring⟩ def nm : Float := (-1 : Int64).toFloat def P : FloatArray := ⟨Array.ofFn (n := 512) fun i => if i.val < 256 then pw (i.val - 1) else nm * pw (i.val - 256 - 1)⟩ def P_size : P.size = 512 := by simp [P, FloatArray.size] def P_get (i : USize) (h : i.toNat < P.size) : P.uget i h = if i.toNat < 256 then pw (i.toNat - 1) else nm * pw (i.toNat - 256 - 1) := by simp [P, FloatArray.uget] def eS (w : UInt32) : (expOf w).toNat = (w <<< 1).toNat / 2 ^ 24 := by rw [expA, absA, UInt32.toNat_shiftLeft]; simp only [UInt32.reduceToNat, Nat.reduceMod, Nat.shiftLeft_eq] have := w.toNat_lt; omega def sh23 (w : UInt32) : (w >>> 23).toNat = w.toNat / 2 ^ 23 := by rw [UInt32.toNat_shiftRight]; simp [Nat.shiftRight_eq_div_pow] @[inline] def dw (w : UInt32) : Float := (Core.mW w).toInt64.toFloat * P.uget (w >>> 23).toUSize (by rw [P_size, u32_toUSize, sh23]; have := w.toNat_lt; omega) def ofIntR (z e : Int) : (ofIntDyadic z e).toReal = (z : ℝ) * (2 : ℝ) ^ e := by rw [← FloatLib.Numerics.Dyadic.cast_toRat, toRat_ofIntDyadic]; push_cast; rfl def nmulZ (x y : Float) (hx : fv x) (hy : fv y) (z e : Int) (hd : rv x * rv y = (z : ℝ) * (2 : ℝ) ^ e) (hs : z.natAbs < 2 ^ 53) (he : -1074 ≤ e) (hb : |(z : ℝ) * (2 : ℝ) ^ e| ≤ (2 : ℝ) ^ (971 : Int)) : fv (x * y) ∧ rv (x * y) = (z : ℝ) * (2 : ℝ) ^ e := by obtain ⟨h1, h2⟩ := fmR x y hx hy (by rw [hd]; exact hb) have := rx (ofIntDyadic z e) hs he (by rw [ofIntR]; exact hb) rw [ofIntR] at this exact ⟨h1, by rw [h2, hd, this]⟩ def svB (w : UInt32) : (sv w).natAbs < 2 ^ 24 := by have := mantOf_lt_24 w; unfold sv; split <;> simp <;> omega def pwB (a b c : Nat) (hab : a + b ≤ c) (hc : c ≤ 971) (z : Int) (hz : z.natAbs < 2 ^ a) : |(z : ℝ) * (2 : ℝ) ^ (b : Int)| ≤ (2 : ℝ) ^ (971 : Int) := by rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < 2 ^ (b : Int)), zpow_natCast] have h1 : |(z : ℝ)| ≤ 2 ^ a := by rw [← Int.cast_abs, Int.abs_eq_natAbs]; exact_mod_cast hz.le refine (mul_le_mul_of_nonneg_right h1 (by positivity)).trans ?_ rw [← pow_add, ← zpow_natCast]; exact zpow_le_zpow_right₀ (by norm_num) (by clear h1 hz;omega) def mV (u : UInt64) (n : Nat) (hu : u.toNat = n) (hn : n < 2 ^ 25) : fv u.toInt64.toFloat ∧ rv u.toInt64.toFloat = (n : Int) := by have : u.toInt64.toInt = n := by rw [show u.toInt64.toInt = Core.sval u from rfl, sval_eq, hu]; split <;> (clear hu;omega) rw [← this]; exact i64 _ (by rw [this]; simp; clear*-hn;omega) def qV (c : Nat) (A : FloatArray) (hA : ∀ i h, A.uget i h = if i.toNat < 256 then pw (i.toNat - c) else nm * pw (i.toNat - 256 - c)) (w : UInt32) (h) : fv (A.uget (w >>> 23).toUSize h) ∧ ∃ σ : Int, (∀ v, signOf v = signOf w → σ * mantOf v = sv v) ∧ σ.natAbs = 1 ∧ rv (A.uget (w >>> 23).toUSize h) = σ * 2 ^ ((expOf w).toNat - c) := by have := expL w; have := w.toNat_lt; have hsg := Core.signOf_iff w obtain ⟨f2, v2⟩ := pwV ((expOf w).toNat - c) (by clear h hA hsg this;omega) rw [hA, u32_toUSize, sh23, wdiv]; split ·rw [show (expOf w).toNat + 256 * (w.toNat / 2 ^ 31) - c = (expOf w).toNat - c by clear f2 h hA hsg this v2;omega] exact ⟨f2, 1, fun v hv => by simp only [sv, hv, hsg]; split <;> (clear f2 h hA hsg hv this v2;omega), rfl, by rw [v2]; push_cast; ring⟩ ·rw [show (expOf w).toNat + 256 * (w.toNat / 2 ^ 31) - 256 - c = (expOf w).toNat - c by clear f2 h hA hsg v2;omega] have e0 := i64 (-1) (by decide) obtain ⟨f3, v3⟩ := nmulZ _ _ e0.1 f2 (-1) ((expOf w).toNat - c : ℕ) (by rw [e0.2, v2, zpow_natCast]; rfl) (by decide) (by clear*-;omega) (pwB 1 _ 971 (by clear e0 f2 h hA hsg this v2;omega) le_rfl _ (by decide)) exact ⟨f3, -1, fun v hv => by simp only [sv, hv, hsg]; split <;> (clear e0 f2 f3 h hA hsg hv this v2 v3;omega), rfl, by rw [← zpow_natCast]; exact v3⟩ def dG (c q : Nat) (A : FloatArray) (hA : ∀ i h, A.uget i h = if i.toNat < 256 then pw (i.toNat - c) else nm * pw (i.toNat - 256 - c)) (u : UInt64) (v w : UInt32) (h) (hq : q ≤ 2) (hu : u.toNat = q * mantOf v) (hs : signOf v = signOf w) (he : (q : ℝ) * 2 ^ ((expOf w).toNat - c) = 2 ^ idxOf v) : fv (u.toInt64.toFloat * A.uget (w >>> 23).toUSize h) ∧ rv (u.toInt64.toFloat * A.uget (w >>> 23).toUSize h) = (sv v : ℝ) * 2 ^ idxOf v := by have := mantOf_lt_24 v; have := Nat.mul_le_mul_right (mantOf v) hq; have := expL w obtain ⟨e1, e2⟩ := mV u _ hu (by clear h hA he hq hs hu this;omega) obtain ⟨f2, σ, hs', h1, v2⟩ := qV c A hA w h have hb : (((q * mantOf v : Nat) : Int) * σ).natAbs < 2 ^ 25 := by rw [Int.natAbs_mul, h1]; simp; clear e1 e2 f2 h h1 hA he hq hs hs' hu this v2;omega have := nmulZ _ _ e1 f2 _ ((expOf w).toNat - c : Nat) (by rw [e2, v2, zpow_natCast]; push_cast; ring) (hb.trans (by norm_num)) (by clear*-;omega) (pwB 25 _ 971 (by clear*-this;omega) le_rfl _ hb) exact ⟨this.1, by rw [this.2, ← he, zpow_natCast, ← hs' v hs]; push_cast; ring⟩ def dwV (w : UInt32) (_ : expOf w ≠ 255) : fv (dw w) ∧ rv (dw w) = (sv w : ℝ) * 2 ^ idxOf w := dG 1 1 P P_get _ w w _ (by omega) (by simp [Core.mW_toNat]) rfl (by simp [idxE]) def pvV (x w : UInt32) (hx : expOf x ≠ 255) (hw : expOf w ≠ 255) : fv (dw x * dw w) ∧ rv (dw x * dw w) = (Core.tm x w : ℝ) := by obtain ⟨f1, v1⟩ := dwV x hx; obtain ⟨f2, v2⟩ := dwV w hw have hb : (sv x * sv w).natAbs < 2 ^ 48 := by rw [Int.natAbs_mul]; exact (Nat.mul_lt_mul'' (svB x) (svB w)).trans_eq (by norm_num) have := nmulZ _ _ f1 f2 (sv x * sv w) (idxOf x + idxOf w : Nat) (by rw [v1, v2, zpow_natCast, pow_add]; push_cast; ring) (lt_trans hb (by norm_num)) (by clear*-;omega) (pwB 48 _ 971 (by rw [idxE, idxE]; have := expL x; have := expL w; clear f1 f2 hb hw hx v1 v2;omega) le_rfl _ hb) refine ⟨this.1, ?_⟩; rw [this.2, Core.tm, zpow_natCast]; push_cast; ring @[inline] def eF (b : UInt64) : UInt64 := (b >>> 52) &&& 2047 @[inline] def mF (b : UInt64) : UInt64 := (b &&& 0xfffffffffffff) ||| 0x10000000000000 def sg63 (u : UInt64) : (u &&& 0x8000000000000000 != 0) = (u >>> 63 != 0) := by apply Bool.eq_iff_iff.mpr simp only [bne_iff_ne, ne_eq, ← UInt64.toNat_inj] rw [UInt64.toNat_and, UInt64.toNat_shiftRight] change ¬u.toNat &&& 2 ^ 63 = 0 ↔ ¬u.toNat >>> 63 = 0 rw [Nat.and_two_pow, Nat.shiftRight_eq_div_pow, Nat.testBit_eq_decide_div_mod_eq] have hq : u.toNat / 2 ^ 63 < 2 := by have h := UInt64.toNat_lt u; omega rw [Nat.mod_eq_of_lt hq] by_cases hh : u.toNat / 2 ^ 63 = 1 <;> simp <;> omega def fld (v : Float) : Model.ofFloatModel v.toModel = Model.ofFields FloatFormat.binary64 (v.toBits >>> 63 != 0) (((v.toBits >>> 52) &&& 2047).toNat) ((v.toBits &&& 0xfffffffffffff).toNat) := by rw [← Model.ofFields_signBit_expField_fracField (Model.ofFloatModel v.toModel)]; congr 1 rw [← sg63]; apply Bool.eq_iff_iff.mpr; simp only [Model.signBit, bne_iff_ne, ne_eq]; rw [← UInt64.toBitVec_inj]; exact Iff.rfl def fq (v : Float) : ((v.toBits >>> 52) &&& 2047).toNat < 2 ^ 11 ∧ (v.toBits &&& 0xfffffffffffff).toNat < 2 ^ 52 := by simp only [UInt64.toNat_and]; exact ⟨lt_of_le_of_lt Nat.and_le_right (by decide), lt_of_le_of_lt Nat.and_le_right (by decide)⟩ def bitsD (v : Float) (hv : fv v) (he : ¬eF v.toBits = 0) : rv v = (⟨v.toBits >>> 63 != 0, (v.toBits &&& 0xfffffffffffff).toNat + 2 ^ 52, ((eF v.toBits).toNat : Int) - 1075⟩ : FloatLib.Numerics.Dyadic).toReal := by unfold eF at he ⊢ have hq := (fq v).1 have hr := (fq v).2 have he' : ((v.toBits >>> 52) &&& 2047).toNat ≠ 0 := fun h => he (UInt64.toNat_inj.mp (by simpa using h)) unfold fv at hv; unfold rv rw [fld] at hv ⊢ rw [Model.toReal_eq, Model.toDyadic?_ofFields_of_isFinite _ _ _ _ hq hr hv, if_neg he'] simp only [show FloatFormat.binary64.fracWidth = 52 from rfl, show FloatFormat.binary64.exponentBias = 1023 from rfl, Model.pow2_eq_two_pow] congr 2 <;> (try simp only [Int.ofNat_eq_natCast, Nat.cast_ofNat]) <;> ring def ofW_toWord (z : Model Fmt) : ofW (toWord z) = z := by have h : z.toNatBits < 2 ^ 32 := Model.toNatBits_lt_two_pow z simp only [ofW, toWord, Model.ofUInt32, UInt32.toNat_ofNat', Nat.mod_eq_of_lt h] exact Model.ofNatBits_toNatBits z def toReal_ofW (w : Word) (hf : expOf w ≠ 255) : Model.toReal (ofW w) = (sv w : ℝ) * (2 : ℝ) ^ ((idxOf w : Int) - 149) := by rw [ofW, Model.toReal_eq, toDyadic_ofUInt32 w hf] change (decodeD w).toReal = _ rw [← FloatLib.Numerics.Dyadic.cast_toRat, decodeD_toRat] push_cast; rfl def ofW_ne (w : Word) (hf : expOf w ≠ 255) (hz : w &&& 0x7FFFFFFF ≠ 0) : Model.toReal (ofW w) ≠ 0 := by rw [toReal_ofW w hf] refine mul_ne_zero ?_ (zpow_ne_zero _ (by norm_num)) have hm : mantOf w ≠ 0 := by unfold mantOf; split ·rename_i h0 have h1 := (exp0 w).mp h0; rw [absA] at h1 have h2 : (absW w).toNat ≠ 0 := fun h => hz (UInt32.toNat_inj.mp (h.trans UInt32.toNat_zero.symm)) rw [absA] at h2; unfold fracOf; rw [fr23]; omega ·omega unfold sv; split <;> simp [hm] def sand (d1 d2 d3 : FloatLib.Numerics.Dyadic) (h12 : d1.toReal ≤ d2.toReal) (h23 : d2.toReal ≤ d3.toReal) (hw : toWord (Model.roundDyadic Fmt d1) = toWord (Model.roundDyadic Fmt d3)) (hf : expOf (toWord (Model.roundDyadic Fmt d1)) ≠ 255) (hz : toWord (Model.roundDyadic Fmt d1) &&& 0x7FFFFFFF ≠ 0) (hb : |d2.toReal| ≤ (2 : ℝ) ^ (127 : Int)) : toWord (Model.roundDyadic Fmt d2) = toWord (Model.roundDyadic Fmt d1) := by have e := ofW_toWord (Model.roundDyadic Fmt d1) have f1 : Model.isFinite (Model.roundDyadic Fmt d1) = true := by rw [← e, ofW, isFinite_ofUInt32]; simpa using hf have f2 := Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite Fmt (by decide) d2 (hb.trans ((Model.abs_signed_mul_bpow_le_toReal_posMaxFinite Fmt false (2 ^ 23) 104 (by decide) (by decide)).trans' (by change _ ≤ |(if false = true then (-1 : ℝ) else 1) * ((2 ^ 23 : ℕ) : ℝ) * (2 : ℝ) ^ (104 : ℤ)|; norm_num))) have e3 : Model.roundDyadic Fmt d3 = Model.roundDyadic Fmt d1 := by rw [← ofW_toWord (Model.roundDyadic Fmt d3), ← hw, e] have r := Model.toReal_roundDyadic_eq_roundAt Fmt (by decide) have m1 := Model.roundAt_mono Fmt h12 have m2 := Model.roundAt_mono Fmt h23 rw [← r d1 f1, ← r d2 f2] at m1 rw [← r d2 f2, ← r d3 (by rw [e3]; exact f1), e3] at m2 rw [Model.eq_of_toReal_eq_of_nonzero f2 f1 (le_antisymm m2 m1) (by rw [le_antisymm m2 m1, ← e]; exact ofW_ne _ hf hz)] def r39 (x : Nat) (hx : x < 2 ^ 53) (ht : x % 2 ^ 29 ≠ 2 ^ 28) : (Core.rne39 (UInt64.ofNat (x * 2 ^ 10))).toNat = (x + 2 ^ 28) / 2 ^ 29 := by simp only [Core.rne39, UInt64.toNat_shiftRight, UInt64.toNat_add, UInt64.toNat_and, UInt64.reduceToNat, UInt64.toNat_ofNat_of_lt' (by simp only [UInt64.size]; omega : x * 2 ^ 10 < UInt64.size), Nat.reduceMod, Nat.shiftRight_eq_div_pow, Nat.and_one_is_mod] grind @[inline, irreducible] def cert2 (S : Float) (h : UInt64) : UInt64 := let b := S.toBits let f := b &&& 0xfffffffffffff let E := eF b let d := h + 1075 - E let g := (1 : UInt64) <<< d let u := (f + 0x10000000) &&& 0x1FFFFFFF let r := ((b &&& 0x7FFFFFFFFFFFFFFF) + 0x10000000) >>> 29 if d ≤ 26 && E - 1195 < 253 && u - (g + 1) < 0x1FFFFFFF - (g + g) && r &&& 0x7FFFFF != 0 then ((b >>> 63) <<< 31) + r - 0x255000000 else 0x100000000 def rb (b : UInt64) (h : (((b &&& 0x7FFFFFFFFFFFFFFF) + 0x10000000) >>> 29 &&& 0x7FFFFF != 0) = true) : 2 ^ 28 ≤ (b &&& 0xfffffffffffff).toNat ∧ (b &&& 0xfffffffffffff).toNat + 2 ^ 28 < 2 ^ 52 := by simp only [bne_iff_ne, ne_eq, ← UInt64.toNat_inj, UInt64.toNat_and, UInt64.toNat_shiftRight, UInt64.toNat_add, UInt64.reduceToNat, Nat.reduceMod, Nat.shiftRight_eq_div_pow] at h ⊢ rw [Nat.and_two_pow_sub_one_eq_mod _ 63, Nat.and_two_pow_sub_one_eq_mod _ 23] at h rw [Nat.and_two_pow_sub_one_eq_mod _ 52] omega def c3c (h E f : UInt64) (hh : h.toNat < 2 ^ 63) (hE : E.toNat < 2048) (hf : f.toNat < 2 ^ 52) (c1 : h + 1075 - E ≤ 26) (c2 : E - 1195 < 253) (c3 : ((f + 0x10000000) &&& 0x1FFFFFFF) - (((1 : UInt64) <<< (h + 1075 - E)) + 1) < 0x1FFFFFFF - (((1 : UInt64) <<< (h + 1075 - E)) + ((1 : UInt64) <<< (h + 1075 - E)))) (c4 : 2 ^ 28 ≤ f.toNat ∧ f.toNat + 2 ^ 28 < 2 ^ 52) : E.toNat ≤ h.toNat + 1075 ∧ h.toNat + 1075 - E.toNat ≤ 26 ∧ 1195 ≤ E.toNat ∧ E.toNat ≤ 1447 ∧ 2 ^ (h.toNat + 1075 - E.toNat) + 1 ≤ (f.toNat + 2 ^ 28) % 2 ^ 29 ∧ (f.toNat + 2 ^ 28) % 2 ^ 29 + 2 ^ (h.toNat + 1075 - E.toNat) < 2 ^ 29 ∧ 2 ^ (h.toNat + 1075 - E.toNat) ≤ f.toNat ∧ f.toNat + 2 ^ (h.toNat + 1075 - E.toNat) < 2 ^ 52 := by simp only [UInt64.le_iff_toNat_le, UInt64.lt_iff_toNat_lt, UInt64.toNat_sub, UInt64.toNat_add, UInt64.toNat_and, UInt64.toNat_shiftLeft, UInt64.reduceToNat, UInt64.toNat_one, Nat.one_shiftLeft] at c1 c2 c3 have hk : (2 ^ 64 - E.toNat + (h.toNat + 1075) % 2 ^ 64) % 2 ^ 64 = h.toNat + 1075 - E.toNat := by clear*-c1 hE hh;omega rw [hk] at c1 c3 have := Nat.pow_le_pow_right (n := 2) (by norm_num) c1 rw [Nat.mod_eq_of_lt (by clear*-c1;omega : _ < 64), Nat.and_two_pow_sub_one_eq_mod _ 29] at c3 simp (disch:=omega) only[Nat.mod_eq_of_lt] at c3 have:E.toNat≤h.toNat+1075∧1195≤E.toNat∧E.toNat≤1447:=by clear*-c1 c2 hE hk;omega clear hk c2;generalize 2^(h.toNat+1075-E.toNat)=P at * have:P+1≤(f.toNat+2^28)%2^29∧(f.toNat+2^28)%2^29+P<2^29:=by clear*-c3 this;omega clear c3;clear hE;omega def c3w (b : UInt64) (hE : 1195 ≤ (eF b).toNat) : (((b >>> 63) <<< 31) + (((b &&& 0x7FFFFFFFFFFFFFFF) + 0x10000000) >>> 29) - 0x255000000).toNat = b.toNat / 2 ^ 63 * 2 ^ 31 + (((eF b).toNat - 1085 - 110) * 2 ^ 23 + (2 ^ 23 + ((b &&& 0xfffffffffffff).toNat + 2 ^ 28) / 2 ^ 29)) := by simp only [eF, UInt64.toNat_sub, UInt64.toNat_add, UInt64.toNat_shiftLeft, UInt64.toNat_shiftRight, UInt64.toNat_and, UInt64.reduceToNat, Nat.reduceMod, Nat.shiftRight_eq_div_pow, Nat.shiftLeft_eq] at hE ⊢ rw [Nat.and_two_pow_sub_one_eq_mod _ 11] at hE ⊢ rw [Nat.and_two_pow_sub_one_eq_mod _ 63, Nat.and_two_pow_sub_one_eq_mod _ 52] have := b.toNat_lt simp (disch:=omega) only[Nat.mod_eq_of_lt] generalize b.toNat=n at * have m:n%2^63=n/2^52%2^11*2^52+n%2^52:=by clear*-;omega have s:n/2^63<2:=by clear hE m;omega have h:n/2^52%2^11<2^11:=by clear*-;omega have f:n%2^52<2^52:=by clear*-;omega rw[m];clear m this generalize n/2^63=S,n/2^52%2^11=E,n%2^52=F at * have q:(E*2^52+F+268435456)/2^29=E*2^23+(F+2^28)/2^29:=by clear*-;omega have l:(F+2^28)/2^29≤2^23:=by clear*-f;omega rw[q];clear q f generalize (F+2^28)/2^29=U at * omega def cert2_spec (S : Float) (hS : fv S) (h : UInt64) (hh : h.toNat < 2 ^ 63) (T : Int) (hT : |rv S - (T : ℝ)| ≤ (2 : ℝ) ^ (h.toNat : Int)) (hTb : |(T : ℝ)| ≤ (2 : ℝ) ^ (425 : Int)) (hc : cert2 S h < 0x100000000) : T ≠ 0 ∧ (cert2 S h).toUInt32 = finishWord T (-298) false := by unfold cert2 at hc ⊢ dsimp only at hc ⊢ split; swap; · simp [*] at hc rename_i hc' simp only [Bool.and_eq_true, decide_eq_true_eq] at hc' obtain ⟨⟨⟨c1, c2⟩, c3⟩, c4⟩ := hc' have hsg : (if (S.toBits >>> 63 != 0) = true then 2 ^ 31 else 0) = S.toBits.toNat / 2 ^ 63 * 2 ^ 31 := by simp only [Core.neg_iff, decide_eq_true_eq]; have := S.toBits.toNat_lt; split <;> (clear c1 c2 c3 c4 hS hT hTb hc hh;omega) obtain ⟨d1, d2, e1, e2, u1, u2, f1, f2⟩ := c3c h (eF S.toBits) _ hh (fq S).1 (fq S).2 c1 c2 c3 (rb _ c4) have hw := c3w S.toBits e1 have hv := bitsD S hS (fun h0 => by rw [h0] at e1; simp at e1) rw [← hsg] at hw have hsc : (eF S.toBits - 1085).toNat = (eF S.toBits).toNat - 1085 := by rw [UInt64.toNat_sub]; simp only [UInt64.reduceToNat]; clear*-e1 e2;omega generalize hW : UInt64.toUInt32 _ = W generalize (S.toBits >>> 63 != 0) = ng at * generalize (eF S.toBits).toNat = EN at * generalize hG : 2 ^ (h.toNat + 1075 - EN) = G at * generalize (S.toBits &&& 0xfffffffffffff).toNat = fN at * have hWn : W.toNat = (if ng then 2 ^ 31 else 0) + ((EN - 1085 - 110) * 2 ^ 23 + (2 ^ 23 + (fN + 2 ^ 28) / 2 ^ 29)) := by rw [← hW, UInt64.toNat_toUInt32, hw]; split <;> (clear*-e1 e2 f2;omega) have key : ∀ N, fN + 2 ^ 52 ≤ N + G → N ≤ fN + 2 ^ 52 + G → toWord (Model.roundDyadic Fmt ⟨ng, N * 2 ^ 10, ((EN - 1085 : ℕ) : ℤ) - 298⟩) = W := fun N l r => by have n := UInt64.toNat_ofNat_of_lt' (show N * 2 ^ 10 < UInt64.size by simp only [UInt64.size]; clear*-f2 r;omega) have w := (Core.rnd62n ng (UInt64.ofNat (N * 2 ^ 10)) (eF S.toBits - 1085) (by clear*-f1 l n;omega) (by clear*-f2 n r;omega) (by clear*-e1 e2 hsc;omega) (by clear*-e1 e2 hsc;omega)).1 rw [← n, ← hsc, ← Core.rnd_eq _ _ _ (by clear*-e1 e2 hsc;omega)] exact UInt32.toNat_inj.mp (by rw [w, r39 N (by clear*-f2 r;omega) (by clear*-l r u1 u2;omega), hWn]; clear*-e1 e2 hsc l r u1 u2;omega) have qf : expOf W ≠ 255 := fun hx => by have := expA W; simp only [hx, absA, hWn, UInt32.reduceToNat] at this; split at this <;> (clear*-e1 e2 f2 this;omega) have qz : W &&& 0x7FFFFFFF ≠ 0 := fun hx => by have := absA W; simp only [absW, hx, hWn, UInt32.toNat_zero] at this; split at this <;> (clear hWn hsg u1;omega) have k1 := key (fN + 2 ^ 52 - G) (by clear*-f1;omega) (by clear*-f1;omega) have k3 := key (fN + 2 ^ 52 + G) (by clear*-;omega) (by clear*-;omega) have hM : G < fN + 2 ^ 52 := by clear*-f1;omega rw [dyR] at hv have hU : (2 : ℝ) ^ (h.toNat : Int) = G * (2 : ℝ) ^ ((EN : Int) - 1075) := by rw [← hG, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast, ← zpow_add₀ two_ne_zero]; congr 1; clear*-d1 e1 e2;omega have hE2 : ∀ m : ℕ, ((m * 2 ^ 10 : ℕ) : ℝ) * 2 ^ (((EN - 1085 : ℕ) : ℤ) - 298) = m * 2 ^ ((EN : ℤ) - 1075) * 2 ^ (-298 : ℤ) := fun m => by rw [Nat.cast_mul, mul_assoc, mul_assoc, Nat.cast_pow, Nat.cast_ofNat, ← zpow_natCast (2 : ℝ) 10, ← zpow_add₀ two_ne_zero, ← zpow_add₀ two_ne_zero, show ((10 : ℕ) : ℤ) + (((EN - 1085 : ℕ) : ℤ) - 298) = (EN : ℤ) - 1075 + -298 by clear*-e1 e2;omega] have hu : (0 : ℝ) < (2 : ℝ) ^ ((EN : Int) - 1075) := by positivity have h298 : (0 : ℝ) < (2 : ℝ) ^ (-298 : Int) := by positivity have hT2 : |(ofIntDyadic T (-298)).toReal| ≤ (2 : ℝ) ^ (127 : Int) := by rw [ofIntR, abs_mul, abs_of_pos h298, show (127 : ℤ) = 425 + -298 by norm_num, zpow_add₀ two_ne_zero]; gcongr rw [hU, hv] at hT generalize fN + 2 ^ 52 = M at hT k1 k3 hM have c1' : ((M - G : ℕ) : ℝ) = M - G := Nat.cast_sub hM.le have hMl : (G : ℝ) < M := by exact_mod_cast hM cases ng <;> simp only [Bool.false_eq_true, ite_false, ite_true] at hT <;> obtain ⟨t1, t2⟩ := abs_le.mp hT <;> have hT0 : T ≠ 0 := by rintro rfl; push_cast at t1 t2; nlinarith only [t1, t2, hMl, hu] all_goals refine ⟨hT0, ?_⟩; simp only [finishWord, hT0, ↓reduceIte] on_goal 2 => refine ((sand _ _ _ ?_ ?_ (k3.trans k1.symm) (k3 ▸ qf) (k3 ▸ qz) hT2).trans k3).symm refine ((sand _ _ _ ?_ ?_ (k1.trans k3.symm) (k1 ▸ qf) (k1 ▸ qz) hT2).trans k1).symm all_goals simp only [ofIntR, dyR, Bool.false_eq_true, ite_false, ite_true, neg_mul, hE2, c1']; push_cast; nlinarith only [t1, t2, h298] @[specialize] def sfold (p : Nat → Float) (n t : Nat) (a : Float) : Float := if t < n then sfold p n (t + 1) (a + p t) else a termination_by n - t structure A8 where a0 : Float a1 : Float a2 : Float a3 : Float a4 : Float a5 : Float a6 : Float a7 : Float local instance : Inhabited A8 := ⟨⟨0, 0, 0, 0, 0, 0, 0, 0⟩⟩ @[inline] def A8.f (s : A8) : Nat → Float | 0 => s.a0 | 1 => s.a1 | 2 => s.a2 | 3 => s.a3 | 4 => s.a4 | 5 => s.a5 | 6 => s.a6 | _ => s.a7 def uk {i k : USize} {S : Nat} (hk : k.toNat < 8) (h : i.toNat + 8 ≤ S) (hs : S < 2 ^ 32) : (i + k).toNat < S := by have := USize.le_size; rw [uadd (by omega)]; omega def ug (X : FloatArray) (i : USize) (h : i.toNat < X.size) : X.uget i h = X.data[i.toNat]! := by rcases X with ⟨d⟩; simp only [FloatArray.uget]; rw [getElem!_pos d i.toNat h]; rfl def psz (Y : FloatArray) (v : Float) : (Y.push v).size = Y.size + 1 := by rcases Y with ⟨d⟩; simp [FloatArray.push, FloatArray.size] def ssz (Y : FloatArray) (i : Nat) (v : Float) : (Y.set! i v).size = Y.size := by rcases Y with ⟨d⟩; simp [FloatArray.set!, FloatArray.size] def sg (Y : FloatArray) (i q : Nat) (v : Float) (hq : q < Y.size) : (Y.set! i v).data[q]! = if i = q then v else Y.data[q]! := by rcases Y with ⟨d⟩; change q < d.size at hq simp only [FloatArray.set!, Array.set!, getElem!_pos d q hq, getElem!_pos (d.setIfInBounds i v) q (by simpa using hq), Array.getElem_setIfInBounds hq] def pg (Y : FloatArray) (v : Float) (q : Nat) (hq : q < Y.size + 1) : (Y.push v).data[q]! = if q < Y.size then Y.data[q]! else v := by rcases Y with ⟨d⟩; change q < d.size + 1 at hq; change (d.push v)[q]! = if q < d.size then d[q]! else v rw [getElem!_pos _ _ (by simp; omega), Array.getElem_push]; split <;> simp [*, getElem!_pos] @[specialize] def bld (f : Nat → Float) (N : Nat) (Y : FloatArray) : FloatArray := if Y.size < N then bld f N (Y.push (f Y.size)) else Y termination_by N - Y.size decreasing_by rw [psz]; omega def bld_spec (f : Nat → Float) (N : Nat) : ∀ k (Y : FloatArray), N - Y.size = k → Y.size ≤ N → (bld f N Y).size = N ∧ (∀ q < Y.size, (bld f N Y).data[q]! = Y.data[q]!) ∧ ∀ q, Y.size ≤ q → q < N → (bld f N Y).data[q]! = f q := by intro k; induction k <;> intro Y hk hY ·rw [bld, if_neg (by omega)]; exact ⟨by omega, fun q _ => rfl, fun q h1 h2 => by omega⟩ rename_i ih rw [bld, if_pos (by clear hY;omega)] have hs := psz Y (f Y.size) obtain ⟨i1, i2, i3⟩ := ih (Y.push (f Y.size)) (by omega) (by clear hY;omega) refine ⟨i1, fun q hq => by rw [i2 q (by clear*-hq hs;omega), pg _ _ _ (by clear*-hq;omega), if_pos hq], fun q h1 h2 => ?_⟩ rcases eq_or_ne q Y.size with rfl | e ·rw [i2 _ (by clear*-hs;omega), pg _ _ _ (by clear*-;omega), if_neg (lt_irrefl _)] exact i3 q (by clear*-e h1 hs;omega) h2 def fvE (v : Float) (h : (eF v.toBits).toNat < 2047) : fv v := by unfold fv; rw [fld] have hq := (fq v).1 have hr := (fq v).2 rw [Model.isFinite_ofFields _ _ _ _ hq hr] have e1 : FloatFormat.binary64.expAllOnesNat = 2047 := by decide unfold eF at h simp only [show FloatFormat.binary64.encoding = .ieee from rfl, e1, bne_iff_ne, ne_eq]; omega def bitsB (v : Float) (hv : fv v) : |rv v| < (2 : ℝ) ^ (((eF v.toBits).toNat : Int) - 1022) := by have key : ∀ (m k : ℕ) (e f : ℤ), m < 2 ^ k → k + e ≤ f → (m : ℝ) * 2 ^ e < 2 ^ f := fun m k e f h h' => (mul_lt_mul_of_pos_right (by exact_mod_cast h : (m : ℝ) < 2 ^ k) (zpow_pos two_pos e)).trans_le (by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact zpow_le_zpow_right₀ (by norm_num) h') unfold rv eF; unfold fv at hv; rw [fld] at hv ⊢ rw [Model.toReal_eq, Model.toDyadic?_ofFields_of_isFinite _ _ _ _ (fq v).1 (fq v).2 hv] have := (fq v).2 split_ifs with h0 <;> simp only [Model.Dyadic.abs_toReal] ·simp; positivity ·exact key _ 52 _ _ this (by rw [h0]; decide) ·exact key _ 53 _ _ (by simp only [FloatFormat.binary64, Model.pow2_eq_two_pow]; omega) (by simp [FloatFormat.binary64]; clear*-;omega) def rlt (x y : Float) (hx : fv x) (hy : fv y) (hs : fv (x + y)) (E : Int) (h1 : -1074 ≤ E) (h2 : E ≤ 971) (h : |rv (x + y)| < (2 : ℝ) ^ E) : |rv x + rv y| < (2 : ℝ) ^ E := by have hm := addM x y hx hy have hr := Model.toReal_add_eq_roundAt _ _ (by decide) hx hy (hm ▸ hs) unfold rv at h ⊢; rw [hm, hr, abs_lt] at h have hp := rx ⟨false, 1, E⟩ (by norm_num) h1 (by simp [dyR]; exact zpow_le_zpow_right₀ (by norm_num) h2) have hn := rx ⟨true, 1, E⟩ (by norm_num) h1 (by simp [dyR]; exact zpow_le_zpow_right₀ (by norm_num) h2) simp only [dyR, Bool.false_eq_true, ite_false, ite_true, Nat.cast_one, one_mul, neg_mul] at hp hn exact abs_lt.2 ⟨lt_of_not_ge fun h4 => by linarith [Model.roundAt_mono FloatFormat.binary64 h4], lt_of_not_ge fun h4 => by linarith [Model.roundAt_mono FloatFormat.binary64 h4]⟩ @[specialize] def sT (p : Nat → Float) (n t : Nat) (a : Float) (m : UInt64) : Float × UInt64 := if t < n then let a' := a + p t let e := eF a'.toBits sT p n (t + 1) a' (if m < e then e else m) else (a, m) termination_by n - t def mxv (m e : UInt64) : (if m < e then e else m).toNat = max m.toNat e.toNat := by split <;> rename_i h <;> simp only [UInt64.lt_iff_toNat_lt] at h <;> omega def sT_ge (p : Nat → Float) (n : Nat) : ∀ k t a m, n - t = k → m.toNat ≤ (sT p n t a m).2.toNat := by intro k; induction k with | zero => intro t a m h; rw [sT, if_neg (by omega)] | succ k ih => intro t a m h; rw [sT, if_pos (by omega)]; dsimp only have := ih (t + 1) (a + p t) (if m < eF (a + p t).toBits then eF (a + p t).toBits else m) (by omega) rw [mxv] at this; clear h ih;omega def sT_err (p : Nat → Float) (z : Nat → Int) (za : Int) (n K : Nat) (hK1 : 1 ≤ K) (hK2 : K ≤ 1993) (hp : ∀ t < n, fv (p t) ∧ rv (p t) = z t) : ∀ m t a M, n - t = m → t ≤ n → fv a → |rv a - ((za : ℝ) + ∑ s ∈ Finset.range t, (z s : ℝ))| ≤ t * (2 : ℝ) ^ ((K : Int) - 1076) → (sT p n t a M).2.toNat ≤ K → fv (sT p n t a M).1 ∧ |rv (sT p n t a M).1 - ((za : ℝ) + ∑ s ∈ Finset.range n, (z s : ℝ))| ≤ n * (2 : ℝ) ^ ((K : Int) - 1076) := by intro m; induction m <;> intro t a M hm ht ha he hk ·obtain rfl : t = n := by clear*-hm ht;omega rw [sT, if_neg (lt_irrefl _)]; exact ⟨ha, he⟩ rename_i ih have htn : t < n := by clear*-hm;omega rw [sT, if_pos htn] at hk ⊢; dsimp only at hk ⊢ obtain ⟨fp, vp⟩ := hp t htn have hg := sT_ge p n _ (t + 1) (a + p t) (if M < eF (a + p t).toBits then eF (a + p t).toBits else M) rfl rw [mxv] at hg have fs := fvE (a + p t) (by clear*-hK1 hK2 hg hk;omega) obtain ⟨f2, e2⟩ := fadd a (p t) ha fp _ (by clear*-hK1;omega) (by clear*-hK1 hK2;omega) (rlt a (p t) ha fp fs ((K : Int) - 1022) (by clear*-hK1;omega) (by clear*-hK1 hK2;omega) ((bitsB _ fs).trans_le (zpow_le_zpow_right₀ (by norm_num) (by clear*-hg hk;omega)))) refine ih (t + 1) (a + p t) _ (by clear*-hm htn;omega) (by clear*-htn;omega) f2 ?_ hk rw [show (K : Int) - 1022 - 53 = ((K : Int) - 1076) + 1 by ring, zpow_add_one₀ two_ne_zero, mul_div_cancel_right₀ _ two_ne_zero] at e2 push_cast [Finset.sum_range_succ, abs_le] at e2 he ⊢; constructor <;> linarith only [e2.1, e2.2, he.1, he.2, vp] def cw (n : Nat) (fa fb : Nat → Word) (hfin : Core.finAll n fa fb) (S : Float) (hS : fv S) (h : UInt64) (hh : h.toNat < 2 ^ 63) (hT : |rv S - (Core.tsum n fa fb : ℝ)| ≤ (2 : ℝ) ^ (h.toNat : Int)) (hTb : |(Core.tsum n fa fb : ℝ)| ≤ (2 : ℝ) ^ (425 : Int)) (hc : cert2 S h < 0x100000000) : (cert2 S h).toUInt32 = dotOf n fa fb := by obtain ⟨hT0, hw⟩ := cert2_spec S hS h hh _ hT hTb hc rw [hw, Core.dotOf_round n fa fb hfin hT0] def emx (A : Array Word) (i : USize) (m : UInt32) : UInt32 := if h : i < A.usize then let e := (A.uget i (ulen h) >>> 23) &&& 255 emx A (i + 1) (if m < e then e else m) else m termination_by A.size - i.toNat decreasing_by have := ulen h; rw [usucc h]; omega def emx_spec (A : Array Word) (hs : A.size < USize.size) : ∀ k (i : USize) (m : UInt32), A.size - i.toNat = k → m.toNat ≤ (emx A i m).toNat ∧ ∀ q, i.toNat ≤ q → q < A.size → (expOf A[q]!).toNat ≤ (emx A i m).toNat := by intro k; induction k <;> intro i m hk ·have h : ¬ i < A.usize := fun h => by have := ulen h; clear h hs;omega rw [emx, dif_neg h]; exact ⟨le_rfl, fun q h1 h2 => by clear h hs;omega⟩ rename_i ih have h : i < A.usize := by rw [USize.lt_iff_toNat_lt, Array.usize, toUSize_toNat hs]; clear*-hk;omega rw [emx, dif_pos h]; dsimp only have hv : ∀ e : UInt32, (if m < e then e else m).toNat = max m.toNat e.toNat := fun e => by split <;> rename_i he <;> simp only [UInt32.lt_iff_toNat_lt] at he <;> (clear*-he;omega) obtain ⟨i1, i2⟩ := ih (i + 1) (if m < (A.uget i (ulen h) >>> 23) &&& 255 then (A.uget i (ulen h) >>> 23) &&& 255 else m) (by rw [usucc h]; clear*-hk;omega) rw [hv] at i1 refine ⟨by clear*-h i1;omega, fun q h1 h2 => ?_⟩ rcases eq_or_ne q i.toNat with rfl | e ·rw [← uget_eq A i (ulen h)]; unfold expOf; clear*-h i1;omega exact i2 q (by rw [usucc h]; clear*-e h h1;omega) h2 def exF (A : Array Word) (hs : A.size < USize.size) (h : emx A 0 0 < 255) (q : Nat) : expOf A[q]! ≠ 255 ∧ idxOf A[q]! ≤ (emx A 0 0).toNat - 1 := by have h' := UInt32.lt_iff_toNat_lt.mp h have hq : (expOf A[q]!).toNat ≤ (emx A 0 0).toNat := by by_cases hq : q < A.size ·exact (emx_spec A hs _ 0 0 rfl).2 q (by simp) hq ·rw [getElem!_neg A q hq]; exact Nat.zero_le _ refine ⟨fun e => by rw [e] at hq; simp at hq h'; clear*-h' hq;omega, by rw [idxE]; clear*-hq;omega⟩ @[inline] def s8 (Y : FloatArray) (o : USize) (e0 e1 e2 e3 e4 e5 e6 e7 : Float) : FloatArray := (((((((Y.set! o.toNat e0).set! (o + 1).toNat e1).set! (o + 2).toNat e2).set! (o + 3).toNat e3).set! (o + 4).toNat e4).set! (o + 5).toNat e5).set! (o + 6).toNat e6).set! (o + 7).toNat e7 def s8_spec (Y : FloatArray) (o : USize) (e : Nat → Float) (h : o.toNat + 8 < USize.size) : (s8 Y o (e 0) (e 1) (e 2) (e 3) (e 4) (e 5) (e 6) (e 7)).size = Y.size ∧ ∀ q < Y.size, (s8 Y o (e 0) (e 1) (e 2) (e 3) (e 4) (e 5) (e 6) (e 7)).data[q]! = if o.toNat ≤ q ∧ q < o.toNat + 8 then e (q - o.toNat) else Y.data[q]! := by refine ⟨by simp only [s8, ssz], fun q hq => ?_⟩ simp (disch := (try simp only [ssz, USize.reduceToNat]); omega) only [s8, sg, uadd, USize.reduceToNat] split_ifs <;> first | rfl | omega | (congr 1; clear h hq;omega) def gD (X : Array Word) (k : Nat) : X.getD k 0 = X[k]! := by unfold Array.getD; split <;> rename_i h ·rw [getElem!_pos X k h]; rfl ·rw [getElem!_neg X k h]; rfl @[inline] def xr (X : Array Word) (q st : USize) (r : Nat) : Float := dw (X.getD (q + r.toUSize * st).toNat 0) def bx (X : Array Word) (st s : USize) : Nat → USize → USize → FloatArray → FloatArray | 0, _, _, Y => Y | k + 1, q, o, Y => bx X st s k (q + s) (o + 8) (s8 Y o (xr X q st 0) (xr X q st 1) (xr X q st 2) (xr X q st 3) (xr X q st 4) (xr X q st 5) (xr X q st 6) (xr X q st 7)) def bx_spec (X : Array Word) (st s : USize) : ∀ k (q o : USize) (Y : FloatArray), q.toNat + k * s.toNat + 8 * st.toNat + o.toNat + 8 * k < USize.size → o.toNat + 8 * k ≤ Y.size → (bx X st s k q o Y).size = Y.size ∧ (∀ p < o.toNat, (bx X st s k q o Y).data[p]! = Y.data[p]!) ∧ ∀ τ r, τ < k → r < 8 → (bx X st s k q o Y).data[o.toNat + 8 * τ + r]! = dw X[q.toNat + τ * s.toNat + r * st.toNat]! := by intro k; induction k with | zero => intro q o Y _ _; exact ⟨rfl, fun _ _ => rfl, fun τ r h => absurd h (by clear*-h;omega)⟩ | succ k ih => intro q o Y hB hY; rw [Nat.succ_mul] at hB have := USize.le_size; have := USize.size_eq_two_pow obtain ⟨s1, s2⟩ := s8_spec Y o (xr X q st) (by clear*-hB;omega) have e1 : (q + s).toNat = q.toNat + s.toNat := uadd (by clear*-hB;omega) have e2 : (o + 8).toNat = o.toNat + 8 := by rw [uadd (by simp; clear*-hB;omega)]; simp obtain ⟨i1, i2, i3⟩ := ih (q + s) (o + 8) _ (by clear*-e1 e2 hB;omega) (by rw [s1]; clear*-e2 hY;omega) rw [e2] at i2; rw [e1, e2] at i3 refine ⟨by rw [bx, i1, s1], fun p hp => by rw [bx, i2 p (by clear*-hp;omega), s2 p (by clear*-hY hp;omega), if_neg (by clear*-hp;omega)], fun τ r h1 hr => ?_⟩ rw [bx]; rcases τ with _ | τ ·have m : (r.toUSize * st).toNat = r * st.toNat := by rw [USize.toNat_mul, toUSize_toNat (by clear e1 e2 h1 hB hY i1 i2 i3 ih s1 s2 this;omega), Nat.mod_eq_of_lt (by have := Nat.mul_le_mul_right st.toNat hr.le; clear e1 e2 h1 hY hr i1 i2 i3 ih s1 s2;omega)] rw [i2 _ (by clear*-hr;omega), s2 _ (by clear*-hY hr;omega), if_pos (by clear*-hr;omega), show o.toNat + 8 * 0 + r - o.toNat = r by clear*-hr;omega, xr, uadd (by rw [m]; have := Nat.mul_le_mul_right st.toNat hr.le; clear*-hB this;omega), m, gD]; simp ·grind def ZT : Array FloatArray := Array.ofFn (n := 10) fun k => ⟨Array.replicate (2 ^ (k.val + 7)) 0⟩ def zT (n : Nat) : FloatArray := let k := Nat.log2 (8 * n) + 1 - 7 if k < 10 then ZT[k]! else ⟨Array.replicate (8 * n) 0⟩ def zsz (n : Nat) : 8 * n ≤ (zT n).size ∧ ((zT n).size = 8 * n ∨ (zT n).size ≤ 2 ^ 16) := by unfold zT; dsimp only; split ·rw [getElem!_pos ZT _ (by simp [ZT]; omega)] simp only [ZT, Array.getElem_ofFn, FloatArray.size, Array.size_replicate] exact ⟨(Nat.lt_log2_self (n := 8 * n)).le.trans (Nat.pow_le_pow_right (by decide) (by omega)), .inr (Nat.pow_le_pow_right (by decide) (by omega))⟩ ·simp [FloatArray.size] @[inline] def rX (X : Array Word) (i : USize) : Float := if h : i < X.usize then dw (X.uget i (ulen h)) else dw 0 def fulen {Y : FloatArray} {i : USize} (h : i < Y.usize) : i.toNat < Y.size := by have := USize.lt_iff_toNat_lt.mp h simp only [FloatArray.usize, Nat.toUSize_eq, USize.toNat_ofNat] at this exact lt_of_lt_of_le this (Nat.mod_le _ _) @[inline] def wF (Y : FloatArray) (i : USize) (v : Float) : FloatArray := if h : i < Y.usize then Y.uset i v (fulen h) else Y @[inline] def cE (F a : Float) : UInt64 := let e := eF (F * a).toBits; if 1078 < e then e - 1078 else 0 @[inline] def tS (relu : Bool) (L n : Nat) (p : Nat → Float) (bpf : Unit → Float) (fbk : Unit → Word) : Word := let r := sT p n 0 (bpf ()) 0 let c := if 1 ≤ r.2.toNat ∧ r.2.toNat ≤ 1993 ∧ 1076 ≤ r.2.toNat + L then cert2 r.1 (r.2.toNat + L - 1076).toUInt64 else 0x100000000 if c < 0x100000000 then act relu c.toUInt32 else fbk () @[inline] def tf (relu : Bool) (S : Float) (hh : UInt64) (sl : Unit → Word) : Word := let c := cert2 S hh if c < 0x100000000 then act relu c.toUInt32 else sl () def gg (X : FloatArray) (i : Nat) : X.get! i = X.data[i]! := by rcases X with ⟨d⟩; rfl def rre (z : ℝ) : |Model.roundAt FloatFormat.binary64 z - z| ≤ (2 : ℝ) ^ (-53 : Int) * |z| + 2 ^ (-1075 : Int) := by by_cases h : |z| < (2 : ℝ) ^ (-1021 : Int) ·refine (re z (-1021) le_rfl h).trans ?_ rw [div_eq_mul_inv, ← zpow_sub_one₀ two_ne_zero]; norm_num ·have hz : 0 < |z| := lt_of_lt_of_le (by positivity) (not_lt.1 h) have h1 := Int.zpow_log_le_self (b := 2) (by norm_num) hz have h2 := Int.lt_zpow_succ_log_self (b := 2) (by norm_num) |z| simp only [Nat.cast_ofNat] at h1 h2 have hE : (-1021 : Int) ≤ Int.log 2 |z| + 1 := by by_contra hc; linarith [zpow_le_zpow_right₀ (by norm_num : (1 : ℝ) ≤ 2) (by omega : Int.log 2 |z| + 1 ≤ -1021)] refine (re z _ hE h2).trans ?_ rw [div_eq_mul_inv, ← zpow_sub_one₀ two_ne_zero, show Int.log 2 |z| + 1 - 53 - 1 = -53 + Int.log 2 |z| by ring, zpow_add₀ two_ne_zero] linarith [mul_le_mul_of_nonneg_left h1 (by positivity : (0 : ℝ) ≤ 2 ^ (-53 : Int)), show (0 : ℝ) ≤ 2 ^ (-1075 : Int) by positivity] def rra (x y : Float) (hx : fv x) (hy : fv y) (hb : |rv x + rv y| ≤ (2 : ℝ) ^ (970 : Int)) : fv (x + y) ∧ |rv (x + y) - (rv x + rv y)| ≤ (2 : ℝ) ^ (-53 : Int) * |rv x + rv y| + 2 ^ (-1075 : Int) := by obtain ⟨f, e⟩ := faR x y hx hy (hb.trans ((zpow_le_zpow_right₀ (by norm_num) (by norm_num)).trans (pm 971 le_rfl))) exact ⟨f, by rw [e]; exact rre _⟩ def rrm (x y : Float) (hx : fv x) (hy : fv y) (hb : |rv x * rv y| ≤ (2 : ℝ) ^ (971 : Int)) : fv (x * y) ∧ |rv (x * y) - rv x * rv y| ≤ (2 : ℝ) ^ (-53 : Int) * |rv x * rv y| + 2 ^ (-1075 : Int) := by obtain ⟨f, e⟩ := fmR x y hx hy hb exact ⟨f, by rw [e]; exact rre _⟩ def bitsS (v : Float) (hv : fv v) (he : eF v.toBits = 0) : rv v = (⟨v.toBits >>> 63 != 0, (v.toBits &&& 0xfffffffffffff).toNat, -1074⟩ : FloatLib.Numerics.Dyadic).toReal := by unfold eF at he; unfold fv at hv; unfold rv rw [fld] at hv ⊢ rw [Model.toReal_eq, Model.toDyadic?_ofFields_of_isFinite _ _ _ _ (fq v).1 (fq v).2 hv, ite_eq_left (by rw [he]; rfl)] split_ifs with h0 ·dsimp only; rw [dyR, dyR, h0]; simp ·rfl def eFb (v : Float) (hv : fv v) : |rv v| < (2 : ℝ) ^ (((eF v.toBits).toNat : Int) - 1022) := by have hr := (fq v).2 by_cases he : eF v.toBits = 0 ·rw [bitsS v hv he, dyR, show (eF v.toBits).toNat = 0 by rw [he]; rfl, show (2 : ℝ) ^ (((0 : Nat) : Int) - 1022) = 2 ^ 52 * 2 ^ (-1074 : Int) by rw [show (2 : ℝ) ^ 52 = 2 ^ (52 : Int) by norm_num, ← zpow_add₀ two_ne_zero]; norm_num] have : ((v.toBits &&& 0xfffffffffffff).toNat : ℝ) < 2 ^ 52 := by exact_mod_cast hr split <;> simp only [neg_mul, abs_neg, abs_mul, abs_zpow, abs_two, Nat.abs_cast] <;> exact mul_lt_mul_of_pos_right this (by positivity) ·rw [bitsD v hv he, dyR, show (2 : ℝ) ^ (((eF v.toBits).toNat : Int) - 1022) = 2 ^ 53 * 2 ^ (((eF v.toBits).toNat : Int) - 1075) by rw [show (2 : ℝ) ^ 53 = 2 ^ (53 : Int) by norm_num, ← zpow_add₀ two_ne_zero]; congr 1; ring] have : (((v.toBits &&& 0xfffffffffffff).toNat + 2 ^ 52 : Nat) : ℝ) < 2 ^ 53 := by exact_mod_cast (by omega : (v.toBits &&& 0xfffffffffffff).toNat + 2 ^ 52 < 2 ^ 53) split <;> simp only [neg_mul, abs_neg, abs_mul, abs_zpow, abs_two, Nat.abs_cast] <;> exact mul_lt_mul_of_pos_right this (by positivity) def sfR (p : Nat → Float) (z : Nat → ℝ) (za : ℝ) (n : Nat) (hp : ∀ t < n, fv (p t) ∧ rv (p t) = z t) (hn : n ≤ 2 ^ 32) (hA : |za| + ∑ s ∈ Finset.range n, |z s| ≤ (2 : ℝ) ^ (968 : Int)) : ∀ m t a, n - t = m → t ≤ n → fv a → |rv a - (za + ∑ s ∈ Finset.range t, z s)| ≤ t * ((2 : ℝ) ^ (-53 : Int) * (1 + 2 ^ (-20 : Int)) * (|za| + ∑ s ∈ Finset.range t, |z s|) + 2 ^ (-1074 : Int)) → fv (sfold p n t a) ∧ |rv (sfold p n t a) - (za + ∑ s ∈ Finset.range n, z s)| ≤ n * ((2 : ℝ) ^ (-53 : Int) * (1 + 2 ^ (-20 : Int)) * (|za| + ∑ s ∈ Finset.range n, |z s|) + 2 ^ (-1074 : Int)) := by have h970 : (2 : ℝ) ^ (970 : Int) = 2 ^ (968 : Int) * 4 := by rw [show (970 : Int) = 968 + 2 by norm_num, zpow_add₀ two_ne_zero]; norm_num have hη : (2 : ℝ) ^ (-1075 : Int) = 2 ^ (-1074 : Int) / 2 := by rw [show (-1074 : Int) = -1075 + 1 by norm_num, zpow_add_one₀ two_ne_zero]; ring have hηH : (4294967296 : ℝ) * 2 ^ (-1074 : Int) ≤ 2 ^ (968 : Int) := by rw [show (4294967296 : ℝ) = 2 ^ (32 : Int) by norm_num, ← zpow_add₀ two_ne_zero] exact zpow_le_zpow_right₀ (by norm_num) (by norm_num) have hη0 : (0 : ℝ) < 2 ^ (-1074 : Int) := by positivity intro m; induction m with | zero => intro t a hm ht ha h; obtain rfl : t = n := by omega rw [sfold, if_neg (lt_irrefl _)]; exact ⟨ha, h⟩ | succ m ih => intro t a hm ht ha h have htn : t < n := by omega rw [sfold, if_pos htn] obtain ⟨fp, vp⟩ := hp t htn have hS := Finset.sum_le_sum_of_subset_of_nonneg (Finset.range_mono htn) (fun i _ _ => abs_nonneg (z i)) have hT := (abs_add_le za _).trans (add_le_add le_rfl (Finset.abs_sum_le_sum_abs z (Finset.range (t + 1)))) simp only [Finset.sum_range_succ] at hS hT have hY := abs_add_le (rv a - (za + ∑ s ∈ Finset.range t, z s)) (za + (∑ s ∈ Finset.range t, z s + z t)) rw [show rv a - (za + ∑ s ∈ Finset.range t, z s) + (za + (∑ s ∈ Finset.range t, z s + z t)) = rv a + rv (p t) by rw [vp]; ring] at hY have ht' : (t : ℝ) ≤ 4294967296 := by exact_mod_cast (by clear*-hn htn;omega : t ≤ 2 ^ 32) have k1 := mul_le_mul_of_nonneg_right ht' (abs_nonneg za) have k2 := mul_le_mul_of_nonneg_right ht' (Finset.sum_nonneg fun i (_ : i ∈ Finset.range t) => abs_nonneg (z i)) have k3 := mul_le_mul_of_nonneg_right ht' (abs_nonneg (z t)) have k4 := mul_le_mul_of_nonneg_right ht' hη0.le have hs0 : 0 ≤ ∑ s ∈ Finset.range t, |z s| := Finset.sum_nonneg fun i _ => abs_nonneg (z i) have k5 := mul_nonneg (Nat.cast_nonneg t : (0 : ℝ) ≤ t) (abs_nonneg (z t)) have k6 := abs_nonneg za have k7 := abs_nonneg (z t) have h' : |rv a - (za + ∑ s ∈ Finset.range t, z s)| ≤ 1 / 9007199254740992 * (1 + 1 / 1048576) * (t * |za|) + 1 / 9007199254740992 * (1 + 1 / 1048576) * (t * ∑ s ∈ Finset.range t, |z s|) + t * 2 ^ (-1074 : Int) := h.trans_eq (by ring) obtain ⟨f2, e2⟩ := rra a (p t) ha fp (by rw [h970]; generalize (2 : ℝ) ^ (968 : Int) = H at *; generalize (2 : ℝ) ^ (-1074 : Int) = η at * linarith only [hY, h', hT, hS, hA, k1, k2, k4, hηH, hs0, k6, k7, hη0]) refine ih (t + 1) (a + p t) (by omega) (by clear*-htn;omega) f2 ?_ rw [hη, show (2 : ℝ) ^ (-53 : Int) = 1 / 9007199254740992 by norm_num] at e2 have key := abs_add_le (rv (a + p t) - (rv a + rv (p t))) (rv a - (za + ∑ s ∈ Finset.range t, z s)) rw [show rv (a + p t) - (rv a + rv (p t)) + (rv a - (za + ∑ s ∈ Finset.range t, z s)) = rv (a + p t) - (za + (∑ s ∈ Finset.range t, z s + z t)) by rw [vp]; ring] at key simp only [Finset.sum_range_succ] generalize (2 : ℝ) ^ (-1074 : Int) = η at * calc _ ≤ 1 / 9007199254740992 * (1 + 1 / 1048576) * (t * |za| + t * ∑ s ∈ Finset.range t, |z s| + t * |z t| + (|za| + (∑ s ∈ Finset.range t, |z s| + |z t|))) + t * η + η := by linarith _ = _ := by push_cast; ring def upAbs (m : Float.Model) : (Float.Model.pack m.unpack.abs).unpack = m.unpack.abs := by have h1 : (Float.Model.pack m.unpack).unpack = m.unpack := by have := Model.toFloatModel_ofFloatModel m conv_rhs => rw [← this] rfl generalize m.unpack = u at h1 ⊢ simp only [Float.Model.pack, Float.Model.unpack, UInt64.toBitVec_ofBitVec] at h1 ⊢ cases u with | notANumber => exact h1 | finite s mt e hm => simp only [Float.Model.UnpackedFloat.abs, Float.Model.UnpackedFloat.pack, Float.Model.UnpackedFloat.packedInfinity] at h1 ⊢ split_ifs at h1 ⊢ <;> simp only [Float.Model.UnpackedFloat.unpack, Float.Model.UnpackedFloat.unpackExponent_packComponents, Float.Model.UnpackedFloat.unpackMantissa_packComponents, Model.unpackSign_packComponents] at h1 ⊢ <;> split_ifs at h1 ⊢ <;> simp_all | _ => simp only [Float.Model.UnpackedFloat.abs, Float.Model.UnpackedFloat.pack, Float.Model.UnpackedFloat.packedInfinity, Float.Model.UnpackedFloat.packedZero, Float.Model.UnpackedFloat.unpack, Float.Model.UnpackedFloat.unpackExponent_packComponents, Float.Model.UnpackedFloat.unpackMantissa_packComponents, Model.unpackSign_packComponents] at h1 ⊢ split_ifs at h1 ⊢ <;> simp_all def fabs (v : Float) (hv : fv v) : fv v.abs ∧ rv v.abs = |rv v| := by have e : v.abs.toModel.unpack = v.toModel.unpack.abs := upAbs v.toModel rw [fvI] at hv ⊢; rw [rvU, rvU, e] generalize v.toModel.unpack = u at hv ⊢ cases u with | notANumber | infinity _ => simp [Float.Model.UnpackedFloat.isFinite] at hv | zero _ => simp [Float.Model.UnpackedFloat.abs, Float.Model.UnpackedFloat.isFinite, Model.unpackedToReal, Model.unpackedToDyadic?] | finite s mt e hm => refine ⟨by simp [Float.Model.UnpackedFloat.abs, Float.Model.UnpackedFloat.isFinite], ?_⟩ simp only [Float.Model.UnpackedFloat.abs, Model.unpackedToReal_finite, abs_mul] have hp := FloatLib.Floats.Formats.Flocq.bpow.pos FloatLib.Numerics.binaryRadix e split <;> split <;> simp_all [abs_of_pos hp] def c2T (S : Float) (hS : fv S) (h : UInt64) (hh : h.toNat < 2 ^ 63) (T : ℝ) (hT : |rv S - T| ≤ (2 : ℝ) ^ (h.toNat : Int)) (hc : cert2 S h < 0x100000000) : |T| ≤ (2 : ℝ) ^ (425 : Int) := by unfold cert2 at hc; dsimp only at hc split at hc swap; · exact absurd hc (by decide) rename_i g; simp only [Bool.and_eq_true, decide_eq_true_eq] at g obtain ⟨⟨⟨c1, c2⟩, c3⟩, c4⟩ := g obtain ⟨d1, d2, e1, e2, -, -, -, f2⟩ := c3c h (eF S.toBits) (S.toBits &&& 0xfffffffffffff) hh (fq S).1 (fq S).2 c1 c2 c3 (rb _ c4) have hv := bitsD S hS (fun h0 => by rw [h0] at e1; simp at e1) rw [dyR] at hv generalize (eF S.toBits).toNat = E at d1 d2 e1 e2 f2 hv generalize (S.toBits &&& 0xfffffffffffff).toNat = f at f2 hv have hu : (0 : ℝ) < 2 ^ ((E : Int) - 1075) := by positivity have hB : ((f + 2 ^ 52 : Nat) : ℝ) + ((2 ^ (h.toNat + 1075 - E) : Nat) : ℝ) ≤ 2 ^ 53 := by exact_mod_cast (by clear*-f2;omega : f + 2 ^ 52 + 2 ^ (h.toNat + 1075 - E) ≤ 2 ^ 53) have hS : |rv S| = ((f + 2 ^ 52 : Nat) : ℝ) * 2 ^ ((E : Int) - 1075) := by rw [hv, abs_mul, abs_of_pos hu]; split <;> simp only [abs_neg, Nat.abs_cast] have := abs_sub (rv S) (rv S - T) rw [sub_sub_cancel, hS] at this rw [show (2 : ℝ) ^ (h.toNat : Int) = ((2 ^ (h.toNat + 1075 - E) : Nat) : ℝ) * 2 ^ ((E : Int) - 1075) by push_cast; rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; congr 1; clear*-d1;omega] at hT have h425 : (2 : ℝ) ^ (53 : Nat) * 2 ^ ((E : Int) - 1075) ≤ 2 ^ (425 : Int) := by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact zpow_le_zpow_right₀ (by norm_num) (by clear*-e1 e2;omega) linarith [mul_le_mul_of_nonneg_right hB hu.le] def cw2 (n : Nat) (fa fb : Nat → Word) (hfin : Core.finAll n fa fb) (S : Float) (hS : fv S) (h : UInt64) (hh : h.toNat < 2 ^ 63) (hT : |rv S - (Core.tsum n fa fb : ℝ)| ≤ (2 : ℝ) ^ (h.toNat : Int)) (hc : cert2 S h < 0x100000000) : (cert2 S h).toUInt32 = dotOf n fa fb := cw n fa fb hfin S hS h hh hT (c2T S hS h hh _ hT hc) hc def wF_eq (Y : FloatArray) (hY : Y.size < 2 ^ 32) (i : USize) (v : Float) : wF Y i v = Y.set! i.toNat v := by rcases Y with ⟨d⟩ unfold wF; split next h => simp only [FloatArray.uset, FloatArray.set!, Array.uset, Array.set!, Array.setIfInBounds]; rw [dite_eq_left (show i.toNat < d.size from fulen h)] next h => simp only [FloatArray.set!, Array.set!, Array.setIfInBounds] rw [dite_eq_right fun h' => h (by rw [USize.lt_iff_toNat_lt, FloatArray.usize, toUSize_toNat (lt_of_lt_of_le hY USize.le_size)]; exact h')] def rX_eq (X : Array Word) (hX : X.size < 2 ^ 32) (i : USize) : rX X i = dw X[i.toNat]! := by unfold rX; split ·rw [uget_eq] next h => rw [getElem!_neg X _ fun h' => h (by rw [USize.lt_iff_toNat_lt, Array.usize, toUSize_toNat (lt_of_lt_of_le hX USize.le_size)]; exact h')]; rfl def sfold_shift (p : Nat → Float) (n : Nat) : ∀ m t a, n - t = m → sfold p (n + 1) (t + 1) a = sfold (fun τ => p (τ + 1)) n t a := by intro m; induction m with | zero => intro t a h; unfold sfold; rw [if_neg (by omega), if_neg (by omega)] | succ m ih => intro t a h; unfold sfold; rw [if_pos (by omega), if_pos (by omega)]; exact ih (t + 1) _ (by omega) def bnd (n : ℕ) (σ za E A C H M : ℝ) (hσ : 0 ≤ σ) (hA : 0 < A) (hC : 1 ≤ C) (hn : (n : ℝ) ≤ 2 ^ (32 : Int)) (hE : E ≤ n * ((2 : ℝ) ^ (-53 : Int) * (1 + 2 ^ (-20 : Int)) * (|za| + A * σ) + 2 ^ (-1074 : Int)) + 2 ^ (26 : Int) * σ) (hK : (2 : ℝ) ^ (26 : Int) ≤ A * 2 ^ (-53 : Int)) (hc : 9 * ((n : ℝ) + 1) * σ * (1 - 2 ^ (-20 : Int)) ≤ C * 2 ^ (56 : Int) + 2 ^ (-900 : Int)) (hz : (n : ℝ) * |za| ≤ H * 2 ^ (49 : Int)) (hM1 : A * C ≤ M) (hM2 : H ≤ M) (hM3 : (2 : ℝ) ^ (79 : Int) ≤ M) : E ≤ M := by have h1 : (n : ℝ) * 2 ^ (-1074 : Int) ≤ 1 := (mul_le_mul_of_nonneg_right hn (by positivity)).trans (by rw [← zpow_add₀ two_ne_zero]; exact zpow_le_one_of_nonpos₀ (by norm_num) (by norm_num)) have h2 : (2 : ℝ) ^ (-900 : Int) ≤ 1 := zpow_le_one_of_nonpos₀ (by norm_num) (by norm_num) generalize (2 : ℝ) ^ (-1074 : Int) = η at * generalize (2 : ℝ) ^ (-900 : Int) = ε at * norm_num at hE hK hc hz hM3 linarith [mul_le_mul_of_nonneg_right hK hσ, mul_le_mul_of_nonneg_left hc hA.le, mul_le_mul_of_nonneg_left h2 hA.le, mul_le_mul_of_nonneg_left hC hA.le] def cE_spec (n : Nat) (hn : n < 2 ^ 29) (a : Float) (σ : ℝ) (ha : fv a) (hσ : 0 ≤ σ) (hσ2 : σ ≤ 2 ^ (400 : Int)) (herr : |rv a - σ| ≤ n * ((2 : ℝ) ^ (-53 : Int) * (1 + 2 ^ (-20 : Int)) * σ + 2 ^ (-1074 : Int))) : 9 * ((n : ℝ) + 1) * σ * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE (9 * (n + 1)).toUInt64.toInt64.toFloat a).toNat : Int) + 56) + 2 ^ (-900 : Int) := by have e : (9 * (n + 1)).toUInt64.toInt64.toInt = ((9 * (n + 1) : Nat) : Int) := by rw [show (9 * (n + 1)).toUInt64.toInt64.toInt = Core.sval (9 * (n + 1)).toUInt64 from rfl, sval_eq, Nat.toUInt64_eq, UInt64.toNat_ofNat_of_lt' (by simp only [UInt64.size]; omega)] split <;> omega obtain ⟨fF, vF⟩ := i64 (9 * (n + 1)).toUInt64.toInt64 (by rw [e]; simp; clear*-hn;omega) rw [e] at vF; push_cast at vF have hc : (2 : ℝ) ^ (((eF ((9 * (n + 1)).toUInt64.toInt64.toFloat * a).toBits).toNat : Int) - 1022) ≤ 2 ^ (((cE (9 * (n + 1)).toUInt64.toInt64.toFloat a).toNat : Int) + 56) := by apply zpow_le_zpow_right₀ (by norm_num) unfold cE; dsimp only; split ·rw [UInt64.toNat_sub_of_le _ _ (UInt64.le_of_lt ‹_›)]; have := UInt64.lt_iff_toNat_lt.mp ‹_› simp only [UInt64.reduceToNat] at this ⊢; clear*-this;omega ·have := UInt64.le_iff_toNat_le.mp (UInt64.not_lt.mp ‹_›); simp only [UInt64.reduceToNat] at this ⊢; clear*-this;omega have hm : (n : ℝ) ≤ 536870912 := by exact_mod_cast hn.le have hy : (2 : ℝ) ^ (-1074 : Int) = 2 ^ (-1075 : Int) * 2 := by rw [← zpow_add_one₀ two_ne_zero]; norm_num have hε : (2 : ℝ) ^ (-1075 : Int) * 2 ^ 64 ≤ 2 ^ (-900 : Int) := by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact zpow_le_zpow_right₀ (by norm_num) (by norm_num) have hW : (2 : ℝ) ^ 40 * 2 ^ (400 : Int) ≤ 2 ^ (971 : Int) := by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact zpow_le_zpow_right₀ (by norm_num) (by norm_num) have hZ : (1 : ℝ) ≤ 2 ^ (400 : Int) := one_le_zpow₀ (by norm_num) (by norm_num) have hy0 : (0 : ℝ) < 2 ^ (-1075 : Int) := by positivity have he1 : (2 : ℝ) ^ (-900 : Int) ≤ 1 := zpow_le_one_of_nonpos₀ (by norm_num) (by norm_num) rw [show (2 : ℝ) ^ (-53 : Int) = 1 / 9007199254740992 by norm_num, show (2 : ℝ) ^ (-20 : Int) = 1 / 1048576 by norm_num, hy, mul_add, ← mul_assoc] at herr have k2 := mul_le_mul_of_nonneg_right hm hy0.le generalize hk : (n : ℝ) * (1 / 9007199254740992 * (1 + 1 / 1048576)) = kn at herr have hk1 : kn ≤ 1 / 8388608 := by rw [← hk]; nlinarith have k3 := mul_le_mul_of_nonneg_right hk1 hσ have hA : |rv a| ≤ 3 * 2 ^ (400 : Int) := by have := abs_sub_abs_le_abs_sub (rv a) σ; rw [abs_of_nonneg hσ] at this generalize (2 : ℝ) ^ (-1075 : Int) = y at *; generalize (2 : ℝ) ^ (-900 : Int) = ε at * generalize (2 : ℝ) ^ (400 : Int) = Z at *; linarith have hb : |rv (9 * (n + 1)).toUInt64.toInt64.toFloat * rv a| ≤ 2 ^ (971 : Int) := by rw [vF, abs_mul, abs_of_pos (by positivity)] have := mul_le_mul_of_nonneg_left hA (by positivity : (0 : ℝ) ≤ 9 * (n + 1)) have := mul_le_mul_of_nonneg_right hm (by positivity : (0 : ℝ) ≤ 2 ^ (400 : Int)) generalize (2 : ℝ) ^ (400 : Int) = Z at *; generalize (2 : ℝ) ^ (971 : Int) = Z' at *; linarith obtain ⟨fP, eP⟩ := rrm _ a fF ha hb have hQ := lt_of_le_of_lt' hc (lt_of_le_of_lt (abs_nonneg _) (eFb _ fP)) have hP := lt_of_lt_of_le (lt_of_le_of_lt (le_abs_self _) (eFb _ fP)) hc rw [vF, show (2 : ℝ) ^ (-53 : Int) = 1 / 9007199254740992 by norm_num] at eP rw [show (2 : ℝ) ^ (-20 : Int) = 1 / 1048576 by norm_num] generalize (2 : ℝ) ^ (((cE (9 * (n + 1)).toUInt64.toInt64.toFloat a).toNat : Int) + 56) = Q at * generalize rv ((9 * (n + 1)).toUInt64.toInt64.toFloat * a) = P at * generalize rv a = A at * generalize (2 : ℝ) ^ (-1075 : Int) = y at * generalize (2 : ℝ) ^ (-900 : Int) = ε at * have hen : (n : ℝ) * (y * 2) ≤ 1073741824 * y := by linarith generalize (n : ℝ) * (y * 2) = en at herr hen have hN : (0 : ℝ) ≤ 9 * (n + 1) := by positivity have hN4 := mul_le_mul_of_nonneg_right (by linarith : 9 * ((n : ℝ) + 1) ≤ 2 ^ 33) hy0.le generalize 9 * ((n : ℝ) + 1) = N at * obtain ⟨h1, -⟩ := abs_le.mp herr rcases le_or_gt 0 A with h0 | h0 ·rw [abs_of_nonneg (mul_nonneg hN h0)] at eP have := mul_le_mul_of_nonneg_left h1 (by linarith : 0 ≤ N * (1 - 1 / 9007199254740992)) nlinarith [(abs_le.mp eP).1] ·have := mul_le_mul_of_nonneg_left (by linarith : σ ≤ 2 * en) hN nlinarith def dwB (x : Word) (hx : expOf x ≠ 255) : |rv (dw x)| ≤ 2 ^ (277 : Int) := by rw [(dwV x hx).2, abs_mul, abs_pow, abs_two] have : (expOf x).toNat ≠ 255 := fun h => hx (UInt32.toNat_inj.mp (by simpa using h)) have := expL x calc _ ≤ (2 : ℝ) ^ 24 * 2 ^ 253 := mul_le_mul (by rw [← Int.cast_abs]; exact_mod_cast (sv_abs x).le) (pow_le_pow_right₀ (by norm_num) (by rw [idxE]; omega)) (by positivity) (by positivity) _ = 2 ^ (277 : Int) := by rw [← pow_add, ← zpow_natCast]; rfl def f0 : fv (0 : Float) ∧ rv (0 : Float) = 0 := by have e : (0 : Float).toModel.unpack = .zero .positive := rfl refine ⟨by rw [fvI, e]; rfl, by rw [rvU, e]; simp [Model.unpackedToReal, Model.unpackedToDyadic?]⟩ def ix3 (b s st τ r : Nat) (hs : s < 2 ^ 32) (hst : st < 2 ^ 32) (hτ : τ < 2 ^ 32) (hr : r < 2 ^ 32) (h : b + τ * s + r * st < 2 ^ 32) : (b.toUSize + τ.toUSize * s.toUSize + r.toUSize * st.toUSize).toNat = b + τ * s + r * st := by have := USize.le_size; have := USize.size_eq_two_pow have m : ∀ x y : Nat, x < 2 ^ 32 → y < 2 ^ 32 → x * y < 2 ^ 32 → (x.toUSize * y.toUSize).toNat = x * y := fun x y hx hy h => by rw [USize.toNat_mul, toUSize_toNat (by clear h hr hs hst hy hτ this;omega), toUSize_toNat (by clear h hr hs hst hx hτ this;omega), Nat.mod_eq_of_lt (by clear hr hs hst hx hy hτ;omega)] have m1 := m τ s hτ hs (by clear*-h;omega); have m2 := m r st hr hst (by clear*-h;omega) rw [uadd (by rw [uadd (by rw [toUSize_toNat (by clear hr hs hst hτ m m1 m2 this;omega), m1]; clear hr hs hst hτ m m1 m2 this;omega), toUSize_toNat (by clear hr hs hst hτ m m1 m2 this;omega), m1, m2]; clear hr hs hst hτ m m1 m2 this;omega), uadd (by rw [toUSize_toNat (by clear hr hs hst hτ m m1 m2 this;omega), m1]; clear hr hs hst hτ m m1 m2 this;omega), toUSize_toNat (by clear hr hs hst hτ m m1 m2 this;omega), m1, m2] def tmOne (b : Word) (IB : Nat) (hb : idxOf b ≤ IB) : |(Core.tm oneW b : ℝ)| ≤ 2 ^ (173 + IB) := by unfold Core.tm rw [show sv oneW = 2 ^ 23 by decide, show idxOf oneW = 126 by decide, Int.cast_mul, Int.cast_mul, abs_mul, abs_mul, Int.cast_pow, Int.cast_pow, Int.cast_ofNat, abs_pow, abs_pow, abs_two] have a1 : |(sv b : ℝ)| ≤ 2 ^ 24 := by rw [← Int.cast_abs]; exact_mod_cast (sv_abs _).le calc (2 : ℝ) ^ 23 * |(sv b : ℝ)| * 2 ^ (126 + idxOf b) ≤ 2 ^ 23 * 2 ^ 24 * 2 ^ (126 + IB) := by gcongr; norm_num _ = 2 ^ (173 + IB) := by rw [← pow_add, ← pow_add]; congr 1; omega def eF_le (b : UInt64) : (eF b).toNat ≤ 2047 := by unfold eF; simp only [UInt64.toNat_and, UInt64.reduceToNat]; exact Nat.and_le_right def cE_le (F a : Float) : (cE F a).toNat ≤ 969 := by unfold cE; dsimp only; split ·rename_i h; have := eF_le (F * a).toBits; have h' := UInt64.lt_iff_toNat_lt.mp h rw [UInt64.toNat_sub_of_le _ _ (UInt64.le_of_lt h)]; simp only [UInt64.reduceToNat] at h' ⊢; clear h';omega ·simp abbrev Iv (F : Nat → Word) (a : Array Word) (P : Nat → Prop) (A : Array Word) : Prop := A.size = a.size ∧ ∀ q, (A[q]? = a[q]? ∨ A[q]? = some (F q)) ∧ (P q → q < a.size → A[q]? = some (F q)) def lr8h_mono (F : Nat → Word) (u0 u2 : Array Word) (S U : Nat → Prop) (hU : ∀ q, U q → S q) (h : Iv F u0 S u2) : Iv F u0 U u2 := ⟨h.1, fun q => ⟨(h.2 q).1, fun hq' hq => (h.2 q).2 (hU q hq') hq⟩⟩ def emr (A : Array Word) (e : USize) (he : e ≤ A.usize) (i : USize) (m : UInt32) : UInt32 := if h : i < e then emr A e he (i + 1) (max m ((A.uget i (ulen (USize.lt_iff_toNat_lt.mpr (Nat.lt_of_lt_of_le (USize.lt_iff_toNat_lt.mp h) (USize.le_iff_toNat_le.mp he)))) >>> 23) &&& 255)) else m termination_by e.toNat - i.toNat decreasing_by have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega def emr_spec (A : Array Word) (e : USize) (he : e ≤ A.usize) : ∀ k (i : USize) (m : UInt32), e.toNat - i.toNat = k → m.toNat ≤ (emr A e he i m).toNat ∧ ∀ q, i.toNat ≤ q → q < e.toNat → (expOf A[q]!).toNat ≤ (emr A e he i m).toNat := by intro k; induction k with | zero => intro i m hk rw [emr, dif_neg fun h => by have := USize.lt_iff_toNat_lt.mp h; omega]; exact ⟨le_rfl, fun q h1 h2 => by omega⟩ | succ k ih => intro i m hk have h : i < e := USize.lt_iff_toNat_lt.mpr (by omega) have hi : i < A.usize := USize.lt_iff_toNat_lt.mpr (Nat.lt_of_lt_of_le (USize.lt_iff_toNat_lt.mp h) (USize.le_iff_toNat_le.mp he)) rw [emr, dif_pos h] obtain ⟨i1, i2⟩ := ih (i + 1) (max m ((A.uget i (ulen hi) >>> 23) &&& 255)) (by rw [usucc h]; omega) rw [UInt32.toNat_max] at i1 refine ⟨by clear hk i2 ih;omega, fun q h1' h2 => ?_⟩ by_cases hq : q = i.toNat ·subst hq; rw [← uget_eq A i (ulen hi)]; unfold expOf; clear*-h he hi i1;omega ·exact i2 q (by rw [usucc h]; clear*-h1' he hi hq;omega) h2 def dN (n : Nat) (fa fb : Nat → Word) : ∀ c i, i + c = n → dallNZ (Array.ofFn (n := n + 1) fun t => if t.val < n then fb t.val else oneW) (Array.ofFn (n := n + 1) fun t => if t.val < n then fa t.val else 0x80000000) i (c + 1) = dallNZ (Array.ofFn (n := n) fun t => fa t.val) (Array.ofFn (n := n) fun t => fb t.val) i c := by intro c; induction c with | zero => intro i h; obtain rfl : i = n := by omega simp only [dallNZ, getElem!_ofFn (i + 1) (fun t => if t < i then fb t else oneW) i (by omega), getElem!_ofFn (i + 1) (fun t => if t < i then fa t else 0x80000000) i (by omega), lt_irrefl, if_false]; rfl | succ c ih => intro i h rw [dallNZ, ih (i + 1) (by omega), dallNZ, getElem!_ofFn (n + 1) (fun t => if t < n then fb t else oneW) i (by omega), getElem!_ofFn (n + 1) (fun t => if t < n then fa t else 0x80000000) i (by omega), getElem!_ofFn n fa i (by omega), getElem!_ofFn n fb i (by omega)] simp only [show i < n by omega, ↓reduceIte, Nat.mul_comm (mantOf (fb i)), Bool.xor_comm (signOf (fb i))] def dz (n : Nat) (fa fb : Nat → Word) (hn : 0 < n) (hf : Core.finAll n fa fb) : dotOf (n + 1) (fun t => if t < n then fb t else oneW) (fun t => if t < n then fa t else 0x80000000) = dotOf n fa fb := by rw [Core.dotOf_val _ _ _ fun t _ => by split; exacts [(hf t ‹_›).symm, by decide], Core.dotOf_val _ _ _ hf, Core.tsum_succ, dN n fa fb n 0 (by omega)] congr 1 ·simp only [lt_irrefl, if_false, show Core.tm oneW 0x80000000 = 0 by decide, add_zero] exact Finset.sum_congr rfl fun t ht => by simp only [if_pos (Finset.mem_range.mp ht)]; unfold Core.tm; rw [Nat.add_comm]; ring ·simp [hn.ne'] end F def lt32 {a : Nat} (h : a ≤ 4294967295) : a < 2 ^ 32 := by omega end Dense namespace Bn namespace NativeAdd def bridge (x : Float32) : Model.ofFloat32Model x.toModel = ofW x.toBits := congrArg Model.mk (ofUInt32_bits x.toBits).symm def nbits (x : Float32) : toWord (Model.ofFloat32Model x.toModel) = x.toBits := UInt32.ofNat_toNat def native_input (a : Word) (h : expOf a ≠ 255) : (Float32.ofBits a).toBits = a ∧ (Float32.ofBits a).isFinite = true := by have he : Float.Model.UnpackedFloat.unpackExponent (spec := Float.Model.Format.binary32) a.toBitVec ≠ -1#8 := fun bad => h (UInt32.toNat_inj.mp ((show (expOf a).toNat = (a.toBitVec.extractLsb' 23 8).toNat by simp only [expOf, UInt32.toNat_and, UInt32.toNat_shiftRight, BitVec.extractLsb'_toNat] exact Nat.and_two_pow_sub_one_eq_mod _ 8).trans (congrArg BitVec.toNat bad :))) have hb : (Float32.ofBits a).toBits = a := by change UInt32.ofBitVec (Float.Model.UnpackedFloat.pack Float.Model.Format.binary32 (Float.Model.UnpackedFloat.unpack Float.Model.Format.binary32 a.toBitVec)) = a rw [Model.pack_unpack_eq, if_neg (he ·.1)] refine ⟨hb, ?_⟩ change (Float.Model.UnpackedFloat.unpack Float.Model.Format.binary32 (Float32.ofBits a).toBits.toBitVec).isFinite = true simp only [hb, Float.Model.UnpackedFloat.unpack, he, ite_false] split_ifs <;> rfl @[noinline] def fallback (relu : Bool) (a b : Word) : Word := act relu (toWord (Model.add (ofW a) (ofW b))) @[inline] def actB (relu : Bool) (w : Word) : Word := w &&& ~~~((0 : Word) - ((if relu then w >>> 31 else 0) &&& (if w &&& 0x7FFFFFFF ≤ 0x7F800000 then 1 else 0))) def sgnW (w : Word) : (w &&& 0x80000000 != 0) = decide (2 ^ 31 ≤ w.toNat) := by have hw := w.toNat_lt rw [Bool.eq_iff_iff, bne_iff_ne, ne_eq, ← UInt32.toNat_inj, UInt32.toNat_and, decide_eq_true_iff, show (0x80000000 : UInt32).toNat = 2 ^ 31 from rfl, Nat.and_two_pow] simp only [UInt32.toNat_zero, Nat.testBit, Nat.shiftRight_eq_div_pow, Nat.one_and_eq_mod_two] constructor ·intro h; by_contra h'; apply h; rw [Nat.div_eq_of_lt (by clear hw;omega)]; simp ·intro h; rw [show w.toNat / 2 ^ 31 = 1 by omega]; simp def actB_eq (relu : Bool) (w : Word) : actB relu w = act relu w := by have hw := w.toNat_lt have hs : (w >>> 31).toNat = w.toNat / 2 ^ 31 := by rw [UInt32.toNat_shiftRight]; simp [Nat.shiftRight_eq_div_pow] have ha := Dense.absA w have he := Dense.expA w have hf : (fracOf w).toNat = w.toNat % 2 ^ 23 := by unfold fracOf; rw [UInt32.toNat_and]; exact Nat.and_two_pow_sub_one_eq_mod _ 23 unfold Dense.absW at ha he have k1 : ∀ x : Word, x &&& ~~~((0 : Word) - 0) = x := fun x => by apply UInt32.toNat_inj.mp; rw [UInt32.toNat_and] rw [show (~~~((0 : Word) - 0)).toNat = 2 ^ 32 - 1 from rfl, Nat.and_two_pow_sub_one_eq_mod, Nat.mod_eq_of_lt x.toNat_lt] have k0 : ∀ x : Word, x &&& ~~~((0 : Word) - 1) = 0 := fun x => by apply UInt32.toNat_inj.mp; rw [UInt32.toNat_and]; simp have e31 : w >>> 31 = if 2 ^ 31 ≤ w.toNat then 1 else 0 := by apply UInt32.toNat_inj.mp; rw [hs]; split <;> simp <;> (clear ha he hf hs k0 k1;omega) have eA : (w &&& 0x7FFFFFFF ≤ 0x7F800000) ↔ w.toNat % 2 ^ 31 ≤ 0x7F800000 := by rw [UInt32.le_iff_toNat_le, ha]; rfl have hR : (w &&& 0x80000000 != 0 && !(expOf w = 255 && fracOf w != 0)) = true ↔ (2 ^ 31 ≤ w.toNat ∧ w.toNat % 2 ^ 31 ≤ 0x7F800000) := by rw [sgnW] simp only [Bool.and_eq_true, decide_eq_true_eq, Bool.not_eq_true', Bool.and_eq_false_iff, decide_eq_false_iff_not, bne_eq_false_iff_eq, ← UInt32.toNat_inj, he, hf, ha, UInt32.reduceToNat, UInt32.toNat_zero] clear*-;omega unfold actB act cases relu ·simp only [Bool.false_eq_true, ite_false, UInt32.zero_and, k1] simp only [ite_true] unfold reluW rw [e31] by_cases c1 : 2 ^ 31 ≤ w.toNat ·rw [if_pos c1] by_cases c2 : w.toNat % 2 ^ 31 ≤ 0x7F800000 ·rw [if_pos (eA.mpr c2), show (1 : Word) &&& 1 = 1 from rfl, k0, if_pos (hR.mpr ⟨c1, c2⟩)] ·rw [if_neg (mt eA.mp c2), show (1 : Word) &&& 0 = 0 from rfl, k1, if_neg (fun h => c2 (hR.mp h).2)] ·rw [if_neg c1, UInt32.zero_and, k1, if_neg (fun h => c1 (hR.mp h).1)] @[inline] def add (relu : Bool) (a b : Word) : Word := if expOf a != 255 && expOf b != 255 then actB relu (Float32.ofBits a + Float32.ofBits b).toBits else fallback relu a b def add_eq (relu : Bool) (a b : Word) : add relu a b = act relu (toWord (Model.add (ofW a) (ofW b))) := by unfold add split ·rename_i h rw [actB_eq] simp only [Bool.and_eq_true, bne_iff_ne] at h have ha := native_input a h.1 have hb := native_input b h.2 have hn := ExecFloat.Binary.toModel_ofFloat32_add_of_isFinite _ _ ha.2 hb.2 simp only [ExecFloat.Binary.toModel_ofFloat32, bridge, ha.1, hb.1] at hn rw [← hn, ← bridge, nbits] ·rfl end NativeAdd @[specialize] def umap (stop : USize) (f : (i : USize) → i.toNat < stop.toNat → Word → Word) (i : USize) (x : Array Word) (h : stop.toNat ≤ x.size) : Array Word := if hi : i < stop then have hs := USize.lt_iff_toNat_lt.mp hi umap stop f (i + 1) (x.uset i (f i hs (x.uget i (by omega))) (by omega)) (by rw [Array.size_uset]; exact h) else x termination_by stop.toNat - i.toNat decreasing_by rw [Dense.usucc hi]; omega def umap_spec (stop : USize) (f : (i : USize) → i.toNat < stop.toNat → Word → Word) (F : Nat → Word → Word) (hF : ∀ i hi w, f i hi w = F i.toNat w) (i : USize) (x : Array Word) (h : stop.toNat ≤ x.size) : (umap stop f i x h).size = x.size ∧ ∀ j, (umap stop f i x h)[j]? = if i.toNat ≤ j ∧ j < stop.toNat then x[j]?.map (F j) else x[j]? := by fun_induction umap ·next i x h hi hs ih => refine ⟨by rw [ih.1, Array.size_uset], fun j => ?_⟩ rw [ih.2, Dense.usucc hi, Array.uset_eq_set, Array.getElem?_set (by clear*-h hs;omega)] split_ifs <;> first | rfl | omega | (subst_vars; rw [Array.getElem?_eq_getElem (by clear*-h hs;omega), Option.map_some, hF]; rfl) ·next i x h hi => exact ⟨rfl, fun j => by rw [if_neg (by rw [USize.lt_iff_toNat_lt] at hi; clear*-hi;omega)]⟩ @[inline] def rE (b : UInt64) : UInt64 := (b + (0x0FFFFFFF : UInt64) + ((b >>> 29) &&& 1)) >>> 29 @[inline] def wE (x : UInt64) : UInt64 := ((x >>> 34) <<< 31) + (x - 0x20A800000) def r39g (N : Nat) (hN : N < 2 ^ 63) : (Core.rne39 (UInt64.ofNat N)).toNat = (N + (2 ^ 38 - 1) + N / 2 ^ 39 % 2) / 2 ^ 39 := by simp only [Core.rne39, UInt64.toNat_shiftRight, UInt64.toNat_add, UInt64.toNat_and, UInt64.reduceToNat, UInt64.toNat_ofNat_of_lt' (by simp only [UInt64.size]; omega : N < UInt64.size), Nat.reduceMod, Nat.shiftRight_eq_div_pow, Nat.and_one_is_mod] omega def r39e (x : Nat) (hx : x < 2 ^ 53) : (Core.rne39 (UInt64.ofNat (x * 2 ^ 10))).toNat = (x + (2 ^ 28 - 1) + x / 2 ^ 29 % 2) / 2 ^ 29 := by rw [r39g _ (by omega), show x * 2 ^ 10 / 2 ^ 39 = x / 2 ^ 29 by omega] have hq : x / 2 ^ 29 % 2 < 2 := by omega generalize x / 2 ^ 29 % 2 = q at * rw [show (2 : Nat) ^ 39 = 2 ^ 10 * 2 ^ 29 by norm_num, ← Nat.div_div_eq_div_mul] congr 1; clear hx;omega def wD (n : Nat) (hn : n < 2 ^ 64) : ∃ s E c r, n = s * 2 ^ 63 + E * 2 ^ 52 + c * 2 ^ 29 + r ∧ s < 2 ∧ c < 2 ^ 23 ∧ r < 2 ^ 29 ∧ n / 2 ^ 63 = s ∧ n / 2 ^ 52 % 2 ^ 11 = E ∧ n % 2 ^ 52 = c * 2 ^ 29 + r ∧ n / 2 ^ 29 % 2 = c % 2 := ⟨n / 2 ^ 63, n / 2 ^ 52 % 2 ^ 11, n % 2 ^ 52 / 2 ^ 29, n % 2 ^ 29, by omega⟩ def wN (s E c r t : Nat) (hs : s < 2) (hE1 : 1046 ≤ E) (hE2 : E < 1299) (hc : c < 2 ^ 23) (hr : r < 2 ^ 29) (ht : (r + (2 ^ 28 - 1) + c % 2) / 2 ^ 29 = t) : ((s * 2 ^ 63 + E * 2 ^ 52 + c * 2 ^ 29 + r + 268435455) % 2 ^ 64 + c % 2) % 2 ^ 64 / 2 ^ 29 = s * 2 ^ 34 + (E * 2 ^ 23 + c + t) ∧ (c * 2 ^ 29 + r + 2 ^ 52 + (2 ^ 28 - 1) + (c * 2 ^ 29 + r + 2 ^ 52) / 2 ^ 29 % 2) / 2 ^ 29 = 2 ^ 23 + c + t ∧ t ≤ 1 := by omega def wM (s Y Z : Nat) (hs : s < 2) (hY : Y = Z + 8766095360) (hZ : Z < 2 ^ 31) : ((s * 2 ^ 34 + Y) / 2 ^ 34 * 2 ^ 31 % 2 ^ 64 + (2 ^ 64 - 8766095360 + (s * 2 ^ 34 + Y)) % 2 ^ 64) % 2 ^ 64 % 2 ^ 32 = s * 2 ^ 31 + Z := by subst hY obtain rfl | rfl : s = 0 ∨ s = 1 := by omega all_goals omega def wEb (b : UInt64) (h1 : 1046 ≤ (Dense.F.eF b).toNat) (h2 : (Dense.F.eF b).toNat < 1299) : (wE (rE b)).toNat % 2 ^ 32 = b.toNat / 2 ^ 63 * 2 ^ 31 + (((Dense.F.eF b).toNat - 1046) * 2 ^ 23 + ((b &&& 0xfffffffffffff).toNat + 2 ^ 52 + (2 ^ 28 - 1) + ((b &&& 0xfffffffffffff).toNat + 2 ^ 52) / 2 ^ 29 % 2) / 2 ^ 29) := by have m11 : ∀ x, x &&& 2047 = x % 2 ^ 11 := (Nat.and_two_pow_sub_one_eq_mod · 11) have m52 : ∀ x, x &&& 4503599627370495 = x % 2 ^ 52 := (Nat.and_two_pow_sub_one_eq_mod · 52) simp only [Dense.F.eF, wE, rE, UInt64.toNat_sub, UInt64.toNat_add, UInt64.toNat_shiftLeft, UInt64.toNat_shiftRight, UInt64.toNat_and, UInt64.reduceToNat, Nat.reduceMod, Nat.shiftRight_eq_div_pow, Nat.shiftLeft_eq, Nat.and_one_is_mod, m11, m52] at h1 h2 ⊢ obtain ⟨s, E, c, r, hd, hs, hc, hr, a3, a4, a2, a5⟩ := wD _ b.toNat_lt rw [a4] at h1 h2 rw [a2, a3, a4, a5] obtain ⟨t, ht⟩ : ∃ t, (r + (2 ^ 28 - 1) + c % 2) / 2 ^ 29 = t := ⟨_, rfl⟩ obtain ⟨b1, b2, b3⟩ := wN s E c r t hs h1 h2 hc hr ht rw [hd, b1, b2] have := wM s (E * 2 ^ 23 + c + t) ((E - 1046) * 2 ^ 23 + (2 ^ 23 + c + t)) hs (by clear * - h1; omega) (by clear * - h2 hc b3; omega) rw [Nat.mod_mod_of_dvd _ (by norm_num : 2 ^ 32 ∣ 2 ^ 64)] at this ⊢ exact this def addX2 (A B : Int) (i j : Nat) (hA : A.natAbs < 2 ^ 24) (hB : B.natAbs < 2 ^ 24) (h : i ≤ j) (g : j ≤ i + 29) : ((A + B * 2 ^ (j - i) : Int) : ℝ) * (2 : ℝ) ^ (i : Int) = (A : ℝ) * 2 ^ i + (B : ℝ) * 2 ^ j ∧ (A + B * 2 ^ (j - i)).natAbs < 2 ^ 53 := by constructor ·push_cast rw [add_mul, mul_assoc, zpow_natCast, ← pow_add, Nat.sub_add_cancel h] ·have hp : 2 ^ (j - i) ≤ 2 ^ 29 := Nat.pow_le_pow_right (by norm_num) (by clear*-g;omega) have h1 := Int.natAbs_add_le A (B * 2 ^ (j - i)) rw [Int.natAbs_mul, Int.natAbs_pow] at h1 have h2 : B.natAbs * 2 ^ (j - i) ≤ (2 ^ 24 - 1) * 2 ^ 29 := Nat.mul_le_mul (by clear*-hB;omega) hp rw [show (2 : Int).natAbs = 2 from rfl] at h1 clear*-h1 h2 hA;omega open Dense.F in def addW (a b : Word) (ha : expOf a ≠ 255) (hb : expOf b ≠ 255) (g1 : idxOf a ≤ idxOf b + 29) (g2 : idxOf b ≤ idxOf a + 29) : fv (dw a + dw b) ∧ rv (dw a + dw b) = (sv a : ℝ) * 2 ^ idxOf a + (sv b : ℝ) * 2 ^ idxOf b := by obtain ⟨f1, v1⟩ := dwV a ha obtain ⟨f2, v2⟩ := dwV b hb have la := idxOf_le a ha have lb := idxOf_le b hb have key : ∀ (z : Int) (e : Nat), (z : ℝ) * (2 : ℝ) ^ (e : Int) = rv (dw a) + rv (dw b) → z.natAbs < 2 ^ 53 → e ≤ 253 → fv (dw a + dw b) ∧ rv (dw a + dw b) = rv (dw a) + rv (dw b) := fun z e h1 h2 h3 => addX _ _ f1 f2 (ofIntDyadic z e) (by rw [ofIntR]; exact h1) h2 (by change (-1074 : Int) ≤ e; clear*-;omega) (by rw [ofIntR]; exact pwB 53 e 971 (by clear*-h3;omega) le_rfl z h2) rw [← v1, ← v2] rcases le_total (idxOf a) (idxOf b) with h | h ·obtain ⟨e1, e2⟩ := addX2 (sv a) (sv b) _ _ (svB a) (svB b) h g2 exact key _ _ (by rw [e1, v1, v2]) e2 la ·obtain ⟨e1, e2⟩ := addX2 (sv b) (sv a) _ _ (svB b) (svB a) h g1 exact key _ _ (by rw [e1, v1, v2, add_comm]) e2 lb open Dense.F in def wF (S : Float) (fS : fv S) (hE : eF S.toBits - 1046 < 253) : ∃ Ts : Int, Ts ≠ 0 ∧ (wE (rE S.toBits)).toUInt32 = finishWord Ts (-298) false ∧ (Ts : ℝ) * 2 ^ (-298 : Int) = rv S * 2 ^ (-149 : Int) := by have hq := (fq S).1 have hr := (fq S).2 have hEn : 1046 ≤ (eF S.toBits).toNat ∧ (eF S.toBits).toNat < 1299 := by simp only [UInt64.lt_iff_toNat_lt, UInt64.toNat_sub, UInt64.reduceToNat] at hE unfold eF at *; clear * - hE hq; omega obtain ⟨h1, h2⟩ := hEn have hv := bitsD S fS (fun h0 => by rw [h0] at h1; simp at h1) have hw := wEb S.toBits h1 h2 have hsg : S.toBits.toNat / 2 ^ 63 * 2 ^ 31 = if (S.toBits >>> 63 != 0) = true then 2 ^ 31 else 0 := by simp only [Core.neg_iff, decide_eq_true_eq]; have := S.toBits.toNat_lt; clear * - this; split <;> omega rw [hsg] at hw have hsc : (eF S.toBits - 936).toNat = (eF S.toBits).toNat - 936 := by rw [UInt64.toNat_sub]; simp only [UInt64.reduceToNat]; clear * - h1 h2; omega generalize wE (rE S.toBits) = W at * generalize (S.toBits >>> 63 != 0) = ng at * generalize hEN : (eF S.toBits).toNat = EN at * generalize hx : (S.toBits &&& 0xfffffffffffff).toNat + 2 ^ 52 = x at * generalize eF S.toBits - 936 = sc at * have xb : 2 ^ 52 ≤ x ∧ x < 2 ^ 53 := by clear * - hx hr; omega have xc : 2 ^ 62 ≤ x * 2 ^ 10 ∧ x * 2 ^ 10 < 2 ^ 63 := by clear * - xb; omega have sb : 110 ≤ sc.toNat ∧ sc.toNat < 363 := by clear * - hsc h1 h2; omega have nN : (UInt64.ofNat (x * 2 ^ 10)).toNat = x * 2 ^ 10 := UInt64.toNat_ofNat_of_lt' (xc.2.trans (by decide)) obtain ⟨r1, -, r3⟩ := Core.rnd62n ng (UInt64.ofNat (x * 2 ^ 10)) sc (by rw [nN]; exact xc.1) (by rw [nN]; exact xc.2) sb.1 sb.2 have r2 := Core.rnd_fw ng (UInt64.ofNat (x * 2 ^ 10)) sc (by clear * - nN xc; omega) (by clear * - sb; omega) rw [r39e x xb.2] at r1 r3 have he : sc.toNat - 110 = EN - 1046 := by clear * - hsc h1; omega rw [he] at r1 have hW : W.toUInt32 = Core.rnd ng (UInt64.ofNat (x * 2 ^ 10)) sc := UInt32.toNat_inj.mp (by rw [UInt64.toNat_toUInt32, r1, hw]) rw [hW, r2, nN, hsc] refine ⟨_, mul_ne_zero (by clear * - xb; split <;> omega) (by positivity), rfl, ?_⟩ rw [dyR] at hv have hz : (2 : ℝ) ^ ((EN : Int) - 1075) * 2 ^ (-149 : Int) = 2 ^ 10 * 2 ^ (EN - 936) * 2 ^ (-298 : Int) := by rw [← zpow_natCast (2 : ℝ) (EN - 936), ← zpow_natCast (2 : ℝ) 10, ← zpow_add₀ two_ne_zero, ← zpow_add₀ two_ne_zero, ← zpow_add₀ two_ne_zero, show (EN : Int) - 1075 + -149 = ((10 : Nat) : Int) + ((EN - 936 : Nat) : Int) + -298 by clear * - h1; omega] rw [hv, mul_assoc, hz] cases ng <;> simp <;> ring def nU (M i : Nat) (h1 : 2 ^ 23 ≤ M) (h2 : M < 2 ^ 24) (h3 : i < 253) : 2 ^ 62 ≤ M * 2 ^ 39 + 2 ^ 35 ∧ M * 2 ^ 39 + 2 ^ 35 < 2 ^ 63 ∧ 110 ≤ i + 110 ∧ i + 110 < 363 ∧ (M * 2 ^ 39 + 2 ^ 35 + (2 ^ 38 - 1) + (M * 2 ^ 39 + 2 ^ 35) / 2 ^ 39 % 2) / 2 ^ 39 = M ∧ (i + 110 - 110) * 2 ^ 23 + M = i * 2 ^ 23 + M := by omega def nL (M i : Nat) (h1 : 2 ^ 23 < M) (h2 : M < 2 ^ 24) (h3 : i < 253) : 2 ^ 62 ≤ M * 2 ^ 39 - 2 ^ 35 ∧ M * 2 ^ 39 - 2 ^ 35 < 2 ^ 63 ∧ 110 ≤ i + 110 ∧ i + 110 < 363 ∧ (M * 2 ^ 39 - 2 ^ 35 + (2 ^ 38 - 1) + (M * 2 ^ 39 - 2 ^ 35) / 2 ^ 39 % 2) / 2 ^ 39 = M ∧ (i + 110 - 110) * 2 ^ 23 + M = i * 2 ^ 23 + M := by omega def nZ (i : Nat) (h1 : 1 ≤ i) (h3 : i < 253) : 2 ^ 62 ≤ 2 ^ 63 - 2 ^ 36 ∧ 2 ^ 63 - 2 ^ 36 < 2 ^ 63 ∧ 110 ≤ i + 109 ∧ i + 109 < 363 ∧ (2 ^ 63 - 2 ^ 36 + (2 ^ 38 - 1) + (2 ^ 63 - 2 ^ 36) / 2 ^ 39 % 2) / 2 ^ 39 = 2 ^ 24 ∧ (i + 109 - 110) * 2 ^ 23 + 2 ^ 24 = i * 2 ^ 23 + 2 ^ 23 := by omega open Dense.F in def nearW (w : Word) (hi : 1 ≤ idxOf w) (he : (expOf w).toNat ≤ 253) (d : FloatLib.Numerics.Dyadic) (hd : |d.toReal - (sv w : ℝ) * 2 ^ ((idxOf w : Int) - 149)| ≤ 2 ^ ((idxOf w : Int) - 153)) (hb : |d.toReal| ≤ (2 : ℝ) ^ (127 : Int)) : toWord (Model.roundDyadic Fmt d) = w := by have e1 := Dense.idxE w have e2 := Dense.wdiv w have e3 : (fracOf w).toNat = w.toNat % 2 ^ 23 := Dense.fr23 w have e4 := fracOf_toNat_lt w have e5 := Core.signOf_iff w have e6 := w.toNat_lt have hne : expOf w ≠ 0 := fun h => by rw [h] at e1; simp at e1; clear*-e1 hi;omega have hm : mantOf w = 2 ^ 23 + (fracOf w).toNat := by unfold mantOf; rw [if_neg hne] generalize hMd : mantOf w = M at * generalize hid : idxOf w = i at * have hM : 2 ^ 23 ≤ M ∧ M < 2 ^ 24 := by clear*-e3 hm;omega have hwn : w.toNat = (if signOf w = true then 2 ^ 31 else 0) + (i * 2 ^ 23 + M) := by split ·rename_i h; have := e5.1 h; clear*-e1 e2 e3 e6 hi hm this;omega ·rename_i h; have : ¬2 ^ 31 ≤ w.toNat := fun x => h (e5.2 x); clear*-e1 e2 e3 hi hm this;omega have R : ∀ (N sc K : Nat), 2 ^ 62 ≤ N → N < 2 ^ 63 → 110 ≤ sc → sc < 363 → (N + (2 ^ 38 - 1) + N / 2 ^ 39 % 2) / 2 ^ 39 = K → (sc - 110) * 2 ^ 23 + K = i * 2 ^ 23 + M → toWord (Model.roundDyadic Fmt ⟨signOf w, N, (sc : Int) - 298⟩) = w := fun N sc K h1 h2 h3 h4 hK hs => by have n := UInt64.toNat_ofNat_of_lt' (show N < UInt64.size from h2.trans (by decide)) have s := UInt64.toNat_ofNat_of_lt' (show sc < UInt64.size from h4.trans (by decide)) obtain ⟨r1, -, -⟩ := Core.rnd62n (signOf w) (UInt64.ofNat N) (UInt64.ofNat sc) (by rw [n]; exact h1) (by rw [n]; exact h2) (by rw [s]; exact h3) (by rw [s]; exact h4) rw [r39g N h2, hK, s, hs, ← hwn] at r1 have := Core.rnd_eq (signOf w) (UInt64.ofNat N) (UInt64.ofNat sc) (by rw [s]; clear * - h4; omega) rw [n, s] at this rw [← this]; exact UInt32.toNat_inj.mp r1 have hi2 : i < 253 := by clear * - e1 he; omega have hU := by obtain ⟨u1, u2, u3, u4, u5, u6⟩ := nU M i hM.1 hM.2 hi2 exact R _ _ _ u1 u2 u3 u4 u5 u6 obtain ⟨dL, hL, hLw⟩ : ∃ dL : FloatLib.Numerics.Dyadic, dL.toReal = (if signOf w = true then -(((M * 2 ^ 39 - 2 ^ 35 : Nat) : ℝ)) else ((M * 2 ^ 39 - 2 ^ 35 : Nat) : ℝ)) * 2 ^ ((i : Int) - 188) ∧ toWord (Model.roundDyadic Fmt dL) = w := by by_cases h23 : M = 2 ^ 23 ·obtain ⟨u1, u2, u3, u4, u5, u6⟩ := nZ i hi hi2 refine ⟨_, ?_, R _ _ _ u1 u2 u3 u4 u5 (h23 ▸ u6)⟩ subst h23 rw [dyR, show (((i + 109 : Nat) : Int) - 298) = (i : Int) - 188 + -1 by clear*-;omega, zpow_add₀ two_ne_zero] norm_num split <;> ring ·obtain ⟨u1, u2, u3, u4, u5, u6⟩ := nL M i (by clear * - h23 hM; omega) hM.2 hi2 refine ⟨_, ?_, R _ _ _ u1 u2 u3 u4 u5 u6⟩ rw [dyR, show (((i + 110 : Nat) : Int) - 298) = (i : Int) - 188 by clear*-;omega] have hf : expOf w ≠ 255 := fun h => by rw [h] at he; simp at he have hz : w &&& 0x7FFFFFFF ≠ 0 := fun h => hne ((Dense.exp0 w).2 (by simp only [Dense.absW, h]; simp)) rw [show ((i + 110 : Nat) : Int) - 298 = (i : Int) - 188 by clear*-;omega] at hU obtain ⟨dU, hUr, hU⟩ : ∃ dU : FloatLib.Numerics.Dyadic, dU.toReal = (if signOf w = true then -((M : ℝ) * 2 ^ 39 + 2 ^ 35) else (M : ℝ) * 2 ^ 39 + 2 ^ 35) * 2 ^ ((i : Int) - 188) ∧ toWord (Model.roundDyadic Fmt dU) = w := ⟨_, by rw [dyR]; split <;> push_cast <;> ring, hU⟩ have c0 : (0 : ℝ) < 2 ^ ((i : Int) - 188) := by positivity have c1 : (2 : ℝ) ^ ((i : Int) - 149) = 2 ^ 39 * 2 ^ ((i : Int) - 188) := by rw [← zpow_natCast (2 : ℝ) 39, ← zpow_add₀ two_ne_zero]; congr 1; clear*-;omega have c2 : (2 : ℝ) ^ ((i : Int) - 153) = 2 ^ 35 * 2 ^ ((i : Int) - 188) := by rw [← zpow_natCast (2 : ℝ) 35, ← zpow_add₀ two_ne_zero]; congr 1; clear*-;omega have c3 : ((M * 2 ^ 39 - 2 ^ 35 : Nat) : ℝ) = (M : ℝ) * 2 ^ 39 - 2 ^ 35 := by rw [Nat.cast_sub (by clear*-hm;omega)]; push_cast; ring rw [c1, c2] at hd rw [c3] at hL generalize (2 : ℝ) ^ ((i : Int) - 188) = c at * obtain ⟨t1, t2⟩ := abs_le.mp hd have hsv : (sv w : ℝ) = if signOf w = true then -(M : ℝ) else M := by unfold sv; rw [hMd]; split <;> simp rw [hsv] at t1 t2 cases hs : signOf w <;> simp only [hs, Bool.false_eq_true, ite_false, ite_true] at hL hLw hU hUr t1 t2 ·rw [sand dL d _ (by rw [hL]; nlinarith only [t1]) (by rw [hUr]; nlinarith only [t2]) (by rw [hLw, hU]) (by rwa [hLw]) (by rwa [hLw]) hb, hLw] ·rw [sand _ d dL (by rw [hUr]; nlinarith only [t1]) (by rw [hL]; nlinarith only [t2]) (by rw [hLw, hU]) (by rwa [hU]) (by rwa [hU]) hb, hU] open Dense.F in def farB (x y : Float) (fx : fv x) (fy : fv y) (A B : Int) (i j : Nat) (hA : A.natAbs < 2 ^ 24) (hB : B.natAbs < 2 ^ 24) (g : j + 30 ≤ i) (hi : i ≤ 300) (hs : rv x + rv y = (A : ℝ) * 2 ^ i + (B : ℝ) * 2 ^ j) : fv (x + y) ∧ |rv (x + y) - (A : ℝ) * 2 ^ i| ≤ 2 ^ 26 * 2 ^ (i - 30) ∧ |rv x + rv y - (A : ℝ) * 2 ^ i| ≤ 2 ^ 26 * 2 ^ (i - 30) := by have ab : ∀ z : Int, z.natAbs < 2 ^ 24 → |(z : ℝ)| ≤ 2 ^ 24 := fun z h => by rw [← Int.cast_abs, Int.abs_eq_natAbs]; exact_mod_cast h.le have p0 : (0 : ℝ) < 2 ^ (i - 30) := by positivity have e1 : (2 : ℝ) ^ i = 2 ^ 30 * 2 ^ (i - 30) := by rw [← pow_add]; congr 1; clear*-g hi;omega have e2 : (2 : ℝ) ^ j ≤ 2 ^ (i - 30) := pow_le_pow_right₀ (by norm_num) (by clear*-g hi;omega) have t1 : |(B : ℝ) * 2 ^ j| ≤ 2 ^ 24 * 2 ^ (i - 30) := by rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < 2 ^ j)] exact mul_le_mul (ab B hB) e2 (by positivity) (by positivity) have t2 : |(A : ℝ) * 2 ^ i| ≤ 2 ^ 54 * 2 ^ (i - 30) := by rw [abs_mul, abs_of_pos (by positivity : (0 : ℝ) < 2 ^ i), e1] calc |(A : ℝ)| * (2 ^ 30 * 2 ^ (i - 30)) ≤ 2 ^ 24 * (2 ^ 30 * 2 ^ (i - 30)) := mul_le_mul_of_nonneg_right (ab A hA) (by positivity) _ = 2 ^ 54 * 2 ^ (i - 30) := by ring have t3 : |rv x + rv y| < (2 : ℝ) ^ (((i + 25 : Nat) : Int)) := by rw [hs, zpow_natCast, show i + 25 = 55 + (i - 30) by clear*-g hi;omega, pow_add] calc _ ≤ |(A : ℝ) * 2 ^ i| + |(B : ℝ) * 2 ^ j| := abs_add_le _ _ _ ≤ 2 ^ 54 * 2 ^ (i - 30) + 2 ^ 24 * 2 ^ (i - 30) := add_le_add t2 t1 _ < 2 ^ 55 * 2 ^ (i - 30) := by nlinarith only [p0] obtain ⟨f, h⟩ := fadd x y fx fy _ (by clear*-;omega) (by clear*-hi;omega) t3 have t4 : (2 : ℝ) ^ ((((i + 25 : Nat) : Int)) - 53) / 2 = 2 * 2 ^ (i - 30) := by rw [show (((i + 25 : Nat) : Int)) - 53 = 2 + ((i - 30 : Nat) : Int) by clear*-g hi;omega, zpow_add₀ two_ne_zero, zpow_natCast] norm_num; ring rw [t4] at h have t5 : |rv x + rv y - (A : ℝ) * 2 ^ i| ≤ 2 ^ 24 * 2 ^ (i - 30) := by rw [hs, add_sub_cancel_left]; exact t1 refine ⟨f, ?_, t5.trans (by nlinarith only [p0])⟩ calc _ ≤ |rv (x + y) - (rv x + rv y)| + |rv x + rv y - (A : ℝ) * 2 ^ i| := abs_sub_le _ _ _ _ ≤ 2 * 2 ^ (i - 30) + 2 ^ 24 * 2 ^ (i - 30) := add_le_add h t5 _ ≤ 2 ^ 26 * 2 ^ (i - 30) := by nlinarith only [p0] open Dense.F in def farE (x y : Float) (fx : fv x) (fy : fv y) (w : Word) (B : Int) (j : Nat) (hB : B.natAbs < 2 ^ 24) (g : j + 30 ≤ idxOf w) (he : (expOf w).toNat ≤ 253) (hs : rv x + rv y = (sv w : ℝ) * 2 ^ idxOf w + (B : ℝ) * 2 ^ j) (hE : eF (x + y).toBits - 1046 < 253) (D : FloatLib.Numerics.Dyadic) (hD : D.toReal = (rv x + rv y) * 2 ^ (-149 : Int)) : (wE (rE (x + y).toBits)).toUInt32 = toWord (Model.roundDyadic Fmt D) := by have hi := idxOf_le w (fun h => by rw [h] at he; simp at he) obtain ⟨fS, h1, h2⟩ := farB x y fx fy (sv w) B (idxOf w) j (svB w) hB g (by clear*-hi;omega) hs obtain ⟨Ts, h0, hW, hR⟩ := wF _ fS hE have hq := (fq (x + y)).1 have hE' : (eF (x + y).toBits).toNat ≤ 1298 := by simp only [UInt64.lt_iff_toNat_lt, UInt64.toNat_sub, UInt64.reduceToNat] at hE unfold eF at *; clear*-hE hq;omega have hb1 := bitsB _ fS have up : (2 : ℝ) ^ (((eF (x + y).toBits).toNat : Int) - 1022) ≤ 2 ^ (276 : Int) := zpow_le_zpow_right₀ (by norm_num) (by clear*-hE';omega) have hb2 := rlt x y fx fy fS (((eF (x + y).toBits).toNat : Int) - 1022) (by clear*-;omega) (by clear*-hE';omega) hb1 have c : (0 : ℝ) < 2 ^ (-149 : Int) := by positivity have bd : ∀ t : ℝ, |t| < 2 ^ (((eF (x + y).toBits).toNat : Int) - 1022) → |t * 2 ^ (-149 : Int)| ≤ 2 ^ (127 : Int) := fun t h => by rw [abs_mul, abs_of_pos c, show (127 : Int) = 276 + -149 by norm_num, zpow_add₀ two_ne_zero] exact mul_le_mul_of_nonneg_right (h.le.trans up) c.le have nr : ∀ t : ℝ, |t - (sv w : ℝ) * 2 ^ idxOf w| ≤ 2 ^ 26 * 2 ^ (idxOf w - 30) → |t * 2 ^ (-149 : Int) - (sv w : ℝ) * 2 ^ ((idxOf w : Int) - 149)| ≤ 2 ^ ((idxOf w : Int) - 153) := fun t h => by have e1 : (2 : ℝ) ^ ((idxOf w : Int) - 149) = 2 ^ idxOf w * 2 ^ (-149 : Int) := by rw [sub_eq_add_neg, zpow_add₀ two_ne_zero, zpow_natCast] have e2 : (2 : ℝ) ^ ((idxOf w : Int) - 153) = 2 ^ 26 * 2 ^ (idxOf w - 30) * 2 ^ (-149 : Int) := by rw [← zpow_natCast (2 : ℝ) (idxOf w - 30), ← zpow_natCast (2 : ℝ) 26, ← zpow_add₀ two_ne_zero, ← zpow_add₀ two_ne_zero] congr 1; clear*-g hi;omega rw [e1, e2, ← mul_assoc, ← sub_mul, abs_mul, abs_of_pos c] exact mul_le_mul_of_nonneg_right h c.le have a1 := nearW w (by clear*-g;omega) he (ofIntDyadic Ts (-298)) (by rw [ofIntR, hR]; exact nr _ h1) (by rw [ofIntR, hR]; exact bd _ hb1) have a2 := nearW w (by clear*-g;omega) he D (by rw [hD]; exact nr _ h2) (by rw [hD]; exact bd _ hb2) rw [hW, a2] unfold finishWord rw [if_neg h0, a1] @[noinline] def aS (r : Bool) (a b : Word) : Word := NativeAdd.add r a b @[inline] def aC (r : Bool) (w : Word) : Word := if r then NativeAdd.actB true w else w def aC_eq (r : Bool) (w : Word) : aC r w = act r w := by cases r ·rfl ·exact NativeAdd.actB_eq true w @[inline] def aE (r : Bool) (a b : Word) : Word := if (a >>> 23) &&& 0xFF < 254 && (b >>> 23) &&& 0xFF < 254 then let B := (Dense.F.dw a + Dense.F.dw b).toBits if Dense.F.eF B - 1046 < 253 then aC r (wE (rE B)).toUInt32 else aS r a b else aS r a b open Dense.F in def aR (a b : Word) (ha : (expOf a).toNat ≤ 253) (hb : (expOf b).toNat ≤ 253) (hE : eF (dw a + dw b).toBits - 1046 < 253) : (wE (rE (dw a + dw b).toBits)).toUInt32 = toWord (Model.add (ofW a) (ofW b)) := by have na : expOf a ≠ 255 := fun h => by rw [h] at ha; simp at ha have nb : expOf b ≠ 255 := fun h => by rw [h] at hb; simp at hb obtain ⟨f1, v1⟩ := dwV a na obtain ⟨f2, v2⟩ := dwV b nb have hd : ∀ w, expOf w ≠ 255 → (decodeD w).toReal = rv (dw w) * 2 ^ (-149 : Int) := fun w h => by rw [(dwV w h).2, ← FloatLib.Numerics.Dyadic.cast_toRat, decodeD_toRat]; push_cast rw [sub_eq_add_neg, zpow_add₀ two_ne_zero, zpow_natCast, mul_assoc] have hD : (Model.addDyadic (decodeD a) (decodeD b)).toReal = (rv (dw a) + rv (dw b)) * 2 ^ (-149 : Int) := by rw [Model.Dyadic.toReal_addDyadic, hd a na, hd b nb, add_mul] have hadd : Model.add (ofW a) (ofW b) = Model.roundDyadic Fmt (Model.addDyadic (decodeD a) (decodeD b)) := by simp [Model.Proof.add_eq_spec, Model.Spec.add, ofW, toDyadic_ofUInt32 a na, toDyadic_ofUInt32 b nb] rw [hadd] by_cases g1 : idxOf a + 30 ≤ idxOf b ·exact farE _ _ f1 f2 b (sv a) (idxOf a) (svB a) g1 hb (by rw [v1, v2, add_comm]) hE _ hD by_cases g2 : idxOf b + 30 ≤ idxOf a ·exact farE _ _ f1 f2 a (sv b) (idxOf b) (svB b) g2 ha (by rw [v1, v2]) hE _ hD obtain ⟨fS, vS⟩ := addW a b na nb (by clear*-g2;omega) (by clear*-g1;omega) obtain ⟨Ts, h0, hW, hR⟩ := wF _ fS hE rw [hW] refine finishWord_of_ne _ _ _ _ h0 ?_ apply Rat.cast_injective (α := ℝ) rw [FloatLib.Numerics.Dyadic.cast_toRat, hD] push_cast rw [hR, vS, v1, v2] def aE_eq (r : Bool) (a b : Word) : aE r a b = act r (toWord (Model.add (ofW a) (ofW b))) := by have hs : aS r a b = act r (toWord (Model.add (ofW a) (ofW b))) := NativeAdd.add_eq r a b unfold aE; dsimp only split; swap; · exact hs rename_i h simp only [Bool.and_eq_true, decide_eq_true_eq] at h obtain ⟨h1, h2⟩ := h split; swap; · exact hs simp only [UInt32.lt_iff_toNat_lt] at h1 h2 rw [aC_eq, aR a b (Nat.le_of_lt_succ h1) (Nat.le_of_lt_succ h2) ‹_›] @[inline] def addL (r : Bool) (a b : Array Word) (h : a.size ≤ b.size ∧ a.size < USize.size) : Array Word := umap a.size.toUSize (fun i hi x => aE r x (b.uget i (by rw [Dense.toUSize_toNat h.2] at hi; omega))) 0 a (by rw [Dense.toUSize_toNat h.2]) def addRelu (relu : Bool) (a b : Array Word) : Array Word := if h : a.size ≤ b.size ∧ a.size < USize.size then if relu then addL true a b h else addL false a b h else addReluSpec relu a b def addRelu_eq : addRelu = addReluSpec := by funext relu a b unfold addRelu split; swap; · rfl rename_i h rw [show (if relu then addL true a b h else addL false a b h) = addL relu a b h by cases relu <;> rfl] have hs := Dense.toUSize_toNat h.2 refine Array.ext_getElem? fun j => ?_ unfold addL rw [(umap_spec _ _ (fun j x => act relu (toWord (Model.add (ofW x) (ofW b[j]!)))) (fun i hi x => ?_) 0 a _).2 j, addReluSpec, Array.getElem?_ofFn] ·by_cases hj : j < a.size ·rw [if_pos ⟨by simp, by rwa [hs]⟩, dif_pos hj, Array.getElem?_eq_getElem hj]; rfl ·rw [if_neg (by rw [hs]; clear*-hj;omega), dif_neg hj, Array.getElem?_eq_none (by clear*-hj;omega)] ·rw [aE_eq, getElem!_pos b i.toNat (by omega)]; rfl end Bn namespace Dense namespace F @[inline] def aF (relu : Bool) (w : Word) : Word := if relu then w &&& ((w >>> 31) - 1) else w def aF_eq (relu : Bool) (w : Word) (hw : expOf w ≠ 255) : aF relu w = act relu w := by unfold aF act reluW cases relu ·simp have hs := Core.signOf_iff w have h3 : (w >>> 31).toNat = w.toNat / 2 ^ 31 := by rw [UInt32.toNat_shiftRight]; simp [Nat.shiftRight_eq_div_pow] have hl := w.toNat_lt by_cases h : 2 ^ 31 ≤ w.toNat ·have e1 : w >>> 31 = 1 := UInt32.toNat_inj.mp (by rw [h3]; simp only [UInt32.toNat_one]; clear h3;omega) have e2 : signOf w = true := hs.mpr h unfold signOf at e2 simp [e1, e2, hw] ·have e1 : w >>> 31 = 0 := UInt32.toNat_inj.mp (by rw [h3]; simp only [UInt32.toNat_zero]; omega) have e2 : signOf w ≠ true := fun q => h (hs.mp q) unfold signOf at e2 simp only [Bool.not_eq_true] at e2 simp [e1, e2] def certF (S : Float) (h : UInt64) (hc : cert2 S h < 0x100000000) : expOf (cert2 S h).toUInt32 ≠ 255 := by unfold cert2 at hc ⊢ dsimp only at hc ⊢ split at hc swap; · exact absurd hc (by decide) rename_i hcond rw [if_pos hcond] simp only [Bool.and_eq_true, decide_eq_true_eq] at hcond obtain ⟨⟨⟨-, c2⟩, -⟩, -⟩ := hcond have hE11 : (eF S.toBits).toNat < 2048 := by unfold eF; rw [UInt64.toNat_and]; exact lt_of_le_of_lt Nat.and_le_right (by decide) have hf52 : (S.toBits &&& 0xfffffffffffff).toNat < 2 ^ 52 := by rw [UInt64.toNat_and]; exact lt_of_le_of_lt Nat.and_le_right (by decide) rw [UInt64.lt_iff_toNat_lt, UInt64.toNat_sub] at c2 simp only [UInt64.reduceToNat] at c2 have e1 : 1195 ≤ (eF S.toBits).toNat := by omega have hw := c3w S.toBits e1 have hs2 : S.toBits.toNat / 2 ^ 63 < 2 := by have := S.toBits.toNat_lt; clear*-this;omega rw [UInt64.lt_iff_toNat_lt] at hc simp only [UInt64.reduceToNat] at hc intro h255 have h2 := congrArg UInt32.toNat h255 rw [expOf, UInt32.toNat_and, UInt32.toNat_shiftRight, UInt64.toNat_toUInt32] at h2 simp only [UInt32.reduceToNat, Nat.reduceMod, Nat.shiftRight_eq_div_pow] at h2 rw [Nat.and_two_pow_sub_one_eq_mod _ 8, Nat.mod_eq_of_lt hc, hw] at h2 clear h255 hc hs2 hw;omega @[inline] def tfB (relu : Bool) (S : Float) (hh : UInt64) (sl : Unit → Word) : Word := let c := cert2 S hh if c < 0x100000000 then aF relu c.toUInt32 else sl () def tfB_eq (relu : Bool) (S : Float) (hh : UInt64) (sl : Unit → Word) : tfB relu S hh sl = tf relu S hh sl := by unfold tfB tf; dsimp only; split ·rename_i hc; rw [aF_eq _ _ (certF _ _ hc)] ·rfl def tmB3 (x w : Word) (e : Nat) (he : (expOf w).toNat ≤ e) : |(Core.tm x w : ℝ)| ≤ |(sv x : ℝ) * 2 ^ idxOf x| * 2 ^ (max e 56 + 23) := by unfold Core.tm push_cast rw [show (sv x : ℝ) * sv w * 2 ^ (idxOf x + idxOf w) = (sv x * 2 ^ idxOf x) * (sv w * 2 ^ idxOf w) by rw [pow_add]; ring, abs_mul] gcongr rw [abs_mul, abs_pow, abs_two] refine (mul_le_mul (b := 2 ^ 24) (by rw [← Int.cast_abs]; exact_mod_cast (sv_abs _).le) (pow_le_pow_right₀ (by norm_num) (by rw [idxE]; omega : _ ≤ max e 56 - 1)) (by positivity) (by positivity)).trans_eq ?_ rw [← pow_add]; congr 1; clear*-;omega def SB (n : Nat) (fa fb : Nat → Word) (ba : Word) (S : Float) : Prop := (∀ s < n, expOf (fb s) ≠ 255) → |(Core.tm oneW ba : ℝ)| + ∑ s ∈ Finset.range n, |(Core.tm (fa s) (fb s) : ℝ)| ≤ (2 : ℝ) ^ (968 : Int) → fv S ∧ |rv S - ((Core.tm oneW ba : ℝ) + ∑ s ∈ Finset.range n, (Core.tm (fa s) (fb s) : ℝ))| ≤ n * ((2 : ℝ) ^ (-53 : Int) * (1 + 2 ^ (-20 : Int)) * (|(Core.tm oneW ba : ℝ)| + ∑ s ∈ Finset.range n, |(Core.tm (fa s) (fb s) : ℝ)|) + 2 ^ (-1074 : Int)) def pS (n : Nat) (fa fb : Nat → Word) (ba : Word) (p : Nat → Float) (hba : expOf ba ≠ 255) (hn : 8 * n < 2 ^ 32) (hp : ∀ s < n, expOf (fb s) ≠ 255 → fv (p s) ∧ rv (p s) = Core.tm (fa s) (fb s)) : SB n fa fb ba (sfold p n 0 (dw oneW * dw ba)) := fun hw hA => by have hB := pvV oneW ba (by decide) hba exact sfR p (fun s => (Core.tm (fa s) (fb s) : ℝ)) (Core.tm oneW ba : ℝ) n (fun s hs => hp s hs (hw s hs)) (by omega) hA n 0 _ (by clear hn;omega) (Nat.zero_le _) hB.1 (by rw [hB.2]; simp) def pw3 (relu : Bool) (n : Nat) (fa fb : Nat → Word) (ba : Word) (ib IB L : Nat) (e : Word) (c hb : UInt64) (S : Float) (fbk0 fbk : Unit → Word) (hx : ∀ s < n, expOf (fa s) ≠ 255) (hba : expOf ba ≠ 255 ∧ idxOf ba ≤ IB) (hib : 174 + IB ≤ ib) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hibL : ib + L ≤ 425) (hn : 8 * n < 2 ^ 32) (hS : SB n fa fb ba S) (he : ∀ s < n, (expOf (fb s)).toNat ≤ e.toNat) (hc : 9 * ((n : ℝ) + 1) * (∑ s ∈ Finset.range n, |rv (dw (fa s))|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ ((c.toNat : Int) + 56) + 2 ^ (-900 : Int)) (hcB : c.toNat ≤ 1000) (hhb : hb.toNat = ib + L - 50) (hk0 : fbk0 () = act relu (dotOf (n + 1) (fun s => if s < n then fa s else oneW) (fun s => if s < n then fb s else ba))) (hk : (∀ s < n, expOf (fb s) ≠ 255) → fbk () = act relu (dotOf (n + 1) (fun s => if s < n then fa s else oneW) (fun s => if s < n then fb s else ba))) : (if e < 255 && (if e.toUInt64 < 56 then 56 else e.toUInt64) + 23 + c ≤ 400 then tfB relu S (if (if e.toUInt64 < 56 then 56 else e.toUInt64) + 23 + c < hb then hb else (if e.toUInt64 < 56 then 56 else e.toUInt64) + 23 + c) fbk else fbk0 ()) = act relu (dotOf (n + 1) (fun s => if s < n then fa s else oneW) (fun s => if s < n then fb s else ba)) := by have P : ∀ {a b : ℕ}, a ≤ b → (2 : ℝ) ^ a ≤ 2 ^ b := pow_le_pow_right₀ (by norm_num) generalize hP : (if e.toUInt64 < 56 then 56 else e.toUInt64) + 23 + c = q have hq : q.toNat = max e.toNat 56 + 23 + c.toNat := by have := UInt32.toNat_lt e rw [← hP]; split <;> rename_i h <;> simp only [UInt64.lt_iff_toNat_lt, UInt32.toNat_toUInt64, UInt64.toNat_add, UInt64.reduceToNat] at h ⊢ <;> (clear*-h hcB this;omega) split; swap; · exact hk0 rename_i hg; simp only [Bool.and_eq_true, decide_eq_true_eq, UInt32.lt_iff_toNat_lt, UInt64.le_iff_toNat_le, UInt32.reduceToNat, UInt64.reduceToNat] at hg generalize hH : (if q < hb then hb else q) = hh have hhv : hh.toNat = max q.toNat hb.toNat := by rw [← hH]; split <;> rename_i h <;> simp only [UInt64.lt_iff_toNat_lt] at h <;> (clear*-h;omega) have hw : ∀ s < n, expOf (fb s) ≠ 255 := fun s hs h => by have := he s hs; simp [h] at this; clear*-hg this;omega have hB := pvV oneW ba (by decide) hba.1 generalize hd : (∑ s ∈ Finset.range n, |rv (dw (fa s))|) = z at hc have h0 : 0 ≤ z := hd ▸ Finset.sum_nonneg fun _ _ => abs_nonneg _ rw [zpow_add₀ two_ne_zero, zpow_natCast] at hc have hz := tmOne ba IB hba.2 have h3 : (n : ℝ) ≤ 2 ^ 32 := by exact_mod_cast (show n ≤ 2 ^ 32 by clear*-hn;omega) have hN : z ≤ n * 2 ^ 277 := hd ▸ (Finset.sum_le_sum fun s (hs : s ∈ Finset.range n) => dwB _ (hx s (Finset.mem_range.1 hs))).trans_eq (by simp) have hZ : ∑ s ∈ Finset.range n, |(Core.tm (fa s) (fb s) : ℝ)| ≤ 2 ^ (max e.toNat 56 + 23) * z := by rw [← hd, Finset.mul_sum] exact Finset.sum_le_sum fun s hs => by rw [(dwV _ (hx s (Finset.mem_range.1 hs))).2] exact (tmB3 _ _ _ (he s (Finset.mem_range.1 hs))).trans_eq (mul_comm _ _) have hA : |(Core.tm oneW ba : ℝ)| + ∑ s ∈ Finset.range n, |(Core.tm (fa s) (fb s) : ℝ)| ≤ 2 ^ (968 : Int) := by rw [show (2 : ℝ) ^ (968 : Int) = 2 ^ 967 + 2 ^ 967 by rw [← two_mul, ← pow_succ']; norm_num] refine add_le_add (hz.trans (P (by clear*-hL27 hib hibL;omega))) (hZ.trans ((mul_le_mul (P (by clear*-hcB hg hq;omega : _ ≤ 400)) (hN.trans (mul_le_mul_of_nonneg_right h3 (by positivity))) h0 (by positivity)).trans ?_)) rw [← pow_add, ← pow_add]; exact P (by norm_num) obtain ⟨fS, eS⟩ := hS hw hA have hT : (Core.tsum (n + 1) (fun s => if s < n then fa s else oneW) (fun s => if s < n then fb s else ba) : ℝ) = Core.tm oneW ba + ∑ s ∈ Finset.range n, (Core.tm (fa s) (fb s) : ℝ) := by rw [Core.tsum_succ, Core.tsum]; push_cast; simp only [lt_irrefl, ite_false]; rw [add_comm]; congr 1 exact Finset.sum_congr rfl fun s hs => by simp [Finset.mem_range.1 hs] have hE : |rv S - (Core.tsum (n + 1) (fun s => if s < n then fa s else oneW) (fun s => if s < n then fb s else ba) : ℝ)| ≤ (2 : ℝ) ^ (hh.toNat : Int) := by rw [hT] refine bnd n z (Core.tm oneW ba : ℝ) _ (2 ^ (max e.toNat 56 + 23)) _ (2 ^ hb.toNat) _ h0 (by positivity) (one_le_pow₀ (by norm_num)) (by simpa using h3) ?_ ?_ hc ?_ ?_ ?_ ?_ ·exact (eS.trans (by gcongr)).trans (le_add_of_nonneg_right (by positivity)) ·rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact zpow_le_zpow_right₀ (by norm_num) (by clear*-;omega) ·rw [show (2 : ℝ) ^ (49 : Int) = 2 ^ 49 by norm_num, ← pow_add] refine (mul_le_mul (by exact_mod_cast (show n ≤ 2 ^ L by clear*-hL;omega) : (n : ℝ) ≤ 2 ^ L) hz (abs_nonneg _) (by positivity)).trans ?_ rw [← pow_add]; exact P (by clear*-hL27 hhb hib;omega) ·rw [← pow_add, zpow_natCast]; exact P (by clear*-hhv hq;omega) ·rw [zpow_natCast]; exact P (by clear*-hhv;omega) ·exact zpow_le_zpow_right₀ (by norm_num) (by clear*-hcB hhv hq;omega) rw [tfB_eq]; unfold tf; dsimp only; split ·rename_i hc' have hf : Core.finAll (n + 1) (fun s => if s < n then fa s else oneW) (fun s => if s < n then fb s else ba) := fun k _ => by by_cases h : k < n <;> simp only [h, ↓reduceIte] exacts [⟨hx k h, hw k h⟩, ⟨by decide, hba.1⟩] rw [cw2 _ _ _ hf S fS hh (by clear*-hg hhb hhv hibL;omega) hE hc'] ·exact hk hw def tS_eq (relu : Bool) (n : Nat) (fa fb : Nat → Word) (p : Nat → Float) (bpf : Unit → Float) (L : Nat) (fbk : Unit → Word) (hp : ∀ s < n, fv (p s) ∧ rv (p s) = Core.tm (fa s) (fb s)) (hbp : fv (bpf ()) ∧ rv (bpf ()) = Core.tm (fa n) (fb n)) (hfin : Core.finAll (n + 1) fa fb) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hk : fbk () = act relu (dotOf (n + 1) fa fb)) : tS relu L n p bpf fbk = act relu (dotOf (n + 1) fa fb) := by unfold tS; dsimp only generalize hr : sT p n 0 (bpf ()) 0 = r split next hk' => split next hc => obtain ⟨fS2, eS2⟩ := sT_err _ _ (Core.tm (fa n) (fb n)) n r.2.toNat hk'.1 hk'.2.1 hp n 0 _ 0 rfl (by clear*-;omega) hbp.1 (by simp [hbp.2]) (by rw [hr]) rw [hr] at eS2 fS2 have hu : ((r.2.toNat + L - 1076).toUInt64).toNat = r.2.toNat + L - 1076 := by rw [Nat.toUInt64_eq, UInt64.toNat_ofNat_of_lt' (by simp only [UInt64.size]; clear*-hL27 hk';omega)] refine congrArg _ (cw2 _ _ _ hfin _ fS2 _ (by rw [hu]; clear*-hL27 hk';omega) ?_ hc) rw [Core.tsum_succ, hu]; unfold Core.tsum; push_cast; rw [add_comm] exact eS2.trans ((mul_le_mul_of_nonneg_right (by exact_mod_cast (by clear*-hL;omega : n ≤ 2 ^ L) : (n : ℝ) ≤ 2 ^ L) (by positivity)).trans_eq (by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact congrArg (2 ^ ·) (by clear*-hk';omega))) ·exact hk ·rw [if_neg (by decide)]; exact hk end F end Dense namespace Sr structure Ent {α : Type} (f : Array Word → Array Word → Nat → α) where w : Array Word b : Array Word n : Nat v : α ok : v = f w b n a : USize structure St {α : Type} (f : Array Word → Array Word → Nat → α) where e : Array (Ent f) x : ByteArray hd : Nat tl : Nat u : Nat structure Tab {α : Type} (f : Array Word → Array Word → Nat → α) where r : ST.Ref Unit (St f) z : Ent f zx : ByteArray cap : Nat variable {α : Type} {f : Array Word → Array Word → Nat → α} def Tab.make (f : Array Word → Array Word → Nat → α) (N cap : Nat) : Tab f := let z : Ent f := ⟨#[], #[], 0, f #[] #[] 0, rfl, 0⟩ let zx : ByteArray := ⟨Array.replicate (4 * N) 0⟩ ⟨(ST.Prim.mkRef ⟨Array.replicate N z, zx, 0, 0, 0⟩ (Void.mk ())).val, z, zx, cap⟩ @[inline] def Ent.hit (e : Ent f) (w b : Array Word) (n : Nat) : Bool := e.n == n && withPtrEq e.w w (fun _ => e.w == w) (fun h => by rw [h]; simp) && withPtrEq e.b b (fun _ => e.b == b) (fun h => by rw [h]; simp) def Ent.hit_ok {e : Ent f} {w b : Array Word} {n : Nat} (h : e.hit w b n = true) : e.v = f w b n := by simp only [Ent.hit, withPtrEq, Bool.and_eq_true, beq_iff_eq] at h obtain ⟨⟨h1, h2⟩, h3⟩ := h rw [e.ok, h1, h2, h3] @[inline] def Ent.sz (e : Ent f) : Nat := e.w.size + e.b.size + 64 @[inline] def hs (a : USize) : USize := (((a >>> 4).toUInt64 * 0x9E3779B97F4A7C15) >>> 48).toUSize def ul {β : Type} {a : Array β} {i : USize} (h : i < a.usize) : i.toNat < a.size := by have h' := USize.lt_iff_toNat_lt.mp h simp only [Array.usize, Nat.toUSize_eq] at h' exact Nat.lt_of_lt_of_le h' (by simp [Nat.mod_le]) def ub {a : ByteArray} {i : USize} (h : i < a.usize) : i.toNat < a.size := by have h' := USize.lt_iff_toNat_lt.mp h simp only [ByteArray.usize, Nat.toUSize_eq] at h' exact Nat.lt_of_lt_of_le h' (by simp [Nat.mod_le]) def xput (x : ByteArray) (m : USize) (c : UInt8) : Nat → USize → ByteArray | 0, _ => x | p + 1, i => let k := i &&& m if h : k < x.usize then if x.uget k (ub h) == 0 then x.uset k c (ub h) else xput x m c p (i + 1) else x def xall (e : Array (Ent f)) (m : USize) (i : Nat) (x : ByteArray) : ByteArray := if h : i < e.size then let q := e[i] xall e m (i + 1) (if q.w.isEmpty then x else xput x m (i + 1).toUInt8 x.size (hs q.a)) else x termination_by e.size - i @[inline] def St.drop (s : St f) (z : Ent f) : St f := let o := s.e.getD s.hd z ⟨s.e.setIfInBounds s.hd z, s.x, (s.hd + 1) % s.e.size, s.tl, if o.w.isEmpty then s.u else s.u - o.sz⟩ def St.room (t : Tab f) (sz : Nat) : Nat → St f → St f | 0, s => s | p + 1, s => if s.u + sz ≤ t.cap then s else St.room t sz p (s.drop t.z) def St.fd (s : St f) (t : Tab f) (w b : Array Word) (n : Nat) : Nat → {y // y = f w b n} | 0 => ⟨f w b n, rfl⟩ | p + 1 => let e := s.e.getD p t.z if h : e.hit w b n = true then ⟨e.v, Ent.hit_ok h⟩ else s.fd t w b n p @[noinline] def Tab.miss (t : Tab f) (w b : Array Word) (n : Nat) (a : USize) : {y // y = f w b n} := let r := (ST.Prim.Ref.get t.r (Void.mk ())).val let y := r.fd t w b n r.e.size let q : Ent f := ⟨w, b, n, y.1, y.2, a⟩ let sz := q.sz if 4 * sz ≤ t.cap then let s := (ST.Prim.Ref.get t.r (Void.mk ())).val let s := St.room t sz s.e.size s let s := if (s.e.getD s.tl t.z).w.isEmpty then s else s.drop t.z let e := s.e.setIfInBounds s.tl q let x := xall e (t.zx.usize - 1) 0 t.zx let o := (ST.Prim.Ref.swap t.r ⟨e, x, s.hd, (s.tl + 1) % e.size, s.u + sz⟩ (Void.mk ())).val if o.u = 0xFFFFFFFFFFFF then if h : (o.e.getD 0 t.z).hit w b n = true then ⟨_, Ent.hit_ok h⟩ else y else y else y def St.scan (s : St f) (t : Tab f) (w b : Array Word) (n : Nat) (a m : USize) : Nat → USize → {y // y = f w b n} | 0, _ => t.miss w b n a | p + 1, i => let k := i &&& m if h : k < s.x.usize then let c := s.x.uget k (ub h) if c == 0 then t.miss w b n a else let j := (c - 1).toUSize if hj : j < s.e.usize then let e := s.e.uget j (ul hj) if e.a == a then if hk : e.hit w b n = true then ⟨e.v, Ent.hit_ok hk⟩ else s.scan t w b n a m p (i + 1) else s.scan t w b n a m p (i + 1) else s.scan t w b n a m p (i + 1) else t.miss w b n a local instance {β : Type} (y : β) : Subsingleton {z // z = y} := ⟨fun p q => Subtype.ext (p.2.trans q.2.symm)⟩ @[inline] def Tab.get (t : Tab f) (w b : Array Word) (n : Nat) : {y // y = f w b n} := withPtrAddr w (fun a => let s := (ST.Prim.Ref.get t.r (Void.mk ())).val s.scan t w b n a (s.x.usize - 1) s.x.size (hs a)) (fun _ _ => Subsingleton.elim _ _) end Sr namespace Dense namespace F namespace Pn def dR (X : Array Word) (st : USize) : Nat → USize → USize → FloatArray → Float → FloatArray | 0, _, o, Y, a => wF Y o a | k + 1, q, o, Y, a => let v := rX X q; dR X st k (q + st) (o + 1) (wF Y o v) (a + v.abs) def us_e (Y : FloatArray) (i : USize) (v : Float) (h : i.toNat < Y.size) (hs : Y.size < 2 ^ 32) : Y.uset i v h = wF Y i v := by unfold wF; rw [dif_pos] have := USize.le_size rw [USize.lt_iff_toNat_lt, FloatArray.usize, toUSize_toNat (by omega)]; exact h def us_z (Y : FloatArray) (i : USize) (v : Float) (h : i.toNat < Y.size) : (Y.uset i v h).size = Y.size := by rcases Y with ⟨d⟩; simp only [FloatArray.uset, FloatArray.size, Array.uset]; apply Array.size_set def dU (X : Array Word) (st nu t q o : USize) (Y : FloatArray) (a : Float) (ht : t.toNat ≤ nu.toNat) (hb : o.toNat + (nu.toNat - t.toNat) < Y.size) (hs : Y.size < 2 ^ 32) : FloatArray := if h : t < nu then have htl := USize.lt_iff_toNat_lt.mp h have ul := USize.le_size let v := rX X q dU X st nu (t + 1) (q + st) (o + 1) (Y.uset o v (by omega)) (a + v.abs) (by rw [usucc h]; omega) (by rw [us_z, usucc h, uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega) (by rw [us_z]; exact hs) else Y.uset o a (by omega) termination_by nu.toNat - t.toNat decreasing_by (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def dU_eq (X : Array Word) (st nu : USize) : ∀ k (t q o : USize) (Y : FloatArray) (a : Float) (ht : t.toNat ≤ nu.toNat) (hb : o.toNat + (nu.toNat - t.toNat) < Y.size) (hs : Y.size < 2 ^ 32), nu.toNat - t.toNat = k → dU X st nu t q o Y a ht hb hs = dR X st k q o Y a := by intro k; induction k <;> intro t q o Y a ht hb hs hk ·rw [dU, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hk;omega), us_e _ _ _ _ hs, dR] rename_i k ih have h : t < nu := USize.lt_iff_toNat_lt.mpr (by clear*-hk;omega) rw [dU, dif_pos h]; dsimp only rw [ih _ _ _ _ _ _ _ _ (by rw [usucc h]; clear*-h hk ih;omega), us_e _ _ _ _ hs, dR] @[inline] def dQ (X : Array Word) (st : USize) (n : Nat) (q o : USize) (Y : FloatArray) : FloatArray := if h : n ≤ 4294967295 ∧ o.toNat + n < Y.size ∧ Y.size ≤ 4294967295 then have e : n.toUSize.toNat = n := toUSize_toNat (by have := USize.le_size; omega) dU X st n.toUSize 0 q o Y 0 (by simp) (by rw [e]; simp only [USize.toNat_zero, Nat.sub_zero]; exact h.2.1) (by have := h.2.2; omega) else dR X st n q o Y 0 def dQ_eq (X : Array Word) (st : USize) (n : Nat) (q o : USize) (Y : FloatArray) : dQ X st n q o Y = dR X st n q o Y 0 := by unfold dQ; split ·rename_i h have e : n.toUSize.toNat = n := toUSize_toNat (by have := USize.le_size; omega) exact dU_eq _ _ _ _ _ _ _ _ _ _ _ _ (by rw [e]; simp) ·rfl def dO (X : Array Word) (st s m : USize) (n : Nat) : Nat → USize → USize → FloatArray → FloatArray | 0, _, _, Y => Y | k + 1, q, o, Y => dO X st s m n k (q + s) (o + m) (dQ X st n q o Y) def qL (W : Array Word) (su m : USize) (n : Nat) : Nat → USize → FloatArray → FloatArray | 0, _, Y => Y | k + 1, q, Y => qL W su m n k (q + m) (bx W su 1 n q (q + 1) Y) def usf (q st : USize) (τ : Nat) : q + st + τ.toUSize * st = q + (τ + 1).toUSize * st := by rw [Nat.toUSize_eq, Nat.toUSize_eq, USize.ofNat_add, USize.add_mul, show USize.ofNat 1 = 1 from rfl, USize.one_mul, USize.add_assoc, USize.add_comm st] def uz (q st : USize) : q + (0 : Nat).toUSize * st = q := by simp [Nat.toUSize_eq, show USize.ofNat 0 = 0 from rfl] def dR_spec (X : Array Word) (st : USize) : ∀ k (q o : USize) (Y : FloatArray) (a : Float), Y.size < 2 ^ 32 → o.toNat + k < Y.size → (dR X st k q o Y a).size = Y.size ∧ (∀ i, i < Y.size → i < o.toNat ∨ o.toNat + k < i → (dR X st k q o Y a).data[i]! = Y.data[i]!) ∧ (∀ τ < k, (dR X st k q o Y a).data[o.toNat + τ]! = rX X (q + τ.toUSize * st)) ∧ (dR X st k q o Y a).data[o.toNat + k]! = sfold (fun τ => (rX X (q + τ.toUSize * st)).abs) k 0 a := by intro k; induction k with | zero => intro q o Y a hY ho rw [dR, wF_eq Y hY, sfold, if_neg (by omega)] refine ⟨ssz .., fun i h1 h2 => ?_, fun τ h => absurd h (by clear*-h;omega), ?_⟩ ·rw [sg _ _ _ _ h1, if_neg (by clear*-h2;omega)] ·rw [sg _ _ _ _ ho, if_pos (by clear*-;omega)] | succ k ih => intro q o Y a hY ho have := USize.le_size have h1 : (o + 1).toNat = o.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] rw [dR, wF_eq Y hY] obtain ⟨i1, i2, i3, i4⟩ := ih (q + st) (o + 1) (Y.set! o.toNat (rX X q)) (a + (rX X q).abs) (by rw [ssz]; exact hY) (by rw [ssz, h1]; clear*-ho;omega) rw [ssz] at i1 refine ⟨i1, fun i hi hc => ?_, fun τ h => ?_, ?_⟩ ·rw [i2 i (by rw [ssz]; exact hi) (by clear*-h1 hc;omega), sg _ _ _ _ hi, if_neg (by clear*-hc;omega)] ·rcases τ with _ | τ ·rw [i2 _ (by rw [ssz]; clear*-ho;omega) (by clear*-h1;omega), sg _ _ _ _ (by clear*-ho;omega), if_pos (by clear*-;omega), uz] ·have := i3 τ (by clear*-h;omega) rw [h1, show o.toNat + 1 + τ = o.toNat + (τ + 1) by clear*-;omega] at this rw [this, usf] ·have := i4 rw [h1, show o.toNat + 1 + k = o.toNat + (k + 1) by clear*-;omega] at this rw [this] conv_rhs => rw [sfold, if_pos (by clear*-;omega), sfold_shift _ k _ 0 _ rfl] simp only [usf, uz] def dO_spec (X : Array Word) (st s m : USize) (n : Nat) (hm : m.toNat = n + 1) (hn : n + 1 < 2 ^ 32) : ∀ k (q o : USize) (Y : FloatArray), Y.size < 2 ^ 32 → o.toNat + k * (n + 1) ≤ Y.size → (dO X st s m n k q o Y).size = Y.size ∧ (∀ i, i < Y.size → i < o.toNat → (dO X st s m n k q o Y).data[i]! = Y.data[i]!) ∧ (∀ j < k, ∀ τ < n, (dO X st s m n k q o Y).data[o.toNat + j * (n + 1) + τ]! = rX X (q + j.toUSize * s + τ.toUSize * st)) ∧ (∀ j < k, (dO X st s m n k q o Y).data[o.toNat + j * (n + 1) + n]! = sfold (fun τ => (rX X (q + j.toUSize * s + τ.toUSize * st)).abs) n 0 0) := by intro k; induction k with | zero => intro q o Y _ _; exact ⟨rfl, fun _ _ _ => rfl, fun j h => absurd h (by clear*-h;omega), fun j h => absurd h (by clear*-h;omega)⟩ | succ k ih => intro q o Y hY ho rw [Nat.succ_mul] at ho have := USize.le_size have h1 : (o + m).toNat = o.toNat + (n + 1) := by rw [uadd (by omega), hm] obtain ⟨r1, r2, r3, r4⟩ := dR_spec X st n q o Y 0 hY (by clear*-ho;omega) obtain ⟨i1, i2, i3, i4⟩ := ih (q + s) (o + m) (dR X st n q o Y 0) (by rw [r1]; exact hY) (by rw [r1, h1]; clear*-ho;omega) rw [r1] at i1 rw [dO, dQ_eq] refine ⟨i1, fun i hi hc => ?_, fun j h τ hτ => ?_, fun j h => ?_⟩ ·rw [i2 i (by rw [r1]; exact hi) (by clear*-h1 hc;omega), r2 i hi (by clear*-hc;omega)] ·rcases j with _ | j ·rw [Nat.zero_mul, Nat.add_zero, i2 _ (by rw [r1]; clear*-ho hτ;omega) (by clear*-h1 hτ;omega), r3 τ hτ, uz] ·have := i3 j (by clear*-h;omega) τ hτ rw [h1, show o.toNat + (n + 1) + j * (n + 1) = o.toNat + (j + 1) * (n + 1) by rw [Nat.succ_mul]; clear*-;omega] at this rw [this, usf] ·rcases j with _ | j ·rw [Nat.zero_mul, Nat.add_zero, i2 _ (by rw [r1]; clear*-ho;omega) (by clear*-h1;omega), r4] simp only [uz] ·have := i4 j (by clear*-h;omega) rw [h1, show o.toNat + (n + 1) + j * (n + 1) = o.toNat + (j + 1) * (n + 1) by rw [Nat.succ_mul]; clear*-;omega] at this rw [this]; simp only [usf] def qL_spec (W : Array Word) (su m : USize) (n : Nat) (hm : m.toNat = 8 * n) (hu : su.toNat = n) : ∀ k (q : USize) (Y : FloatArray), 2 * (q.toNat + k * (8 * n)) + 32 * n < 2 ^ 32 → q.toNat + k * (8 * n) + 1 ≤ Y.size → (qL W su m n k q Y).size = Y.size ∧ (∀ i, i < q.toNat + 1 → (qL W su m n k q Y).data[i]! = Y.data[i]!) ∧ ∀ g < k, ∀ τ < n, ∀ r < 8, (qL W su m n k q Y).data[q.toNat + g * (8 * n) + 1 + 8 * τ + r]! = dw W[q.toNat + g * (8 * n) + τ + r * n]! := by intro k; induction k with | zero => intro q Y _ _; exact ⟨rfl, fun _ _ => rfl, fun g h => absurd h (by clear*-h;omega)⟩ | succ k ih => intro q Y hB hY rw [Nat.add_mul, Nat.one_mul] at hB hY have := USize.le_size have h1 : (q + m).toNat = q.toNat + 8 * n := by rw [uadd (by clear hY hu ih;omega), hm] have h2 : (q + 1).toNat = q.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; clear*-h1 hB this;omega)]; simp only [USize.reduceToNat] obtain ⟨r1, r2, r3⟩ := bx_spec W su 1 n q (q + 1) Y (by simp only [USize.reduceToNat, h2]; clear*-hB hu this;omega) (by rw [h2]; clear*-hY;omega) simp only [USize.reduceToNat, Nat.mul_one, hu, h2] at r2 r3 obtain ⟨i1, i2, i3⟩ := ih (q + m) (bx W su 1 n q (q + 1) Y) (by rw [h1]; clear*-hB;omega) (by rw [r1, h1]; clear*-hY;omega) rw [r1] at i1 rw [qL] refine ⟨i1, fun i hi => ?_, fun g h τ hτ r hr => ?_⟩ ·rw [i2 i (by clear*-h1 hi;omega), r2 i hi] ·rcases g with _ | g ·rw [Nat.zero_mul, Nat.add_zero, i2 _ (by rw [h1]; clear*-hr hτ;omega), r3 τ r hτ hr, Nat.add_zero] ·have := i3 g (by clear*-h;omega) τ hτ r hr rw [h1, show q.toNat + 8 * n + g * (8 * n) = q.toNat + (g + 1) * (8 * n) by rw [Nat.add_mul, Nat.one_mul]; clear*-;omega] at this exact this @[inline] def pp (V P : FloatArray) (vo xb r s : Nat) : Float := V.get! (vo + s) * P.get! (xb + 8 * s + r) def sU (V P : FloatArray) (vo nu : USize) (hV : vo.toNat + nu.toNat ≤ V.size) (hu : V.size + P.size + 16 < 2 ^ 32) (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size + 7) (a : Float) (m : UInt64) : Float × UInt64 := if h : t < nu then have ht := USize.lt_iff_toNat_lt.mp h have := USize.le_size let a' := a + V.uget (vo + t) (by rw [uadd (by omega)]; omega) * P.uget i (by omega) let e := eF a'.toBits sU V P vo nu hV hu (t + 1) (i + 8) (by rw [usucc h, uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega) a' (if m < e then e else m) else (a, m) termination_by nu.toNat - t.toNat decreasing_by all_goals (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def sU_eq (V P : FloatArray) (vo nu : USize) (hV : vo.toNat + nu.toNat ≤ V.size) (hu : V.size + P.size + 16 < 2 ^ 32) (xb r : Nat) : ∀ k (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size + 7) (a : Float) (m : UInt64), nu.toNat - t.toNat = k → i.toNat = xb + 8 * t.toNat + r → sU V P vo nu hV hu t i hi a m = sT (pp V P vo.toNat xb r) nu.toNat t.toNat a m := by intro k; induction k <;> intro t i hi a m hk hx ·rw [sU, sT, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hk;omega), if_neg (by clear*-hk;omega)] rename_i ih have := USize.le_size have ht : t.toNat < nu.toNat := by clear*-hk;omega have h : t < nu := USize.lt_iff_toNat_lt.mpr ht rw [sU, sT, dif_pos h, if_pos ht]; dsimp only have hp : ∀ (h1 : (vo + t).toNat < V.size) (h2 : i.toNat < P.size), V.uget (vo + t) h1 * P.uget i h2 = pp V P vo.toNat xb r t.toNat := fun h1 h2 => by rw [ug, ug, pp, gg, gg, uadd (by clear h h1 hi hk ht ih;omega), hx] rw [hp, ih (t + 1) (i + 8) _ _ _ (by rw [usucc h]; omega) (by rw [usucc h, uadd (by simp only [USize.reduceToNat]; omega), hx]; simp only [USize.reduceToNat]; omega), usucc h] @[inline] def tR (relu : Bool) (L : Nat) (q : Float × UInt64) (fbk : Unit → Word) : Word := let c := if 1 ≤ q.2.toNat ∧ q.2.toNat ≤ 1993 ∧ 1076 ≤ q.2.toNat + L then cert2 q.1 (q.2.toNat + L - 1076).toUInt64 else 0x100000000 if c < 0x100000000 then act relu c.toUInt32 else fbk () @[noinline] def sQ (n : Nat) (relu : Bool) (X W b : @& Array Word) (V P : @& FloatArray) (vo xb r xo st j : Nat) : Word := if h : vo + n ≤ V.size ∧ V.size + P.size + 16 < 2 ^ 32 ∧ xb + r + 8 * n ≤ P.size + 7 then tR relu (Nat.log2 (n + 1) + 1) (sU V P vo.toUSize n.toUSize (by rw [toUSize_toNat (by have := USize.le_size; omega), toUSize_toNat (by have := USize.le_size; omega)]; exact h.1) h.2.1 0 (xb + r).toUSize (by rw [toUSize_toNat (by have := USize.le_size; omega), toUSize_toNat (by have := USize.le_size; omega)]; simp only [USize.toNat_zero]; omega) (dw oneW * dw b[j]!) 0) fun _ => cellFB n relu X W b xo st j else tS relu (Nat.log2 (n + 1) + 1) n (pp V P vo xb r) (fun _ => dw oneW * dw b[j]!) fun _ => cellFB n relu X W b xo st j def sQ_eq (n : Nat) (relu : Bool) (X W b : Array Word) (V P : FloatArray) (vo xb r xo st j : Nat) : sQ n relu X W b V P vo xb r xo st j = tS relu (Nat.log2 (n + 1) + 1) n (pp V P vo xb r) (fun _ => dw oneW * dw b[j]!) fun _ => cellFB n relu X W b xo st j := by unfold sQ; split; swap; · rfl rename_i h have ul := USize.le_size have e1 : vo.toUSize.toNat = vo := toUSize_toNat (by omega) have e2 : n.toUSize.toNat = n := toUSize_toNat (by clear e1;omega) have e3 : (xb + r).toUSize.toNat = xb + r := toUSize_toNat (by clear*-h ul;omega) rw [sU_eq _ _ _ _ _ _ xb r _ _ _ _ _ _ rfl (by rw [e3]; simp only [USize.toNat_zero]; clear*-;omega), e1, e2] rfl @[inline] def pO (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o r : Nat) (V P : FloatArray) (vo : USize) (q : USize) (on : Bool) (acc : Array Word) (S : Float) : Array Word := if h : on = true ∧ q < acc.usize then acc.uset q (if ok then tfB relu S hh (fun _ => sQ n relu X W b V P vo.toNat (o * n + 1) r xo st (o + r)) else cellFB n relu X W b xo st (o + r)) (ulen h.2) else acc @[noinline] def fP (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (V P : FloatArray) (vo : USize) (a0 a1 a2 a3 a4 a5 a6 a7 : Float) (acc : Array Word) : Array Word := pO relu ok hh n X W b xo st o 7 V P vo (q0 + 7 * so) (decide (7 < mu)) (pO relu ok hh n X W b xo st o 6 V P vo (q0 + 6 * so) (decide (6 < mu)) (pO relu ok hh n X W b xo st o 5 V P vo (q0 + 5 * so) (decide (5 < mu)) (pO relu ok hh n X W b xo st o 4 V P vo (q0 + 4 * so) (decide (4 < mu)) (pO relu ok hh n X W b xo st o 3 V P vo (q0 + 3 * so) (decide (3 < mu)) (pO relu ok hh n X W b xo st o 2 V P vo (q0 + 2 * so) (decide (2 < mu)) (pO relu ok hh n X W b xo st o 1 V P vo (q0 + 1 * so) (decide (1 < mu)) (pO relu ok hh n X W b xo st o 0 V P vo (q0 + 0 * so) (decide (0 < mu)) acc a0) a1) a2) a3) a4) a5) a6) a7 def fP_spec (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (V P : FloatArray) (vo : USize) (a0 a1 a2 a3 a4 a5 a6 a7 : Float) (acc : Array Word) (F : Nat → Word) (hq0 : q0.toNat + 8 * so.toNat ≤ 4294967295) (hz : acc.size ≤ 4294967295) (hv : ∀ k < 8, k < mu.toNat → (if ok then tfB relu (A8.f ⟨a0, a1, a2, a3, a4, a5, a6, a7⟩ k) hh (fun _ => sQ n relu X W b V P vo.toNat (o * n + 1) k xo st (o + k)) else cellFB n relu X W b xo st (o + k)) = F (q0.toNat + k * so.toNat)) : Iv F acc (fun q => ∃ k, k < 8 ∧ k < mu.toNat ∧ q = q0.toNat + k * so.toNat) (fP relu ok hh n X W b xo st o q0 so mu V P vo a0 a1 a2 a3 a4 a5 a6 a7 acc) := by let I j := q0.toNat + j * so.toNat let Q k := Iv F acc fun q => ∃ j, j < k ∧ j < mu.toNat ∧ q = I j have ul := USize.le_size have st' : ∀ k {a qk on}, Q k a → k < 8 → (k < mu.toNat → USize.toNat qk = I k) → on = decide (k < mu.toNat) → Q (k + 1) (pO relu ok hh n X W b xo st o k V P vo qk on a (A8.f ⟨a0, a1, a2, a3, a4, a5, a6, a7⟩ k)) := by intro k a qk on ⟨h1, h2⟩ hk hq hon unfold pO; split next hc => have hk' : k < mu.toNat := by simpa [hon] using hc.1 refine ⟨by simp [h1], fun q => ?_⟩ rw [Array.uset_eq_set, Array.getElem?_set, hv k hk hk'] by_cases h : qk.toNat = q ·subst h; simp [hq hk', I] ·rw [if_neg h] exact ⟨(h2 q).1, fun ⟨j, hj, h3, h4⟩ => (h2 q).2 ⟨j, Nat.lt_of_le_of_ne (Nat.le_of_lt_succ hj) fun e => by subst e; exact h ((hq h3).trans h4.symm), h3, h4⟩⟩ next hc => refine ⟨h1, fun q => ⟨(h2 q).1, fun ⟨j, hj, h3, h4⟩ hq' => (h2 q).2 ⟨j, Nat.lt_of_le_of_ne (Nat.le_of_lt_succ hj) fun e => hc ⟨by simp [hon]; clear*-e h3;omega, ?_⟩, h3, h4⟩ hq'⟩⟩ subst e; rw [USize.lt_iff_toNat_lt, Array.usize, toUSize_toNat (by clear*-h1 hz ul;omega), hq h3, ← h4]; clear*-h1 hq';omega have hqk : ∀ c : USize, c.toNat < 8 → (q0 + c * so).toNat = q0.toNat + c.toNat * so.toNat := fun c hc => by have m1 : c.toNat * so.toNat ≤ 8 * so.toNat := Nat.mul_le_mul_right _ hc.le have e : (c * so).toNat = c.toNat * so.toNat := by rw [USize.toNat_mul, ← USize.size_eq_two_pow, Nat.mod_eq_of_lt (by omega)] rw [uadd (by omega), e] unfold fP refine st' 7 (st' 6 (st' 5 (st' 4 (st' 3 (st' 2 (st' 1 (st' 0 ?_ ?_ ?_ ?_) ?_ ?_ ?_) ?_ ?_ ?_) ?_ ?_ ?_) ?_ ?_ ?_) ?_ ?_ ?_) ?_ ?_ ?_) ?_ ?_ ?_ all_goals first | decide | (intro _; rw [hqk _ (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat, I]) | simp only [USize.lt_iff_toNat_lt, USize.reduceToNat] | simp [Q, Iv] def pk (V P : FloatArray) (vo nu : USize) (hs : V.size < 2 ^ 32 ∧ P.size < 2 ^ 32) (hV : vo.toNat + nu.toNat ≤ V.size) (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size) (a0 a1 a2 a3 a4 a5 a6 a7 : Float) (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (acc : Array Word) : Array Word := if h : t < nu then have ht := USize.lt_iff_toNat_lt.mp h have hI : i.toNat + 8 ≤ P.size := by omega have hJ : (i + 8).toNat + 8 * (nu.toNat - (t + 1).toNat) ≤ P.size := by rw [usucc h, uadd (by have := USize.le_size; simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega let x := V.uget (vo + t) (by have := USize.le_size; rw [uadd (by omega)]; omega) let b0 := a0 + x * P.uget (i + 0) (uk (by simp) hI hs.2) let b1 := a1 + x * P.uget (i + 1) (uk (by simp) hI hs.2) let b2 := a2 + x * P.uget (i + 2) (uk (by simp) hI hs.2) let b3 := a3 + x * P.uget (i + 3) (uk (by simp) hI hs.2) if mu ≤ 4 then pk V P vo nu hs hV (t + 1) (i + 8) hJ b0 b1 b2 b3 a4 a5 a6 a7 relu ok hh n X W b xo st o q0 so mu acc else let b4 := a4 + x * P.uget (i + 4) (uk (by simp) hI hs.2) let b5 := a5 + x * P.uget (i + 5) (uk (by simp) hI hs.2) let b6 := a6 + x * P.uget (i + 6) (uk (by simp) hI hs.2) let b7 := a7 + x * P.uget (i + 7) (uk (by simp) hI hs.2) pk V P vo nu hs hV (t + 1) (i + 8) hJ b0 b1 b2 b3 b4 b5 b6 b7 relu ok hh n X W b xo st o q0 so mu acc else fP relu ok hh n X W b xo st o q0 so mu V P vo a0 a1 a2 a3 a4 a5 a6 a7 acc termination_by nu.toNat - t.toNat decreasing_by all_goals (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def pO_off (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o r : Nat) (V P : FloatArray) (vo q : USize) (acc : Array Word) (S : Float) : pO relu ok hh n X W b xo st o r V P vo q false acc S = acc := by simp [pO] def pk_eq (V P : FloatArray) (vo nu : USize) (hs : V.size < 2 ^ 32 ∧ P.size < 2 ^ 32) (hV : vo.toNat + nu.toNat ≤ V.size) (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (acc : Array Word) (xb : Nat) : ∀ m (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size) (a0 a1 a2 a3 a4 a5 a6 a7 : Float), nu.toNat - t.toNat = m → i.toNat = xb + 8 * t.toNat → pk V P vo nu hs hV t i hi a0 a1 a2 a3 a4 a5 a6 a7 relu ok hh n X W b xo st o q0 so mu acc = fP relu ok hh n X W b xo st o q0 so mu V P vo (sfold (pp V P vo.toNat xb 0) nu.toNat t.toNat a0) (sfold (pp V P vo.toNat xb 1) nu.toNat t.toNat a1) (sfold (pp V P vo.toNat xb 2) nu.toNat t.toNat a2) (sfold (pp V P vo.toNat xb 3) nu.toNat t.toNat a3) (sfold (pp V P vo.toNat xb 4) nu.toNat t.toNat a4) (sfold (pp V P vo.toNat xb 5) nu.toNat t.toNat a5) (sfold (pp V P vo.toNat xb 6) nu.toNat t.toNat a6) (sfold (pp V P vo.toNat xb 7) nu.toNat t.toNat a7) acc := by intro m; induction m <;> intro t i hi a0 a1 a2 a3 a4 a5 a6 a7 hm hx ·rw [pk, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hm;omega)] have e : ∀ p a, sfold p nu.toNat t.toNat a = a := fun p a => by rw [sfold, if_neg (by clear*-hm;omega)] simp only [e] rename_i ih have := USize.le_size have ht : t.toNat < nu.toNat := by clear*-hm;omega have h : t < nu := USize.lt_iff_toNat_lt.mpr ht have h8 : (i + 8).toNat = i.toNat + 8 := by rw [uadd (by simp only [USize.reduceToNat]; clear h hV ht hx ih;omega)]; simp only [USize.reduceToNat] have hw : (vo + t).toNat = vo.toNat + t.toNat := uadd (by clear*-hV hs ht this;omega) have sp : ∀ r a, sfold (pp V P vo.toNat xb r) nu.toNat t.toNat a = sfold (pp V P vo.toNat xb r) nu.toNat (t.toNat + 1) (a + pp V P vo.toNat xb r t.toNat) := fun r a => by rw [sfold, if_pos ht] have e : ∀ (c : USize) (r : Nat) (hc : c.toNat = r) (hr : r < 8) (h1 : (vo + t).toNat < V.size) (h2 : (i + c).toNat < P.size), V.uget (vo + t) h1 * P.uget (i + c) h2 = pp V P vo.toNat xb r t.toNat := fun c r hc hr h1 h2 => by rw [ug, ug, pp, gg, gg, hw, uadd (by clear*-hc hi hm hr hs this;omega), hx, hc] have c : ∀ {k : USize}, mu.toNat ≤ k.toNat → decide (k < mu) = false := fun e => by rw [decide_eq_false_iff_not, USize.lt_iff_toNat_lt]; clear*-e;omega rw [pk, dif_pos h] split_ifs <;> rw [ih (t + 1) (i + 8) _ _ _ _ _ _ _ _ _ (by rw [usucc h]; clear*-hm ht;omega) (by rw [usucc h, h8, hx]; ring), usucc h] <;> simp only [USize.le_iff_toNat_le, USize.reduceToNat] at * <;> simp (disch := simp only [USize.reduceToNat]; omega) only [sp, e 0 0 (by simp) (by clear*-;omega), e 1 1 (by simp) (by clear*-;omega), e 2 2 (by simp) (by clear*-;omega), e 3 3 (by simp) (by clear*-;omega), e 4 4 (by simp) (by clear*-;omega), e 5 5 (by simp) (by clear*-;omega), e 6 6 (by simp) (by clear*-;omega), e 7 7 (by simp) (by clear*-;omega), fP, c, pO_off] def u32 {i k : USize} {S : Nat} (hk : k.toNat < 32) (h : i.toNat + 32 ≤ S) (hs : S < 2 ^ 32) : (i + k).toNat < S := by have := USize.le_size rw [uadd (by omega)]; omega def p4 (V P : FloatArray) (vo nu e : USize) (hs : V.size < 2 ^ 32 ∧ P.size < 2 ^ 32) (hV : vo.toNat + nu.toNat ≤ V.size) (he : e.toNat = 0 ∨ e.toNat + 3 ≤ nu.toNat) (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size) (a0 a1 a2 a3 a4 a5 a6 a7 : Float) (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (acc : Array Word) : Array Word := if h : t < e then have ht := USize.lt_iff_toNat_lt.mp h have ul := USize.le_size have hI : i.toNat + 32 ≤ P.size := by omega have h4 : (t + 4).toNat = t.toNat + 4 := by rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] have hJ : (i + 32).toNat + 8 * (nu.toNat - (t + 4).toNat) ≤ P.size := by rw [h4, uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega have hw : (vo + t).toNat = vo.toNat + t.toNat := uadd (by omega) have hW : ∀ k : USize, k.toNat < 4 → (vo + t + k).toNat < V.size := fun k hk => by rw [uadd (by omega), hw]; omega let w := vo + t let x0 := V.uget (w + 0) (hW _ (by simp)) let x1 := V.uget (w + 1) (hW _ (by simp)) let x2 := V.uget (w + 2) (hW _ (by simp)) let x3 := V.uget (w + 3) (hW _ (by simp)) let b0 := a0 + x0 * P.uget (i + 0) (u32 (by simp) hI hs.2) let b1 := a1 + x0 * P.uget (i + 1) (u32 (by simp) hI hs.2) let b2 := a2 + x0 * P.uget (i + 2) (u32 (by simp) hI hs.2) let b3 := a3 + x0 * P.uget (i + 3) (u32 (by simp) hI hs.2) let b4 := a4 + x0 * P.uget (i + 4) (u32 (by simp) hI hs.2) let b5 := a5 + x0 * P.uget (i + 5) (u32 (by simp) hI hs.2) let b6 := a6 + x0 * P.uget (i + 6) (u32 (by simp) hI hs.2) let b7 := a7 + x0 * P.uget (i + 7) (u32 (by simp) hI hs.2) let c0 := b0 + x1 * P.uget (i + 8) (u32 (by simp) hI hs.2) let c1 := b1 + x1 * P.uget (i + 9) (u32 (by simp) hI hs.2) let c2 := b2 + x1 * P.uget (i + 10) (u32 (by simp) hI hs.2) let c3 := b3 + x1 * P.uget (i + 11) (u32 (by simp) hI hs.2) let c4 := b4 + x1 * P.uget (i + 12) (u32 (by simp) hI hs.2) let c5 := b5 + x1 * P.uget (i + 13) (u32 (by simp) hI hs.2) let c6 := b6 + x1 * P.uget (i + 14) (u32 (by simp) hI hs.2) let c7 := b7 + x1 * P.uget (i + 15) (u32 (by simp) hI hs.2) let d0 := c0 + x2 * P.uget (i + 16) (u32 (by simp) hI hs.2) let d1 := c1 + x2 * P.uget (i + 17) (u32 (by simp) hI hs.2) let d2 := c2 + x2 * P.uget (i + 18) (u32 (by simp) hI hs.2) let d3 := c3 + x2 * P.uget (i + 19) (u32 (by simp) hI hs.2) let d4 := c4 + x2 * P.uget (i + 20) (u32 (by simp) hI hs.2) let d5 := c5 + x2 * P.uget (i + 21) (u32 (by simp) hI hs.2) let d6 := c6 + x2 * P.uget (i + 22) (u32 (by simp) hI hs.2) let d7 := c7 + x2 * P.uget (i + 23) (u32 (by simp) hI hs.2) let e0 := d0 + x3 * P.uget (i + 24) (u32 (by simp) hI hs.2) let e1 := d1 + x3 * P.uget (i + 25) (u32 (by simp) hI hs.2) let e2 := d2 + x3 * P.uget (i + 26) (u32 (by simp) hI hs.2) let e3 := d3 + x3 * P.uget (i + 27) (u32 (by simp) hI hs.2) let e4 := d4 + x3 * P.uget (i + 28) (u32 (by simp) hI hs.2) let e5 := d5 + x3 * P.uget (i + 29) (u32 (by simp) hI hs.2) let e6 := d6 + x3 * P.uget (i + 30) (u32 (by simp) hI hs.2) let e7 := d7 + x3 * P.uget (i + 31) (u32 (by simp) hI hs.2) p4 V P vo nu e hs hV he (t + 4) (i + 32) hJ e0 e1 e2 e3 e4 e5 e6 e7 relu ok hh n X W b xo st o q0 so mu acc else pk V P vo nu hs hV t i hi a0 a1 a2 a3 a4 a5 a6 a7 relu ok hh n X W b xo st o q0 so mu acc termination_by nu.toNat - t.toNat decreasing_by have ht := USize.lt_iff_toNat_lt.mp h have ul := USize.le_size rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega def p4_eq (V P : FloatArray) (vo nu e : USize) (hs : V.size < 2 ^ 32 ∧ P.size < 2 ^ 32) (hV : vo.toNat + nu.toNat ≤ V.size) (he : e.toNat = 0 ∨ e.toNat + 3 ≤ nu.toNat) (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (acc : Array Word) (xb : Nat) : ∀ m (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size) (a0 a1 a2 a3 a4 a5 a6 a7 : Float), nu.toNat - t.toNat ≤ m → i.toNat = xb + 8 * t.toNat → p4 V P vo nu e hs hV he t i hi a0 a1 a2 a3 a4 a5 a6 a7 relu ok hh n X W b xo st o q0 so mu acc = fP relu ok hh n X W b xo st o q0 so mu V P vo (sfold (pp V P vo.toNat xb 0) nu.toNat t.toNat a0) (sfold (pp V P vo.toNat xb 1) nu.toNat t.toNat a1) (sfold (pp V P vo.toNat xb 2) nu.toNat t.toNat a2) (sfold (pp V P vo.toNat xb 3) nu.toNat t.toNat a3) (sfold (pp V P vo.toNat xb 4) nu.toNat t.toNat a4) (sfold (pp V P vo.toNat xb 5) nu.toNat t.toNat a5) (sfold (pp V P vo.toNat xb 6) nu.toNat t.toNat a6) (sfold (pp V P vo.toNat xb 7) nu.toNat t.toNat a7) acc := by have ul := USize.le_size intro m; induction m <;> intro t i hi a0 a1 a2 a3 a4 a5 a6 a7 hm hx ·rw [p4]; split ·rename_i h have := USize.lt_iff_toNat_lt.mp h omega ·exact pk_eq V P vo nu hs hV relu ok hh n X W b xo st o q0 so mu acc xb _ t i hi _ _ _ _ _ _ _ _ rfl hx rename_i m ih rw [p4]; split swap ·exact pk_eq V P vo nu hs hV relu ok hh n X W b xo st o q0 so mu acc xb _ t i hi _ _ _ _ _ _ _ _ rfl hx rename_i h have ht := USize.lt_iff_toNat_lt.mp h have h4 : (t + 4).toNat = t.toNat + 4 := by rw [uadd (by simp only [USize.reduceToNat]; clear*-hi hs hx ul;omega)]; simp only [USize.reduceToNat] have h32 : (i + 32).toNat = i.toNat + 32 := by rw [uadd (by simp only [USize.reduceToNat]; clear*-he hi hs ht ul;omega)]; simp only [USize.reduceToNat] have hw : (vo + t).toNat = vo.toNat + t.toNat := uadd (by clear*-hV he hs ht ul;omega) have sp : ∀ r a, sfold (pp V P vo.toNat xb r) nu.toNat t.toNat a = sfold (pp V P vo.toNat xb r) nu.toNat (t.toNat + 4) ((((a + pp V P vo.toNat xb r t.toNat) + pp V P vo.toNat xb r (t.toNat + 1)) + pp V P vo.toNat xb r (t.toNat + 2)) + pp V P vo.toNat xb r (t.toNat + 3)) := fun r a => by rw [sfold, if_pos (by clear*-he ht;omega), sfold, if_pos (by clear*-he ht;omega), sfold, if_pos (by clear*-he ht;omega), sfold, if_pos (by clear*-he ht;omega)] have e0 : ∀ (d c : USize) (u r : Nat) (hd : d.toNat = u) (hc : c.toNat = 8 * u + r) (hu : u < 4) (hr : r < 8) (h1 : (vo + t + d).toNat < V.size) (h2 : (i + c).toNat < P.size), V.uget (vo + t + d) h1 * P.uget (i + c) h2 = pp V P vo.toNat xb r (t.toNat + u) := fun d c u r hd hc hu hr h1 h2 => by rw [ug, ug, pp, gg, gg, uadd (by rw [hw]; clear*-hV hd he hs ht hu ul;omega), hw, uadd (by clear*-h32 hc he hi hr hs ht hu ul;omega), hx, hc, hd] rw [show vo.toNat + t.toNat + u = vo.toNat + (t.toNat + u) by clear*-;omega, show xb + 8 * t.toNat + (8 * u + r) = xb + 8 * (t.toNat + u) + r by clear*-;omega] dsimp only rw [ih (t + 4) (i + 32) _ _ _ _ _ _ _ _ _ (by rw [h4]; clear*-hm;omega) (by rw [h32, h4, hx]; ring), h4] simp only [sp, Nat.add_zero, e0 0 0 0 0 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 1 0 1 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 2 0 2 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 3 0 3 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 4 0 4 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 5 0 5 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 6 0 6 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 0 7 0 7 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 8 1 0 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 9 1 1 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 10 1 2 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 11 1 3 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 12 1 4 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 13 1 5 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 14 1 6 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 1 15 1 7 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 16 2 0 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 17 2 1 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 18 2 2 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 19 2 3 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 20 2 4 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 21 2 5 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 22 2 6 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 2 23 2 7 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 24 3 0 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 25 3 1 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 26 3 2 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 27 3 3 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 28 3 4 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 29 3 5 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 30 3 6 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega), e0 3 31 3 7 (by simp) (by simp) (by clear*-;omega) (by clear*-;omega)] def pk2 (V P : FloatArray) (vo wo nu : USize) (hs : V.size < 2 ^ 32 ∧ P.size < 2 ^ 32) (hV : vo.toNat + nu.toNat ≤ V.size) (hW : wo.toNat + nu.toNat ≤ V.size) (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size) (a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Float) (relu ok ok2 : Bool) (hh hh2 : UInt64) (n : Nat) (X W b : Array Word) (xo xo2 st o : Nat) (q0 q2 so mu : USize) (acc : Array Word) : Array Word := if h : t < nu then have ht := USize.lt_iff_toNat_lt.mp h have ul := USize.le_size have hI : i.toNat + 8 ≤ P.size := by omega have hJ : (i + 8).toNat + 8 * (nu.toNat - (t + 1).toNat) ≤ P.size := by rw [usucc h, uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega let x := V.uget (vo + t) (by rw [uadd (by omega)]; omega) let y := V.uget (wo + t) (by rw [uadd (by omega)]; omega) let p0 := P.uget (i + 0) (uk (by simp) hI hs.2) let p1 := P.uget (i + 1) (uk (by simp) hI hs.2) let p2 := P.uget (i + 2) (uk (by simp) hI hs.2) let p3 := P.uget (i + 3) (uk (by simp) hI hs.2) let p4 := P.uget (i + 4) (uk (by simp) hI hs.2) let p5 := P.uget (i + 5) (uk (by simp) hI hs.2) let p6 := P.uget (i + 6) (uk (by simp) hI hs.2) let p7 := P.uget (i + 7) (uk (by simp) hI hs.2) let c0 := a0 + x * p0 let c1 := a1 + x * p1 let c2 := a2 + x * p2 let c3 := a3 + x * p3 let c4 := a4 + x * p4 let c5 := a5 + x * p5 let c6 := a6 + x * p6 let c7 := a7 + x * p7 let d0 := b0 + y * p0 let d1 := b1 + y * p1 let d2 := b2 + y * p2 let d3 := b3 + y * p3 let d4 := b4 + y * p4 let d5 := b5 + y * p5 let d6 := b6 + y * p6 let d7 := b7 + y * p7 pk2 V P vo wo nu hs hV hW (t + 1) (i + 8) hJ c0 c1 c2 c3 c4 c5 c6 c7 d0 d1 d2 d3 d4 d5 d6 d7 relu ok ok2 hh hh2 n X W b xo xo2 st o q0 q2 so mu acc else fP relu ok2 hh2 n X W b xo2 st o q2 so mu V P wo b0 b1 b2 b3 b4 b5 b6 b7 (fP relu ok hh n X W b xo st o q0 so mu V P vo a0 a1 a2 a3 a4 a5 a6 a7 acc) termination_by nu.toNat - t.toNat decreasing_by (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def pk2_eq (V P : FloatArray) (vo wo nu : USize) (hs : V.size < 2 ^ 32 ∧ P.size < 2 ^ 32) (hV : vo.toNat + nu.toNat ≤ V.size) (hW : wo.toNat + nu.toNat ≤ V.size) (relu ok ok2 : Bool) (hh hh2 : UInt64) (n : Nat) (X W b : Array Word) (xo xo2 st o : Nat) (q0 q2 so mu : USize) (acc : Array Word) (xb : Nat) : ∀ m (t i : USize) (hi : i.toNat + 8 * (nu.toNat - t.toNat) ≤ P.size) (a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 : Float), nu.toNat - t.toNat = m → i.toNat = xb + 8 * t.toNat → pk2 V P vo wo nu hs hV hW t i hi a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 relu ok ok2 hh hh2 n X W b xo xo2 st o q0 q2 so mu acc = fP relu ok2 hh2 n X W b xo2 st o q2 so mu V P wo (sfold (pp V P wo.toNat xb 0) nu.toNat t.toNat b0) (sfold (pp V P wo.toNat xb 1) nu.toNat t.toNat b1) (sfold (pp V P wo.toNat xb 2) nu.toNat t.toNat b2) (sfold (pp V P wo.toNat xb 3) nu.toNat t.toNat b3) (sfold (pp V P wo.toNat xb 4) nu.toNat t.toNat b4) (sfold (pp V P wo.toNat xb 5) nu.toNat t.toNat b5) (sfold (pp V P wo.toNat xb 6) nu.toNat t.toNat b6) (sfold (pp V P wo.toNat xb 7) nu.toNat t.toNat b7) (fP relu ok hh n X W b xo st o q0 so mu V P vo (sfold (pp V P vo.toNat xb 0) nu.toNat t.toNat a0) (sfold (pp V P vo.toNat xb 1) nu.toNat t.toNat a1) (sfold (pp V P vo.toNat xb 2) nu.toNat t.toNat a2) (sfold (pp V P vo.toNat xb 3) nu.toNat t.toNat a3) (sfold (pp V P vo.toNat xb 4) nu.toNat t.toNat a4) (sfold (pp V P vo.toNat xb 5) nu.toNat t.toNat a5) (sfold (pp V P vo.toNat xb 6) nu.toNat t.toNat a6) (sfold (pp V P vo.toNat xb 7) nu.toNat t.toNat a7) acc) := by intro m; induction m <;> intro t i hi a0 a1 a2 a3 a4 a5 a6 a7 b0 b1 b2 b3 b4 b5 b6 b7 hm hx ·rw [pk2, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hm;omega)] have e : ∀ p a, sfold p nu.toNat t.toNat a = a := fun p a => by rw [sfold, if_neg (by clear*-hm;omega)] simp only [e] rename_i ih have := USize.le_size have ht : t.toNat < nu.toNat := by clear*-hm;omega have h : t < nu := USize.lt_iff_toNat_lt.mpr ht have h8 : (i + 8).toNat = i.toNat + 8 := by rw [uadd (by simp only [USize.reduceToNat]; clear*-hi hm hs this;omega)]; simp only [USize.reduceToNat] have sp : ∀ (u r a), sfold (pp V P u xb r) nu.toNat t.toNat a = sfold (pp V P u xb r) nu.toNat (t.toNat + 1) (a + pp V P u xb r t.toNat) := fun u r a => by rw [sfold, if_pos ht] have e : ∀ (u : USize) (c : USize) (r : Nat) (hc : c.toNat = r) (hr : r < 8) (hu : u.toNat + nu.toNat ≤ V.size) (h1 : (u + t).toNat < V.size) (h2 : (i + c).toNat < P.size), V.uget (u + t) h1 * P.uget (i + c) h2 = pp V P u.toNat xb r t.toNat := fun u c r hc hr hu h1 h2 => by rw [ug, ug, pp, gg, gg, uadd (by clear*-hs ht hu this;omega), uadd (by clear*-hc hi hm hr hs this;omega), hx, hc] rw [pk2, dif_pos h]; dsimp only rw [ih (t + 1) (i + 8) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (by rw [usucc h]; clear*-hm ht;omega) (by rw [usucc h, h8, hx]; ring), usucc h] simp (disch := simp only [USize.reduceToNat]; omega) only [sp, e vo 0 0 (by simp) (by clear*-;omega) hV, e vo 1 1 (by simp) (by clear*-;omega) hV, e vo 2 2 (by simp) (by clear*-;omega) hV, e vo 3 3 (by simp) (by clear*-;omega) hV, e vo 4 4 (by simp) (by clear*-;omega) hV, e vo 5 5 (by simp) (by clear*-;omega) hV, e vo 6 6 (by simp) (by clear*-;omega) hV, e vo 7 7 (by simp) (by clear*-;omega) hV, e wo 0 0 (by simp) (by clear*-;omega) hW, e wo 1 1 (by simp) (by clear*-;omega) hW, e wo 2 2 (by simp) (by clear*-;omega) hW, e wo 3 3 (by simp) (by clear*-;omega) hW, e wo 4 4 (by simp) (by clear*-;omega) hW, e wo 5 5 (by simp) (by clear*-;omega) hW, e wo 6 6 (by simp) (by clear*-;omega) hW, e wo 7 7 (by simp) (by clear*-;omega) hW] def J (D : ByteArray) (p : Nat) : Nat := D.data[p]!.toNat + 256 * D.data[p + 1]!.toNat def bg (D : ByteArray) (i : USize) (h : i.toNat < D.size) : D.uget i h = D.data[i.toNat]! := by rcases D with ⟨d⟩ have h' : i.toNat < d.size := h simp only [ByteArray.uget, getElem!_pos d i.toNat h'] rfl @[inline] def jr (D : ByteArray) (c : USize) (h : c.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) : USize := (D.uget c (by omega)).toUSize + (D.uget (c + 1) (by have := USize.le_size rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; exact h)).toUSize * 256 def jr_eq (D : ByteArray) (c : USize) (h : c.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) : (jr D c h hs).toNat = J D c.toNat := by have ul := USize.le_size have h1 : (c + 1).toNat = c.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] unfold jr J rw [bg, bg, h1] have a : (D.data[c.toNat]!).toNat < 256 := (D.data[c.toNat]!).toNat_lt have b : (D.data[c.toNat + 1]!).toNat < 256 := (D.data[c.toNat + 1]!).toNat_lt have m : ((D.data[c.toNat + 1]!).toUSize * 256).toNat = (D.data[c.toNat + 1]!).toNat * 256 := by rw [USize.toNat_mul, ← USize.size_eq_two_pow] simp only [UInt8.toNat_toUSize, USize.reduceToNat] exact Nat.mod_eq_of_lt (by clear*-b ul;omega) rw [uadd (by rw [m]; simp only [UInt8.toNat_toUSize]; clear*-a b ul;omega), m] simp only [UInt8.toNat_toUSize]; clear*-;omega def dtt (d t : USize) (h : d.toNat + 2 * t.toNat < 2 ^ 32) : (d + t + t).toNat = d.toNat + 2 * t.toNat := by have ul := USize.le_size rw [uadd (by rw [uadd (by omega)]; omega), uadd (by omega)]; omega def pz (V P : FloatArray) (D : ByteArray) (d vo bs nu m : USize) (hs : V.size < 2 ^ 31 ∧ P.size < 2 ^ 31 ∧ D.size < 2 ^ 31) (hd : d.toNat + 2 * nu.toNat ≤ D.size) (hV : vo.toNat + m.toNat ≤ V.size) (hP : bs.toNat + 8 * m.toNat ≤ P.size) (hj : ∀ c < nu.toNat, J D (d.toNat + 2 * c) < m.toNat) (t : USize) (a0 a1 a2 a3 a4 a5 a6 a7 : Float) (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (acc : Array Word) : Array Word := if h : t < nu then have ht := USize.lt_iff_toNat_lt.mp h have ul := USize.le_size have hc : (d + t + t).toNat = d.toNat + 2 * t.toNat := dtt d t (by omega) let j := jr D (d + t + t) (by rw [hc]; omega) (by omega) have hjm : j.toNat < m.toNat := by rw [jr_eq, hc]; exact hj _ ht have h8 : (j * 8).toNat = 8 * j.toNat := by rw [USize.toNat_mul, ← USize.size_eq_two_pow]; simp only [USize.reduceToNat]; rw [Nat.mod_eq_of_lt (by omega)]; omega have hi : (bs + j * 8).toNat = bs.toNat + 8 * j.toNat := by rw [uadd (by rw [h8]; omega), h8] let x := V.uget (vo + j) (by rw [uadd (by omega)]; omega) let i := bs + j * 8 have hI : i.toNat + 8 ≤ P.size := by show (bs + j * 8).toNat + 8 ≤ P.size; rw [hi]; omega have hs2 : P.size < 2 ^ 32 := by omega let b0 := a0 + x * P.uget (i + 0) (uk (by simp) hI hs2) let b1 := a1 + x * P.uget (i + 1) (uk (by simp) hI hs2) let b2 := a2 + x * P.uget (i + 2) (uk (by simp) hI hs2) let b3 := a3 + x * P.uget (i + 3) (uk (by simp) hI hs2) let b4 := a4 + x * P.uget (i + 4) (uk (by simp) hI hs2) let b5 := a5 + x * P.uget (i + 5) (uk (by simp) hI hs2) let b6 := a6 + x * P.uget (i + 6) (uk (by simp) hI hs2) let b7 := a7 + x * P.uget (i + 7) (uk (by simp) hI hs2) pz V P D d vo bs nu m hs hd hV hP hj (t + 1) b0 b1 b2 b3 b4 b5 b6 b7 relu ok hh n X W b xo st o q0 so mu acc else fP relu ok hh n X W b xo st o q0 so mu V P vo a0 a1 a2 a3 a4 a5 a6 a7 acc termination_by nu.toNat - t.toNat decreasing_by (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def pz_eq (V P : FloatArray) (D : ByteArray) (d vo bs nu m : USize) (hs : V.size < 2 ^ 31 ∧ P.size < 2 ^ 31 ∧ D.size < 2 ^ 31) (hd : d.toNat + 2 * nu.toNat ≤ D.size) (hV : vo.toNat + m.toNat ≤ V.size) (hP : bs.toNat + 8 * m.toNat ≤ P.size) (hj : ∀ c < nu.toNat, J D (d.toNat + 2 * c) < m.toNat) (relu ok : Bool) (hh : UInt64) (n : Nat) (X W b : Array Word) (xo st o : Nat) (q0 so mu : USize) (acc : Array Word) : ∀ k (t : USize) (a0 a1 a2 a3 a4 a5 a6 a7 : Float), nu.toNat - t.toNat = k → pz V P D d vo bs nu m hs hd hV hP hj t a0 a1 a2 a3 a4 a5 a6 a7 relu ok hh n X W b xo st o q0 so mu acc = fP relu ok hh n X W b xo st o q0 so mu V P vo (sfold (fun c => pp V P vo.toNat bs.toNat 0 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a0) (sfold (fun c => pp V P vo.toNat bs.toNat 1 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a1) (sfold (fun c => pp V P vo.toNat bs.toNat 2 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a2) (sfold (fun c => pp V P vo.toNat bs.toNat 3 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a3) (sfold (fun c => pp V P vo.toNat bs.toNat 4 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a4) (sfold (fun c => pp V P vo.toNat bs.toNat 5 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a5) (sfold (fun c => pp V P vo.toNat bs.toNat 6 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a6) (sfold (fun c => pp V P vo.toNat bs.toNat 7 (J D (d.toNat + 2 * c))) nu.toNat t.toNat a7) acc := by intro k; induction k <;> intro t a0 a1 a2 a3 a4 a5 a6 a7 hk ·rw [pz, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hk;omega)] have e : ∀ p a, sfold p nu.toNat t.toNat a = a := fun p a => by rw [sfold, if_neg (by clear*-hk;omega)] simp only [e] rename_i ih have ul := USize.le_size have ht : t.toNat < nu.toNat := by clear*-hk;omega have h : t < nu := USize.lt_iff_toNat_lt.mpr ht have hc : (d + t + t).toNat = d.toNat + 2 * t.toNat := dtt d t (by clear*-hd hs ht;omega) have sp : ∀ (r : Nat) a, sfold (fun c => pp V P vo.toNat bs.toNat r (J D (d.toNat + 2 * c))) nu.toNat t.toNat a = sfold (fun c => pp V P vo.toNat bs.toNat r (J D (d.toNat + 2 * c))) nu.toNat (t.toNat + 1) (a + pp V P vo.toNat bs.toNat r (J D (d.toNat + 2 * t.toNat))) := fun r a => by rw [sfold, if_pos ht] rw [pz, dif_pos h]; dsimp only rw [ih (t + 1) _ _ _ _ _ _ _ _ (by rw [usucc h]; clear*-hk ht;omega), usucc h] have hj0 := hj _ ht have hjv : (jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega)).toNat = J D (d.toNat + 2 * t.toNat) := by rw [jr_eq, hc] have e0 : ∀ j : USize, j.toNat = J D (d.toNat + 2 * t.toNat) → ∀ (c : USize) (r : Nat) (hc : c.toNat = r) (hr : r < 8) (h1 : (vo + j).toNat < V.size) (h2 : (bs + j * 8 + c).toNat < P.size), V.uget (vo + j) h1 * P.uget (bs + j * 8 + c) h2 = pp V P vo.toNat bs.toNat r (J D (d.toNat + 2 * t.toNat)) := fun j hv c r hc hr h1 h2 => by rw [← hv] at hj0 have h8 : (j * 8).toNat = 8 * j.toNat := by rw [USize.toNat_mul, ← USize.size_eq_two_pow]; simp only [USize.reduceToNat]; rw [Nat.mod_eq_of_lt (by clear*-hP hj0 hs ul;omega)]; clear*-;omega have hi : (bs + j * 8).toNat = bs.toNat + 8 * j.toNat := by rw [uadd (by rw [h8]; clear*-hP hj0 hs ul;omega), h8] have hw : (vo + j).toNat = vo.toNat + j.toNat := uadd (by clear*-hV hj0 hs ul;omega) rw [ug, ug, pp, gg, gg, hw, uadd (by rw [hi]; clear*-hP hc hj0 hr hs ul;omega), hi, hc, hv] have e := e0 _ hjv have hsz : ∀ (c : USize), c.toNat < 8 → (bs + jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega) * 8 + c).toNat < P.size := fun c h => by rw [← hjv] at hj0 have h8 : ((jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega)) * 8).toNat = 8 * (jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega)).toNat := by rw [USize.toNat_mul, ← USize.size_eq_two_pow]; simp only [USize.reduceToNat]; rw [Nat.mod_eq_of_lt (by clear*-hP hj0 hs ul;omega)]; clear*-;omega have hi : (bs + (jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega)) * 8).toNat = bs.toNat + 8 * (jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega)).toNat := by rw [uadd (by rw [h8]; clear*-hP hj0 hs ul;omega), h8] rw [uadd (by rw [hi]; clear*-h hP hj0 hs ul;omega), hi]; clear*-h hP hj0;omega have hv1 : (vo + jr D (d + t + t) (by rw [hc]; clear*-hd ht;omega) (by clear*-hs;omega)).toNat < V.size := by rw [← hjv] at hj0; rw [uadd (by clear*-hV hj0 hs ul;omega)]; clear*-hV hj0;omega simp only [sp, e 0 0 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 1 1 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 2 2 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 3 3 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 4 4 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 5 5 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 6 6 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp)), e 7 7 (by simp) (by clear*-;omega) hv1 (hsz _ (by simp))] def rsum (j : Nat → Nat) (nu n : Nat) (hj : ∀ c < nu, j c < n) (hm : ∀ a b, a < b → b < nu → j a < j b) (f : Nat → ℝ) (hf : ∀ s < n, (∀ c < nu, j c ≠ s) → f s = 0) : ∑ c ∈ Finset.range nu, f (j c) = ∑ s ∈ Finset.range n, f s := by have inj : Set.InjOn j (Finset.range nu : Set Nat) := fun a ha b hb h => by simp only [Finset.coe_range, Set.mem_Iio] at ha hb rcases Nat.lt_trichotomy a b with h1 | h1 | h1 ·have := hm a b h1 hb; omega ·exact h1 ·have := hm b a h1 ha; omega rw [← Finset.sum_image (f := f) inj] refine Finset.sum_subset (fun s hs => ?_) fun s hs hn => ?_ ·obtain ⟨c, hc, rfl⟩ := Finset.mem_image.1 hs exact Finset.mem_range.2 (hj c (Finset.mem_range.1 hc)) ·exact hf s (Finset.mem_range.1 hs) fun c hc h => hn (Finset.mem_image.2 ⟨c, Finset.mem_range.2 hc, h⟩) def sv0 (w : Word) (h : (w <<< 1) = 0) : sv w = 0 := by have e := eS w rw [h] at e have e0 : expOf w = 0 := UInt32.toNat_inj.mp (by rw [e]; simp) have h2 := congrArg UInt32.toNat h rw [UInt32.toNat_shiftLeft] at h2 simp only [UInt32.reduceToNat, Nat.reduceMod, Nat.shiftLeft_eq, UInt32.toNat_zero] at h2 have f : (fracOf w).toNat = 0 := by unfold fracOf rw [UInt32.toNat_and] simp only [UInt32.reduceToNat] rw [show (8388607 : Nat) = 2 ^ 23 - 1 by norm_num, Nat.and_two_pow_sub_one_eq_mod] clear*-h2;omega unfold sv mantOf simp [e0, f] def pSz (n nu : Nat) (fa fb : Nat → Word) (ba : Word) (j : Nat → Nat) (p : Nat → Float) (hba : expOf ba ≠ 255) (hn : 8 * n < 2 ^ 32) (hnu : nu ≤ n) (hj : ∀ c < nu, j c < n) (hm : ∀ a b, a < b → b < nu → j a < j b) (hz : ∀ s < n, (∀ c < nu, j c ≠ s) → (fa s <<< 1) = 0) (hp : ∀ s < n, expOf (fb s) ≠ 255 → fv (p s) ∧ rv (p s) = Core.tm (fa s) (fb s)) : SB n fa fb ba (sfold (fun c => p (j c)) nu 0 (dw oneW * dw ba)) := fun hw hA => by have hB := pvV oneW ba (by decide) hba have tz : ∀ s < n, (∀ c < nu, j c ≠ s) → (Core.tm (fa s) (fb s) : ℝ) = 0 := fun s hs h => by simp [Core.tm, sv0 _ (hz s hs h)] have e1 := rsum j nu n hj hm (fun s => (Core.tm (fa s) (fb s) : ℝ)) tz have e2 := rsum j nu n hj hm (fun s => |(Core.tm (fa s) (fb s) : ℝ)|) fun s hs h => by simp only [tz s hs h, abs_zero] have := sfR (fun c => p (j c)) (fun c => (Core.tm (fa (j c)) (fb (j c)) : ℝ)) (Core.tm oneW ba : ℝ) nu (fun c hc => hp _ (hj c hc) (hw _ (hj c hc))) (by omega) (by rw [e2]; exact hA) nu 0 _ (by clear*-;omega) (Nat.zero_le _) hB.1 (by rw [hB.2]; simp) rw [e1, e2] at this refine ⟨this.1, this.2.trans (mul_le_mul_of_nonneg_right (by exact_mod_cast hnu) (by positivity))⟩ @[inline] def wB (D : ByteArray) (i : USize) (v : UInt8) : ByteArray := if h : i < D.usize then D.uset i v (Sr.ub h) else D def wB_s (D : ByteArray) (i : USize) (v : UInt8) : (wB D i v).size = D.size := by unfold wB; split ·rcases D with ⟨d⟩ simp only [ByteArray.uset, ByteArray.size, Array.uset, Array.size_set] ·rfl def wB_g (D : ByteArray) (i : USize) (v : UInt8) (hi : i.toNat < D.size) (hs : D.size < 2 ^ 32) (q : Nat) : (wB D i v).data[q]! = if q = i.toNat then v else D.data[q]! := by have ul := USize.le_size have h : i < D.usize := by rw [USize.lt_iff_toNat_lt, ByteArray.usize, toUSize_toNat (by omega)]; exact hi unfold wB; rw [dif_pos h] rcases D with ⟨d⟩ have hi' : i.toNat < d.size := hi simp only [ByteArray.uset, Array.uset] by_cases hq : q = i.toNat ·subst hq; simp [hi'] ·rw [if_neg hq] by_cases hb : q < d.size ·rw [getElem!_pos (d.set i.toNat v hi') q (by simpa using hb), getElem!_pos d q hb, Array.getElem_set_ne _ _ (Ne.symm hq)] ·rw [getElem!_neg (d.set i.toNat v hi') q (by simpa using hb), getElem!_neg d q hb] @[inline] def w2 (D : ByteArray) (p x : USize) : ByteArray := wB (wB D p x.toUInt8) (p + 1) (x >>> 8).toUInt8 def w2_s (D : ByteArray) (p x : USize) : (w2 D p x).size = D.size := by rw [w2, wB_s, wB_s] def w2_J (D : ByteArray) (p x : USize) (hp : p.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) (hx : x.toNat < 65536) : J (w2 D p x) p.toNat = x.toNat ∧ ∀ q, q + 1 < p.toNat ∨ p.toNat + 1 < q → J (w2 D p x) q = J D q := by have ul := USize.le_size have h1 : (p + 1).toNat = p.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; clear hx;omega)]; simp only [USize.reduceToNat] have g : ∀ q, (w2 D p x).data[q]! = if q = p.toNat + 1 then (x >>> 8).toUInt8 else if q = p.toNat then x.toUInt8 else D.data[q]! := fun q => by rw [w2, wB_g _ _ _ (by rw [wB_s, h1]; omega) (by rw [wB_s]; omega), wB_g _ _ _ (by clear*-hp;omega) hs, h1] constructor ·unfold J; rw [g, g] simp only [show p.toNat ≠ p.toNat + 1 by clear*-;omega, if_false, if_true] have a : x.toUInt8.toNat = x.toNat % 256 := by simp have b : (x >>> 8).toUInt8.toNat = x.toNat / 256 % 256 := by rw [USize.toNat_toUInt8, USize.toNat_shiftRight] rcases System.Platform.numBits_eq with h | h <;> simp [Nat.shiftRight_eq_div_pow, h] rw [a, b]; clear*-hx;omega ·intro q hq; unfold J; rw [g, g, if_neg (by clear*-hq;omega), if_neg (by clear*-hq;omega), if_neg (by clear*-hq;omega), if_neg (by clear*-hq;omega)] def w2_b (D : ByteArray) (p x : USize) (hp : p.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) (q : Nat) (hq : q ≠ p.toNat) (hq' : q ≠ p.toNat + 1) : (w2 D p x).data[q]! = D.data[q]! := by have ul := USize.le_size have h1 : (p + 1).toNat = p.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] rw [w2, wB_g _ _ _ (by rw [wB_s, h1]; omega) (by rw [wB_s]; omega), wB_g _ _ _ (by clear*-hp;omega) hs, h1, if_neg hq', if_neg hq] def RI (D : ByteArray) (db t c : Nat) (nz : Nat → Prop) : Prop := (∀ i < c, J D (db + 2 + 2 * i) < t) ∧ (∀ a b, a < b → b < c → J D (db + 2 + 2 * a) < J D (db + 2 + 2 * b)) ∧ ∀ s < t, nz s → ∃ i < c, J D (db + 2 + 2 * i) = s def RL (D : ByteArray) (db n : Nat) (nz : Nat → Prop) : Prop := J D db ≤ n ∧ RI D db n (J D db) nz def RI_step (D : ByteArray) (db t c : Nat) (nz : Nat → Prop) (p x : USize) (hp : p.toNat = db + 2 + 2 * c) (hx : x.toNat = t) (ht : t < 65536) (hb : p.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) (h : RI D db t c nz) : RI (w2 D p x) db (t + 1) (c + 1) nz ∧ (¬ nz t → RI (w2 D p x) db (t + 1) c nz) := by obtain ⟨j1, j2⟩ := w2_J D p x hb hs (by clear*-ht hx;omega) have e : ∀ i < c, J (w2 D p x) (db + 2 + 2 * i) = J D (db + 2 + 2 * i) := fun i hi => j2 _ (by clear*-hi hp;omega) have e' : J (w2 D p x) (db + 2 + 2 * c) = t := by rw [← hp, j1, hx] obtain ⟨a1, a2, a3⟩ := h refine ⟨⟨fun i hi => ?_, fun a b hab hb' => ?_, fun s hs' hn => ?_⟩, fun hn => ⟨fun i hi => ?_, fun a b hab hb' => ?_, fun s hs' hz => ?_⟩⟩ ·by_cases h : i < c ·have := a1 i h; rw [e i h]; clear*-this;omega ·rw [show i = c by clear*-h hi;omega, e']; clear*-;omega ·by_cases h : b < c ·rw [e a (by clear*-h hab;omega), e b h]; exact a2 a b hab h ·have := a1 a (by clear*-h hab hb';omega); rw [show b = c by clear*-h hb';omega, e', e a (by clear*-h hab hb';omega)]; omega ·by_cases h : s < t ·obtain ⟨i, hi, hq⟩ := a3 s h hn; exact ⟨i, by omega, by rw [e i hi, hq]⟩ ·exact ⟨c, by omega, by rw [e']; omega⟩ ·have := a1 i hi; rw [e i hi]; clear*-this;omega ·rw [e a (by clear*-hab hb';omega), e b hb']; exact a2 a b hab hb' ·by_cases h : s < t ·obtain ⟨i, hi, hq⟩ := a3 s h hz; exact ⟨i, hi, by rw [e i hi, hq]⟩ ·exact absurd (show nz t by rwa [show t = s by omega]) hn def cz (X : Array Word) (st db nu t q c : USize) (D : ByteArray) : ByteArray := if h : t < nu then let w : Word := if h : q < X.usize then X.uget q (ulen h) else 0 cz X st db nu (t + 1) (q + st) (c + ((w <<< 1) != 0).toUInt64.toUSize) (w2 D (db + 2 + c + c) t) else w2 D db c termination_by nu.toNat - t.toNat decreasing_by (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def rW (X : Array Word) (q : USize) (hX : X.size < 2 ^ 32) : (if h : q < X.usize then X.uget q (ulen h) else 0) = X[q.toNat]! := by have ul := USize.le_size split ·rename_i h rw [getElem!_pos X _ (ulen h)]; rfl ·rename_i h rw [getElem!_neg X] ·rfl ·intro h'; exact h (by rw [USize.lt_iff_toNat_lt, Array.usize, toUSize_toNat (by omega)]; exact h') def cz_spec (X : Array Word) (st db nu : USize) (q0 : Nat) (nz : Nat → Prop) (hX : X.size < 2 ^ 32) (hz : ∀ s, nz s → (X[q0 + s * st.toNat]! <<< 1) ≠ 0) (hq : q0 + (nu.toNat + 1) * st.toNat < 2 ^ 32) (hn : nu.toNat < 65536) : ∀ k (t q c : USize) (D : ByteArray), nu.toNat - t.toNat = k → t.toNat ≤ nu.toNat → c.toNat ≤ t.toNat → q.toNat = q0 + t.toNat * st.toNat → D.size < 2 ^ 32 → db.toNat + 2 + 2 * nu.toNat ≤ D.size → RI D db.toNat t.toNat c.toNat nz → (cz X st db nu t q c D).size = D.size ∧ (∀ p, p < db.toNat ∨ db.toNat + 2 + 2 * nu.toNat ≤ p → (cz X st db nu t q c D).data[p]! = D.data[p]!) ∧ RL (cz X st db nu t q c D) db.toNat nu.toNat nz := by have ul := USize.le_size intro k; induction k <;> intro t q c D hk ht hc hqt hs hb hR ·have htn : t.toNat = nu.toNat := by clear*-hk ht;omega rw [cz, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-htn;omega)] obtain ⟨j1, j2⟩ := w2_J D db c (by clear*-hb;omega) hs (by clear*-hc hn htn;omega) obtain ⟨a1, a2, a3⟩ := hR have e : ∀ i < c.toNat, J (w2 D db c) (db.toNat + 2 + 2 * i) = J D (db.toNat + 2 + 2 * i) := fun i _ => j2 _ (by clear*-;omega) refine ⟨w2_s _ _ _, fun p hp => w2_b _ _ _ (by clear*-hb;omega) hs _ (by clear*-hp;omega) (by clear*-hp;omega), ?_⟩ unfold RL; rw [j1] refine ⟨by clear*-hc htn;omega, fun i hi => ?_, fun a b hab hb' => ?_, fun s hs' hn' => ?_⟩ ·rw [e i hi, ← htn]; exact a1 i hi ·rw [e a (by clear*-hab hb';omega), e b hb']; exact a2 a b hab hb' ·obtain ⟨i, hi, hq'⟩ := a3 s (by omega) hn'; exact ⟨i, hi, by rw [e i hi, hq']⟩ rename_i k ih have htl : t.toNat < nu.toNat := by clear*-hk;omega have h : t < nu := USize.lt_iff_toNat_lt.mpr htl rw [cz, dif_pos h]; dsimp only rw [rW X q hX] have h2 : (db + 2).toNat = db.toNat + 2 := by rw [uadd (by simp only [USize.reduceToNat]; clear*-hb hs htl ul;omega)]; simp only [USize.reduceToNat] have hp : (db + 2 + c + c).toNat = db.toNat + 2 + 2 * c.toNat := by rw [dtt _ _ (by rw [h2]; clear*-hb hc hs htl;omega), h2] have m1 : (t.toNat + 1) * st.toNat ≤ (nu.toNat + 1) * st.toNat := Nat.mul_le_mul_right _ (by clear*-htl;omega) rw [Nat.add_mul, Nat.one_mul] at m1 have hq1 : (q + st).toNat = q0 + (t + 1).toNat * st.toNat := by rw [usucc h, Nat.add_mul, Nat.one_mul, uadd (by clear*-hq hqt m1 ul;omega)]; clear*-hqt;omega obtain ⟨r1, r2⟩ := RI_step D db.toNat t.toNat c.toNat nz _ t hp rfl (by clear*-hn htl;omega) (by rw [hp]; clear*-hb hc htl;omega) hs hR have fin : ∀ c' : USize, c'.toNat ≤ (t + 1).toNat → RI (w2 D (db + 2 + c + c) t) db.toNat (t + 1).toNat c'.toNat nz → (cz X st db nu (t + 1) (q + st) c' (w2 D (db + 2 + c + c) t)).size = D.size ∧ (∀ p, p < db.toNat ∨ db.toNat + 2 + 2 * nu.toNat ≤ p → (cz X st db nu (t + 1) (q + st) c' (w2 D (db + 2 + c + c) t)).data[p]! = D.data[p]!) ∧ RL (cz X st db nu (t + 1) (q + st) c' (w2 D (db + 2 + c + c) t)) db.toNat nu.toNat nz := fun c' h1 h2 => by obtain ⟨i1, i2, i3⟩ := ih (t + 1) (q + st) c' _ (by rw [usucc h]; clear*-hk htl;omega) (by rw [usucc h]; clear*-htl;omega) h1 hq1 (by rw [w2_s]; exact hs) (by rw [w2_s]; exact hb) h2 refine ⟨by rw [i1, w2_s], fun p hp' => ?_, i3⟩ rw [i2 p hp', w2_b _ _ _ (by rw [hp]; clear*-hb hc htl;omega) hs _ (by rw [hp]; clear*-hc hp' htl;omega) (by rw [hp]; clear*-hc hp' htl;omega)] rw [hqt] by_cases hw : (X[q0 + t.toNat * st.toNat]! <<< 1) = 0 ·have e : ((X[q0 + t.toNat * st.toNat]! <<< 1) != 0).toUInt64.toUSize = 0 := by rw [show ((X[q0 + t.toNat * st.toNat]! <<< 1) != 0) = false by rw [hw]; rfl]; rfl rw [e, show c + 0 = c by simp] exact fin c (by rw [usucc h]; clear*-hc;omega) (by rw [usucc h]; exact r2 fun hn' => hz _ hn' hw) ·have e : ((X[q0 + t.toNat * st.toNat]! <<< 1) != 0).toUInt64.toUSize = 1 := by rw [show ((X[q0 + t.toNat * st.toNat]! <<< 1) != 0) = true from bne_iff_ne.mpr hw]; rfl rw [e] have hc1 : (c + 1).toNat = c.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; clear*-hc hn htl ul;omega)]; simp only [USize.reduceToNat] exact fin (c + 1) (by rw [usucc h, hc1]; clear*-hc;omega) (by rw [usucc h, hc1]; exact r1) def RL_cg (D E : ByteArray) (db n : Nat) (nz : Nat → Prop) (hE : ∀ p, db ≤ p → p < db + 2 + 2 * n → E.data[p]! = D.data[p]!) (h : RL D db n nz) : RL E db n nz := by have e0 : J E db = J D db := by unfold J; rw [hE _ (by omega) (by omega), hE _ (by omega) (by omega)] obtain ⟨a0, a1, a2, a3⟩ := h have e : ∀ i < n, J E (db + 2 + 2 * i) = J D (db + 2 + 2 * i) := fun i hi => by unfold J; rw [hE _ (by clear*-;omega) (by clear*-hi;omega), hE _ (by clear*-;omega) (by clear*-hi;omega)] unfold RL RI; rw [e0] refine ⟨a0, fun i hi => ?_, fun a b hab hb => ?_, fun s hs hn => ?_⟩ ·rw [e i (by clear*-a0 hi;omega)]; exact a1 i hi ·rw [e a (by clear*-a0 hab hb;omega), e b (by clear*-a0 hb;omega)]; exact a2 a b hab hb ·obtain ⟨i, hi, hq⟩ := a3 s hs hn; exact ⟨i, hi, by rw [e i (by omega), hq]⟩ def us_s (D : ByteArray) (i : USize) (v : UInt8) (h : i.toNat < D.size) : (D.uset i v h).size = D.size := by rcases D with ⟨d⟩ simp only [ByteArray.uset, ByteArray.size, Array.uset, Array.size_set] @[inline] def w2u (D : ByteArray) (p x : USize) (h : p.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) : ByteArray := have h1 : (p + 1).toNat = p.toNat + 1 := by have := USize.le_size rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] (D.uset p x.toUInt8 (by omega)).uset (p + 1) (x >>> 8).toUInt8 (by rw [h1, us_s]; exact h) def w2u_eq (D : ByteArray) (p x : USize) (h : p.toNat + 1 < D.size) (hs : D.size < 2 ^ 32) : w2u D p x h hs = w2 D p x := by have ul := USize.le_size have h1 : (p + 1).toNat = p.toNat + 1 := by rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] have e : ∀ (E : ByteArray) (i : USize) (v : UInt8) (hi : i.toNat < E.size), E.size < 2 ^ 32 → wB E i v = E.uset i v hi := fun E i v hi hE => by unfold wB; rw [dif_pos] rw [USize.lt_iff_toNat_lt, ByteArray.usize, toUSize_toNat (by clear*-hE ul;omega)]; exact hi unfold w2u w2 rw [e D p _ (by clear*-h;omega) hs, e _ (p + 1) _ (by rw [h1, us_s]; exact h) (by rw [us_s]; exact hs)] def cb (c : USize) (b : Bool) (hc : c.toNat + 1 < 2 ^ 32) : (c + b.toUInt64.toUSize).toNat ≤ c.toNat + 1 := by have ul := USize.le_size cases b ·rw [show (false).toUInt64.toUSize = 0 from rfl]; simp ·rw [show (true).toUInt64.toUSize = 1 from rfl, uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat]; omega def czu (X : Array Word) (st db nu t q c : USize) (D : ByteArray) (hc : c.toNat ≤ t.toNat) (ht : t.toNat ≤ nu.toNat) (hb : db.toNat + 2 + 2 * nu.toNat ≤ D.size) (hs : D.size < 2 ^ 32) : ByteArray := if h : t < nu then have htl := USize.lt_iff_toNat_lt.mp h have ul := USize.le_size have h2 : (db + 2).toNat = db.toNat + 2 := by rw [uadd (by simp only [USize.reduceToNat]; omega)]; simp only [USize.reduceToNat] have hp : (db + 2 + c + c).toNat = db.toNat + 2 + 2 * c.toNat := by rw [dtt _ _ (by rw [h2]; omega), h2] let w : Word := if h : q < X.usize then X.uget q (ulen h) else 0 czu X st db nu (t + 1) (q + st) (c + ((w <<< 1) != 0).toUInt64.toUSize) (w2u D (db + 2 + c + c) t (by rw [hp]; omega) hs) (by rw [usucc h]; exact cb c _ (by omega) |>.trans (by omega)) (by rw [usucc h]; omega) (by rw [w2u_eq, w2_s]; exact hb) (by rw [w2u_eq, w2_s]; exact hs) else w2u D db c (by omega) hs termination_by nu.toNat - t.toNat decreasing_by (have := USize.lt_iff_toNat_lt.mp h; rw [usucc h]; omega) def czu_eq (X : Array Word) (st db nu : USize) : ∀ k (t q c : USize) (D : ByteArray) (hc : c.toNat ≤ t.toNat) (ht : t.toNat ≤ nu.toNat) (hb : db.toNat + 2 + 2 * nu.toNat ≤ D.size) (hs : D.size < 2 ^ 32), nu.toNat - t.toNat = k → czu X st db nu t q c D hc ht hb hs = cz X st db nu t q c D := by intro k; induction k <;> intro t q c D hc ht hb hs hk ·rw [czu, cz, dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hk;omega), dif_neg (by rw [USize.lt_iff_toNat_lt]; clear*-hk;omega), w2u_eq] rename_i k ih have h : t < nu := USize.lt_iff_toNat_lt.mpr (by clear*-hk;omega) rw [czu, cz, dif_pos h, dif_pos h]; dsimp only rw [ih _ _ _ _ _ _ _ _ (by rw [usucc h]; clear*-hk;omega), w2u_eq] def czA (X : Array Word) (st s2 nu ds : USize) : Nat → USize → USize → ByteArray → ByteArray | 0, _, _, D => D | k + 1, q, db, D => czA X st s2 nu ds k (q + s2) (db + ds) (if h : db.toNat + 2 + 2 * nu.toNat ≤ D.size ∧ D.size ≤ 4294967295 then czu X st db nu 0 q 0 D (by simp) (by simp) h.1 (by have := h.2; omega) else D) def czA_spec (X : Array Word) (st s2 nu ds : USize) (R : Nat) (nz : Nat → Nat → Prop) (hX : X.size < 2 ^ 32) (hz : ∀ i s, nz i s → (X[i * s2.toNat + s * st.toNat]! <<< 1) ≠ 0) (hm : ds.toNat = 2 * nu.toNat + 2) (hn : nu.toNat < 65536) (hq : R * s2.toNat + (nu.toNat + 1) * st.toNat < 2 ^ 32) : ∀ k r (q db : USize) (D : ByteArray), r + k = R → q.toNat = r * s2.toNat → db.toNat = r * ds.toNat → D.size < 2 ^ 32 → R * ds.toNat ≤ D.size → (∀ i < r, RL D (i * ds.toNat) nu.toNat (nz i)) → (czA X st s2 nu ds k q db D).size = D.size ∧ ∀ i < R, RL (czA X st s2 nu ds k q db D) (i * ds.toNat) nu.toNat (nz i) := by have ul := USize.le_size intro k; induction k <;> intro r q db D hk hq' hd hs hb hR ·exact ⟨rfl, fun i hi => hR i (by clear*-hi hk;omega)⟩ rename_i k ih have hrR : (r + 1) * ds.toNat ≤ R * ds.toNat := Nat.mul_le_mul_right _ (by clear*-hk;omega) have hrS : (r + 1) * s2.toNat ≤ R * s2.toNat := Nat.mul_le_mul_right _ (by clear*-hk;omega) rw [Nat.add_mul, Nat.one_mul] at hrR hrS have m1 : r * s2.toNat + (nu.toNat + 1) * st.toNat < 2 ^ 32 := by clear*-hq hrS;omega obtain ⟨c1, c2, c3⟩ := cz_spec X st db nu (r * s2.toNat) (nz r) hX (hz r) m1 hn nu.toNat 0 q 0 D (by simp) (by simp) (by simp) (by simpa using hq') hs (by clear*-hb hd hm hrR;omega) ⟨fun i hi => by simp at hi, fun a b _ hb => by simp at hb, fun s hs' => by simp at hs'⟩ simp only [czA] rw [dif_pos ⟨by clear*-hb hd hm hrR;omega, by clear*-hs;omega⟩, czu_eq _ _ _ _ _ _ _ _ _ _ _ _ _ rfl] refine (fun H => ⟨H.1.trans c1, H.2⟩) (ih (r + 1) (q + s2) (db + ds) _ (by clear*-hk;omega) (by rw [uadd (by clear*-hq hq' hrS ul;omega), Nat.add_mul, Nat.one_mul]; clear*-hq';omega) (by rw [uadd (by clear*-hb hd hrR hs ul;omega), Nat.add_mul, Nat.one_mul]; clear*-hd;omega) (by rw [c1]; exact hs) (by rw [c1]; exact hb) fun i hi => ?_) by_cases h : i < r ·refine RL_cg D _ _ _ _ (fun p h1 h2 => c2 p (.inl ?_)) (hR i h) have := Nat.mul_le_mul_right ds.toNat (show i + 1 ≤ r by clear*-h;omega) rw [Nat.add_mul, Nat.one_mul] at this; clear*-h2 hd hm this;omega ·rw [show i = r by clear*-h hi;omega, ← hd]; exact c3 def ZB : Array ByteArray := Array.ofFn (n := 12) fun k => ⟨Array.replicate (2 ^ (k.val + 8)) 0⟩ def zB (n : Nat) : ByteArray := let k := Nat.log2 n + 1 - 8 if k < 12 then ZB[k]! else ⟨Array.replicate n 0⟩ def zbs (n : Nat) : n ≤ (zB n).size ∧ ((zB n).size = n ∨ (zB n).size ≤ 2 ^ 19) := by unfold zB; dsimp only; split ·rw [getElem!_pos ZB _ (by simp [ZB]; omega)] simp only [ZB, Array.getElem_ofFn, ByteArray.size, Array.size_replicate] exact ⟨(Nat.lt_log2_self (n := n)).le.trans (Nat.pow_le_pow_right (by decide) (by omega)), .inr (Nat.pow_le_pow_right (by decide) (by omega))⟩ ·simp [ByteArray.size] def zc (X : Array Word) : Nat → USize → USize → USize | 0, _, c => c | k + 1, i, c => if h : i < X.usize then zc X k (i + 1) (c + ((X.uget i (ulen h) <<< 1) == 0).toUInt64.toUSize) else c def nzf (t : Bool) (R n : Nat) (X : Array Word) (r s : Nat) : Prop := (X[(if t then r else r * n) + s * (if t then R else 1)]! <<< 1) ≠ 0 def czR (t : Bool) (R n : Nat) (X : Array Word) : ByteArray := czA X (if t then R else 1).toUSize (if t then 1 else n).toUSize n.toUSize (2 * n + 2).toUSize R 0 0 (zB (R * (2 * n + 2) + 8)) def czR_spec (t : Bool) (R n : Nat) (X : Array Word) (hX : X.size < 2 ^ 32) (hn : n < 65536) (hR : R * (2 * n + 2) + 8 < 2 ^ 31) (hq : R * (if t then 1 else n) + (n + 1) * (if t then R else 1) ≤ 4294967295) : (czR t R n X).size < 2 ^ 31 ∧ R * (2 * n + 2) ≤ (czR t R n X).size ∧ ∀ r < R, RL (czR t R n X) (r * (2 * n + 2)) n (nzf t R n X r) := by have ul := USize.le_size obtain ⟨z1, z2⟩ := zbs (R * (2 * n + 2) + 8) have hzs : (zB (R * (2 * n + 2) + 8)).size < 2 ^ 31 := by rcases z2 with h | h <;> (clear*-h hR;omega) have hR1 : R ≤ R * (2 * n + 2) := Nat.le_mul_of_pos_right _ (by clear*-;omega) have hst : (if t then R else 1).toUSize.toNat = if t then R else 1 := toUSize_toNat (by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-hR1 hzs ul z1;omega)) have hs2 : (if t then 1 else n).toUSize.toNat = if t then 1 else n := toUSize_toNat (by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-hn ul;omega)) have hnu : n.toUSize.toNat = n := toUSize_toNat (by clear*-hn ul;omega) have hds : (2 * n + 2).toUSize.toNat = 2 * n + 2 := toUSize_toNat (by clear*-hn ul;omega) have h0 : (0 : USize).toNat = 0 := rfl obtain ⟨k1, k2⟩ := czA_spec X (if t then R else 1).toUSize (if t then 1 else n).toUSize n.toUSize (2 * n + 2).toUSize R (nzf t R n X) hX (fun i s h => by rw [hst, hs2] have e : i * (if t then 1 else n) = if t then i else i * n := by cases t <;> simp rw [e]; exact h) (by rw [hds, hnu]) (by rw [hnu]; exact hn) (by rw [hst, hs2, hnu]; clear*-hq;omega) R 0 0 0 (zB (R * (2 * n + 2) + 8)) (by clear*-;omega) (by simp) (by simp) (by clear*-hzs;omega) (by rw [hds]; clear*-z1;omega) (fun i hi => by clear*-hi;omega) rw [hds, hnu] at k2 unfold czR refine ⟨by rw [k1]; exact hzs, by rw [k1]; clear*-z1;omega, fun r hr => k2 r hr⟩ @[specialize] def l2 (U V : Nat) (f : Nat → Nat → Array Word → Array Word) (u v : Nat) (a : Array Word) : Array Word := if u < U then if v < V then l2 U V f u (v + 1) (f u v a) else l2 U V f (u + 1) 0 a else a termination_by (U - u, V - v) def l2_spec (U V N : Nat) (f : Nat → Nat → Array Word → Array Word) (F : Nat → Word) (C : Nat → Nat → Nat → Prop) (hf : ∀ u v a, u < U → v < V → a.size = N → Iv F a (C u v) (f u v a)) (u v : Nat) (a : Array Word) : a.size = N → (∀ q, (∃ u' v', u' < U ∧ v' < V ∧ (u' < u ∨ u' = u ∧ v' < v) ∧ C u' v' q) → q < a.size → a[q]? = some (F q)) → (l2 U V f u v a).size = a.size ∧ ∀ q, (∃ u' v', u' < U ∧ v' < V ∧ C u' v' q) → q < a.size → (l2 U V f u v a)[q]? = some (F q) := by induction u, v, a using l2.induct U V f with | case1 u v a hu hv ih => intro hN ha; rw [l2, if_pos hu, if_pos hv] obtain ⟨hs, hq⟩ := hf u v a hu hv hN obtain ⟨i1, i2⟩ := ih (by clear*-hN hs;omega) fun q ⟨u', v', h1, h2, h3, h4⟩ hq' => by have hq2 : q < a.size := by omega by_cases e : u' = u ∧ v' = v ·obtain ⟨rfl, rfl⟩ := e; exact (hq q).2 h4 hq2 ·have := ha q ⟨u', v', h1, h2, by omega, h4⟩ hq2 rcases (hq q).1 with h | h ·rw [h, this] ·exact h exact ⟨i1.trans hs, fun q hc hq' => i2 q hc (by clear*-hq' hs;omega)⟩ | case2 u v a hu hv ih => intro hN ha; rw [l2, if_pos hu, if_neg hv] exact ih hN fun q ⟨u', v', h1, h2, h3, h4⟩ hq' => ha q ⟨u', v', h1, h2, by omega, h4⟩ hq' | case3 u v a hu => intro hN ha; rw [l2, if_neg hu] exact ⟨rfl, fun q ⟨u', v', h1, h2, h4⟩ hq' => ha q ⟨u', v', h1, h2, by omega, h4⟩ hq'⟩ def l2_fin (U V N : Nat) (f : Nat → Nat → Array Word → Array Word) (F : Nat → Word) (C : Nat → Nat → Nat → Prop) (hf : ∀ u v a, u < U → v < V → a.size = N → Iv F a (C u v) (f u v a)) (hc : ∀ q, q < N → ∃ u v, u < U ∧ v < V ∧ C u v q) : l2 U V f 0 0 (Array.replicate N 0) = Array.ofFn (n := N) fun q => F q.val := by obtain ⟨h1, h2⟩ := l2_spec U V N f F C hf 0 0 (Array.replicate N 0) (by simp) fun q ⟨u', v', _, _, h, _⟩ _ => by omega apply Array.ext_getElem?; intro q by_cases hq : q < N ·obtain ⟨u, v, hu, hv, hC⟩ := hc q hq rw [h2 q ⟨u, v, hu, hv, hC⟩ (by simpa using hq), Array.getElem?_ofFn]; simp [hq] ·simp_all structure PD where Q : FloatArray B : FloatArray bw : Array Word e : Word eb : Word def pd (W b : Array Word) (n : Nat) : PD := let ow := W.size / n let G := (ow + 7) / 8 let bw := if b.isEmpty then Array.replicate ow 0x80000000 else b ⟨qL W n.toUSize (8 * n).toUSize n G 0 (zT (n * G + 1)), bld (fun o => dw oneW * rX bw o.toUSize) (8 * G) (FloatArray.emptyWithCapacity (8 * G)), bw, emx W 0 0, emx bw 0 0⟩ def oF (t : Bool) (R n ow : Nat) (relu : Bool) (X W b : Array Word) (q : Nat) : Word := act relu (dotOf (n + 1) (fun s => if s < n then X[if t then q % R + s * R else q / ow * n + s]! else oneW) (fun s => if s < n then W[(if t then q / R else q % ow) * n + s]! else b[if t then q / R else q % ow]!)) def ts {a S : Nat} (h : a ≤ S) (hS : S < 2 ^ 32) : a.toUSize.toNat = a := toUSize_toNat (by have := USize.le_size; omega) @[inline] def stp (f4 t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (g r : Nat) (a : Array Word) : Array Word := let vo := r * (n + 1) let o := 8 * g if h : vo + n < Y.size ∧ o * n + 1 + 8 * n ≤ Q.size ∧ o + 8 ≤ B.size then have hn : n.toUSize.toNat = n := ts (by omega) hs.1 have hv : vo.toUSize.toNat = vo := ts (by omega) hs.1 have hb8 : o.toUSize.toNat + 8 ≤ B.size := by rw [ts (by omega) hB]; exact h.2.2 let bo := o.toUSize let p := e6 + 23 + cE F (Y.uget (vo + n).toUSize (by rw [ts (by omega) hs.1]; exact h.1)) if f4 then p4 Y Q vo.toUSize n.toUSize (if 4 < ow - o ∧ 3 < n then (n - 3).toUSize else 0) hs (by rw [hv, hn]; omega) (by split ·rw [ts (S := Y.size) (by omega) hs.1, hn]; omega ·exact .inl rfl) 0 (o * n + 1).toUSize (by rw [ts (by omega) hs.2, hn]; simp only [USize.toNat_zero, Nat.sub_zero]; omega) (B.uget (bo + 0) (uk (by simp) hb8 hB)) (B.uget (bo + 1) (uk (by simp) hb8 hB)) (B.uget (bo + 2) (uk (by simp) hb8 hB)) (B.uget (bo + 3) (uk (by simp) hb8 hB)) (B.uget (bo + 4) (uk (by simp) hb8 hB)) (B.uget (bo + 5) (uk (by simp) hb8 hB)) (B.uget (bo + 6) (uk (by simp) hb8 hB)) (B.uget (bo + 7) (uk (by simp) hb8 hB)) relu (eok && p ≤ 400) (if p < hb then hb else p) n X W bw (if t then r else r * n) (if t then R else 1) o (if t then o * R + r else r * ow + o).toUSize (if t then R else 1).toUSize (min 8 (ow - o)).toUSize a else pk Y Q vo.toUSize n.toUSize hs (by rw [hv, hn]; omega) 0 (o * n + 1).toUSize (by rw [ts (by omega) hs.2, hn]; simp only [USize.toNat_zero, Nat.sub_zero]; omega) (B.uget (bo + 0) (uk (by simp) hb8 hB)) (B.uget (bo + 1) (uk (by simp) hb8 hB)) (B.uget (bo + 2) (uk (by simp) hb8 hB)) (B.uget (bo + 3) (uk (by simp) hb8 hB)) (B.uget (bo + 4) (uk (by simp) hb8 hB)) (B.uget (bo + 5) (uk (by simp) hb8 hB)) (B.uget (bo + 6) (uk (by simp) hb8 hB)) (B.uget (bo + 7) (uk (by simp) hb8 hB)) relu (eok && p ≤ 400) (if p < hb then hb else p) n X W bw (if t then r else r * n) (if t then R else 1) o (if t then o * R + r else r * ow + o).toUSize (if t then R else 1).toUSize (min 8 (ow - o)).toUSize a else a def cR (X : Array Word) (n : Nat) (hn : n < 2 ^ 29) (hx : ∀ q : Nat, expOf X[q]! ≠ 255) (f : Nat → Nat) (g : Nat → Float) (hg : ∀ τ < n, g τ = dw X[f τ]!) : 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[f τ]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE (9 * (n + 1)).toUInt64.toInt64.toFloat (sfold (fun τ => (g τ).abs) n 0 0)).toNat : Int) + 56) + 2 ^ (-900 : Int) := by have h0 : 0 ≤ ∑ τ ∈ Finset.range n, |rv (dw X[f τ]!)| := Finset.sum_nonneg fun _ _ => abs_nonneg _ have h1 : ∑ τ ∈ Finset.range n, |rv (dw X[f τ]!)| ≤ 2 ^ (400 : Int) := by refine (Finset.sum_le_sum fun τ _ => dwB _ (hx _)).trans ?_ have : (n : ℝ) ≤ 2 ^ 29 := by exact_mod_cast hn.le rw [Finset.sum_const, Finset.card_range, nsmul_eq_mul] calc (n : ℝ) * 2 ^ (277 : Int) ≤ 2 ^ 29 * 2 ^ (277 : Int) := by gcongr _ ≤ 2 ^ (400 : Int) := by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; exact zpow_le_zpow_right₀ (by norm_num) (by norm_num) obtain ⟨fa, ea⟩ := sfR (fun τ => (g τ).abs) (fun τ => |rv (dw X[f τ]!)|) 0 n (fun τ hτ => by rw [hg τ hτ]; exact fabs _ (dwV _ (hx _)).1) (by omega) (by simpa using h1.trans (zpow_le_zpow_right₀ (by norm_num) (by norm_num : (400 : ℤ) ≤ 968))) n 0 0 rfl (Nat.zero_le _) f0.1 (by simp [f0.2]) simp only [abs_zero, zero_add, abs_abs] at ea exact cE_spec n hn _ _ fa h0 h1 ea def stp_fin (t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (e : Word) (ib IB L : Nat) (hLd : L = Nat.log2 (n + 1) + 1) (he6 : e6 = if e.toUInt64 < 56 then 56 else e.toUInt64) (hok : eok = decide (e < 255)) (hF : F = (9 * (n + 1)).toUInt64.toInt64.toFloat) (hhb : hb = (ib + L - 50).toUInt64) (hx : ∀ q : Nat, expOf X[q]! ≠ 255) (hbq : ∀ q : Nat, expOf bw[q]! ≠ 255 ∧ idxOf bw[q]! ≤ IB) (hib : 174 + IB ≤ ib) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hibL : ib + L ≤ 425) (hn : 8 * n < 2 ^ 32) (he : ∀ q : Nat, (expOf W[q]!).toNat ≤ e.toNat) (hYs : R * (n + 1) ≤ Y.size) (hY1 : ∀ j < R, ∀ τ < n, Y.data[j * (n + 1) + τ]! = dw X[(if t then j else j * n) + τ * (if t then R else 1)]!) (hY2 : ∀ j < R, 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[(if t then j else j * n) + τ * (if t then R else 1)]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE F Y.data[j * (n + 1) + n]!).toNat : Int) + 56) + 2 ^ (-900 : Int)) (hQs : ∀ g < (ow + 7) / 8, 8 * g * n + 1 + 8 * n ≤ Q.size) (hQ : ∀ g < (ow + 7) / 8, ∀ τ < n, ∀ r < 8, Q.data[8 * g * n + 1 + 8 * τ + r]! = dw W[(8 * g + r) * n + τ]!) (hBs : 8 * ((ow + 7) / 8) ≤ B.size) (hB1 : ∀ o < ow, B.data[o]! = dw oneW * dw bw[o]!) (hsz : R * ow + 9 * R + ow + 8 ≤ 4294967295) (g r : Nat) (hg : g < (ow + 7) / 8) (hr : r < R) (a : Array Word) (ha : a.size = R * ow) (A : A8) (hA : ∀ k < 8, 8 * g + k < ow → SB n (fun s => X[(if t then r else r * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! (A.f k)) : Iv (oF t R n ow relu X W bw) a (fun q => ∃ k, k < 8 ∧ 8 * g + k < ow ∧ q = if t then (8 * g + k) * R + r else r * ow + (8 * g + k)) (fP relu (eok && (e6 + 23 + cE F Y.data[r * (n + 1) + n]!) ≤ 400) (if (e6 + 23 + cE F Y.data[r * (n + 1) + n]!) < hb then hb else (e6 + 23 + cE F Y.data[r * (n + 1) + n]!)) n X W bw (if t then r else r * n) (if t then R else 1) (8 * g) (if t then 8 * g * R + r else r * ow + 8 * g).toUSize (if t then R else 1).toUSize (min 8 (ow - 8 * g)).toUSize Y Q (r * (n + 1)).toUSize A.a0 A.a1 A.a2 A.a3 A.a4 A.a5 A.a6 A.a7 a) := by subst hLd he6 hok hF hhb have ul := USize.le_size have hoo : 8 * g < ow := by clear*-hg;omega have h1 : r * (n + 1) + n < Y.size := by have := Nat.mul_le_mul_right (n + 1) hr; rw [Nat.succ_mul] at this; clear*-hYs this;omega have hvo : (r * (n + 1)).toUSize.toNat = r * (n + 1) := ts (by clear*-h1;omega) hs.1 have m1 : 8 * g * R ≤ ow * R := Nat.mul_le_mul_right R hoo.le have m2 : r * ow ≤ R * ow := Nat.mul_le_mul_right ow hr.le have cm : ow * R = R * ow := Nat.mul_comm _ _ have hq0 : (if t then 8 * g * R + r else r * ow + 8 * g).toUSize.toNat = if t then 8 * g * R + r else r * ow + 8 * g := toUSize_toNat (by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-cm hoo hr hsz m1 m2 ul;omega)) have hsu : (if t then R else 1).toUSize.toNat = if t then R else 1 := toUSize_toNat (by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-hsz ul;omega)) have hmu : (min 8 (ow - 8 * g)).toUSize.toNat = min 8 (ow - 8 * g) := toUSize_toNat (by clear*-ul;omega) have hI : ∀ k, (if t then 8 * g * R + r else r * ow + 8 * g) + k * (if t then R else 1) = if t then (8 * g + k) * R + r else r * ow + (8 * g + k) := fun k => by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte, Nat.mul_one, Nat.add_mul] <;> (clear*-;omega) have dm : ∀ a c m : Nat, c < m → (a * m + c) / m = a ∧ (a * m + c) % m = c := fun a c m h => ⟨by rw [Nat.add_comm, Nat.add_mul_div_right _ _ (by clear*-h;omega), Nat.div_eq_of_lt h, Nat.zero_add], by rw [Nat.add_comm, Nat.add_mul_mod_self_right, Nat.mod_eq_of_lt h]⟩ refine lr8h_mono _ _ _ _ _ (fun q ⟨k, hk, hok, hq⟩ => ⟨k, hk, ?_, ?_⟩) (fP_spec _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ a _ ?_ (by clear*-ha hsz;omega) fun k hk hk' => ?_) ·rw [hq0, hsu]; cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-cm hoo hr hsz m1 m2;omega) rotate_left ·rw [hmu]; clear*-hk hok hoo;omega ·rw [hq0, hsu, hI]; exact hq rw [hmu] at hk' have hok : 8 * g + k < ow := by clear*-hk hk';omega rw [hq0, hsu, hI] have hA' : A8.f ⟨A.a0, A.a1, A.a2, A.a3, A.a4, A.a5, A.a6, A.a7⟩ k = A.f k := rfl rw [hA'] simp only [hvo] have hpp : ∀ s < n, expOf W[(8 * g + k) * n + s]! ≠ 255 → fv (pp Y Q (r * (n + 1)) (8 * g * n + 1) k s) ∧ rv (pp Y Q (r * (n + 1)) (8 * g * n + 1) k s) = Core.tm X[(if t then r else r * n) + s * (if t then R else 1)]! W[(8 * g + k) * n + s]! := fun s hs' h => by rw [pp, gg, gg, hY1 r hr s hs', hQ g hg s hs' k hk]; exact pvV _ _ (hx _) h have hk0 : cellFB n relu X W bw (if t then r else r * n) (if t then R else 1) (8 * g + k) = act relu (dotOf (n + 1) (fun s => if s < n then X[(if t then r else r * n) + s * (if t then R else 1)]! else oneW) (fun s => if s < n then W[(8 * g + k) * n + s]! else bw[8 * g + k]!)) := by simp only [cellFB, x2d_eq] refine (pw3 relu n (fun s => X[(if t then r else r * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! ib IB _ e _ _ _ (fun _ => cellFB n relu X W bw (if t then r else r * n) (if t then R else 1) (8 * g + k)) (fun _ => sQ n relu X W bw Y Q (r * (n + 1)) (8 * g * n + 1) k (if t then r else r * n) (if t then R else 1) (8 * g + k)) (fun s _ => hx _) (hbq _) hib hL hL27 hibL hn (hA k hk hok) (fun s _ => he _) (hY2 r hr) (Nat.le_trans (cE_le _ _) (by decide : 969 ≤ 1000)) ?_ hk0 (fun hw => ?_)).trans ?_ ·rw [Nat.toUInt64_eq, UInt64.toNat_ofNat_of_lt' (by simp only [UInt64.size]; clear*-hibL;omega)] ·rw [sQ_eq] refine tS_eq _ _ _ _ _ _ _ _ (fun s hs' => ?_) ?_ (fun s _ => ?_) hL hL27 hk0 ·simpa only [if_pos hs'] using hpp s hs' (hw s hs') ·simpa only [lt_irrefl, ↓reduceIte] using pvV oneW bw[8 * g + k]! (by decide) (hbq _).1 ·by_cases h : s < n <;> simp only [h, ↓reduceIte] exacts [⟨hx _, hw s h⟩, ⟨by decide, (hbq _).1⟩] ·unfold oF cases t ·obtain ⟨d1, d2⟩ := dm r (8 * g + k) ow hok simp only [d1, d2, Bool.false_eq_true, ↓reduceIte, Nat.mul_one] ·obtain ⟨d1, d2⟩ := dm (8 * g + k) r R hr simp only [d1, d2, ↓reduceIte] def stp_spec (f4 t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (e : Word) (ib IB L : Nat) (hLd : L = Nat.log2 (n + 1) + 1) (he6 : e6 = if e.toUInt64 < 56 then 56 else e.toUInt64) (hok : eok = decide (e < 255)) (hF : F = (9 * (n + 1)).toUInt64.toInt64.toFloat) (hhb : hb = (ib + L - 50).toUInt64) (hx : ∀ q : Nat, expOf X[q]! ≠ 255) (hbq : ∀ q : Nat, expOf bw[q]! ≠ 255 ∧ idxOf bw[q]! ≤ IB) (hib : 174 + IB ≤ ib) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hibL : ib + L ≤ 425) (hn : 8 * n < 2 ^ 32) (he : ∀ q : Nat, (expOf W[q]!).toNat ≤ e.toNat) (hYs : R * (n + 1) ≤ Y.size) (hY1 : ∀ j < R, ∀ τ < n, Y.data[j * (n + 1) + τ]! = dw X[(if t then j else j * n) + τ * (if t then R else 1)]!) (hY2 : ∀ j < R, 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[(if t then j else j * n) + τ * (if t then R else 1)]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE F Y.data[j * (n + 1) + n]!).toNat : Int) + 56) + 2 ^ (-900 : Int)) (hQs : ∀ g < (ow + 7) / 8, 8 * g * n + 1 + 8 * n ≤ Q.size) (hQ : ∀ g < (ow + 7) / 8, ∀ τ < n, ∀ r < 8, Q.data[8 * g * n + 1 + 8 * τ + r]! = dw W[(8 * g + r) * n + τ]!) (hBs : 8 * ((ow + 7) / 8) ≤ B.size) (hB1 : ∀ o < ow, B.data[o]! = dw oneW * dw bw[o]!) (hsz : R * ow + 9 * R + ow + 8 ≤ 4294967295) (g r : Nat) (hg : g < (ow + 7) / 8) (hr : r < R) (a : Array Word) (ha : a.size = R * ow) : Iv (oF t R n ow relu X W bw) a (fun q => ∃ k, k < 8 ∧ 8 * g + k < ow ∧ q = if t then (8 * g + k) * R + r else r * ow + (8 * g + k)) (stp f4 t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a) := by have ul := USize.le_size have hoo : 8 * g < ow := by clear*-hg;omega have h1 : r * (n + 1) + n < Y.size := by have := Nat.mul_le_mul_right (n + 1) hr; rw [Nat.succ_mul] at this; clear*-hYs this;omega have h2 := hQs g hg have h3 : 8 * g + 8 ≤ B.size := by clear*-hBs hg;omega have hnu : n.toUSize.toNat = n := ts (by clear*-h1;omega) hs.1 have hvo : (r * (n + 1)).toUSize.toNat = r * (n + 1) := ts (by clear*-h1;omega) hs.1 have hoU : (8 * g).toUSize.toNat = 8 * g := ts (by clear*-h3;omega) hB have hoi : (8 * g * n + 1).toUSize.toNat = 8 * g * n + 1 := ts (by clear*-h2;omega) hs.2 have hBk : ∀ (c : USize) (m : Nat) (hc : c.toNat = m) (hm : m < 8) (hh : ((8 * g).toUSize + c).toNat < B.size) (ho : 8 * g + m < ow), B.uget ((8 * g).toUSize + c) hh = dw oneW * dw bw[8 * g + m]! := fun c m hc hm hh ho => by rw [ug, uadd (by clear*-hc hm ho hoU hsz ul;omega), hoU, hc, hB1 _ ho] have hY0 : ∀ h, Y.uget (r * (n + 1) + n).toUSize h = Y.data[r * (n + 1) + n]! := fun h => by rw [ug, ts h1.le hs.1] unfold stp; dsimp only rw [dif_pos ⟨h1, h2, h3⟩] cases f4 <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> first | rw [pk_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (8 * g * n + 1) _ _ _ _ _ _ _ _ _ _ _ _ rfl (by rw [hoi]; simp)] | rw [p4_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (8 * g * n + 1) _ _ _ _ _ _ _ _ _ _ _ _ le_rfl (by rw [hoi]; simp)] all_goals simp only [hY0, hnu, hvo, USize.toNat_zero] all_goals refine stp_fin t R n ow relu X W bw Y Q B F hb e6 eok hs hB e ib IB L hLd he6 hok hF hhb hx hbq hib hL hL27 hibL hn he hYs hY1 hY2 hQs hQ hBs hB1 hsz g r hg hr a ha ⟨_, _, _, _, _, _, _, _⟩ fun k hk hok => ?_ all_goals ( have hpp : ∀ s < n, expOf W[(8 * g + k) * n + s]! ≠ 255 → fv (pp Y Q (r * (n + 1)) (8 * g * n + 1) k s) ∧ rv (pp Y Q (r * (n + 1)) (8 * g * n + 1) k s) = Core.tm X[(if t then r else r * n) + s * (if t then R else 1)]! W[(8 * g + k) * n + s]! := fun s hs' h => by rw [pp, gg, gg, hY1 r hr s hs', hQ g hg s hs' k hk]; exact pvV _ _ (hx _) h have := pS n (fun s => X[(if t then r else r * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! (pp Y Q (r * (n + 1)) (8 * g * n + 1) k) (hbq _).1 hn hpp have e : ∀ z : Float, z = dw oneW * dw bw[8 * g + k]! → SB n (fun s => X[(if t then r else r * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! (sfold (pp Y Q (r * (n + 1)) (8 * g * n + 1) k) n 0 z) := fun z h => h ▸ this interval_cases k <;> (simp only [A8.f]; exact e _ (hBk _ _ (by simp only [USize.reduceToNat]) (by omega) _ hok))) @[inline] def stpZ (t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (D : ByteArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 31 ∧ Q.size < 2 ^ 31 ∧ D.size < 2 ^ 31) (hB : B.size < 2 ^ 32) (hDs : R * (2 * n + 2) ≤ D.size) (hD : ∀ r < R, RL D (r * (2 * n + 2)) n (nzf t R n X r)) (g r : Nat) (a : Array Word) : Array Word := let vo := r * (n + 1) let o := 8 * g if h : r < R ∧ vo + n < Y.size ∧ o * n + 1 + 8 * n ≤ Q.size ∧ o + 8 ≤ B.size then have hd1 : (r + 1) * (2 * n + 2) ≤ R * (2 * n + 2) := Nat.mul_le_mul_right _ h.1 have hd2 : r * (2 * n + 2) + (2 * n + 2) ≤ D.size := by rw [Nat.add_mul, Nat.one_mul] at hd1; omega have hdb : (r * (2 * n + 2)).toUSize.toNat = r * (2 * n + 2) := ts (S := D.size) (by omega) (by omega) have hd3 : (r * (2 * n + 2) + 2).toUSize.toNat = r * (2 * n + 2) + 2 := ts (S := D.size) (by omega) (by omega) have hn : n.toUSize.toNat = n := ts (S := Y.size) (by omega) (by omega) have hv : vo.toUSize.toNat = vo := ts (S := Y.size) (by omega) (by omega) have hb8 : o.toUSize.toNat + 8 ≤ B.size := by rw [ts (by omega) hB]; exact h.2.2.2 let bo := o.toUSize let p := e6 + 23 + cE F (Y.uget (vo + n).toUSize (by rw [ts (S := Y.size) (by omega) (by omega)]; exact h.2.1)) let nu := jr D (r * (2 * n + 2)).toUSize (by rw [hdb]; omega) (by omega) have hu : nu.toNat = J D (r * (2 * n + 2)) := by rw [jr_eq, hdb] pz Y Q D (r * (2 * n + 2) + 2).toUSize vo.toUSize (o * n + 1).toUSize nu n.toUSize hs (by rw [hd3, hu]; have := (hD r h.1).1; omega) (by rw [hv, hn]; omega) (by rw [ts (S := Q.size) (by omega) (by omega), hn]; omega) (fun c hc => by rw [hu] at hc; rw [hd3, hn]; exact (hD r h.1).2.1 c hc) 0 (B.uget (bo + 0) (uk (by simp) hb8 hB)) (B.uget (bo + 1) (uk (by simp) hb8 hB)) (B.uget (bo + 2) (uk (by simp) hb8 hB)) (B.uget (bo + 3) (uk (by simp) hb8 hB)) (B.uget (bo + 4) (uk (by simp) hb8 hB)) (B.uget (bo + 5) (uk (by simp) hb8 hB)) (B.uget (bo + 6) (uk (by simp) hb8 hB)) (B.uget (bo + 7) (uk (by simp) hb8 hB)) relu (eok && p ≤ 400) (if p < hb then hb else p) n X W bw (if t then r else r * n) (if t then R else 1) o (if t then o * R + r else r * ow + o).toUSize (if t then R else 1).toUSize (min 8 (ow - o)).toUSize a else a def stpZ_spec (t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (D : ByteArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 31 ∧ Q.size < 2 ^ 31 ∧ D.size < 2 ^ 31) (hB : B.size < 2 ^ 32) (hDs : R * (2 * n + 2) ≤ D.size) (hD : ∀ r < R, RL D (r * (2 * n + 2)) n (nzf t R n X r)) (e : Word) (ib IB L : Nat) (hLd : L = Nat.log2 (n + 1) + 1) (he6 : e6 = if e.toUInt64 < 56 then 56 else e.toUInt64) (hok : eok = decide (e < 255)) (hF : F = (9 * (n + 1)).toUInt64.toInt64.toFloat) (hhb : hb = (ib + L - 50).toUInt64) (hx : ∀ q : Nat, expOf X[q]! ≠ 255) (hbq : ∀ q : Nat, expOf bw[q]! ≠ 255 ∧ idxOf bw[q]! ≤ IB) (hib : 174 + IB ≤ ib) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hibL : ib + L ≤ 425) (hn : 8 * n < 2 ^ 32) (he : ∀ q : Nat, (expOf W[q]!).toNat ≤ e.toNat) (hYs : R * (n + 1) ≤ Y.size) (hY1 : ∀ j < R, ∀ τ < n, Y.data[j * (n + 1) + τ]! = dw X[(if t then j else j * n) + τ * (if t then R else 1)]!) (hY2 : ∀ j < R, 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[(if t then j else j * n) + τ * (if t then R else 1)]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE F Y.data[j * (n + 1) + n]!).toNat : Int) + 56) + 2 ^ (-900 : Int)) (hQs : ∀ g < (ow + 7) / 8, 8 * g * n + 1 + 8 * n ≤ Q.size) (hQ : ∀ g < (ow + 7) / 8, ∀ τ < n, ∀ r < 8, Q.data[8 * g * n + 1 + 8 * τ + r]! = dw W[(8 * g + r) * n + τ]!) (hBs : 8 * ((ow + 7) / 8) ≤ B.size) (hB1 : ∀ o < ow, B.data[o]! = dw oneW * dw bw[o]!) (hsz : R * ow + 9 * R + ow + 8 ≤ 4294967295) (g r : Nat) (hg : g < (ow + 7) / 8) (hr : r < R) (a : Array Word) (ha : a.size = R * ow) : Iv (oF t R n ow relu X W bw) a (fun q => ∃ k, k < 8 ∧ 8 * g + k < ow ∧ q = if t then (8 * g + k) * R + r else r * ow + (8 * g + k)) (stpZ t R n ow relu X W bw Y Q B D F hb e6 eok hs hB hDs hD g r a) := by have ul := USize.le_size have hoo : 8 * g < ow := by clear*-hg;omega have h1 : r * (n + 1) + n < Y.size := by have := Nat.mul_le_mul_right (n + 1) hr; rw [Nat.succ_mul] at this; clear*-hYs this;omega have h2 := hQs g hg have h3 : 8 * g + 8 ≤ B.size := by clear*-hBs hg;omega have hnu : n.toUSize.toNat = n := ts (S := Y.size) (by clear*-h1;omega) (by clear*-hs;omega) have hvo : (r * (n + 1)).toUSize.toNat = r * (n + 1) := ts (S := Y.size) (by clear*-h1;omega) (by clear*-hs;omega) have hoU : (8 * g).toUSize.toNat = 8 * g := ts (by clear*-h3;omega) hB have hoi : (8 * g * n + 1).toUSize.toNat = 8 * g * n + 1 := ts (S := Q.size) (by clear*-h2;omega) (by clear*-hs;omega) have hd1 : (r + 1) * (2 * n + 2) ≤ R * (2 * n + 2) := Nat.mul_le_mul_right _ hr have hd2 : r * (2 * n + 2) + (2 * n + 2) ≤ D.size := by rw [Nat.add_mul, Nat.one_mul] at hd1; clear*-hDs hd1;omega have hd3 : (r * (2 * n + 2) + 2).toUSize.toNat = r * (2 * n + 2) + 2 := ts (S := D.size) (by clear*-hd2;omega) (by clear*-hs;omega) have hdb : (r * (2 * n + 2)).toUSize.toNat = r * (2 * n + 2) := ts (S := D.size) (by clear*-hd2;omega) (by clear*-hs;omega) obtain ⟨l0, l1, l2', l3⟩ := hD r hr have hBk : ∀ (c : USize) (m : Nat) (hc : c.toNat = m) (hm : m < 8) (hh : ((8 * g).toUSize + c).toNat < B.size) (ho : 8 * g + m < ow), B.uget ((8 * g).toUSize + c) hh = dw oneW * dw bw[8 * g + m]! := fun c m hc hm hh ho => by rw [ug, uadd (by clear*-hc hm ho hoU hsz ul;omega), hoU, hc, hB1 _ ho] have hY0 : ∀ h, Y.uget (r * (n + 1) + n).toUSize h = Y.data[r * (n + 1) + n]! := fun h => by rw [ug, ts (S := Y.size) h1.le (by clear*-hs;omega)] unfold stpZ; dsimp only rw [dif_pos ⟨hr, h1, h2, h3⟩, pz_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ rfl] simp only [hY0, hoi, hvo, hd3, USize.toNat_zero, jr_eq, hdb] refine stp_fin t R n ow relu X W bw Y Q B F hb e6 eok ⟨by clear*-hs;omega, by clear*-hs;omega⟩ hB e ib IB L hLd he6 hok hF hhb hx hbq hib hL hL27 hibL hn he hYs hY1 hY2 hQs hQ hBs hB1 hsz g r hg hr a ha ⟨_, _, _, _, _, _, _, _⟩ fun k hk hok => ?_ have hpp : ∀ s < n, expOf W[(8 * g + k) * n + s]! ≠ 255 → fv (pp Y Q (r * (n + 1)) (8 * g * n + 1) k s) ∧ rv (pp Y Q (r * (n + 1)) (8 * g * n + 1) k s) = Core.tm X[(if t then r else r * n) + s * (if t then R else 1)]! W[(8 * g + k) * n + s]! := fun s hs' h => by rw [pp, gg, gg, hY1 r hr s hs', hQ g hg s hs' k hk]; exact pvV _ _ (hx _) h have := pSz n (J D (r * (2 * n + 2))) (fun s => X[(if t then r else r * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! (fun c => J D (r * (2 * n + 2) + 2 + 2 * c)) (pp Y Q (r * (n + 1)) (8 * g * n + 1) k) (hbq _).1 hn l0 l1 l2' (fun s hs' hc => by by_contra hz obtain ⟨c, h1, h2⟩ := l3 s hs' hz exact hc c h1 h2) hpp have e : ∀ z : Float, z = dw oneW * dw bw[8 * g + k]! → SB n (fun s => X[(if t then r else r * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! (sfold (fun c => pp Y Q (r * (n + 1)) (8 * g * n + 1) k (J D (r * (2 * n + 2) + 2 + 2 * c))) (J D (r * (2 * n + 2))) 0 z) := fun z h => h ▸ this interval_cases k <;> (simp only [A8.f]; exact e _ (hBk _ _ (by simp only [USize.reduceToNat]) (by omega) _ hok)) def Iv_cmp {F : Nat → Word} {a A C : Array Word} {P Q : Nat → Prop} (h1 : Iv F a P A) (h2 : Iv F A Q C) : Iv F a (fun q => P q ∨ Q q) C := by refine ⟨h2.1.trans h1.1, fun q => ⟨?_, fun hq hs => ?_⟩⟩ ·rcases (h2.2 q).1 with e | e ·rw [e]; exact (h1.2 q).1 ·exact .inr e ·rcases hq with hq | hq ·have e := (h1.2 q).2 hq hs rcases (h2.2 q).1 with e' | e' ·rw [e', e] ·exact e' ·exact (h2.2 q).2 hq (by rw [h1.1]; exact hs) def Iv_cmp' {F : Nat → Word} {a A C : Array Word} {P Q : Nat → Prop} {N : Nat} (ha : a.size = N) (h1 : Iv F a P A) (h2 : A.size = N → Iv F A Q C) : Iv F a (fun q => P q ∨ Q q) C := Iv_cmp h1 (h2 (h1.1.trans ha)) @[inline] def stp2 (t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (g r : Nat) (a : Array Word) : Array Word := let vo := r * (n + 1) let wo := (r + 1) * (n + 1) let o := 8 * g if h : vo + n ≤ wo ∧ wo + n < Y.size ∧ o * n + 1 + 8 * n ≤ Q.size ∧ o + 8 ≤ B.size then have hn : n.toUSize.toNat = n := ts (by omega) hs.1 have hv : vo.toUSize.toNat = vo := ts (by omega) hs.1 have hw : wo.toUSize.toNat = wo := ts (by omega) hs.1 have hb8 : o.toUSize.toNat + 8 ≤ B.size := by rw [ts (by omega) hB]; exact h.2.2.2 let bo := o.toUSize let p := e6 + 23 + cE F (Y.uget (vo + n).toUSize (by rw [ts (by omega) hs.1]; omega)) let p2 := e6 + 23 + cE F (Y.uget (wo + n).toUSize (by rw [ts (by omega) hs.1]; omega)) let c0 := B.uget (bo + 0) (uk (by simp) hb8 hB) let c1 := B.uget (bo + 1) (uk (by simp) hb8 hB) let c2 := B.uget (bo + 2) (uk (by simp) hb8 hB) let c3 := B.uget (bo + 3) (uk (by simp) hb8 hB) let c4 := B.uget (bo + 4) (uk (by simp) hb8 hB) let c5 := B.uget (bo + 5) (uk (by simp) hb8 hB) let c6 := B.uget (bo + 6) (uk (by simp) hb8 hB) let c7 := B.uget (bo + 7) (uk (by simp) hb8 hB) pk2 Y Q vo.toUSize wo.toUSize n.toUSize hs (by rw [hv, hn]; omega) (by rw [hw, hn]; omega) 0 (o * n + 1).toUSize (by rw [ts (by omega) hs.2, hn]; simp only [USize.toNat_zero, Nat.sub_zero]; omega) c0 c1 c2 c3 c4 c5 c6 c7 c0 c1 c2 c3 c4 c5 c6 c7 relu (eok && p ≤ 400) (eok && p2 ≤ 400) (if p < hb then hb else p) (if p2 < hb then hb else p2) n X W bw (if t then r else r * n) (if t then r + 1 else (r + 1) * n) (if t then R else 1) o (if t then o * R + r else r * ow + o).toUSize (if t then o * R + (r + 1) else (r + 1) * ow + o).toUSize (if t then R else 1).toUSize (min 8 (ow - o)).toUSize a else a def stp2_spec (t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (e : Word) (ib IB L : Nat) (hLd : L = Nat.log2 (n + 1) + 1) (he6 : e6 = if e.toUInt64 < 56 then 56 else e.toUInt64) (hok : eok = decide (e < 255)) (hF : F = (9 * (n + 1)).toUInt64.toInt64.toFloat) (hhb : hb = (ib + L - 50).toUInt64) (hx : ∀ q : Nat, expOf X[q]! ≠ 255) (hbq : ∀ q : Nat, expOf bw[q]! ≠ 255 ∧ idxOf bw[q]! ≤ IB) (hib : 174 + IB ≤ ib) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hibL : ib + L ≤ 425) (hn : 8 * n < 2 ^ 32) (he : ∀ q : Nat, (expOf W[q]!).toNat ≤ e.toNat) (hYs : R * (n + 1) ≤ Y.size) (hY1 : ∀ j < R, ∀ τ < n, Y.data[j * (n + 1) + τ]! = dw X[(if t then j else j * n) + τ * (if t then R else 1)]!) (hY2 : ∀ j < R, 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[(if t then j else j * n) + τ * (if t then R else 1)]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE F Y.data[j * (n + 1) + n]!).toNat : Int) + 56) + 2 ^ (-900 : Int)) (hQs : ∀ g < (ow + 7) / 8, 8 * g * n + 1 + 8 * n ≤ Q.size) (hQ : ∀ g < (ow + 7) / 8, ∀ τ < n, ∀ r < 8, Q.data[8 * g * n + 1 + 8 * τ + r]! = dw W[(8 * g + r) * n + τ]!) (hBs : 8 * ((ow + 7) / 8) ≤ B.size) (hB1 : ∀ o < ow, B.data[o]! = dw oneW * dw bw[o]!) (hsz : R * ow + 9 * R + ow + 8 ≤ 4294967295) (g r : Nat) (hg : g < (ow + 7) / 8) (hr : r < R) (a : Array Word) (ha : a.size = R * ow) (hr1 : r + 1 < R) : Iv (oF t R n ow relu X W bw) a (fun q => (∃ k, k < 8 ∧ 8 * g + k < ow ∧ q = if t then (8 * g + k) * R + r else r * ow + (8 * g + k)) ∨ ∃ k, k < 8 ∧ 8 * g + k < ow ∧ q = if t then (8 * g + k) * R + (r + 1) else (r + 1) * ow + (8 * g + k)) (stp2 t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a) := by have ul := USize.le_size have hoo : 8 * g < ow := by clear*-hg;omega have h1 : (r + 1) * (n + 1) + n < Y.size := by have := Nat.mul_le_mul_right (n + 1) hr1; rw [Nat.succ_mul] at this; clear*-hYs this;omega have h0 : r * (n + 1) + n ≤ (r + 1) * (n + 1) := by rw [Nat.add_mul, Nat.one_mul]; clear*-;omega have h2 := hQs g hg have h3 : 8 * g + 8 ≤ B.size := by clear*-hBs hg;omega have hnu : n.toUSize.toNat = n := ts (by clear*-h1;omega) hs.1 have hvo : (r * (n + 1)).toUSize.toNat = r * (n + 1) := ts (by clear*-h0 h1;omega) hs.1 have hwo : ((r + 1) * (n + 1)).toUSize.toNat = (r + 1) * (n + 1) := ts (by clear*-h1;omega) hs.1 have hoU : (8 * g).toUSize.toNat = 8 * g := ts (by clear*-h3;omega) hB have hoi : (8 * g * n + 1).toUSize.toNat = 8 * g * n + 1 := ts (by clear*-h2;omega) hs.2 have hBk : ∀ (c : USize) (m : Nat) (hc : c.toNat = m) (hm : m < 8) (hh : ((8 * g).toUSize + c).toNat < B.size) (ho : 8 * g + m < ow), B.uget ((8 * g).toUSize + c) hh = dw oneW * dw bw[8 * g + m]! := fun c m hc hm hh ho => by rw [ug, uadd (by clear*-hc ho hoU hsz ul;omega), hoU, hc, hB1 _ ho] have hYa : ∀ h, Y.uget (r * (n + 1) + n).toUSize h = Y.data[r * (n + 1) + n]! := fun h => by rw [ug, ts (by clear*-h0 h1;omega) hs.1] have hYb : ∀ h, Y.uget ((r + 1) * (n + 1) + n).toUSize h = Y.data[(r + 1) * (n + 1) + n]! := fun h => by rw [ug, ts (by clear*-h1;omega) hs.1] unfold stp2; dsimp only rw [dif_pos ⟨h0, h1, h2, h3⟩, pk2_eq _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (8 * g * n + 1) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ rfl (by rw [hoi]; simp)] simp only [hYa, hYb, hoi, hnu, hvo, hwo, USize.toNat_zero] have S : ∀ r', r' < R → ∀ k, k < 8 → 8 * g + k < ow → ∀ z : Float, z = dw oneW * dw bw[8 * g + k]! → SB n (fun s => X[(if t then r' else r' * n) + s * (if t then R else 1)]!) (fun s => W[(8 * g + k) * n + s]!) bw[8 * g + k]! (sfold (pp Y Q (r' * (n + 1)) (8 * g * n + 1) k) n 0 z) := fun r' hr' k hk hok z hz => by subst hz exact pS n _ _ _ _ (hbq _).1 hn fun s hs' h => by rw [pp, gg, gg, hY1 r' hr' s hs', hQ g hg s hs' k hk]; exact pvV _ _ (hx _) h refine Iv_cmp' ha (stp_fin t R n ow relu X W bw Y Q B F hb e6 eok hs hB e ib IB L hLd he6 hok hF hhb hx hbq hib hL hL27 hibL hn he hYs hY1 hY2 hQs hQ hBs hB1 hsz g r hg hr a ha ⟨_, _, _, _, _, _, _, _⟩ fun k hk hok => ?_) (fun hA => stp_fin t R n ow relu X W bw Y Q B F hb e6 eok hs hB e ib IB L hLd he6 hok hF hhb hx hbq hib hL hL27 hibL hn he hYs hY1 hY2 hQs hQ hBs hB1 hsz g (r + 1) hg hr1 _ hA ⟨_, _, _, _, _, _, _, _⟩ fun k hk hok => ?_) ·interval_cases k <;> (simp only [A8.f]; exact S r hr _ (by omega) hok _ (hBk _ _ (by simp only [USize.reduceToNat]) (by omega) _ hok)) ·interval_cases k <;> (simp only [A8.f]; exact S (r + 1) hr1 _ (by omega) hok _ (hBk _ _ (by simp only [USize.reduceToNat]) (by omega) _ hok)) def cq (t : Bool) (R ow g r q : Nat) : Prop := ∃ k, k < 8 ∧ 8 * g + k < ow ∧ q = if t then (8 * g + k) * R + r else r * ow + (8 * g + k) @[inline] def stq (two t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (g r : Nat) (a : Array Word) : Array Word := if two then if r % 2 = 1 then a else if r + 1 < R then if 4 < ow - 8 * g then stp2 t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a else stp false t R n ow relu X W bw Y Q B F hb e6 eok hs hB g (r + 1) (stp false t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a) else stp false t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a else stp false t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a def stq_spec (two t : Bool) (R n ow : Nat) (relu : Bool) (X W bw : Array Word) (Y Q B : FloatArray) (F : Float) (hb e6 : UInt64) (eok : Bool) (hs : Y.size < 2 ^ 32 ∧ Q.size < 2 ^ 32) (hB : B.size < 2 ^ 32) (e : Word) (ib IB L : Nat) (hLd : L = Nat.log2 (n + 1) + 1) (he6 : e6 = if e.toUInt64 < 56 then 56 else e.toUInt64) (hok : eok = decide (e < 255)) (hF : F = (9 * (n + 1)).toUInt64.toInt64.toFloat) (hhb : hb = (ib + L - 50).toUInt64) (hx : ∀ q : Nat, expOf X[q]! ≠ 255) (hbq : ∀ q : Nat, expOf bw[q]! ≠ 255 ∧ idxOf bw[q]! ≤ IB) (hib : 174 + IB ≤ ib) (hL : n + 2 ≤ 2 ^ L) (hL27 : L ≤ 27) (hibL : ib + L ≤ 425) (hn : 8 * n < 2 ^ 32) (he : ∀ q : Nat, (expOf W[q]!).toNat ≤ e.toNat) (hYs : R * (n + 1) ≤ Y.size) (hY1 : ∀ j < R, ∀ τ < n, Y.data[j * (n + 1) + τ]! = dw X[(if t then j else j * n) + τ * (if t then R else 1)]!) (hY2 : ∀ j < R, 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[(if t then j else j * n) + τ * (if t then R else 1)]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE F Y.data[j * (n + 1) + n]!).toNat : Int) + 56) + 2 ^ (-900 : Int)) (hQs : ∀ g < (ow + 7) / 8, 8 * g * n + 1 + 8 * n ≤ Q.size) (hQ : ∀ g < (ow + 7) / 8, ∀ τ < n, ∀ r < 8, Q.data[8 * g * n + 1 + 8 * τ + r]! = dw W[(8 * g + r) * n + τ]!) (hBs : 8 * ((ow + 7) / 8) ≤ B.size) (hB1 : ∀ o < ow, B.data[o]! = dw oneW * dw bw[o]!) (hsz : R * ow + 9 * R + ow + 8 ≤ 4294967295) (g r : Nat) (hg : g < (ow + 7) / 8) (hr : r < R) (a : Array Word) (ha : a.size = R * ow) : Iv (oF t R n ow relu X W bw) a (fun q => if two then r % 2 = 0 ∧ (cq t R ow g r q ∨ (r + 1 < R ∧ cq t R ow g (r + 1) q)) else cq t R ow g r q) (stq two t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r a) := by have P : ∀ r' a', r' < R → a'.size = R * ow → Iv (oF t R n ow relu X W bw) a' (cq t R ow g r') (stp false t R n ow relu X W bw Y Q B F hb e6 eok hs hB g r' a') := fun r' a' h1 h2 => stp_spec false t R n ow relu X W bw Y Q B F hb e6 eok hs hB e ib IB L hLd he6 hok hF hhb hx hbq hib hL hL27 hibL hn he hYs hY1 hY2 hQs hQ hBs hB1 hsz g r' hg h1 a' h2 unfold stq cases two ·simpa using P r a hr ha simp only [↓reduceIte] by_cases h1 : r % 2 = 1 ·rw [if_pos h1] exact ⟨rfl, fun q => ⟨.inl rfl, fun hq => by clear*-h1 hq;omega⟩⟩ rw [if_neg h1] by_cases h2 : r + 1 < R ·rw [if_pos h2] have m : ∀ (A : Array Word), Iv (oF t R n ow relu X W bw) a (fun q => cq t R ow g r q ∨ cq t R ow g (r + 1) q) A → Iv (oF t R n ow relu X W bw) a (fun q => r % 2 = 0 ∧ (cq t R ow g r q ∨ (r + 1 < R ∧ cq t R ow g (r + 1) q))) A := fun A h => lr8h_mono _ _ _ _ _ (fun q ⟨_, h3⟩ => h3.imp id (·.2)) h split ·exact m _ (stp2_spec t R n ow relu X W bw Y Q B F hb e6 eok hs hB e ib IB L hLd he6 hok hF hhb hx hbq hib hL hL27 hibL hn he hYs hY1 hY2 hQs hQ hBs hB1 hsz g r hg hr a ha h2) ·exact m _ (Iv_cmp' ha (P r a hr ha) fun hA => P (r + 1) _ h2 hA) ·rw [if_neg h2] exact lr8h_mono _ _ _ _ _ (fun q ⟨_, h3⟩ => h3.elim id fun h => absurd h.1 h2) (P r a hr ha) @[inline] def tw (R n : Nat) : Bool := 2 ≤ R ∧ 64 ≤ n def isA : Bool := System.Platform.target.startsWith "aarch64" @[inline] def runY (t : Bool) (R n ow : Nat) (relu : Bool) (X W : Array Word) (d : PD) (ex : Word) (Y : FloatArray) : Array Word := let L := Nat.log2 (n + 1) + 1 let ib := 174 + (d.eb.toNat - 1) if h : ex < 255 ∧ d.eb < 255 ∧ ib + L ≤ 425 ∧ L ≤ 27 ∧ 0 < n ∧ 8 * n ≤ 4294967295 ∧ X.size ≤ 4294967295 ∧ ow * n ≤ W.size ∧ 2 * W.size + 64 * n ≤ 4294967295 ∧ d.bw.size ≤ 4294967295 ∧ R * ow + 9 * R + ow + 8 ≤ 4294967295 ∧ R * (n + 1) + 8 ≤ 4294967295 ∧ R * (if t then 1 else n) + (n + 1) * (if t then R else 1) ≤ 4294967295 ∧ Y.size ≤ 4294967295 ∧ d.Q.size ≤ 4294967295 ∧ d.B.size ≤ 4294967295 then let e6 := d.e.toUInt64 if h2 : 32 ≤ ow ∧ n < 65536 ∧ R * (2 * n + 2) + 8 < 2 ^ 31 ∧ Y.size < 2 ^ 31 ∧ d.Q.size < 2 ^ 31 ∧ 8 ≤ zc X 32 0 0 then have hz := czR_spec t R n X (lt32 h.2.2.2.2.2.2.1) h2.2.1 h2.2.2.1 h.2.2.2.2.2.2.2.2.2.2.2.2.1 let D := czR t R n X l2 ((ow + 7) / 8) R (stpZ t R n ow relu X W d.bw Y d.Q d.B D (9 * (n + 1)).toUInt64.toInt64.toFloat (ib + L - 50).toUInt64 (if e6 < 56 then 56 else e6) (decide (d.e < 255)) ⟨h2.2.2.2.1, h2.2.2.2.2.1, hz.1⟩ (lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2) hz.2.1 hz.2.2) 0 0 (Array.replicate (R * ow) 0) else if isA then l2 ((ow + 7) / 8) R (stp true t R n ow relu X W d.bw Y d.Q d.B (9 * (n + 1)).toUInt64.toInt64.toFloat (ib + L - 50).toUInt64 (if e6 < 56 then 56 else e6) (decide (d.e < 255)) ⟨lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.1, lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.2.1⟩ (lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2)) 0 0 (Array.replicate (R * ow) 0) else l2 ((ow + 7) / 8) R (stq (tw R n) t R n ow relu X W d.bw Y d.Q d.B (9 * (n + 1)).toUInt64.toInt64.toFloat (ib + L - 50).toUInt64 (if e6 < 56 then 56 else e6) (decide (d.e < 255)) ⟨lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.1, lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.2.1⟩ (lt32 h.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2)) 0 0 (Array.replicate (R * ow) 0) else Array.ofFn (n := R * ow) fun q => cellFB n relu X W d.bw (if t then q.val % R else q.val / ow * n) (if t then R else 1) (if t then q.val / R else q.val % ow) @[inline] def run (t : Bool) (R n ow : Nat) (relu : Bool) (X W : Array Word) (d : PD) (ex : Word) : Array Word := runY t R n ow relu X W d ex (dO X (if t then R else 1).toUSize (if t then 1 else n).toUSize (n + 1).toUSize n R (0 : Nat).toUSize 0 (zT ((R * (n + 1) + 7) / 8))) def pd_spec (W b : Array Word) (n ow : Nat) (hn : 0 < n) (ho : ow * n ≤ W.size) (hs : 2 * W.size + 64 * n ≤ 4294967295) (hbw : (pd W b n).bw.size < 2 ^ 32) : (∀ g < (ow + 7) / 8, 8 * g * n + 1 + 8 * n ≤ (pd W b n).Q.size) ∧ (∀ g < (ow + 7) / 8, ∀ τ < n, ∀ r < 8, (pd W b n).Q.data[8 * g * n + 1 + 8 * τ + r]! = dw W[(8 * g + r) * n + τ]!) ∧ 8 * ((ow + 7) / 8) ≤ (pd W b n).B.size ∧ ∀ o < ow, (pd W b n).B.data[o]! = dw oneW * dw (pd W b n).bw[o]! := by have ul := USize.le_size have h1 : ow ≤ W.size / n := (Nat.le_div_iff_mul_le hn).2 ho have h2 : W.size / n * n ≤ W.size := Nat.div_mul_le_self _ _ have h2' : W.size / n ≤ W.size := Nat.div_le_self _ _ generalize hO : W.size / n = O at h1 h2 h2' have h3 : (O + 7) / 8 * (8 * n) ≤ W.size + 7 * n := by have : 8 * ((O + 7) / 8) * n ≤ (O + 7) * n := Nat.mul_le_mul_right n (by clear*-;omega) rw [Nat.add_mul] at this rw [show (O + 7) / 8 * (8 * n) = 8 * ((O + 7) / 8) * n by ac_rfl]; clear*-h2 this;omega have hG : (ow + 7) / 8 ≤ (O + 7) / 8 := by clear*-h1;omega obtain ⟨z1, -⟩ := zsz (n * ((O + 7) / 8) + 1) have hc : 8 * (n * ((O + 7) / 8) + 1) = (O + 7) / 8 * (8 * n) + 8 := by ring have h0 : (0 : Nat).toUSize.toNat = 0 := toUSize_toNat (by clear*-ul;omega) obtain ⟨q1, -, q3⟩ := qL_spec W n.toUSize (8 * n).toUSize n (toUSize_toNat (by clear*-hs ul;omega)) (toUSize_toNat (by clear*-hs ul;omega)) ((O + 7) / 8) (0 : Nat).toUSize (zT (n * ((O + 7) / 8) + 1)) (by rw [h0]; clear*-h3 hn hs;omega) (by rw [h0]; clear*-hc z1;omega) have hb1 := bld_spec (fun o => dw oneW * rX (pd W b n).bw o.toUSize) (8 * ((O + 7) / 8)) _ (FloatArray.emptyWithCapacity (8 * ((O + 7) / 8))) rfl (Nat.zero_le _) have eQ : (pd W b n).Q = qL W n.toUSize (8 * n).toUSize n ((O + 7) / 8) (0 : Nat).toUSize (zT (n * ((O + 7) / 8) + 1)) := by simp only [pd, hO]; rfl have eB : (pd W b n).B = bld (fun o => dw oneW * rX (pd W b n).bw o.toUSize) (8 * ((O + 7) / 8)) (FloatArray.emptyWithCapacity (8 * ((O + 7) / 8))) := by simp only [pd, hO] refine ⟨fun g hg => ?_, fun g hg τ hτ r hr => ?_, ?_, fun o ho' => ?_⟩ ·have := Nat.mul_le_mul_right (8 * n) (show g + 1 ≤ (O + 7) / 8 by clear*-hG hg;omega) rw [Nat.add_mul, Nat.one_mul] at this rw [eQ, q1, show 8 * g * n = g * (8 * n) by ac_rfl]; clear*-hc this z1;omega ·have := q3 g (by clear*-hG hg;omega) τ hτ r hr rw [h0, Nat.zero_add] at this rw [eQ, show 8 * g * n = g * (8 * n) by ac_rfl, this] congr 2; rw [Nat.add_mul, show 8 * g * n = g * (8 * n) by ac_rfl]; clear*-;omega ·rw [eB, hb1.1]; clear*-hG;omega ·rw [eB, hb1.2.2 o (Nat.zero_le _) (by clear*-h1 ho';omega)] rw [rX_eq _ hbw, toUSize_toNat (by clear*-h1 h2' ho' hs ul;omega)] def dp {c : Prop} [Decidable c] {α : Type} {a : c → α} {b : ¬c → α} {y : α} (h1 : ∀ h : c, a h = y) (h2 : ∀ h, b h = y) : dite c a b = y := by by_cases h : c ·rw [dif_pos h]; exact h1 h ·rw [dif_neg h]; exact h2 h def run_eq (t : Bool) (R n ow : Nat) (relu : Bool) (X W b : Array Word) (ex : Word) (hex : ex = emx X 0 0) : run t R n ow relu X W (pd W b n) ex = Array.ofFn (n := R * ow) fun q => oF t R n ow relu X W (pd W b n).bw q.val := by have ul := USize.le_size unfold run runY; dsimp only refine dp (fun h => ?_) fun _ => ?_ swap ·congr 1; funext q; unfold oF; cases t <;> simp only [cellFB, x2d_eq, Nat.mul_one, ↓reduceIte, Bool.false_eq_true] obtain ⟨g1, g2, g3, g4, g5, g6, g7, g8, g9, g10, g11, g12, g13, g14, g15, g16⟩ := h obtain ⟨P1, P2, P3, P4⟩ := pd_spec W b n ow g5 g8 g9 (lt32 g10) have hx := exF X (by clear*-g7 ul;omega) (hex ▸ g1) have hbq := exF (pd W b n).bw (by clear*-g10 ul;omega) g2 have he : ∀ q : Nat, (expOf W[q]!).toNat ≤ (pd W b n).e.toNat := fun q => by by_cases hq : q < W.size ·exact (emx_spec W (by clear*-g5 g9 ul;omega) _ 0 0 rfl).2 q (by simp) hq ·rw [getElem!_neg W q hq]; exact Nat.zero_le _ have hL : n + 2 ≤ 2 ^ (Nat.log2 (n + 1) + 1) := @Nat.lt_log2_self (n + 1) have hR1 : R ≤ R * (n + 1) := Nat.le_mul_of_pos_right _ (by clear*-g5;omega) obtain ⟨z1, z2⟩ := zsz ((R * (n + 1) + 7) / 8) have hZ : (zT ((R * (n + 1) + 7) / 8)).size < 2 ^ 32 := by rcases z2 with h | h <;> (clear*-g12 h;omega) have hsu : (if t then 1 else n) < 2 ^ 32 := by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-g5 g6;omega) have hst : (if t then R else 1) < 2 ^ 32 := by cases t <;> simp only [Bool.false_eq_true, ↓reduceIte] <;> (clear*-g11;omega) have K := dO_spec X (if t then R else 1).toUSize (if t then 1 else n).toUSize (n + 1).toUSize n (toUSize_toNat (by clear*-g5 g6 ul;omega)) (by clear*-g5 g6;omega) R (0 : Nat).toUSize 0 _ hZ (by simp only [USize.toNat_zero, Nat.zero_add]; clear*-z1;omega) simp only [USize.toNat_zero, Nat.zero_add] at K obtain ⟨K1, -, K3, K4⟩ := K have key : ∀ j < R, ∀ τ < n, rX X ((0 : Nat).toUSize + j.toUSize * (if t then 1 else n).toUSize + τ.toUSize * (if t then R else 1).toUSize) = dw X[(if t then j else j * n) + τ * (if t then R else 1)]! := fun j hj τ hτ => by have m1 := Nat.mul_le_mul_right (if t then 1 else n) hj.le have m2 := Nat.mul_le_mul_right (if t then R else 1) (show τ ≤ n + 1 by clear*-hτ;omega) rw [rX_eq X (by clear*-g7;omega), ix3 0 _ _ j τ hsu hst (by clear*-g11 hj;omega) (by clear*-g9 hτ;omega) (by clear*-g13 m1 m2;omega)] cases t <;> simp only [Bool.false_eq_true, ↓reduceIte, Nat.zero_add, Nat.mul_one] generalize dO X (if t then R else 1).toUSize (if t then 1 else n).toUSize (n + 1).toUSize n R (0 : Nat).toUSize 0 _ = Y at * have hY1 : ∀ j < R, ∀ τ < n, Y.data[j * (n + 1) + τ]! = dw X[(if t then j else j * n) + τ * (if t then R else 1)]! := fun j hj τ hτ => by rw [K3 j hj τ hτ, key j hj τ hτ] have hY2 : ∀ j < R, 9 * ((n : ℝ) + 1) * (∑ τ ∈ Finset.range n, |rv (dw X[(if t then j else j * n) + τ * (if t then R else 1)]!)|) * (1 - 2 ^ (-20 : Int)) ≤ 2 ^ (((cE (9 * (n + 1)).toUInt64.toInt64.toFloat Y.data[j * (n + 1) + n]!).toNat : Int) + 56) + 2 ^ (-900 : Int) := fun j hj => by rw [K4 j hj] exact cR X n (by clear*-g5 g6;omega) (fun q => (hx q).1) (fun τ => (if t then j else j * n) + τ * (if t then R else 1)) _ (fun τ hτ => key j hj τ hτ) have Cv : ∀ q, q < R * ow → ∃ g r, g < (ow + 7) / 8 ∧ r < R ∧ cq t R ow g r q := ?_ ·have Fin : ∀ (f : Nat → Nat → Array Word → Array Word) (C : Nat → Nat → Nat → Prop), (∀ g r a, g < (ow + 7) / 8 → r < R → a.size = R * ow → Iv (oF t R n ow relu X W (pd W b n).bw) a (C g r) (f g r a)) → (∀ q, q < R * ow → ∃ g r, g < (ow + 7) / 8 ∧ r < R ∧ C g r q) → l2 ((ow + 7) / 8) R f 0 0 (Array.replicate (R * ow) 0) = Array.ofFn (n := R * ow) fun q => oF t R n ow relu X W (pd W b n).bw q.val := fun f C hf hc => l2_fin _ _ _ _ _ C hf hc refine dp (fun h2 => Fin _ (cq t R ow) (fun g r a hg hr ha => stpZ_spec t R n ow relu X W _ Y _ _ _ _ _ _ _ _ _ _ _ (pd W b n).e _ ((pd W b n).eb.toNat - 1) _ rfl rfl rfl rfl rfl (fun q => (hx q).1) hbq le_rfl hL g4 g3 (by clear*-g5 h2;omega) he (by clear*-K1 z1;omega) hY1 hY2 P1 P2 P3 P4 g11 g r hg hr a ha) Cv) fun _ => ?_ split ·exact Fin _ (cq t R ow) (fun g r a hg hr ha => stp_spec true t R n ow relu X W _ Y _ _ _ _ _ _ _ _ (pd W b n).e _ ((pd W b n).eb.toNat - 1) _ rfl rfl rfl rfl rfl (fun q => (hx q).1) hbq le_rfl hL g4 g3 (by clear*-g5 g6;omega) he (by clear*-K1 z1;omega) hY1 hY2 P1 P2 P3 P4 g11 g r hg hr a ha) Cv refine Fin _ _ (fun g r a hg hr ha => stq_spec (tw R n) t R n ow relu X W _ Y _ _ _ _ _ _ _ _ (pd W b n).e _ ((pd W b n).eb.toNat - 1) _ rfl rfl rfl rfl rfl (fun q => (hx q).1) hbq le_rfl hL g4 g3 (by clear*-g5 g6;omega) he (by clear*-K1 z1;omega) hY1 hY2 P1 P2 P3 P4 g11 g r hg hr a ha) fun q hq => ?_ obtain ⟨g, r, hg, hr, hc⟩ := Cv q hq cases tw R n ·exact ⟨g, r, hg, hr, by simpa using hc⟩ ·by_cases h : r % 2 = 0 ·exact ⟨g, r, hg, hr, by simpa [h] using .inl hc⟩ ·exact ⟨g, r - 1, hg, by clear*-hr;omega, by simp only [↓reduceIte] exact ⟨by clear*-h;omega, .inr ⟨by clear*-h hr;omega, by rwa [show r - 1 + 1 = r by clear*-h;omega]⟩⟩⟩ intro q hq have hw : 0 < ow := Nat.pos_of_ne_zero fun h => by subst h; simp at hq have hR : 0 < R := Nat.pos_of_ne_zero fun h => by subst h; simp at hq cases t ·have h1 := Nat.div_add_mod q ow have h2 := Nat.mod_lt q hw refine ⟨q % ow / 8, q / ow, by clear*-h2;omega, Nat.div_lt_of_lt_mul (by rwa [Nat.mul_comm]), q % ow % 8, by clear*-;omega, by clear*-h2;omega, ?_⟩ simp only [Bool.false_eq_true, ↓reduceIte]; rw [Nat.mul_comm (q / ow)]; clear*-h1;omega ·have h1 := Nat.div_add_mod q R have h2 := Nat.mod_lt q hR have h3 : q / R < ow := Nat.div_lt_of_lt_mul hq refine ⟨q / R / 8, q % R, by clear*-h3;omega, h2, q / R % 8, by clear*-;omega, by clear*-h3;omega, ?_⟩ simp only [↓reduceIte]; rw [show 8 * (q / R / 8) + q / R % 8 = q / R by clear*-;omega, Nat.mul_comm (q / R)]; clear*-h1;omega @[noinline] def TP : Sr.Tab pd := Sr.Tab.make pd 64 (2 ^ 22) @[inline] def dget (W b : Array Word) (n : Nat) : PD := if W.size < 16 then pd W b n else (TP.get W b n).1 def dget_eq (W b : Array Word) (n : Nat) : dget W b n = pd W b n := by unfold dget; split ·rfl ·exact (TP.get W b n).2 def linP (rows n ow : Nat) (relu : Bool) (X W b : Array Word) : Array Word := if 0 < ow ∧ b.size = ow then run false rows n ow relu X W (dget W b n) (emx X 0 0) else linearSpec rows n ow relu X W b def linP_eq : linP = linearSpec := by funext rows n ow relu X W b unfold linP; split; swap; · rfl rename_i h have hb : (pd W b n).bw = b := by have : b.isEmpty = false := by simp [Array.isEmpty, h.2]; omega simp [pd, this] rw [dget_eq, run_eq _ _ _ _ _ _ _ _ _ rfl, hb] unfold linearSpec linearWith oF simp only [Bool.false_eq_true, ↓reduceIte] def gemmP (batch m k n : Nat) (A B : Array Word) : Array Word := let d := dget A #[] k let ex := emx B 0 0 if batch = 1 ∧ 0 < k ∧ m * k ≤ A.size ∧ d.e < 255 ∧ ex < 255 ∧ A.size ≤ 4294967295 ∧ B.size ≤ 4294967295 then run true n k m false B A d ex else gemmSpec batch m k n A B def gemmP_eq : gemmP = gemmSpec := by funext batch m k n A B unfold gemmP; dsimp only; split; swap; · rfl rename_i h obtain ⟨rfl, hk, h2, h3, h4, h5, h6⟩ := h rw [dget_eq] at h3 ⊢ have ul := USize.le_size have hx := F.exF B (by clear*-h6 ul;omega) h4 have hw := F.exF A (by clear*-h5 ul;omega) h3 rw [run_eq _ _ _ _ _ _ _ _ _ rfl] have hb : (pd A #[] k).bw = Array.replicate (A.size / k) 0x80000000 := by simp [pd] have hm : m ≤ A.size / k := (Nat.le_div_iff_mul_le hk).2 h2 unfold gemmSpec gemmWith refine Array.ext (by simp [Nat.mul_comm]) fun q h1 _ => ?_ simp only [Array.size_ofFn] at h1 have hq : q / n < m := Nat.div_lt_of_lt_mul h1 have hz : (pd A #[] k).bw[q / n]! = 0x80000000 := by rw [hb, getElem!_pos _ _ (by rw [Array.size_replicate]; clear*-hm hq;omega), Array.getElem_replicate] simp only [Array.getElem_ofFn, oF, ↓reduceIte, hz, act, Nat.div_eq_of_lt (show q < m * n by rwa [Nat.mul_comm]), Nat.mod_eq_of_lt hq, Nat.zero_mul, Nat.zero_add, Bool.false_eq_true] exact (F.dz k (fun t => A[q / n * k + t]!) (fun t => B[q % n + t * n]!) hk fun t _ => ⟨(hw _).1, (hx _).1⟩).trans (by simp only [Nat.add_comm (q % n)]) end Pn end F end Dense def kernels : Kernels where core := ⟨sumSpec, dotSpec⟩ dense := ⟨Dense.F.Pn.linP, Dense.F.Pn.gemmP⟩ conv := specConv elem := ⟨avgpoolSpec, maxpoolSpec, Bn.addRelu, scaleShiftSpec⟩ norm := specNorm theorem correct : Obligation kernels := by simp only [Obligation, kernels, specKernels, specCore, specDense, specConv, specElem, specNorm, Dense.F.Pn.linP_eq, Dense.F.Pn.gemmP_eq, Bn.addRelu_eq] end Submission