import ContractExact namespace Submission local notation"א"=>by omega local notation"ב"=>by norm_num local notation"ג"=>by simp local notation"ד"=>by linarith open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats structure Acc where pos:Array Nat neg:Array Nat special:Bool negZero:Bool def Acc.empty:Acc:=⟨Array.replicate 18 0,Array.replicate 18 0,false,true⟩ def Acc.total (acc:Acc):Int:=(limbVal acc.pos.toList:Int)-limbVal acc.neg.toList @[inline] def Acc.add (acc:Acc) (m idx:Nat) (neg:Bool):Acc := match acc with | ⟨pos,ng,sp,nz⟩ => if m=0 then ⟨pos,ng,sp,nz && neg⟩ else if neg then ⟨pos,addLimbs64 ng m.toUInt64 idx,sp,false⟩ else ⟨addLimbs64 pos m.toUInt64 idx,ng,sp,false⟩ @[inline] def Acc.markSpecial (acc:Acc):Acc := match acc with | ⟨pos,ng,_,nz⟩=>⟨pos,ng,true,nz⟩ lemma Acc.add_spec (acc:Acc) (m idx:Nat) (neg:Bool) (hp:acc.pos.size=18) (hn:acc.neg.size=18) (hm:m<2^64) (hi:idx/32+1<18) : (acc.add m idx neg).pos.size=18∧(acc.add m idx neg).neg.size=18 ∧ (acc.add m idx neg).special=acc.special ∧ (acc.add m idx neg).negZero=(acc.negZero && (decide (m=0) && neg)) ∧ (acc.add m idx neg).total=acc.total+(if neg then -(m:Int) else m)*2^idx:=by obtain ⟨pos,ng,sp,nz⟩:=acc simp only at hp hn by_cases hm0:m=0 . simp[Acc.add,Acc.total,hm0,hp,hn] . cases neg . refine ⟨by simp[Acc.add,hm0,addLimbs64_size,hp],by simp[Acc.add,hm0,hn], by simp[Acc.add,hm0],by simp[Acc.add,hm0],?_⟩ simp only[Acc.add,hm0,ite_false,Bool.false_eq_true,addLimbs64_eq _ _ _ hm,Acc.total] rw[addLimbs_val _ _ _ א] push_cast; ring . refine ⟨by simp[Acc.add,hm0,hp],by simp[Acc.add,hm0,addLimbs64_size,hn], by simp[Acc.add,hm0],by simp[Acc.add,hm0],?_⟩ simp only[Acc.add,hm0,ite_false,ite_true,addLimbs64_eq _ _ _ hm,Acc.total] rw[addLimbs_val _ _ _ א] push_cast; ring lemma Acc.total_empty:Acc.empty.total=0:=by decide section open FloatLib.Numerics lemma qB2 (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 ב א) 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 ב א) 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 :=א rw[htot] have hfw:Fmt.fracWidth=23:=rfl have hsub:Fmt.minSubnormalExponent=-149:=rfl have hmin:Fmt.minNormalExponent=-126:=rfl rw[hfw,hsub,hmin] split_ifs with h1 h2 h3 h4 <;> try omega . rfl . congr 1 obtain ⟨a,ha⟩:∃ a:Nat,e - -149=Int.negSucc a:=⟨(-(e+149)-1).toNat,by omega⟩ have hb:e+j - -149=Int.negSucc (a-j) :=א rw[ha,hb] dsimp only rw[show a-j+1=(a+1)-j by omega] exact roundShiftRightEven_shiftRightJam m j (a+1) א . congr 1 rw[show m.log2-j-23=(m.log2-23)-j by omega] exact roundShiftRightEven_shiftRightJam m j _ א def winVal (a:Array Nat) (i:Nat):Nat->Nat | 0=>0 | k+1=>a[i]! + 2^32*winVal a (i+1) k lemma qAg (a:Array Nat) (i k m:Nat) : winVal a i (k+m)=winVal a i k+2^(32*k)*winVal a (i+k) m:=by induction k generalizing i with | zero=>simp[winVal] | succ k ih => rw[show k+1+m=(k+m)+1 by omega,winVal,winVal,ih,show i+1+k=i+(k+1) by omega] rw[show 32*(k+1)=32+32*k by ring,pow_add] ring lemma qC0 (a b:Array Nat) (i j k:Nat) (h:∀ t,t< k->a[i+t]! = b[j+t]!) : winVal a i k=winVal b j k:=by induction k generalizing i j with | zero=>rfl | succ k ih => rw[winVal,winVal,ih (i+1) (j+1) (λt ht=>by rw[show i+1+t=i+(t+1) by omega,show j+1+t=j+(t+1) by omega] exact h (t+1) א),show a[i]! = b[j]! from by simpa using h 0 א] lemma qAd (a:Array Nat) (i k:Nat) : winVal a i k=0 ↔ ∀ t,t< k->a[i+t]! = 0:=by induction k generalizing i with | zero=>simp[winVal] | succ k ih => rw[winVal,Nat.add_eq_zero_iff,Nat.mul_eq_zero,ih (i+1)] have hp:(2:ℕ)^32≠0 :=ב constructor . rintro ⟨h0,h1 | h1⟩ t ht . exact absurd h1 hp . rcases t with _ | t . simpa using h0 . rw[show i+(t+1)=i+1+t by omega]; exact h1 t א . intro h refine ⟨by simpa using h 0 א,Or.inr λt ht=>?_⟩ rw[show i+1+t=i+(t+1) by omega]; exact h (t+1) א lemma qD9 (a:Array Nat) (i k:Nat) (h:∀ t,t< k->a[i+t]! < 2^32) : winVal a i k<2^(32*k):=by induction k generalizing i with | zero=>simp[winVal] | succ k ih => have h0:=h 0 א have h1:=ih (i+1) (λt ht=>by rw[show i+1+t=i+(t+1) by omega]; exact h (t+1) א) simp only[Nat.add_zero] at h0 rw[winVal,show 32*(k+1)=32+32*k by ring,pow_add] nlinarith lemma qA8 (a:Array Nat) (t:Nat) (h:a.size<=t):a[t]! = 0:=by simp[getElem!_neg a t א] lemma qBt (a:Array Nat) (i k:Nat) (h:a.size<=i+k) : winVal a i k=limbVal (a.toList.drop i):=by induction k generalizing i with | zero=>simp[winVal,List.drop_of_length_le (by simpa using h:a.toList.length<=i),limbVal] | succ k ih => rw[winVal,ih (i+1) א] by_cases hi:i< a.size . have hl:i< a.toList.length:=by simpa using hi simp only[List.drop_eq_getElem_cons hl,limbVal,getElem!_pos a i hi,Array.getElem_toList] . rw[qA8 a i א,List.drop_of_length_le (by simp; omega), List.drop_of_length_le (by simp; omega)] simp[limbVal] lemma qCj (a:Array Nat) (lo n:Nat) (hlow:∀ t,t< lo->a[t]! = 0) (hhigh:∀ t,lo+n<=t->a[t]! = 0) : limbVal a.toList=2^(32*lo)*winVal a lo n:=by rw[<-List.drop_zero (l:=a.toList),<-qBt a 0 (lo+(n+a.size)) א, qAg,qAg] rw[(qAd a 0 lo).2 (λt ht=>by simpa using hlow t ht), (qAd a (0+lo+n) a.size).2 (λt _=>hhigh _ א)] simp def diffGo (a b:Array Nat) (i ca cb br:Nat) (out:Array Nat) : Nat->Array Nat × Nat × Nat × Nat | 0=>(out,ca,cb,br) | k+1 => let ta:=a[i]! + ca let tb:=b[i]! + cb let t:=ta%4294967296+4294967296-tb%4294967296-br diffGo a b (i+1) (ta/4294967296) (tb/4294967296) (1-t/4294967296) (out.push (t%4294967296)) k lemma qBx (a b:Array Nat) (i ca cb br:Nat) (out:Array Nat) (k:Nat) (hbr:br<=1) (hout:∀ t,t< out.size->out[t]! < 2^32) : let r:=diffGo a b i ca cb br out k r.1.size=out.size+k∧(∀ t,t< r.1.size->r.1[t]! < 2^32) ∧ (winVal r.1 0 r.1.size:Int)+2^(32*(out.size+k))*(r.2.1-r.2.2.1-r.2.2.2:Int) = winVal out 0 out.size+2^(32*out.size) * ((winVal a i k:Int)-winVal b i k+ca-cb-br):=by induction k generalizing i ca cb br out with | zero=>exact ⟨by simp[diffGo],by simpa [diffGo] using hout,by simp[diffGo,winVal]⟩ | succ k ih => simp only[diffGo] set ta:=a[i]! + ca set tb:=b[i]! + cb set t:=ta%4294967296+4294967296-tb%4294967296-br have htb:tb%4294967296<4294967296:=Nat.mod_lt _ ב have hta:ta%4294967296<4294967296:=Nat.mod_lt _ ב have ht2:t<2*4294967296 :=א have hq:t/4294967296<=1 :=א have hd:t%4294967296<2^32:=by have:=Nat.mod_lt t (by norm_num:4294967296 > 0); norm_num; omega have hout':∀ s,s<(out.push (t%4294967296)).size->(out.push (t%4294967296))[s]! < 2^32:=by intro s hs simp only[Array.size_push] at hs rcases Nat.lt_or_eq_of_le (Nat.lt_succ_iff.mp hs) with hs | rfl . rw[getElem!_pos _ s (by simp; omega),Array.getElem_push_lt hs,<-getElem!_pos out s hs] exact hout s hs . rw[getElem!_pos _ _ ג,Array.getElem_push_eq]; exact hd obtain ⟨h1,h2,h3⟩:=ih (i+1) (ta/4294967296) (tb/4294967296) (1-t/4294967296) (out.push (t%4294967296)) א hout' refine ⟨by simp[h1]; omega,h2,?_⟩ have hpush:winVal (out.push (t%4294967296)) 0 (out.size+1) = winVal out 0 out.size+2^(32*out.size)*(t%4294967296):=by rw[qAg,qC0 _ out 0 0 out.size (λs hs=>by rw[getElem!_pos _ _ (by simp; omega),Array.getElem_push_lt א, <-getElem!_pos out _ א])] simp only[winVal,Nat.zero_add,Nat.mul_zero,Nat.add_zero] rw[getElem!_pos _ _ ג,Array.getElem_push_eq] simp only[Array.size_push] at h3 ⊢ rw[show out.size+(k+1)=out.size+1+k by omega] rw[h3,hpush,winVal,winVal] have hstep:((t%4294967296:Nat):Int)+4294967296*((ta/4294967296:Nat)-(tb/4294967296:Nat)-(1-t/4294967296:Nat)) = (a[i]! : Int)-b[i]! + ca-cb-br:=by have e1:=Nat.mod_add_div ta 4294967296 have e2:=Nat.mod_add_div tb 4294967296 have e3:=Nat.mod_add_div t 4294967296 have e4:(1-t/4294967296:Nat)=1-(t/4294967296:Int) :=א have e5:(t:Int)=ta%4294967296+4294967296-tb%4294967296-br :=א push_cast [e4] omega rw[show 32*(out.size+1)=32*out.size+32 by ring,pow_add] simp only[Nat.cast_add,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat] linear_combination (2:Int)^(32*out.size)*hstep def topGo (r:Array Nat):Nat->Option Nat | 0=>none | k+1=>if r[k]! != 0 then some k else topGo r k def anyGo (r:Array Nat):Nat->Bool | 0=>false | k+1=>r[k]! != 0 || anyGo r k lemma qDw (r:Array Nat) (k:Nat) (h:topGo r k=none):∀ t,t< k->r[t]! = 0:=by induction k with | zero=>intro t ht; omega | succ k ih => simp only[topGo] at h split at h . cases h . rename_i hk intro t ht rcases Nat.lt_or_eq_of_le (Nat.lt_succ_iff.mp ht) with ht | rfl . exact ih h t ht . simpa using hk lemma qCc (r:Array Nat) (k h:Nat) (hh:topGo r k=some h) : h< k∧r[h]!≠0∧∀ t,h< t->t< k->r[t]! = 0:=by induction k with | zero=>simp[topGo] at hh | succ k ih => simp only[topGo] at hh split at hh . rename_i hk cases hh exact ⟨by omega,by simpa using hk,λt h1 h2=>by omega⟩ . rename_i hk obtain ⟨a,b,c⟩:=ih hh refine ⟨by omega,b,λt h1 h2=>?_⟩ rcases Nat.lt_or_eq_of_le (Nat.lt_succ_iff.mp h2) with h2 | rfl . exact c t h1 h2 . simpa using hk lemma qBw (r:Array Nat) (k:Nat):anyGo r k=false ↔ ∀ t,t< k->r[t]! = 0:=by induction k with | zero=>simp[anyGo] | succ k ih => simp only[anyGo,Bool.or_eq_false_iff,bne_eq_false_iff_eq,ih] constructor . rintro ⟨h0,h1⟩ t ht rcases Nat.lt_or_eq_of_le (Nat.lt_succ_iff.mp ht) with ht | rfl . exact h1 t ht . exact h0 . intro h; exact ⟨h k א,λt ht=>h t א⟩ lemma qEq (r:Array Nat) (k:Nat):anyGo r k=(winVal r 0 k != 0):=by have hz:=qAd r 0 k simp only[Nat.zero_add] at hz cases h:anyGo r k . rw[hz.2 ((qBw r k).1 h)]; rfl . have:winVal r 0 k≠0:=λh0=>by have:=(qBw r k).2 (hz.1 h0); simp_all simp[this] lemma qDo (low x y h:Nat) (hlow:low<2^(32*h)) : shiftRightJam (low+2^(32*h)*(x+2^32*y)) (32*h+2) = if x%4 != 0 || low != 0 then (y*1073741824+x/4) ||| 1 else y*1073741824+x/4:=by have hX0:0<2^(32*h):=by positivity have hdiv:2^(32*h+2)=4*2^(32*h):=by rw[pow_add]; ring have hs:x%4<4:=Nat.mod_lt x ב have hA:low+2^(32*h)*(x%4)<4*2^(32*h):=by nlinarith have hsplit:low+2^(32*h)*(x+2^32*y) = (low+2^(32*h)*(x%4))+4*2^(32*h)*(y*1073741824+x/4):=by have h4:=Nat.mod_add_div x 4 rw[show (2:Nat)^32=4*1073741824 by norm_num] conv_lhs=>rw[<-h4] ring have hz:low+2^(32*h)*(x%4)=0 ↔ ¬(x%4≠0∨low≠0):=by constructor . intro h0 have h1:=Nat.eq_zero_of_add_eq_zero h0 rcases Nat.mul_eq_zero.mp h1.2 with h2 | h2 <;> omega . intro h0; simp only[not_or,not_not] at h0; simp[h0.1,h0.2] unfold shiftRightJam dsimp only rw[hdiv,hsplit,Nat.add_mul_div_left _ _ א,Nat.div_eq_of_lt hA,Nat.zero_add, Nat.add_mul_mod_self_left,Nat.mod_eq_of_lt hA] by_cases hc:x%4≠0∨low≠0 . have:¬ (low+2^(32*h)*(x%4)=0):=λh0=>hz.mp h0 hc have hb:(x%4 != 0 || low != 0)=true:=by simpa [bne_iff_ne] using hc simp only[beq_iff_eq,this,ite_false,hb,ite_true] . have:low+2^(32*h)*(x%4)=0:=hz.mpr hc have hb:(x%4 != 0 || low != 0)=false:=by simpa [bne_iff_ne] using hc simp only[beq_iff_eq,this,ite_true,hb] rfl def finishDigits (neg:Bool) (r:Array Nat) (e:Int) (negZero:Bool):UInt32 := match topGo r r.size with | none=>finishWord 0 e negZero | some 0=>finishWord (if neg then -(r[0]! : Int) else r[0]!) e negZero | some (h+1) => let x:=r[h]! let v:=r[h+1]! * 1073741824+x/4 let m:=if x%4 != 0 || anyGo r h then v ||| 1 else v toWord (Model.roundDyadic Fmt ⟨neg,m,e+((32*h+2:Nat):Int)⟩) lemma qBu (neg:Bool) (R:Nat) (e:Int) (negZero:Bool) (hR:R≠0) : finishWord (if neg then -(R:Int) else R) e negZero=toWord (Model.roundDyadic Fmt ⟨neg,R,e⟩):=by have hpos:(0:Int)< R:=by exact_mod_cast Nat.pos_of_ne_zero hR cases neg <;> simp[finishWord,ofIntDyadic,hR,not_lt.mpr hpos.le,Nat.pos_of_ne_zero hR] lemma qBd (neg:Bool) (r:Array Nat) (e:Int) (negZero:Bool) (hr:∀ t,t< r.size->r[t]! < 2^32) : finishDigits neg r e negZero = finishWord (if neg then -(winVal r 0 r.size:Int) else winVal r 0 r.size) e negZero:=by unfold finishDigits split . rename_i hnone rw[(qAd r 0 r.size).2 (λt ht=>by simpa using qDw r _ hnone t ht)] simp . rename_i hsome obtain ⟨h1,h2,h3⟩:=qCc r _ 0 hsome rw[show r.size=1+(r.size-1) by omega,qAg, (qAd r (0+1) (r.size-1)).2 (λt ht=>h3 _ א א)] simp[winVal] . rename_i h hsome obtain ⟨h1,h2,h3⟩:=qCc r _ (h+1) hsome have hR:winVal r 0 r.size=winVal r 0 h+2^(32*h)*(r[h]! + 2^32*r[h+1]!):=by rw[show r.size=h+(2+(r.size-h-2)) by omega,qAg,qAg, (qAd r (0+h+2) _).2 (λt ht=>h3 _ א א)] simp[winVal] have hlow:winVal r 0 h<2^(32*h):=qD9 r 0 h (λt ht=>hr _ א) have hR0:winVal r 0 r.size≠0:=by rw[hR]; have:0<2^(32*h)*(r[h]! + 2^32*r[h+1]!):=by have:=Nat.pos_of_ne_zero h2; positivity omega have hlog:32*h+2+25<=(winVal r 0 r.size).log2:=by rw[Nat.le_log2 hR0,hR] have:1<=r[h+1]!:=Nat.pos_of_ne_zero h2 calc 2^(32*h+2+25)<=2^(32*h)*2^32:=by rw[<-pow_add]; exact Nat.pow_le_pow_right ב א _<=2^(32*h)*(r[h]! + 2^32*r[h+1]!):=by gcongr; nlinarith _<=_ :=א rw[qBu neg _ e negZero hR0,<-qB2 neg _ e _ hlog,hR, qDo _ _ _ h hlow,qEq] def highLimb (pos neg:Array Nat):Nat->Nat | 0=>0 | k+1=>if pos[k]! != 0 || neg[k]! != 0 then k+1 else highLimb pos neg k lemma qCp (pos neg:Array Nat) (k:Nat) : ∀ t,highLimb pos neg k<=t->t< k->pos[t]! = 0∧neg[t]! = 0:=by induction k with | zero=>intro t _ ht; omega | succ k ih => intro t h1 h2 simp only[highLimb] at h1 split at h1 . omega . rename_i hk rcases Nat.lt_or_eq_of_le (Nat.lt_succ_iff.mp h2) with h2 | rfl . exact ih t h1 h2 . simpa [Bool.or_eq_true,bne_iff_ne,not_or] using hk def finishFast (pos neg:Array Nat) (e:Int) (negZero:Bool):UInt32 := let lo:=lowLimb pos neg pos.size 0 let n:=highLimb pos neg (max pos.size neg.size)+1-lo let e':=e+((32*lo:Nat):Int) let d:=diffGo pos neg lo 0 0 0 (Array.emptyWithCapacity n) n if d.2.1=0∧d.2.2.1=0∧d.2.2.2=0 then finishDigits false d.1 e' negZero else let d':=diffGo neg pos lo 0 0 0 (Array.emptyWithCapacity n) n if d'.2.1=0∧d'.2.2.1=0∧d'.2.2.2=0 then finishDigits true d'.1 e' negZero else finishLimbs pos neg e negZero lemma qCq (pos neg:Array Nat) (e:Int) (negZero:Bool) : finishFast pos neg e negZero = finishWord ((limbVal pos.toList:Int)-limbVal neg.toList) e negZero:=by unfold finishFast dsimp only set lo:=lowLimb pos neg pos.size 0 set n:=highLimb pos neg (max pos.size neg.size)+1-lo have hlow:=lowLimb_zero pos neg pos.size 0 have hhigh:=qCp pos neg (max pos.size neg.size) have hzero (a:Array Nat) (ha:a=pos∨a=neg) : limbVal a.toList=2^(32*lo)*winVal a lo n:=by apply qCj a lo n . intro t ht; rcases ha with rfl | rfl . exact (hlow t א ht).1 . exact (hlow t א ht).2 . intro t ht by_cases hts:t< max pos.size neg.size . rcases ha with rfl | rfl . exact (hhigh t א hts).1 . exact (hhigh t א hts).2 . rcases ha with rfl | rfl <;> exact qA8 _ t א have hP:=hzero pos (Or.inl rfl) have hN:=hzero neg (Or.inr rfl) rw[show (Array.emptyWithCapacity n:Array Nat)=#[] from rfl] have hd:=qBx pos neg lo 0 0 0 #[] n א ג have hd':=qBx neg pos lo 0 0 0 #[] n א ג have hw0:winVal (#[]:Array Nat) 0 0=0:=rfl simp only[List.size_toArray,List.length_nil,Nat.mul_zero,pow_zero,one_mul, hw0,Nat.cast_zero,zero_add] at hd hd' obtain ⟨-,hb,hv⟩:=hd obtain ⟨-,hb',hv'⟩:=hd' split_ifs with h1 h2 . rw[qBd false _ _ _ hb,finishWord_scale,hP,hN] simp only[Bool.false_eq_true,ite_false] congr 1 rw[h1.1,h1.2.1,h1.2.2] at hv push_cast at hv ⊢ linear_combination (2:Int)^(32*lo)*hv . rw[qBd true _ _ _ hb',finishWord_scale,hP,hN] simp only[ite_true] congr 1 rw[h2.1,h2.2.1,h2.2.2] at hv' push_cast at hv' ⊢ linear_combination (-(2:Int)^(32*lo))*hv' . exact finishLimbs_eq pos neg e negZero end @[inline] def dotStep (acc:Acc) (wa wb:UInt32):Acc := if expOf wa=255∨expOf wb=255 then acc.markSpecial else acc.add (mantOf wa*mantOf wb) (idxOf wa+idxOf wb) (Bool.xor (signOf wa) (signOf wb)) @[specialize] def dotLoop (fa fb:Nat->UInt32) (pos neg:Array Nat) (sp nz:Bool) (index:Nat):Nat->Acc | 0=>⟨pos,neg,sp,nz⟩ | count+1 => match dotStep ⟨pos,neg,sp,nz⟩ (fa index) (fb index) with | ⟨p,n,s,z⟩=>dotLoop fa fb p n s z (index+1) count @[inline] def dotFn (n:Nat) (fa fb:Nat->UInt32):UInt32 := let acc:=dotLoop fa fb (Array.replicate 18 0) (Array.replicate 18 0) false true 0 n if acc.special then dotSpec (Array.ofFn (n:=n) λi=>fa i) (Array.ofFn (n:=n) λi=>fb i) else finishFast acc.pos acc.neg (-298) (n≠0 && acc.negZero) lemma qFv (wa wb:UInt32) : (if Bool.xor (signOf wa) (signOf wb) then -((mantOf wa*mantOf wb:Nat):Int) else ((mantOf wa*mantOf wb:Nat):Int))=sv wa*sv wb:=by unfold sv; cases signOf wa <;> cases signOf wb <;> simp lemma qCa (fa fb:Nat->UInt32) (pos neg:Array Nat) (nz:Bool) (index count:Nat):(dotLoop fa fb pos neg true nz index count).special=true:=by induction count generalizing pos neg nz index with | zero=>rfl | succ count ih => rw[dotLoop] have hs:(dotStep ⟨pos,neg,true,nz⟩ (fa index) (fb index)).special=true:=by unfold dotStep Acc.markSpecial Acc.add; split_ifs <;> rfl generalize dotStep ⟨pos,neg,true,nz⟩ (fa index) (fb index)=r at hs ⊢ obtain ⟨p,q,s,z⟩:=r simp only at hs; subst hs exact ih .. lemma qCx (fa fb:Nat->UInt32) (A B:Array UInt32) (n:Nat) (hA:∀ k,k< n->A[k]! = fa k) (hB:∀ k,k< n->B[k]! = fb k) (acc:Acc) (index remaining:Nat) (h:index+remaining<=n) (hp:acc.pos.size=18) (hn:acc.neg.size=18) (hfin:(dotLoop fa fb acc.pos acc.neg acc.special acc.negZero index remaining).special =false) : acc.special=false ∧ (∀ k,index<=k->k< index+remaining->expOf A[k]!≠255∧expOf B[k]!≠255) ∧ (dotLoop fa fb acc.pos acc.neg acc.special acc.negZero index remaining).total = acc.total+dsum A B index remaining ∧ (dotLoop fa fb acc.pos acc.neg acc.special acc.negZero index remaining).negZero = (acc.negZero && dallNZ A B index remaining):=by induction remaining generalizing acc index with | zero=>obtain ⟨p,n,s,z⟩:=acc; simp_all [dotLoop,dsum,dallNZ] | succ count ih => obtain ⟨p,q,s,z⟩:=acc simp only at hp hn have ha:=hA index א have hb:=hB index א by_cases he:expOf (fa index)=255∨expOf (fb index)=255 . exfalso rw[dotLoop] at hfin have hs:(dotStep ⟨p,q,s,z⟩ (fa index) (fb index)).special=true:=by simp[dotStep,he,Acc.markSpecial] generalize dotStep ⟨p,q,s,z⟩ (fa index) (fb index)=r at hs hfin obtain ⟨p',q',s',z'⟩:=r simp only at hs; subst hs rw[qCa] at hfin exact Bool.noConfusion hfin . have he':=not_or.mp he obtain ⟨h1,h2,h3,h4,h5⟩ := Acc.add_spec ⟨p,q,s,z⟩ (mantOf (fa index)*mantOf (fb index)) (idxOf (fa index)+idxOf (fb index)) (Bool.xor (signOf (fa index)) (signOf (fb index))) hp hn (mul_mant_lt _ _) (by have:=idxOf_le _ he'.1; have:=idxOf_le _ he'.2; omega) have hstep:dotStep ⟨p,q,s,z⟩ (fa index) (fb index) = Acc.add ⟨p,q,s,z⟩ (mantOf (fa index)*mantOf (fb index)) (idxOf (fa index)+idxOf (fb index)) (Bool.xor (signOf (fa index)) (signOf (fb index))):=by simp[dotStep,he] rw[dotLoop,hstep] at hfin ⊢ obtain ⟨hs,hall,hD,hz⟩:=ih _ (index+1) א h1 h2 hfin refine ⟨by rw[<-h3,hs],?_,?_,?_⟩ . intro k k1 k2 rcases Nat.lt_or_ge k (index+1) with hk | hk . have:k=index :=א subst this; rw[ha,hb]; exact he' . exact hall k hk א . rw[hD,h5,dsum,ha,hb,qFv]; ring . rw[hz,h4,dallNZ,ha,hb]; simp[Bool.and_assoc] lemma qAb (n:Nat) (f:Nat->UInt32) (k:Nat) (hk:k< n) : (Array.ofFn (n:=n) λi=>f i.val)[k]! = f k:=by rw[getElem!_pos _ k (by simpa using hk),Array.getElem_ofFn] lemma qEt (n:Nat) (fa fb:Nat->UInt32) : dotFn n fa fb = dotSpec (Array.ofFn (n:=n) λi=>fa i) (Array.ofFn (n:=n) λi=>fb i):=by unfold dotFn set A:=Array.ofFn (n:=n) λi=>fa i with hA set B:=Array.ofFn (n:=n) λi=>fb i with hB set acc:=dotLoop fa fb (Array.replicate 18 0) (Array.replicate 18 0) false true 0 n with hacc by_cases hsp:acc.special=true . simp[hsp] . have hsp':acc.special=false:=by simpa using hsp obtain ⟨-,hall,hD,hz⟩:=qCx fa fb A B n (qAb n fa) (qAb n fb) Acc.empty 0 n א (by simp[Acc.empty]) (by simp[Acc.empty]) hsp' have hD:acc.total=dsum A B 0 n:=by have:=hD; simp only[Acc.total_empty,Int.zero_add] at this; exact this have hz:acc.negZero=dallNZ A B 0 n:=by have:=hz; simp only[Acc.empty,Bool.true_and] at this; exact this simp only[hsp',Bool.false_eq_true,ite_false] rw[qCq,show ((limbVal acc.pos.toList:Int)-limbVal acc.neg.toList)=acc.total from rfl] have hAsize:A.size=n:=by simp[hA] have hBsize:B.size=n:=by simp[hB] set L:=A.map (Model.ofUInt32 (fmt:=Fmt)) with hL set R:=B.map (Model.ofUInt32 (fmt:=Fmt)) with hR have hLR:L.size=R.size:=by simp[hL,hR,hAsize,hBsize] have hLsize:L.size=n:=by simp[hL,hAsize] have hLfin:∀ k (hk:k< L.size),Model.isFinite L[k]=true:=by intro k hk have hk':k< A.size:=by simpa [hL] using hk have:=(hall k א א).1 rw[getElem!_pos A k hk'] at this simp[hL,isFinite_ofUInt32,this] have hRfin:∀ k (hk:k< R.size),Model.isFinite R[k]=true:=by intro k hk have hk':k< B.size:=by simpa [hR] using hk have:=(hall k א א).2 rw[getElem!_pos B k hk'] at this simp[hR,isFinite_ofUInt32,this] have hslice:Model.Reduction.Semantics.finiteDotSlice L R 0 L.size ג (by simp[hLR])=(acc.total:ℚ)*2^(-298:ℤ):=by have:=finiteDotSlice_eq A B 0 L.size (by simp[hL]) (by simp[hL,hAsize,hBsize]) (by intro k k1 k2; exact hall k k1 א) exact this.trans (by rw[hLsize,hD]) have hexact:=Model.Reduction.Internal.dotState_exact_toRat (destination:=Fmt) L R hLR hLfin hRfin unfold dotSpec Model.dot by_cases hS0:acc.total=0 . have hz0:(Model.Reduction.Internal.dotState L R hLR : Model.Reduction.Internal.State Fmt).exact.significand=0:=by rw[<-FloatLib.Numerics.Dyadic.toRat_eq_zero_iff,hexact,hslice,hS0]; simp rw[Model.Reduction.dotWithStatus_eq_zero_of_finite Fmt L R .nearestEven hLR hLfin hRfin hz0,hS0,finishWord_zero] unfold Model.Reduction.Internal.dotState obtain ⟨h1,h2⟩:=dotStateLoop_flags A B {} 0 L.size (by simp[hL]) (by simp[hL,hAsize,hBsize]) (by intro k k1 k2; exact hall k k1 א) have h1':(Model.Reduction.Internal.dotStateLoop L R ({}:Model.Reduction.Internal.State Fmt) 0 L.size ג (by simp[hLR])).sawFiniteTerm=decide (L.size≠0):=by rw[show decide (L.size≠0)=(false || decide (L.size≠0)) by simp]; exact h1 have h2':(Model.Reduction.Internal.dotStateLoop L R ({}:Model.Reduction.Internal.State Fmt) 0 L.size ג (by simp[hLR])).allTermsNegativeZero=dallNZ A B 0 L.size:=by rw[show dallNZ A B 0 L.size=(true && dallNZ A B 0 L.size) by simp]; exact h2 simp only[Except.map,h1',h2'] rw[hz] simp[hLsize] . have hnz:Model.Reduction.Semantics.finiteDot L.toList R.toList≠.ok 0:=by rw[Model.Reduction.Semantics.finiteDot_toList_eq_slice L R hLR] intro h injection h with h rw[hslice] at h simp at h; exact hS0 h rw[Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L R .nearestEven hLR hLfin hRfin hnz] simp only[Except.map] exact finishWord_of_ne _ _ _ _ hS0 (by rw[hexact,hslice]) lemma qBf:dotFn=dotOf := funext λn=>funext λfa=>funext λfb=>qEt n fa fb @[inline] def keyOf (w:Word):Int := if signOf w then -((mantOf w <<< idxOf w:Nat):Int) else ((mantOf w <<< idxOf w:Nat):Int) @[inline] def maxW (a b:Word):Word := if expOf a=255∨expOf b=255 then toWord (Model.maximum (ofW a) (ofW b)) else match compare (keyOf a) (keyOf b) with | .lt=>b | .gt=>a | .eq=>toWord (if Model.isZero (ofW a) && Model.isZero (ofW b) then Model.zero Fmt (Model.signBit (ofW a) && Model.signBit (ofW b)) else ofW a) lemma usz (t n:USize) (h:t< n):(t+1).toNat=t.toNat+1:=by have h1:t.toNat< n.toNat:=USize.lt_iff_toNat_lt.mp h have h2:n.toNat< USize.size:=n.toNat_lt_size have h3:USize.size=2^System.Platform.numBits:=rfl rw[USize.toNat_add,USize.toNat_one] exact Nat.mod_eq_of_lt א lemma qAe (a b:USize) (h:a.toNat+b.toNat<2^32):(a+b).toNat=a.toNat+b.toNat:=by have h1:2^32<=USize.size:=USize.le_size have h3:USize.size=2^System.Platform.numBits:=rfl rw[USize.toNat_add]; exact Nat.mod_eq_of_lt א lemma uk (k:Nat) (h:k<2^32):(USize.ofNat k).toNat=k:=by have h1:2^32<=USize.size:=USize.le_size have h3:USize.size=2^System.Platform.numBits:=rfl rw[USize.toNat_ofNat']; exact Nat.mod_eq_of_lt א lemma qDb (a:FloatArray) (i:USize) (h:i< a.usize):i.toNat< a.size:=by have h1:=USize.lt_iff_toNat_lt.mp h have h2:a.usize.toNat<=a.size:=by simp only[FloatArray.usize,Nat.toUSize_eq,USize.toNat_ofNat'] exact Nat.mod_le _ _ omega lemma qAn (a:Array UInt32) (i:USize) (h:i< a.usize):i.toNat< a.size:=by have h1:=USize.lt_iff_toNat_lt.mp h have h2:a.usize.toNat<=a.size:=by simp only[Array.usize,Nat.toUSize_eq,USize.toNat_ofNat'] exact Nat.mod_le _ _ omega @[inline] def rdW (a:Array UInt32) (i:USize):UInt32 := if h:i< a.usize then a.uget i (qAn a i h) else 0 @[inline] def wrF (a:FloatArray) (i:USize) (v:Float):FloatArray := if h:i< a.usize then a.uset i v (qDb a i h) else a @[inline] def wrW (a:Array UInt32) (i:USize) (v:UInt32):Array UInt32 := if h:i< a.usize then a.uset i v (qAn a i h) else a def pwEntry (i:Nat):Float := let e:=(i%256).toUInt64 let s:UInt64:=if i ≥ 256 then 0x8000000000000000 else 0 if e == 0 then Float.ofBits s else Float.ofBits (s ||| ((e+873) <<< (52:UInt64))) def pw:FloatArray := (List.range 512).foldl (λa i=>a.push (pwEntry i)) (FloatArray.emptyWithCapacity 512) lemma qDg:pw.data=(List.range 512).toArray.map pwEntry:=by have key:∀ (l:List Nat) (a:FloatArray), (l.foldl (λa i=>a.push (pwEntry i)) a).data=a.data ++ (l.toArray.map pwEntry):=by intro l induction l with | nil=>intro a; simp | cons x l ih => intro a simp only[List.foldl_cons,ih] simp[FloatArray.push] simp only[pw,key] simp[FloatArray.emptyWithCapacity] lemma qFe:pw.size=512:=by simp[FloatArray.size,qDg] lemma qF2 (w:UInt32):(w >>> (23:UInt32)).toUSize.toNat< pw.size:=by rw[qFe] have h:=w.toNat_lt_size simp only[UInt32.toNat_toUSize,UInt32.toNat_shiftRight] norm_num [Nat.shiftRight_eq_div_pow] at h ⊢ omega @[inline] def dv (w:UInt32):Float := ((w &&& 0x7FFFFF) ||| 0x800000).toFloat*pw.uget (w >>> (23:UInt32)).toUSize (qF2 w) @[inline] def good (w:UInt32):Bool := let v:=w &&& 0x7FFFFFFF v == 0 || v-(0x00800000:UInt32)<=(0x7EFFFFFF:UInt32) def scan (A:Array UInt32) (n i:USize) (hn:n.toNat<=A.size) (lo hi:UInt32):Bool := if h:i< n then have ht:=USize.lt_iff_toNat_lt.mp h let v:=A.uget i א &&& 0x7FFFFFFF let u:=v-1 scan A n (i+1) hn (if u< lo then u else lo) (if hi< v then v else hi) else (0x007FFFFF<=lo) && (hi<0x7F800000) termination_by n.toNat-i.toNat decreasing_by rw[usz i n h]; omega lemma qBc (a:Array UInt32):a.usize.toNat<=a.size:=by simp only[Array.usize,Nat.toUSize_eq,USize.toNat_ofNat'] exact Nat.mod_le _ _ def pushZ (n k:USize) (a:FloatArray):FloatArray := if h:k< n then pushZ n (k+1) (a.push 0) else a termination_by n.toNat-k.toNat decreasing_by rw[usz k n h]; have:=USize.lt_iff_toNat_lt.mp h; omega @[inline] def ziv (s e:Float):UInt32 := let x:UInt64:=((s+e).toBits+(0x0FFFFFFF:UInt64)) >>> (29:UInt64) let y:UInt64:=((s-e).toBits+(0x0FFFFFFF:UInt64)) >>> (29:UInt64) let ex:UInt64:=(x >>> (23:UInt64)) &&& (0x7FF:UInt64) if x == y && ex-(897:UInt64)<(254:UInt64) then (((x >>> (34:UInt64)) <<< (31:UInt64)) ||| ((x &&& (0x3FFFFFFFF:UInt64))-((896:UInt64) <<< (23:UInt64)))).toUInt32 else 0xFFFFFFFF @[noinline] def slowOut (inW:Nat) (relu:Bool) (X W b:Array Word) (i j:Nat):Word := act relu (dotFn (inW+1) (λt=>if t< inW then X[i*inW+t]! else oneW) (λt=>if t< inW then W[j*inW+t]! else b[j]!)) @[inline] def fin (inW:Nat) (relu:Bool) (X W b:Array Word) (i j:Nat) (s nf t:Float) (bw:UInt32):UInt32 := let bv:=dv bw let r:=ziv (s+bv) (nf*(t+bv.abs)) if r == 0xFFFFFFFF then slowOut inW relu X W b i j else act relu r structure F1 where (s t:Float) def tightGo (X W:Array UInt32) (xo wo n t:USize) (s a:Float):F1 := if h:t< n then let q:=dv (rdW X (xo+t))*dv (rdW W (wo+t)) tightGo X W xo wo n (t+1) (s+q) (a+q.abs) else ⟨s,a⟩ termination_by n.toNat-t.toNat decreasing_by rw[usz t n h]; have:=USize.lt_iff_toNat_lt.mp h; omega @[inline] def fin8 (inW:Nat) (relu:Bool) (X W b:Array Word) (i j:Nat) (s nf a:Float) (hx bw:UInt32) (n:USize):UInt32 := let bv:=dv bw let r:=ziv (s+bv) (nf*(dv hx*a+bv.abs)) if r == 0xFFFFFFFF then let q:=tightGo X W (i*inW).toUSize (j*inW).toUSize n 0 0 0 fin inW relu X W b i j q.s nf q.t bw else act relu r structure R1 where (ix:Array UInt32) (buf:FloatArray) (c:USize) def decR (X:Array UInt32) (o n t:USize) (ix:Array UInt32) (buf:FloatArray) (c:USize):R1 := if h:t< n then let w:=rdW X (o+t) if w &&& 0x7FFFFFFF == 0 then decR X o n (t+1) ix buf c else decR X o n (t+1) (wrW ix c t.toUInt32) (wrF buf c (dv w)) (c+1) else ⟨ix,buf,c⟩ termination_by n.toNat-t.toNat decreasing_by all_goals (rw[usz t n h]; have:=USize.lt_iff_toNat_lt.mp h; omega) lemma wi (w i m:USize) (W:Array UInt32) (hw:w.toNat+m.toNat<=W.size) (hs:W.size<2^32) (hi:i.toNat< m.toNat):(w+i).toNat< W.size:=by rw[qAe _ _ א]; omega structure F4 where (a b c d t0 t1 t2 t3:Float) def go4 (x:FloatArray) (ix W:Array UInt32) (w0 w1 w2 w3 m n t:USize) (hx:n.toNat<=x.size) (hi:n.toNat<=ix.size) (hs:W.size<2^32) (h0:w0.toNat+m.toNat<=W.size) (h1:w1.toNat+m.toNat<=W.size) (h2:w2.toNat+m.toNat<=W.size) (h3:w3.toNat+m.toNat<=W.size) (a b c d t0 t1 t2 t3:Float):F4 := if h:t< n then have ht:=USize.lt_iff_toNat_lt.mp h let v:=x.uget t א let i:=(ix.uget t א).toUSize if hm:i< m then have him:=USize.lt_iff_toNat_lt.mp hm let q0:=v*dv (W.uget (w0+i) (wi w0 i m W h0 hs him)) let q1:=v*dv (W.uget (w1+i) (wi w1 i m W h1 hs him)) let q2:=v*dv (W.uget (w2+i) (wi w2 i m W h2 hs him)) let q3:=v*dv (W.uget (w3+i) (wi w3 i m W h3 hs him)) go4 x ix W w0 w1 w2 w3 m n (t+1) hx hi hs h0 h1 h2 h3 (a+q0) (b+q1) (c+q2) (d+q3) (t0+q0.abs) (t1+q1.abs) (t2+q2.abs) (t3+q3.abs) else go4 x ix W w0 w1 w2 w3 m n (t+1) hx hi hs h0 h1 h2 h3 a b c d t0 t1 t2 t3 else ⟨a,b,c,d,t0,t1,t2,t3⟩ termination_by n.toNat-t.toNat decreasing_by all_goals (rw[usz t n h]; omega) def go1 (x:FloatArray) (ix W:Array UInt32) (w0 m n t:USize) (hx:n.toNat<=x.size) (hi:n.toNat<=ix.size) (hs:W.size<2^32) (h0:w0.toNat+m.toNat<=W.size) (a t0:Float):F1 := if h:t< n then have ht:=USize.lt_iff_toNat_lt.mp h let i:=(ix.uget t א).toUSize if hm:i< m then have him:=USize.lt_iff_toNat_lt.mp hm let q:=x.uget t א*dv (W.uget (w0+i) (wi w0 i m W h0 hs him)) go1 x ix W w0 m n (t+1) hx hi hs h0 (a+q) (t0+q.abs) else go1 x ix W w0 m n (t+1) hx hi hs h0 a t0 else ⟨a,t0⟩ termination_by n.toNat-t.toNat decreasing_by all_goals (rw[usz t n h]; omega) def cols1 (inW outW:Nat) (relu:Bool) (X W b:Array UInt32) (i:Nat) (ix:Array UInt32) (x:FloatArray) (nf:Float) (m n:USize) (j:Nat) (base:USize) (out:Array UInt32):Array UInt32 := if h4:j+4<=outW then let ju:=j.toUSize let w0:=ju*m let w1:=(ju+1)*m let w2:=(ju+2)*m let w3:=(ju+3)*m if hg:n.toNat<=x.size∧n.toNat<=ix.size∧W.size<2^32∧w0.toNat+m.toNat<=W.size ∧ w1.toNat+m.toNat<=W.size∧w2.toNat+m.toNat<=W.size∧w3.toNat+m.toNat<=W.size then let r:=go4 x ix W w0 w1 w2 w3 m n 0 hg.1 hg.2.1 hg.2.2.1 hg.2.2.2.1 hg.2.2.2.2.1 hg.2.2.2.2.2.1 hg.2.2.2.2.2.2 0 0 0 0 0 0 0 0 let o0:=fin inW relu X W b i j r.a nf r.t0 (rdW b ju) let o1:=fin inW relu X W b i (j+1) r.b nf r.t1 (rdW b (ju+1)) let o2:=fin inW relu X W b i (j+2) r.c nf r.t2 (rdW b (ju+2)) let o3:=fin inW relu X W b i (j+3) r.d nf r.t3 (rdW b (ju+3)) let out:=wrW out (base+ju) o0 let out:=wrW out (base+ju+1) o1 let out:=wrW out (base+ju+2) o2 let out:=wrW out (base+ju+3) o3 cols1 inW outW relu X W b i ix x nf m n (j+4) base out else out else if h1:j< outW then let ju:=j.toUSize let w0:=ju*m if hg:n.toNat<=x.size∧n.toNat<=ix.size∧W.size<2^32∧w0.toNat+m.toNat<=W.size then let r:=go1 x ix W w0 m n 0 hg.1 hg.2.1 hg.2.2.1 hg.2.2.2 0 0 let o:=fin inW relu X W b i j r.s nf r.t (rdW b ju) cols1 inW outW relu X W b i ix x nf m n (j+1) base (wrW out (base+ju) o) else out else out termination_by outW-j def rows1 (rows inW outW:Nat) (relu:Bool) (X W b:Array UInt32) (nf:Float) (m:USize) (i:Nat) (ix:Array UInt32) (buf:FloatArray) (out:Array UInt32):Array UInt32 := if h:i< rows then let r:=decR X (i*inW).toUSize m 0 ix buf 0 let out:=cols1 inW outW relu X W b i r.ix r.buf nf m r.c 0 (i*outW).toUSize out rows1 rows inW outW relu X W b nf m (i+1) r.ix r.buf out else out termination_by rows-i structure F8 where (s0 s1 s2 s3 s4 s5 s6 s7 t:Float) lemma xi (xs:FloatArray) (i t n:USize) (k:Nat) (hk:k<8) (ht:t.toNat< n.toNat) (hi:i.toNat=8*t.toNat) (hx:8*n.toNat<=xs.size) (hs:xs.size<2^32) : (i+USize.ofNat k).toNat< xs.size:=by rw[qAe _ _ (by rw[uk k א]; omega),uk k א]; omega def go8 (xs:FloatArray) (W:Array UInt32) (wo n t i:USize) (hx:8*n.toNat<=xs.size) (hsx:xs.size<2^32) (hs:W.size<2^32) (hw:wo.toNat+n.toNat<=W.size) (hi:i.toNat=8*t.toNat) (s0 s1 s2 s3 s4 s5 s6 s7 a:Float):F8 := if h:t< n then have ht:=USize.lt_iff_toNat_lt.mp h let v:=dv (W.uget (wo+t) (wi wo t n W hw hs ht)) go8 xs W wo n (t+1) (i+USize.ofNat 8) hx hsx hs hw (by rw[usz t n h,qAe _ _ (by rw[uk 8 א]; omega),uk 8 א]; omega) (s0+v*xs.uget (i+USize.ofNat 0) (xi xs i t n 0 א ht hi hx hsx)) (s1+v*xs.uget (i+USize.ofNat 1) (xi xs i t n 1 א ht hi hx hsx)) (s2+v*xs.uget (i+USize.ofNat 2) (xi xs i t n 2 א ht hi hx hsx)) (s3+v*xs.uget (i+USize.ofNat 3) (xi xs i t n 3 א ht hi hx hsx)) (s4+v*xs.uget (i+USize.ofNat 4) (xi xs i t n 4 א ht hi hx hsx)) (s5+v*xs.uget (i+USize.ofNat 5) (xi xs i t n 5 א ht hi hx hsx)) (s6+v*xs.uget (i+USize.ofNat 6) (xi xs i t n 6 א ht hi hx hsx)) (s7+v*xs.uget (i+USize.ofNat 7) (xi xs i t n 7 א ht hi hx hsx)) (a+v.abs) else ⟨s0,s1,s2,s3,s4,s5,s6,s7,a⟩ termination_by n.toNat-t.toNat decreasing_by rw[usz t n h]; omega structure H8 where (xs:FloatArray) (h0 h1 h2 h3 h4 h5 h6 h7:UInt32) @[inline] def mx (a w:UInt32):UInt32 := let m:=w &&& 0x7FFFFFFF if m<=a then a else m def dec8 (X:Array UInt32) (n t:USize) (xs:FloatArray) (h0 h1 h2 h3 h4 h5 h6 h7:UInt32):H8 := if h:t< n then let w0:=rdW X t let w1:=rdW X (n+t) let w2:=rdW X (2*n+t) let w3:=rdW X (3*n+t) let w4:=rdW X (4*n+t) let w5:=rdW X (5*n+t) let w6:=rdW X (6*n+t) let w7:=rdW X (7*n+t) dec8 X n (t+1) ((((((((xs.push (dv w0)).push (dv w1)).push (dv w2)).push (dv w3)).push (dv w4)).push (dv w5)).push (dv w6)).push (dv w7)) (mx h0 w0) (mx h1 w1) (mx h2 w2) (mx h3 w3) (mx h4 w4) (mx h5 w5) (mx h6 w6) (mx h7 w7) else ⟨xs,h0,h1,h2,h3,h4,h5,h6,h7⟩ termination_by n.toNat-t.toNat decreasing_by rw[usz t n h]; have:=USize.lt_iff_toNat_lt.mp h; omega def cols8 (inW outW:Nat) (relu:Bool) (X W b:Array UInt32) (d:H8) (nf:Float) (n:USize) (j:Nat) (out:Array UInt32):Array UInt32 := if hj:j< outW then let ju:=j.toUSize let wo:=ju*n if hg:8*n.toNat<=d.xs.size∧d.xs.size<2^32∧W.size<2^32∧wo.toNat+n.toNat<=W.size then let r:=go8 d.xs W wo n 0 0 hg.1 hg.2.1 hg.2.2.1 hg.2.2.2 (by rw[show (0:USize).toNat=0 from rfl]) 0 0 0 0 0 0 0 0 0 let bw:=rdW b ju let ow:=outW.toUSize let out:=wrW out ju (fin8 inW relu X W b 0 j r.s0 nf r.t d.h0 bw n) let out:=wrW out (ow+ju) (fin8 inW relu X W b 1 j r.s1 nf r.t d.h1 bw n) let out:=wrW out (2*ow+ju) (fin8 inW relu X W b 2 j r.s2 nf r.t d.h2 bw n) let out:=wrW out (3*ow+ju) (fin8 inW relu X W b 3 j r.s3 nf r.t d.h3 bw n) let out:=wrW out (4*ow+ju) (fin8 inW relu X W b 4 j r.s4 nf r.t d.h4 bw n) let out:=wrW out (5*ow+ju) (fin8 inW relu X W b 5 j r.s5 nf r.t d.h5 bw n) let out:=wrW out (6*ow+ju) (fin8 inW relu X W b 6 j r.s6 nf r.t d.h6 bw n) let out:=wrW out (7*ow+ju) (fin8 inW relu X W b 7 j r.s7 nf r.t d.h7 bw n) cols8 inW outW relu X W b d nf n (j+1) out else out else out termination_by outW-j def linF (rows inW outW:Nat) (relu:Bool) (X W b:Array UInt32):Array UInt32 := if rows*inW=X.size∧outW*inW=W.size∧outW=b.size∧0< inW∧0< outW∧inW<2^20 ∧ X.size<2^32∧W.size<2^32∧b.size<2^32∧rows*outW<2^32 ∧ scan X X.usize 0 (qBc X) 0xFFFFFFFF 0∧scan W W.usize 0 (qBc W) 0xFFFFFFFF 0 ∧ scan b b.usize 0 (qBc b) 0xFFFFFFFF 0 then let n:=inW.toUSize let nf:Float:=(inW.toUInt64+8).toFloat*Float.ofBits 0x3CC0000000000000 let out:Array UInt32:=Array.replicate (rows*outW) 0 if rows == 8 then cols8 inW outW relu X W b (dec8 X n 0 (FloatArray.emptyWithCapacity (8*inW)) 0 0 0 0 0 0 0 0) nf n 0 out else rows1 rows inW outW relu X W b nf n 0 (Array.replicate inW 0) (pushZ n 0 (FloatArray.emptyWithCapacity inW)) out else linearWith dotFn rows inW outW relu X W b section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open FloatLib.Floats.ExecFloat.Binary noncomputable def R (f:Float):ℝ:=Model.toReal (toModel (ofFloat f)) noncomputable def wv (w:UInt32):ℝ:=Model.toReal (ofW w) noncomputable def exactS (n:Nat) (xw ww:Nat->UInt32) (bw:UInt32):ℝ := (Finset.range n).sum (λt=>wv (xw t)*wv (ww t))+wv bw def nfOf (n:Nat):Float:=(n.toUInt64+8).toFloat*Float.ofBits 0x3CC0000000000000 lemma qAi:FloatFormat.binary64.isIEEE=true:=by decide lemma qAz (a:Model FloatFormat.binary64) : Model.isFinite a=(Model.toModel a).isFinite:=by have hd:=Model.toDyadic?_ieee_eq_model _ qAi a cases hm:Model.toModel a with | notANumber => rw[hm] at hd cases h:Model.isFinite a with | false=>rfl | true => obtain ⟨d,hd'⟩:=Model.exists_toDyadic?_of_isFinite h rw[hd] at hd'; cases hd' | infinity s => rw[hm] at hd cases h:Model.isFinite a with | false=>rfl | true => obtain ⟨d,hd'⟩:=Model.exists_toDyadic?_of_isFinite h rw[hd] at hd'; cases hd' | zero s => rw[hm] at hd exact Model.isFinite_eq_true_of_toDyadic?_some hd | finite s m e h => rw[hm] at hd exact Model.isFinite_eq_true_of_toDyadic?_some hd abbrev A_M (x:Float):Model FloatFormat.binary64:=Model.ofFloatModel x.toModel lemma A_R (x:Float):R x=Model.toReal (A_M x):=rfl lemma qAc (x:Float):Model.isFinite (A_M x)=x.isFinite:=by rw[qAz,Model.toModel_ofFloatModel] rfl lemma qAs (e:ℤ):Formats.Flocq.bpow FloatLib.Numerics.binaryRadix e=(2:ℝ)^e:=by simp[Formats.Flocq.bpow,FloatLib.Numerics.binaryRadix,FloatLib.Numerics.Radix.toReal] lemma qBb:(2:ℝ)^(1000:ℤ)<=Model.toReal (Model.posMaxFinite FloatFormat.binary64):=by rw[Model.toReal_posMaxFinite] have h1:Model.pow2 FloatFormat.binary64.fracWidth+FloatFormat.binary64.maxFiniteFracField =2^53-1:=by decide +kernel have h2:FloatFormat.binary64.maxNormalExponent-Int.ofNat FloatFormat.binary64.fracWidth =971:=by decide +kernel rw[h1,h2] have h3:Model.bpow 971=(2:ℝ)^(971:ℤ):=by simp only[Model.bpow,qAs] rw[h3,show (1000:ℤ)=29+971 from rfl,zpow_add₀ ב] apply mul_le_mul_of_nonneg_right _ (by positivity) norm_num lemma qGp (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) (hb : |R x| + |R y| ≤ 2^(1000:ℤ)) : (x+y).isFinite=true ∧ R (x+y)=Model.roundAt FloatFormat.binary64 (R x+R y):=by have hm:A_M (x+y)=Model.add (A_M x) (A_M y) := toModel_ofFloat_add_of_isFinite x y hx hy have hfx:Model.isFinite (A_M x)=true:=by rw[qAc,hx] have hfy:Model.isFinite (A_M y)=true:=by rw[qAc,hy] constructor . rw[<-qAc,hm] exact Model.isFinite_add_of_abs_add_le_posMaxFinite _ _ qAi hfx hfy (hb.trans qBb) . rw[A_R,hm] exact Model.toReal_add_eq_roundAt_of_abs_add_le_posMaxFinite _ _ qAi hfx hfy (hb.trans qBb) lemma qGs (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) (hb : |R x| + |R y| ≤ 2^(1000:ℤ)) : (x-y).isFinite=true ∧ R (x-y)=Model.roundAt FloatFormat.binary64 (R x-R y):=by have hm:A_M (x-y)=Model.sub (A_M x) (A_M y) := toModel_ofFloat_sub_of_isFinite x y hx hy have hfx:Model.isFinite (A_M x)=true:=by rw[qAc,hx] have hfy:Model.isFinite (A_M y)=true:=by rw[qAc,hy] constructor . rw[<-qAc,hm] exact Model.isFinite_sub_of_abs_add_le_posMaxFinite _ _ qAi hfx hfy (hb.trans qBb) . rw[A_R,hm] exact Model.toReal_sub_eq_roundAt_of_abs_add_le_posMaxFinite _ _ qAi hfx hfy (hb.trans qBb) open Float.Model.UnpackedFloat in lemma qDj (b:BitVec 64) (s m e h) (hu:Float.Model.UnpackedFloat.unpack Float.Model.Format.binary64 b=.finite s m e h) : (2^52<=m∧-1074<=e)∨e=-1074:=by unfold Float.Model.UnpackedFloat.unpack at hu simp only at hu have hb:(Float.Model.Format.binary64.exponentBias:ℤ)=1023:=by decide rw[hb] at hu split_ifs at hu with h1 h2 h3 h4 . injection hu with _ _ he right have:(unpackExponent (spec:=Float.Model.Format.binary64) b).toNat=0:=by simp[h3] rw[this] at he omega . injection hu with _ hm he left have:(unpackExponent (spec:=Float.Model.Format.binary64) b).toNat≠0:=by intro h0; exact h3 (BitVec.eq_of_toNat_eq (by simpa using h0)) constructor . rw[<-hm,BitVec.toNat_append] refine le_trans ?_ Nat.left_le_or simp[Nat.shiftLeft_eq] . omega open Float.Model.UnpackedFloat in lemma qDv (spec:Float.Model.Format) (s:Sign) (m:ℕ) (e:ℤ) (h:e<=spec.targetExponent (Float.Model.totalExponent m e)) : Float.Model.UnpackedFloat.round spec s m e=roundWithAccuracy spec s m e .exact:=by unfold Float.Model.UnpackedFloat.round decreaseExponent have h0:(e-spec.targetExponent (Float.Model.totalExponent m e)).toNat=0 :=א simp[h0] open Float.Model.UnpackedFloat in lemma qG1 (s₁ s₂ m₁ m₂ e₁ e₂ h₁ h₂) (b₁ b₂:BitVec 64) (hu₁:unpack Float.Model.Format.binary64 b₁=.finite s₁ m₁ e₁ h₁) (hu₂:unpack Float.Model.Format.binary64 b₂=.finite s₂ m₂ e₂ h₂) : e₁+e₂<=Float.Model.Format.binary64.targetExponent (Float.Model.totalExponent (m₁*m₂) (e₁+e₂)):=by have c₁:=qDj _ _ _ _ _ hu₁ have c₂:=qDj _ _ _ _ _ hu₂ have hm0:m₁*m₂≠0:=Nat.mul_ne_zero h₁.ne' h₂.ne' have hlog:2^52<=m₁*m₂->52<=(m₁*m₂).log2:=λh=>(Nat.le_log2 hm0).2 h simp only[Float.Model.Format.targetExponent,Float.Model.totalExponent, Float.Model.Format.mantissaBits,Float.Model.Format.minExponent] rcases c₁ with ⟨c₁,_⟩ | c₁ . have:=hlog (le_trans c₁ (Nat.le_mul_of_pos_right _ h₂)) apply le_max_of_le_left norm_num omega . rcases c₂ with ⟨c₂,_⟩ | c₂ . have:=hlog (le_trans c₂ (Nat.le_mul_of_pos_left _ h₁)) apply le_max_of_le_left norm_num omega . apply le_max_of_le_right norm_num omega open Float.Model.UnpackedFloat in lemma qDc (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) : A_M (x*y)=Model.mul (A_M x) (A_M y):=by have hX:Model.toModel (A_M x)=x.toModel.unpack:=Model.toModel_ofFloatModel _ have hY:Model.toModel (A_M y)=y.toModel.unpack:=Model.toModel_ofFloatModel _ change Model.ofFloatModel (Float.Model.mul x.toModel y.toModel)=_ rw[Float.Model.mul,Model.ofFloatModel_pack,Model.Proof.mul_eq_spec,Model.Spec.mul, Model.toDyadic?_ieee_eq_model _ qAi (A_M x),Model.toDyadic?_ieee_eq_model _ qAi (A_M y),hX,hY] change x.toModel.unpack.isFinite=true at hx change y.toModel.unpack.isFinite=true at hy cases hxm:x.toModel.unpack <;> cases hym:y.toModel.unpack <;> simp only[hxm,hym,Float.Model.UnpackedFloat.isFinite,Bool.false_eq_true] at hx hy case zero.zero s₁ s₂ => cases s₁ <;> cases s₂ <;> simp[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.mul] all_goals first | (rw[Model.negZero_eq_ofModel_zero]; rfl) | (rw[Model.posZero_eq_ofModel_zero]; rfl) case zero.finite s₁ s₂ m₂ e₂ h₂ => cases s₁ <;> cases s₂ <;> simp[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.mul] all_goals first | (rw[Model.negZero_eq_ofModel_zero]; rfl) | (rw[Model.posZero_eq_ofModel_zero]; rfl) case finite.zero s₁ m₁ e₁ h₁ s₂ => cases s₁ <;> cases s₂ <;> simp[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.mul] all_goals first | (rw[Model.negZero_eq_ofModel_zero]; rfl) | (rw[Model.posZero_eq_ofModel_zero]; rfl) case finite.finite s₁ m₁ e₁ h₁ s₂ m₂ e₂ h₂ => simp only[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.mul] have hle:=qG1 s₁ s₂ m₁ m₂ e₁ e₂ h₁ h₂ _ _ hxm hym have h0:(m₁ == 0 || m₂ == 0)=false:=by simp[h₁.ne',h₂.ne'] rw[<-qDv _ _ _ _ hle,h0] have hs:Model.modelSign (Model.modelSignBit s₁ ^^ Model.modelSignBit s₂)=s₁*s₂:=by cases s₁ <;> cases s₂ <;> rfl simp only[Bool.false_eq_true,ite_false,Model.roundDyadic,qAi,ite_true, Model.ieeeRoundDyadic,hs] rfl lemma qCu (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) (hb : |R x| * |R y| ≤ 2^(1000:ℤ)) : (x*y).isFinite=true ∧ R (x*y)=Model.roundAt FloatFormat.binary64 (R x*R y):=by have hm:A_M (x*y)=Model.mul (A_M x) (A_M y):=qDc x y hx hy have hfx:Model.isFinite (A_M x)=true:=by rw[qAc,hx] have hfy:Model.isFinite (A_M y)=true:=by rw[qAc,hy] constructor . rw[<-qAc,hm] exact Model.isFinite_mul_of_abs_mul_le_posMaxFinite _ _ qAi hfx hfy (hb.trans qBb) . rw[A_R,hm] exact Model.toReal_mul_eq_roundAt_of_abs_mul_le_posMaxFinite _ _ qAi hfx hfy (hb.trans qBb) noncomputable def A_z:ℝ:=2^(-1021:ℤ) noncomputable def A_B:ℝ:=2^(300:ℤ) lemma qBi:0< A_z:=by unfold A_z; positivity lemma qAl:A_z<=1/2^200*(1/2^200):=by have:(1/2^200*(1/2^200):ℝ)=2^(-400:ℤ):=by rw[show (-400:ℤ)=-200+-200 from rfl,zpow_add₀ ב] norm_num rw[this] exact zpow_le_zpow_right₀ ב ב lemma qCi:0< A_B:=by unfold A_B; positivity lemma qA0:(2:ℝ)^256*2^42<=A_B:=by have:((2:ℝ)^256*2^42)=2^(298:ℤ):=by rw[show (298:ℤ)=256+42 from rfl,zpow_add₀ ב] norm_num rw[this] exact zpow_le_zpow_right₀ ב ב lemma qC3:A_B*2<=2^(1000:ℤ):=by have:A_B*2=2^(301:ℤ):=by unfold A_B rw[show (301:ℤ)=300+1 from rfl,zpow_add₀ ב] norm_num rw[this] exact zpow_le_zpow_right₀ ב ב lemma qB8:A_B*A_B<=2^(1000:ℤ):=by have:A_B*A_B=2^(600:ℤ):=by unfold A_B rw[show (600:ℤ)=300+300 from rfl,zpow_add₀ ב] rw[this] exact zpow_le_zpow_right₀ ב ב lemma qCr (x:ℝ) : |Model.roundAt FloatFormat.binary64 x-x| ≤ 1/2^53*(|x| + A_z):=by have ez:(1/2^53*(|x| + A_z):ℝ)=2^(-53:ℤ) * |x| + 2^(-1074:ℤ):=by have e1:(1/2^53:ℝ)=2^(-53:ℤ) :=ב rw[e1,show (-1074:ℤ)=-53+-1021 from rfl,zpow_add₀ ב (-53),mul_add] rfl rw[ez] have hu:(0:ℝ)<=(2:ℝ)^(-53:ℤ) * |x|:=by positivity have ht:(0:ℝ)<(2:ℝ)^(-1074:ℤ):=by positivity by_cases hx:x=0 . subst hx rw[Model.roundAt_zero] simp only[sub_self,abs_zero] linarith refine (Model.abs_roundAt_sub_le _ x).trans ?_ change Formats.Flocq.ulp _ (Model.fexpOf FloatFormat.binary64) x/2<=_ rw[Formats.Flocq.ulp.of_ne_zero _ _ x hx] simp only[Formats.Flocq.cexp,Model.fexpOf,Formats.Flocq.fltExp] have hl:=Formats.Flocq.bpow_magnitude_sub_one_le FloatLib.Numerics.binaryRadix x hx rw[qAs] at hl rw[qAs,show ((FloatFormat.binary64.fracWidth:ℤ)+1)=53 from rfl, show FloatFormat.binary64.minSubnormalExponent=-1074 from rfl] generalize Formats.Flocq.magnitude FloatLib.Numerics.binaryRadix x=M at hl ⊢ rcases le_total (-1074) (M-53) with h | h . rw[max_eq_left h] have e:(2:ℝ)^(M-53)/2=2^(-53:ℤ)*2^(M-1):=by rw[<-zpow_add₀ ב,show (-53:ℤ)+(M-1)=M-53-1 by ring, zpow_sub₀ ב _ 1,zpow_one] rw[e] have:=mul_le_mul_of_nonneg_left hl (show (0:ℝ)<=2^(-53:ℤ) by positivity) linarith . rw[max_eq_right h] generalize (2:ℝ)^(-1074:ℤ)=t at ht ⊢ generalize (2:ℝ)^(-53:ℤ) * |x| = v at hu ⊢ linarith lemma qBn (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ A_B) (h2 : |R y| ≤ A_B) : (x+y).isFinite=true∧|R (x+y)-(R x+R y)| ≤ 1/2^53*(|R x+R y| + A_z):=by obtain ⟨hf,he⟩:=qGp x y hx hy (by have:=qC3; linarith) exact ⟨hf,he ▸ qCr _⟩ lemma qC2 (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ A_B) (h2 : |R y| ≤ A_B) : (x-y).isFinite=true∧|R (x-y)-(R x-R y)| ≤ 1/2^53*(|R x-R y| + A_z):=by obtain ⟨hf,he⟩:=qGs x y hx hy (by have:=qC3; linarith) exact ⟨hf,he ▸ qCr _⟩ lemma qBq (x y:Float) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ A_B) (h2 : |R y| ≤ A_B) : (x*y).isFinite=true∧|R (x*y)-R x*R y| ≤ 1/2^53*(|R x*R y| + A_z):=by have hb : |R x| * |R y| ≤ 2^(1000:ℤ) := (mul_le_mul h1 h2 (abs_nonneg _) qCi.le).trans qB8 obtain ⟨hf,he⟩:=qCu x y hx hy hb exact ⟨hf,he ▸ qCr _⟩ lemma qAk (m k:ℤ) (hm:m.natAbs<2^53) (hk:-1074<=k) : Model.roundAt FloatFormat.binary64 ((m:ℝ)*2^k)=(m:ℝ)*2^k:=by apply Formats.Flocq.round_preserves_generic apply (Formats.Flocq.generic_format_FLT_iff (FloatFormat.binary64.minSubnormalExponent) (FloatFormat.binary64.fracWidth+1) (by decide) _).2 refine ⟨by decide,⟨m,k⟩,?_,?_,?_⟩ . simp[Formats.Flocq.toReal,qAs] . exact hm . exact hk lemma qAp (x:Float):R x=Model.unpackedToReal x.toModel.unpack:=by rw[A_R,Model.toReal_eq_unpackedToReal_toModel qAi,Model.toModel_ofFloatModel] lemma qEg (f:Float) (s m e h) (hu:f.toModel.unpack=.finite s m e h) : (Model.ofModel FloatFormat.binary64 (.finite .positive m e h)).toModel=.finite .positive m e h:=by have hm:Model.toModel (A_M f)=.finite s m e h:=by rw[Model.toModel_ofFloatModel,hu] cases s with | positive => rw[<-hm] exact Model.toModel_canonicalizeModel _ | negative => have hf:(Model.toModel (A_M f)).isFinite=true:=by rw[hm]; rfl have hn:=Model.toModel_neg_of_isFinite qAi (A_M f) hf rw[hm] at hn have h2:Float.Model.UnpackedFloat.neg (.finite .negative m e h) = .finite .positive m e h:=rfl rw[h2] at hn rw[<-hn] exact Model.toModel_canonicalizeModel _ lemma qAv (f:Float) (hf:f.isFinite=true):f.abs.isFinite=true∧R f.abs = |R f|:=by have hA:A_M f.abs=Model.ofModel FloatFormat.binary64 f.toModel.unpack.abs := Model.ofFloatModel_pack _ change f.toModel.unpack.isFinite=true at hf cases hu:f.toModel.unpack with | notANumber=>simp[hu,Float.Model.UnpackedFloat.isFinite] at hf | infinity s=>simp[hu,Float.Model.UnpackedFloat.isFinite] at hf | zero s => rw[hu] at hA constructor . rw[<-qAc,hA] exact Model.isFinite_ofModel_zero _ qAi _ . rw[A_R f.abs,hA,qAp f,hu] simp[Float.Model.UnpackedFloat.abs,Model.toReal_ofModel_zero _ qAi] | finite s m e h => rw[hu] at hA have hk:=qEg f s m e h hu change Model.toModel (Model.ofModel FloatFormat.binary64 (.finite .positive m e h))=_ at hk constructor . rw[<-qAc,hA,qAz] change (Model.toModel (Model.ofModel FloatFormat.binary64 (.finite .positive m e h))).isFinite=_ rw[hk]; rfl . rw[A_R f.abs,hA,qAp f,hu] change Model.toReal (Model.ofModel FloatFormat.binary64 (.finite .positive m e h))=_ rw[Model.toReal_eq_unpackedToReal_toModel qAi,hk] simp only[Model.unpackedToReal_finite,qAs] have h0:(0:ℝ)<=(m:ℝ)*2^e:=by positivity cases s <;> simp[Model.modelSignBit,abs_of_nonneg h0] lemma qDe (f:Float) (k:ℕ) (hk:k<2^53) (hf:f.toModel=Float.Model.pack (Float.Model.UnpackedFloat.ofNat Float.Model.Format.binary64 k)) : f.isFinite=true∧R f=k:=by have hA:A_M f=Model.roundDyadic FloatFormat.binary64 (FloatLib.Numerics.Dyadic.ofScaledInt k 0):=by change Model.ofFloatModel f.toModel=_ rw[hf,Model.ofFloatModel_pack] exact Model.ofModel_ofInt_eq_roundDyadic _ qAi (k:ℤ) have hd:(FloatLib.Numerics.Dyadic.ofScaledInt k 0).toReal=k:=by rw[<-FloatLib.Numerics.Dyadic.cast_toRat,FloatLib.Numerics.Dyadic.ofScaledInt_toRat] simp have hkR:(k:ℝ)<=2^(1000:ℤ):=by have h1:(k:ℝ)<=2^53:=by exact_mod_cast hk.le have h2:(2:ℝ)^53<=2^256*2^42 :=ב calc (k:ℝ)<=2^53:=h1 _<=2^256*2^42:=h2 _<=A_B:=qA0 _<=A_B*2:=by linarith [qCi] _<=_:=qC3 have hfin:Model.isFinite (A_M f)=true:=by rw[hA] apply Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite _ qAi rw[hd,abs_of_nonneg (Nat.cast_nonneg _)] exact hkR.trans qBb refine ⟨by rw[<-qAc]; exact hfin,?_⟩ rw[A_R,hA,Model.toReal_roundDyadic_eq_roundAt _ qAi _ (hA ▸ hfin),hd] have:=qAk k 0 (by simpa using hk) ב simpa using this lemma qFi (m:UInt32) (h:m.toNat<2^53):m.toFloat.isFinite=true∧R m.toFloat=m.toNat := qDe _ _ h rfl lemma qCf (m:UInt64) (h:m.toNat<2^53):m.toFloat.isFinite=true∧R m.toFloat=m.toNat := qDe _ _ h rfl lemma qBv:(0:Float).toModel.unpack=.zero .positive:=by rfl lemma qHq:(0:Float).isFinite=true∧R 0=0:=by refine ⟨?_,?_⟩ . change (0:Float).toModel.unpack.isFinite=true rw[qBv]; rfl . rw[qAp,qBv]; simp def A_bits (i:ℕ):UInt64 := let e:=(i%256).toUInt64 let s:UInt64:=if i ≥ 256 then 0x8000000000000000 else 0 if e == 0 then s else s ||| ((e+873) <<< (52:UInt64)) lemma qEa (i:ℕ):pwEntry i=Float.ofBits (A_bits i):=by unfold pwEntry A_bits dsimp only split <;> rfl def A_chk (i:ℕ):Bool := match Float.Model.UnpackedFloat.unpack Float.Model.Format.binary64 (A_bits i).toBitVec with | .finite s m e _=>(Model.modelSignBit s == decide (256<=i)) && m == 2^52 && e == ((i%256:ℕ):ℤ)-202 && (i%256 != 0) | .zero _=>i%256 == 0 | _=>false lemma qEl:∀ i,i<512->A_chk i=true:=by decide +kernel lemma qHc (i:ℕ) (hi:i<512) : (pwEntry i).isFinite=true∧R (pwEntry i) = if i%256=0 then 0 else (if 256<=i then -1 else 1)*2^(((i%256:ℕ):ℤ)-150):=by have hc:=qEl i hi rw[qEa] have hU:(Float.ofBits (A_bits i)).toModel.unpack = Float.Model.UnpackedFloat.unpack Float.Model.Format.binary64 (A_bits i).toBitVec := Model.unpack_pack_unpack _ _ unfold A_chk at hc rw[qAp,hU] change (Float.ofBits (A_bits i)).toModel.unpack.isFinite=true∧_ rw[hU] cases hu:Float.Model.UnpackedFloat.unpack Float.Model.Format.binary64 (A_bits i).toBitVec with | notANumber=>rw[hu] at hc; simp at hc | infinity s=>rw[hu] at hc; simp at hc | zero s => rw[hu] at hc simp only[beq_iff_eq] at hc refine ⟨rfl,?_⟩ simp[hc] | finite s m e h => rw[hu] at hc simp only[Bool.and_eq_true,beq_iff_eq,bne_iff_ne] at hc obtain ⟨⟨⟨h1,h2⟩,h3⟩,h4⟩:=hc refine ⟨rfl,?_⟩ have e:((2^52:ℕ):ℝ)*2^(((i%256:ℕ):ℤ)-202) = 2^(((i%256:ℕ):ℤ)-150):=by rw[Nat.cast_pow,Nat.cast_ofNat,<-zpow_natCast,<-zpow_add₀ ב] congr 1 push_cast ring rw[Model.unpackedToReal_finite,qAs,h3,h1,h2,mul_assoc,e] simp only[decide_eq_true_eq,h4,↓reduceIte] lemma qEv (i:USize) (h:i.toNat< pw.size):pw.uget i h=pwEntry i.toNat:=by simp[FloatArray.uget,qDg] lemma qBh (w:UInt32):(w &&& 0x7FFFFFFF).toNat=w.toNat%2^31:=by rw[UInt32.toNat_and] exact Nat.and_two_pow_sub_one_eq_mod w.toNat 31 lemma qDf (w:UInt32):(w &&& 0x7FFFFF).toNat=w.toNat%2^23:=by rw[UInt32.toNat_and] exact Nat.and_two_pow_sub_one_eq_mod w.toNat 23 lemma qE5 (w:UInt32):(w >>> (23:UInt32)).toNat=w.toNat/2^23:=by rw[UInt32.toNat_shiftRight,Nat.shiftRight_eq_div_pow] rfl lemma qE8 (w:UInt32):(expOf w).toNat=w.toNat/2^23%2^8:=by unfold expOf rw[UInt32.toNat_and,qE5] exact Nat.and_two_pow_sub_one_eq_mod _ 8 lemma qGc (w:UInt32):signOf w=decide (2^31<=w.toNat):=by have hw:=w.toNat_lt unfold signOf have h:((w &&& 0x80000000).toNat)=(w.toNat/2^31%2)*2^31:=by rw[UInt32.toNat_and] show w.toNat &&& 2^31=_ rw[Nat.and_two_pow,Nat.testBit_eq_decide_div_mod_eq] have h2:w.toNat/2^31%2=0∨w.toNat/2^31%2=1 :=א rcases h2 with h2 | h2 <;> rw[h2] <;> rfl rw[Bool.eq_iff_iff] simp only[bne_iff_ne,ne_eq,decide_eq_true_eq] rw[<-UInt32.toNat_inj,h] simp only[UInt32.toNat_zero] omega lemma qF8 (w:UInt32) : ((w &&& 0x7FFFFF) ||| 0x800000).toNat=2^23+w.toNat%2^23:=by rw[UInt32.toNat_or,qDf,Nat.or_comm] have h:w.toNat%2^23<2^23:=Nat.mod_lt _ (by positivity) have:=Nat.two_pow_add_eq_or_of_lt h 1 simpa using this.symm lemma qBg (w:UInt32) (h:good w=true) : w.toNat%2^31=0∨(2^23<=w.toNat%2^31∧w.toNat%2^31<0x7F800000):=by have hv:=qBh w have hlt:=(w &&& 0x7FFFFFFF).toNat_lt unfold good at h simp only[Bool.or_eq_true,beq_iff_eq,decide_eq_true_eq] at h rcases h with h | h . left rw[<-hv,h]; rfl . right rw[UInt32.le_iff_toNat_le,UInt32.toNat_sub] at h rw[<-hv] generalize (w &&& 0x7FFFFFFF).toNat=v at * simp at h omega noncomputable def A_mag (v:ℕ):ℝ := if v=0 then 0 else ((2^23+v%2^23:ℕ):ℝ)*2^(((v/2^23:ℕ):ℤ)-150) lemma qAt (v:ℕ):0<=A_mag v:=by unfold A_mag; split_ifs <;> positivity lemma qA6 (w:UInt32) (hg:good w=true) : wv w=(if 2^31<=w.toNat then -1 else 1)*A_mag (w.toNat%2^31):=by have hN:=w.toNat_lt have hgd:=qBg w hg have hE:=qE8 w have hF:(fracOf w).toNat=w.toNat%2^23:=qDf w have h255:expOf w≠255:=by intro h rw[h] at hE change 255=_ at hE omega have hv:wv w=(decodeD w).toReal:=by unfold wv ofW rw[Model.toReal_eq,toDyadic_ofUInt32 w h255] rw[hv] unfold decodeD A_mag by_cases h0:w.toNat%2^31=0 . have e0:expOf w=0:=by apply UInt32.toNat_inj.mp rw[hE]; show _=0; omega have f0:fracOf w=0:=by apply UInt32.toNat_inj.mp rw[hF]; show _=0; omega simp only[e0,f0,h0,↓reduceIte] simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand] . have e0:expOf w≠0:=by intro h; rw[h] at hE change 0=_ at hE omega simp only[e0,h0,↓reduceIte] have f1:w.toNat%2^31%2^23=(fracOf w).toNat:=by rw[hF]; omega have f2:w.toNat%2^31/2^23=(expOf w).toNat:=by rw[hE]; omega rw[f1,f2] simp only[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand,qGc] simp split_ifs <;> ring lemma qEp (v:ℕ) (h:v<0x7F800000):A_mag v<=2^128:=by unfold A_mag split_ifs with h0 . positivity . have h1:((2^23+v%2^23:ℕ):ℝ)<=2^24:=by have:2^23+v%2^23<=2^24 :=א exact_mod_cast this have h2:(2:ℝ)^(((v/2^23:ℕ):ℤ)-150)<=2^(104:ℤ) := zpow_le_zpow_right₀ ב א have h3:(2:ℝ)^(104:ℤ)=2^104 :=ב rw[h3] at h2 calc _<=(2:ℝ)^24*2^104:=mul_le_mul h1 h2 (by positivity) (by positivity) _=2^128 :=ב lemma qA4 (a b:ℕ) (hab:a<=b) (ha:a=0∨2^23<=a):A_mag a<=A_mag b:=by rcases ha with rfl | ha . simpa [A_mag] using qAt b unfold A_mag simp only[show ¬ a=0 by omega,show ¬ b=0 by omega,↓reduceIte] have hdiv:a/2^23<=b/2^23:=Nat.div_le_div_right hab rcases hdiv.eq_or_lt with he | hl . rw[he] apply mul_le_mul_of_nonneg_right _ (by positivity) have:2^23+a%2^23<=2^23+b%2^23 :=א exact_mod_cast this . have h1:((2^23+a%2^23:ℕ):ℝ)<=2^23*2:=by have:2^23+a%2^23<=2^23*2 :=א exact_mod_cast this have h2:(2:ℝ)^(((a/2^23:ℕ):ℤ)-150)*2<=2^(((b/2^23:ℕ):ℤ)-150):=by rw[<-zpow_add_one₀ ב] exact zpow_le_zpow_right₀ ב א have h3:(2:ℝ)^23<=((2^23+b%2^23:ℕ):ℝ):=by have:2^23<=2^23+b%2^23 :=א exact_mod_cast this calc _<=((2:ℝ)^23*2)*2^(((a/2^23:ℕ):ℤ)-150) := mul_le_mul_of_nonneg_right h1 (by positivity) _=2^23*(2^(((a/2^23:ℕ):ℤ)-150)*2):=by ring _<=_:=mul_le_mul h3 h2 (by positivity) (by positivity) lemma qA3 (w:UInt32) (hg:good w=true):(dv w).isFinite=true∧R (dv w)=wv w:=by have hN:=w.toNat_lt have hgd:=qBg w hg have hM:=qF8 w have hm:=qFi ((w &&& 0x7FFFFF) ||| 0x800000) (by rw[hM]; omega) have hI:(w >>> (23:UInt32)).toUSize.toNat=w.toNat/2^23:=by rw[UInt32.toNat_toUSize,qE5] have hp:=qHc (w.toNat/2^23) א unfold dv rw[qEv,hI] have hR1 : |R ((w &&& 0x7FFFFF) ||| 0x800000).toFloat| ≤ 2^24:=by rw[hm.2,hM,abs_of_nonneg (Nat.cast_nonneg _)] have:2^23+w.toNat%2^23<=2^24 :=א exact_mod_cast this have hR2 : |R (pwEntry (w.toNat/2^23))| ≤ 2^106:=by rw[hp.2] split_ifs . simp all_goals simp only[abs_mul,abs_neg,abs_one,one_mul] rw[abs_of_pos (by positivity)] have:(2:ℝ)^(((w.toNat/2^23%256:ℕ):ℤ)-150)<=2^(106:ℤ) := zpow_le_zpow_right₀ ב א simpa using this have hb : |R ((w &&& 0x7FFFFF) ||| 0x800000).toFloat| * |R (pwEntry (w.toNat/2^23))| ≤ 2^(1000:ℤ):=by have h1:=qA0 have e1:(2:ℝ)^24<=2^256*2^42 :=ב have e2:(2:ℝ)^106<=2^256*2^42 :=ב exact (mul_le_mul (hR1.trans (e1.trans h1)) (hR2.trans (e2.trans h1)) (abs_nonneg _) qCi.le).trans qB8 obtain ⟨hf,he⟩:=qCu _ _ hm.1 hp.1 hb refine ⟨hf,?_⟩ rw[he,hm.2,hp.2,qA6 w hg,hM] rcases hgd with h0 | ⟨h1,h2⟩ . have e0:w.toNat/2^23%256=0 :=א rw[h0] simp only[e0,↓reduceIte,mul_zero,Model.roundAt_zero] simp[A_mag] . have e0:¬ w.toNat/2^23%256=0 :=א have e1:w.toNat%2^31/2^23=w.toNat/2^23%256 :=א have e2:w.toNat%2^31%2^23=w.toNat%2^23 :=א have e3:(256<=w.toNat/2^23) ↔ 2^31<=w.toNat :=א unfold A_mag rw[e1,e2] simp only[e0,e3,show ¬ w.toNat%2^31=0 by omega,↓reduceIte] have hk:-1074<=((w.toNat/2^23%256:ℕ):ℤ)-150 :=א have hMl:2^23+w.toNat%2^23<2^53 :=א generalize ((w.toNat/2^23%256:ℕ):ℤ)-150=k at hk ⊢ generalize 2^23+w.toNat%2^23=M at hMl ⊢ by_cases hs:2^31<=w.toNat . have:=qAk (-(M:ℤ)) k (by simpa using hMl) hk simp only[hs,↓reduceIte] push_cast at this rw[show (M:ℝ)*(-1*2^k)=-(M:ℝ)*2^k by ring, show -1*((M:ℝ)*2^k)=-(M:ℝ)*2^k by ring] exact this . have:=qAk (M:ℤ) k (by simpa using hMl) hk simp only[hs,↓reduceIte,one_mul] push_cast at this exact this def A_fsum (l:List Float):Float:=l.foldl (.+·) 0 noncomputable def A_sa (l:List Float):ℝ:=(l.map λq=>|R q|).sum noncomputable def A_sr (l:List Float):ℝ:=(l.map R).sum lemma qAw (l:List Float):0<=A_sa l:=by induction l with | nil=>simp[A_sa] | cons q l ih => simp only[A_sa,List.map_cons,List.sum_cons] at ih ⊢ positivity lemma qBe (l:List Float) (q:Float):A_sa (l ++ [q])=A_sa l + |R q|:=by simp[A_sa] lemma qBo (l:List Float) (q:Float):A_sr (l ++ [q])=A_sr l+R q:=by simp[A_sr] lemma qAy (l:List Float) (q:Float):A_fsum (l ++ [q])=A_fsum l+q:=by simp[A_fsum] lemma qBy (l:List Float) : |A_sr l| ≤ A_sa l:=by induction l with | nil=>simp[A_sa,A_sr] | cons q l ih => simp only[A_sa,A_sr,List.map_cons,List.sum_cons] at ih ⊢ exact (abs_add_le _ _).trans ד lemma qAf (l:List Float) (hf:∀ q∈l,q.isFinite=true) (hlen:l.length<=2^21) (hb:A_sa l<=A_B/4) : (A_fsum l).isFinite=true ∧ |R (A_fsum l)-A_sr l| ≤ 2*l.length*(1/2^53*(A_sa l+A_z)):=by induction l using List.reverseRecOn with | nil => simp only[A_fsum,List.foldl_nil,List.length_nil] refine ⟨qHq.1,?_⟩ simp[qHq.2,A_sr] | append_singleton l q ih => rw[qBe] at hb have hP:=qAw l have hq0:=abs_nonneg (R q) obtain ⟨h1,h2⟩:=ih (λx hx=>hf x (by simp[hx])) (by simp at hlen; omega) ד have hk:(l.length:ℝ)+1<=2^21:=by simp at hlen exact_mod_cast hlen have hk0:(0:ℝ)<=l.length:=Nat.cast_nonneg _ have hS:=qBy l have hz:=qBi have hz1:=qAl have hB:=qCi have hBl:=qA0 rw[qAy,qBe,qBo,List.length_append,List.length_singleton] have hB1:(8:ℝ)<=A_B:=by have:(8:ℝ)<=2^256*2^42 :=ב linarith have hz':A_z<=1:=by have:(1/2^200*(1/2^200):ℝ)<=1 :=ב linarith push_cast set r:=R (A_fsum l) set a:=R q set P:=A_sa l set S:=A_sr l set k:ℝ:=(l.length:ℝ) set W:=(1/2^53:ℝ)*(P + |a| + A_z) with hWdef have hW:(1/2^53:ℝ)*(P+A_z)<=W:=by rw[hWdef] apply mul_le_mul_of_nonneg_left _ ב linarith have hW0:0<=W:=by rw[hWdef]; positivity have hD : |r-S| ≤ 2*k*W:=h2.trans (mul_le_mul_of_nonneg_left hW (by positivity)) have hk2:2*k*(1/2^53)<=1:=by norm_num at hk ⊢ linarith have hUD:(1/2^53:ℝ) * |r-S| ≤ W := calc (1/2^53:ℝ) * |r-S| ≤ 1/2^53*(2*k*W) := mul_le_mul_of_nonneg_left hD ב _=(2*k*(1/2^53))*W:=by ring _<=1*W:=mul_le_mul_of_nonneg_right hk2 hW0 _=W:=one_mul _ have hDP : |r-S| ≤ P+1 := calc |r-S| ≤ 2*k*(1/2^53*(P+A_z)):=h2 _=(2*k*(1/2^53))*(P+A_z):=by ring _<=1*(P+A_z):=mul_le_mul_of_nonneg_right hk2 (by positivity) _<=P+1 :=ד have hr : |r| ≤ A_B:=by have e:r=(r-S)+S:=by ring have:=abs_add_le (r-S) S rw[<-e] at this linarith have ha : |a| ≤ A_B :=ד obtain ⟨hf3,he⟩:=qBn (A_fsum l) q h1 (hf q ג) hr ha refine ⟨hf3,?_⟩ have t1 : |R (A_fsum l+q)-(S+a)| ≤ |R (A_fsum l+q)-(r+a)| + |r-S|:=by have e:R (A_fsum l+q)-(S+a)=(R (A_fsum l+q)-(r+a))+(r-S):=by ring rw[e] exact abs_add_le _ _ have t2 : |r+a| ≤ |r-S| + P + |a|:=by have e:r+a=(r-S)+S+a:=by ring rw[e] have h3:=abs_add_le ((r-S)+S) a have h4:=abs_add_le (r-S) S linarith have t3:(1/2^53:ℝ)*(|r+a| + A_z)<=1/2^53 * |r-S| + W:=by rw[hWdef,<-mul_add] apply mul_le_mul_of_nonneg_left _ ב linarith calc |R (A_fsum l+q)-(S+a)| ≤ W+W+2*k*W :=ד _=2*(k+1)*W:=by ring lemma qHg (n:ℕ) (hn:n<2^20) : (nfOf n).isFinite=true∧R (nfOf n)=((n:ℝ)+8)/2^51:=by have ht:(n.toUInt64+8).toNat=n+8:=by have h8:(8:UInt64).toNat=8:=rfl simp[UInt64.toNat_add,h8] omega have h1:=qCf (n.toUInt64+8) (by rw[ht]; omega) have hu:(Float.ofBits 0x3CC0000000000000).toModel.unpack = .finite .positive (2^52) (-103) (by decide):=by rfl have h2:(Float.ofBits 0x3CC0000000000000).isFinite=true:=by change (Float.ofBits 0x3CC0000000000000).toModel.unpack.isFinite=true rw[hu]; rfl have h3:R (Float.ofBits 0x3CC0000000000000)=1/2^51:=by rw[qAp,hu,Model.unpackedToReal_finite,qAs] simp norm_num have h4:(n:ℝ)+8<=2^21:=by have:n+8<=2^21 :=א exact_mod_cast this obtain ⟨hf,he⟩:=qCu _ _ h1.1 h2 (by rw[h1.2,h3,ht] have h5:(1:ℝ)<=2^256*2^42 :=ב have h6:=qA0 have h7:(2:ℝ)^21<=2^256*2^42 :=ב refine le_trans (mul_le_mul ?_ ?_ (abs_nonneg _) qCi.le) qB8 . rw[Nat.cast_add,abs_of_nonneg (by positivity)] push_cast linarith . rw[abs_of_nonneg (by positivity)] have:(1:ℝ)/2^51<=1 :=ב linarith) unfold nfOf refine ⟨hf,?_⟩ rw[he,h1.2,h3,ht] have:=qAk ((n:ℤ)+8) (-51) א ב push_cast at this ⊢ have e:(2:ℝ)^(-51:ℤ)=1/2^51 :=ב rw[e] at this rw[this] ring lemma qF9 (c Y S T E z:ℝ) (hc1:8<=c) (hc2:c<=2^20+8) (hz1:z<=1/2^200*(1/2^200)) (hY:0<=Y) (hS : |S| ≤ 2*Y) (hT : |T-Y| ≤ Y/2^30+1/2^250) (hE : |E-c/2^51*T| ≤ 1/2^53*(|c/2^51*T| + z)) (hbig:1/2^127 ≤ |S+E| + 1/2^53*(|S+E| + z)) : 4*(c-7)*(1/2^53*Y)+1/2^53*(|S| + |E| + z)< E:=by have hc0:0< c :=ד obtain ⟨hT1,hT2⟩:=abs_le.mp hT have hT' : |T| ≤ 2*Y+1/2^250:=by apply abs_le.mpr constructor <;> linarith have hcG:c/2^51<=1/2^30:=by have:(2:ℝ)^20+8<=2^21 :=ב calc c/2^51<=2^21/2^51:=by gcongr; linarith _=1/2^30 :=ב set G:=c/2^51*T with hGdef have hG : |G| ≤ (2*Y+1/2^250)/2^30:=by rw[hGdef,abs_mul,abs_of_pos (by positivity)] calc _<=(1/2^30:ℝ)*(2*Y+1/2^250) := mul_le_mul hcG hT' (abs_nonneg _) (by positivity) _=_:=by ring have hE1 : |E| ≤ |E-G| + |G|:=by have e:E=(E-G)+G:=by ring have:=abs_add_le (E-G) G rwa [<-e] at this have hSE:=abs_add_le S E have hG0:=abs_nonneg G have hE0:=abs_nonneg E have hYl:1/2^129<=Y :=ד have hT3:Y-Y/2^30-1/2^250<=T :=ד have hT4:0<=Y-Y/2^30-1/2^250 :=ד have hT5:0<=T :=ד have hG1:0<=G:=by rw[hGdef]; positivity rw[abs_of_nonneg hG1] at hE hE1 hG have hE2:=(abs_le.mp hE).1 have hG2:c*(Y-Y/2^30-1/2^250)/2^51<=G:=by rw[hGdef,show c/2^51*T=c*T/2^51 by ring] gcongr have hw1:c*Y<=2^21*Y:=by have:c<=2^21:=by have:(2:ℝ)^20+8<=2^21 :=ב linarith exact mul_le_mul_of_nonneg_right this hY have hG3:c*(Y-Y/2^30-1/2^250) = c*Y-c*Y/2^30-c*(1/2^250):=by ring rw[hG3] at hG2 have hc3:c*(1/2^250)<=2^21*(1/2^250):=by have:c<=2^21:=by have:(2:ℝ)^20+8<=2^21 :=ב linarith exact mul_le_mul_of_nonneg_right this (by positivity) have hgoal:4*(c-7)*(1/2^53*Y)=c*Y/2^51-28*Y/2^53:=by ring rw[hgoal] linarith lemma qDh (n:ℕ) (hn:n<2^20) (s t:Float) (hs:s.isFinite=true) (ht:t.isFinite=true) (X Y:ℝ) (hY0:0<=Y) (hYB:Y<=A_B/8) (h1 : |R s-X| ≤ 4*((n:ℝ)+1)*(1/2^53*Y)) (h2 : |R t-Y| ≤ Y/2^30+1/2^250) (h3 : |R s| ≤ 2*Y) (hbig:(2:ℝ)^(-127:ℤ) ≤ |R (s+nfOf n*t)|) : R (s-nfOf n*t)< X∧X< R (s+nfOf n*t):=by have hB:=qCi have hB8:(8:ℝ)<=A_B:=by have h:(8:ℝ)<=2^256*2^42 :=ב linarith [qA0] have hnR:(n:ℝ)+1<=2^20:=by exact_mod_cast hn have hn0:(0:ℝ)<=n:=Nat.cast_nonneg n obtain ⟨hnf,hnv⟩:=qHg n hn have hT : |R t| ≤ 3/8*A_B:=by have e:R t=(R t-Y)+Y:=by ring have:=abs_add_le (R t-Y) Y rw[<-e,abs_of_nonneg hY0] at this have h:(1:ℝ)/2^250<=1 :=ב have h':Y/2^30<=Y:=by apply div_le_self hY0; norm_num linarith have hT3 : |R t| ≤ A_B :=ד have hN : |R (nfOf n)| ≤ A_B:=by rw[hnv,abs_of_nonneg (by positivity)] have:((n:ℝ)+8)/2^51<=1:=by rw[div_le_one (by positivity)] norm_num at hnR ⊢ linarith linarith obtain ⟨hef,heE⟩:=qBq _ _ hnf ht hN hT3 have hNT : |R (nfOf n)*R t| ≤ |R t|:=by rw[abs_mul,hnv,abs_of_nonneg (show 0<=((n:ℝ)+8)/2^51 by positivity)] have:((n:ℝ)+8)/2^51<=1:=by rw[div_le_one (by positivity)] norm_num at hnR ⊢ linarith nlinarith [abs_nonneg (R t)] have hz:=qBi have hz1:=qAl have hz2:A_z<=1:=by have:(1/2^200*(1/2^200):ℝ)<=1 :=ב linarith have hE : |R (nfOf n*t)| ≤ A_B:=by have e:R (nfOf n*t)=(R (nfOf n*t)-R (nfOf n)*R t)+R (nfOf n)*R t:=by ring have:=abs_add_le (R (nfOf n*t)-R (nfOf n)*R t) (R (nfOf n)*R t) rw[<-e] at this linarith have hSB : |R s| ≤ A_B :=ד obtain ⟨hpf,hpE⟩:=qBn s _ hs hef hSB hE obtain ⟨hmf,hmE⟩:=qC2 s _ hs hef hSB hE have hSb1 : |R s+R (nfOf n*t)| ≤ |R s| + |R (nfOf n*t)|:=abs_add_le _ _ have hSb2 : |R s-R (nfOf n*t)| ≤ |R s| + |R (nfOf n*t)|:=abs_sub _ _ rw[hnv] at heE have hP : |R (s+nfOf n*t)| ≤ |R s+R (nfOf n*t)| + |R (s+nfOf n*t)-(R s+R (nfOf n*t))|:=by have e:R (s+nfOf n*t)=(R s+R (nfOf n*t)) + (R (s+nfOf n*t)-(R s+R (nfOf n*t))):=by ring have:=abs_add_le (R s+R (nfOf n*t)) (R (s+nfOf n*t)-(R s+R (nfOf n*t))) rwa [<-e] at this have hbig':(1:ℝ)/2^127 ≤ |R s+R (nfOf n*t)| + 1/2^53*(|R s+R (nfOf n*t)| + A_z):=by have e:(2:ℝ)^(-127:ℤ)=1/2^127 :=ב rw[e] at hbig linarith have key:=qF9 ((n:ℝ)+8) Y (R s) (R t) (R (nfOf n*t)) A_z ד (by norm_num at hnR ⊢; linarith) hz1 hY0 h3 h2 heE hbig' have e7:4*((n:ℝ)+8-7)=4*((n:ℝ)+1):=by ring rw[e7] at key obtain ⟨h1a,h1b⟩:=abs_le.mp h1 obtain ⟨hpa,hpb⟩:=abs_le.mp hpE obtain ⟨hma,hmb⟩:=abs_le.mp hmE constructor <;> linarith lemma qD4 (g h:ℕ->Float) (l:List ℕ) (a b:Float) : l.foldl (λ(acc:F1) t=>F1.mk (acc.s+g t) (acc.t+h t)) ⟨a,b⟩ = ⟨(l.map g).foldl (.+·) a,(l.map h).foldl (.+·) b⟩:=by induction l generalizing a b with | nil=>rfl | cons x l ih=>simp only[List.foldl_cons,List.map_cons,ih] lemma qCz (l:List Float) (hf:∀ q∈l,q.isFinite=true) : A_sa (l.map Float.abs)=A_sa l∧A_sr (l.map Float.abs)=A_sa l:=by induction l with | nil=>simp[A_sa,A_sr] | cons q l ih => obtain ⟨h1,h2⟩:=ih (λx hx=>hf x (by simp[hx])) have h3:=(qAv q (hf q ג)).2 simp only[A_sa,A_sr,List.map_cons,List.sum_cons,List.map_map] at h1 h2 ⊢ simp only[Function.comp_def,h3,abs_abs] simp only[Function.comp_def] at h1 h2 rw[h1,h2] simp lemma qDi (ts:List ℕ) (q:ℕ->Float) (p:ℕ->ℝ) (hq:∀ t∈ts,|R (q t)-p t| ≤ 1/2^53*(|p t| + A_z)) : |A_sr (ts.map q)-(ts.map p).sum| ≤ 1/2^53*((ts.map λt=>|p t|).sum+ts.length*A_z) ∧ A_sa (ts.map q)<=(ts.map λt=>|p t|).sum + 1/2^53*((ts.map λt=>|p t|).sum+ts.length*A_z) ∧ (ts.map λt=>|p t|).sum<=2*A_sa (ts.map q)+ts.length*A_z:=by induction ts with | nil=>simp[A_sa,A_sr] | cons x ts ih => obtain ⟨h1,h2,h3⟩:=ih (λt ht=>hq t (by simp[ht])) have h4:=hq x ג simp only[A_sa,A_sr,List.map_cons,List.sum_cons,List.map_map,List.length_cons] at h1 h2 h3 ⊢ simp only[Function.comp_def] at h1 h2 h3 ⊢ have hz:=qBi obtain ⟨h5,h6⟩:=abs_le.mp h4 obtain ⟨h7,h8⟩:=abs_le.mp h1 have hpq : |p x| ≤ |R (q x)| + 1/2^53*(|p x| + A_z):=by have e:p x=R (q x)-(R (q x)-p x):=by ring have:=abs_sub (R (q x)) (R (q x)-p x) rw[<-e] at this linarith have hqp : |R (q x)| ≤ |p x| + 1/2^53*(|p x| + A_z):=by have e:R (q x)=p x+(R (q x)-p x):=by ring have:=abs_add_le (p x) (R (q x)-p x) rw[<-e] at this linarith have hp0:=abs_nonneg (p x) refine ⟨abs_le.mpr ⟨?_,?_⟩,?_,?_⟩ <;> push_cast <;> nlinarith lemma qCw (ts:List ℕ) (f:ℕ->ℝ) (M:ℝ) (h:∀ t∈ts,f t<=M) : (ts.map f).sum<=ts.length*M:=by induction ts with | nil=>simp | cons x ts ih => have h1:=ih (λt ht=>h t (by simp[ht])) have h2:=h x ג simp only[List.map_cons,List.sum_cons,List.length_cons] push_cast linarith lemma qB0 (w:UInt32) (hg:good w=true) : |wv w| = A_mag (w.toNat%2^31):=by rw[qA6 w hg,abs_mul,abs_of_nonneg (qAt _)] split_ifs <;> simp lemma qA5 (w:UInt32) (hg:good w=true) : |wv w| ≤ 2^128:=by rw[qB0 w hg] apply qEp rcases qBg w hg with h | h <;> omega lemma qEh (w:UInt32) (hg:good w=true) (h:w &&& 0x7FFFFFFF=0):wv w=0:=by rw[qA6 w hg,<-qBh w,h] simp[A_mag] lemma qBr:(2:ℝ)^128<=A_B:=by have h:(2:ℝ)^128<=2^256*2^42 :=ב linarith [qA0] lemma qEi (a b:UInt32) (ha:good a=true) (hb:good b=true) : (dv a*dv b).isFinite=true ∧ |R (dv a*dv b)-wv a*wv b| ≤ 1/2^53*(|wv a*wv b| + A_z) ∧ |wv a*wv b| ≤ 2^256:=by obtain ⟨fa,ra⟩:=qA3 a ha obtain ⟨fb,rb⟩:=qA3 b hb have la:=qA5 a ha have lb:=qA5 b hb have hab : |wv a*wv b| ≤ 2^256:=by rw[abs_mul] calc |wv a| * |wv b| ≤ 2^128*2^128:=mul_le_mul la lb (abs_nonneg _) (by positivity) _=2^256 :=ב obtain ⟨h1,h2⟩:=qBq _ _ fa fb (by rw[ra]; exact la.trans qBr) (by rw[rb]; exact lb.trans qBr) rw[ra,rb] at h2 exact ⟨h1,h2,hab⟩ lemma qBl (n:ℕ) (xw ww:ℕ->UInt32) (bw:UInt32) (hx:∀ t,t< n->good (xw t)=true) (l:List ℕ) (hl:l.Nodup) (hl2:∀ t∈l,t< n) (hz:∀ t,t< n->t∉l->xw t &&& 0x7FFFFFFF=0) : exactS n xw ww bw=(l.map λt=>wv (xw t)*wv (ww t)).sum+wv bw:=by unfold exactS congr 1 rw[<-List.sum_toFinset _ hl] symm apply Finset.sum_subset . intro t ht simp only[List.mem_toFinset] at ht simpa using hl2 t ht . intro t ht hnl have h1:t< n:=by simpa using ht have h2:t∉l:=by simpa using hnl simp[qEh (xw t) (hx t h1) (hz t h1 h2)] lemma qGq (n:ℕ) (l:List ℕ) (hl:l.Nodup) (hl2:∀ t∈l,t< n):l.length<=n:=by have h:l.toFinset ⊆ Finset.range n:=by intro t ht simp only[List.mem_toFinset] at ht simpa using hl2 t ht have:=Finset.card_le_card h rwa [List.toFinset_card_of_nodup hl,Finset.card_range] at this lemma qC7 (n:ℕ) (hn:n<2^20) (ts:List ℕ) (hlen:ts.length<=n) (g:ℕ->Float) (p:ℕ->ℝ) (b:Float) (bv:ℝ) (hg:∀ t∈ts,(g t).isFinite=true∧|R (g t)-p t| ≤ 1/2^53*(|p t| + A_z) ∧ |p t| ≤ 2^256) (hbf:b.isFinite=true) (hbv:R b=bv) (hbl : |bv| ≤ 2^128) (hbig:(2:ℝ)^(-127:ℤ) ≤ |R (A_fsum (ts.map g ++ [b]) + nfOf n*A_fsum ((ts.map g ++ [b]).map Float.abs))|) : R (A_fsum (ts.map g ++ [b])-nfOf n*A_fsum ((ts.map g ++ [b]).map Float.abs)) < (ts.map p).sum+bv ∧ (ts.map p).sum+bv< R (A_fsum (ts.map g ++ [b]) + nfOf n*A_fsum ((ts.map g ++ [b]).map Float.abs)):=by have hfq:∀ q∈ts.map g ++ [b],q.isFinite=true:=by intro q hq simp only[List.mem_append,List.mem_map,List.mem_singleton] at hq rcases hq with ⟨t,ht,rfl⟩ | rfl . exact (hg t ht).1 . exact hbf obtain ⟨hA1,hA2,hA3⟩:=qDi ts g p (λt ht=>(hg t ht).2.1) have hAle:=qCw ts (λt=>|p t|) _ (λt ht=>(hg t ht).2.2) have hsa:=qBe (ts.map g) b have hsr:=qBo (ts.map g) b have hsag:=qAw (ts.map g) have hsa0:=qAw (ts.map g ++ [b]) rw[hbv] at hsa hsr have hk:(ts.length:ℝ)<=n:=by exact_mod_cast hlen have hk0:(0:ℝ)<=ts.length:=Nat.cast_nonneg _ have hnR:(n:ℝ)+1<=2^20:=by exact_mod_cast hn have hz:=qBi have hz1:=qAl have hz2:A_z<=1:=by have:(1/2^200*(1/2^200):ℝ)<=1 :=ב linarith have hA0:0<=(ts.map λt=>|p t|).sum := List.sum_nonneg (by simp only[List.mem_map]; rintro _ ⟨t,_,rfl⟩; exact abs_nonneg _) set A:=(ts.map λt=>|p t|).sum set k:ℝ:=(ts.length:ℝ) have hkz:k*A_z<=2^20:=by nlinarith have hAl:A<=2^20*2^256:=by refine hAle.trans (mul_le_mul_of_nonneg_right ?_ (by positivity)) linarith have hBl:=qA0 have hnum:(2:ℝ)^20*2^256*3+2^128+2^20+2<=2^256*2^42/8:=by norm_num have hsaB:A_sa (ts.map g ++ [b])+A_z<=A_B/8:=by have hU:(1/2^53:ℝ)*(A+k*A_z)<=A+k*A_z:=by have:0<=A+k*A_z:=by positivity nlinarith linarith have hB8:(1:ℝ)<=A_B/8:=by have:(1:ℝ)<=2^256*2^42/8 :=ב linarith have hlen1:(ts.map g ++ [b]).length<=2^21:=by simp; omega obtain ⟨hf1,he1⟩:=qAf _ hfq hlen1 ד obtain ⟨habs1,habs2⟩:=qCz _ hfq obtain ⟨hf2,he2⟩:=qAf ((ts.map g ++ [b]).map Float.abs) (by intro q hq obtain ⟨x,hx,rfl⟩:=List.mem_map.mp hq exact (qAv x (hfq x hx)).1) (by simpa using hlen1) (by rw[habs1]; linarith) rw[habs1,habs2] at he2 have hl1:(((ts.map g ++ [b]).length:ℕ):ℝ)=k+1:=by simp[k] have hl2:(((ts.map g ++ [b]).map Float.abs).length:ℝ)=k+1:=by simp[k] rw[hl1] at he1 rw[hl2] at he2 generalize hsaD:A_sa (ts.map g ++ [b])=sa at * set Y:=sa+A_z with hYdef have hY0:0<=Y:=by positivity have hUY:0<=(1/2^53:ℝ)*Y:=by positivity have hKU:2*(k+1)*(1/2^53*Y)<=Y/2^30:=by have h:k+1<=2^20 :=ד have:=mul_le_mul_of_nonneg_right h hUY norm_num at this ⊢ linarith have hS1 : |A_sr (ts.map g ++ [b])| ≤ sa:=by rw[<-hsaD]; exact qBy _ obtain ⟨he1a,he1b⟩:=abs_le.mp he1 obtain ⟨he2a,he2b⟩:=abs_le.mp he2 refine qDh n hn _ _ hf1 hf2 _ Y hY0 ד ?_ ?_ ?_ hbig . have hKY:sa+k*A_z<=(k+1)*Y:=by rw[hYdef] nlinarith [mul_nonneg hk0 hsa0] have hU2:(1/2^53:ℝ)*(A+k*A_z)<=2*(k+1)*(1/2^53*Y):=by have h1:A+k*A_z<=2*(sa+k*A_z):=by linarith [abs_nonneg bv] have h2:A+k*A_z<=2*((k+1)*Y) :=ד calc (1/2^53:ℝ)*(A+k*A_z)<=1/2^53*(2*((k+1)*Y)) := mul_le_mul_of_nonneg_left h2 ב _=_:=by ring have hn4:4*(k+1)*(1/2^53*Y)<=4*((n:ℝ)+1)*(1/2^53*Y) := mul_le_mul_of_nonneg_right ד hUY obtain ⟨hA1a,hA1b⟩:=abs_le.mp hA1 apply abs_le.mpr constructor <;> linarith . apply abs_le.mpr constructor . have:(0:ℝ)<=1/2^250 :=ב have:A_z<=1/2^250:=by have:(1/2^200*(1/2^200):ℝ)<=1/2^250 :=ב linarith linarith . linarith . have e:R (A_fsum (ts.map g ++ [b])) = (R (A_fsum (ts.map g ++ [b]))-A_sr (ts.map g ++ [b]))+A_sr (ts.map g ++ [b]):=by ring have h1:=abs_add_le (R (A_fsum (ts.map g ++ [b]))-A_sr (ts.map g ++ [b])) (A_sr (ts.map g ++ [b])) rw[<-e] at h1 have h2:Y/2^30<=Y:=by apply div_le_self hY0; norm_num linarith lemma qCb (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw:UInt32) (hx:∀ t,t< n->good (xw t)=true) (hw:∀ t,t< n->good (ww t)=true) (hb:good bw=true) (l:List Nat) (hl:l.Nodup) (hl2:∀ t∈l,t< n) (hz:∀ t,t< n->t∉l->xw t &&& 0x7FFFFFFF=0) (s e:Float) (hs:let r:=l.foldl (λ(acc:F1) t=>let q:=dv (xw t)*dv (ww t) F1.mk (acc.s+q) (acc.t+q.abs)) ⟨0,0⟩;s=r.s+dv bw∧e=nfOf n*(r.t+(dv bw).abs)) (hbig:(2:ℝ)^(-127:ℤ) ≤ |R (s+e)|) : R (s-e)< exactS n xw ww bw∧exactS n xw ww bw< R (s+e):=by set g:ℕ->Float:=λt=>dv (xw t)*dv (ww t) with hg set p:ℕ->ℝ:=λt=>wv (xw t)*wv (ww t) with hp have hfold:l.foldl (λ(acc:F1) t=>let q:=dv (xw t)*dv (ww t) F1.mk (acc.s+q) (acc.t+q.abs)) ⟨0,0⟩ = ⟨(l.map g).foldl (.+·) 0,(l.map λt=>(g t).abs).foldl (.+·) 0⟩ := qD4 g (λt=>(g t).abs) l 0 0 obtain ⟨hs1,hs2⟩:=hs rw[hfold] at hs1 hs2 have hlen:=qGq n l hl hl2 have hgt:∀ t∈l,(g t).isFinite=true∧|R (g t)-p t| ≤ 1/2^53*(|p t| + A_z) ∧ |p t| ≤ 2^256:=λt ht=>qEi _ _ (hx t (hl2 t ht)) (hw t (hl2 t ht)) obtain ⟨hbf,hbv⟩:=qA3 bw hb have hS:s=A_fsum (l.map g ++ [dv bw]):=by rw[hs1,qAy]; rfl have hE:e=nfOf n*A_fsum ((l.map g ++ [dv bw]).map Float.abs):=by rw[hs2] congr 1 rw[List.map_append,List.map_map,List.map_singleton,qAy] rfl rw[hS,hE] at hbig ⊢ rw[qBl n xw ww bw hx l hl hl2 hz] exact qC7 n hn l hlen g p (dv bw) (wv bw) hgt hbf hbv (qA5 bw hb) hbig lemma qFk (H J Rj Rg Rt b z k:ℝ) (hH0:0<=H) (hH:H<=2^128) (hJ:0<=J) (hb:0<=b) (hz0:0<=z) (hz1:z<=1/2^200*(1/2^200)) (hk:k<=2^20) (hj : |Rj-J| ≤ 2*k*(1/2^53*(J+z))) (hg : |Rg-H*Rj| ≤ 1/2^53*(|H*Rj| + z)) (ht : |Rt-(Rg+b)| ≤ 1/2^53*(|Rg+b| + z)) : |Rt-(H*J+b+z)| ≤ (H*J+b+z)/2^30+1/2^250:=by have e1 : |Rj-J| ≤ (J+z)/2^32:=by refine hj.trans ?_ have h:0<=(1/2^53:ℝ)*(J+z):=mul_nonneg ב (add_nonneg hJ hz0) have:=mul_le_mul_of_nonneg_right hk h norm_num at this ⊢ linarith have e2 : |H*Rj-H*J| ≤ (H*J+H*z)/2^32:=by rw[<-mul_sub,abs_mul,abs_of_nonneg hH0] calc H * |Rj-J| ≤ H*((J+z)/2^32):=mul_le_mul_of_nonneg_left e1 hH0 _=_:=by ring have e3:H*z<=1/2^250:=by calc H*z<=2^128*(1/2^200*(1/2^200)) := mul_le_mul hH hz1 hz0 ב _<=1/2^250 :=ב have hW:0<=H*J:=mul_nonneg hH0 hJ have hZ0:0<=H*z:=mul_nonneg hH0 hz0 generalize H*J=W at * generalize H*z=Z at * generalize H*Rj=G at * obtain ⟨e2a,e2b⟩:=abs_le.mp e2 obtain ⟨hga,hgb⟩:=abs_le.mp hg obtain ⟨hta,htb⟩:=abs_le.mp ht have hG : |G| ≤ W+(W+Z)/2^32:=by apply abs_le.mpr constructor <;> linarith have hRg : |Rg| ≤ 2*W+1/2^200:=by apply abs_le.mpr constructor <;> linarith have hR : |Rg+b| ≤ 2*W+b+1/2^200:=by have:=abs_add_le Rg b rw[abs_of_nonneg hb] at this linarith apply abs_le.mpr constructor <;> linarith lemma qD7 (ts:List ℕ) (f g:ℕ->ℝ) (H:ℝ) (h:∀ t∈ts,f t<=H*g t) : (ts.map f).sum<=H*(ts.map g).sum:=by induction ts with | nil=>simp | cons x ts ih => have h1:=ih (λt ht=>h t (by simp[ht])) have h2:=h x ג simp only[List.map_cons,List.sum_cons,mul_add] linarith lemma qCo (n:ℕ) (hn:n<2^20) (ts:List ℕ) (hlen:ts.length<=n) (g v:ℕ->Float) (p a:ℕ->ℝ) (b f:Float) (bv H:ℝ) (hg:∀ t∈ts,(g t).isFinite=true∧|R (g t)-p t| ≤ 1/2^53*(|p t| + A_z) ∧ |p t| ≤ H * |a t|) (hv:∀ t∈ts,(v t).isFinite=true∧R (v t)=a t∧|a t| ≤ 2^128) (hbf:b.isFinite=true) (hbv:R b=bv) (hbl : |bv| ≤ 2^128) (hf:f.isFinite=true) (hH:R f=H) (hH0:0<=H) (hHl:H<=2^128) (hbig:(2:ℝ)^(-127:ℤ) ≤ |R (A_fsum (ts.map g ++ [b]) + nfOf n*(f*A_fsum (ts.map λt=>(v t).abs)+b.abs))|) : R (A_fsum (ts.map g ++ [b])-nfOf n*(f*A_fsum (ts.map λt=>(v t).abs)+b.abs)) < (ts.map p).sum+bv ∧ (ts.map p).sum+bv< R (A_fsum (ts.map g ++ [b]) + nfOf n*(f*A_fsum (ts.map λt=>(v t).abs)+b.abs)):=by have hfq:∀ q∈ts.map g ++ [b],q.isFinite=true:=by intro q hq simp only[List.mem_append,List.mem_map,List.mem_singleton] at hq rcases hq with ⟨t,ht,rfl⟩ | rfl . exact (hg t ht).1 . exact hbf obtain ⟨hA1,hA2,hA3⟩:=qDi ts g p (λt ht=>(hg t ht).2.1) have hsa:=qBe (ts.map g) b have hsr:=qBo (ts.map g) b have hsa0:=qAw (ts.map g ++ [b]) rw[hbv] at hsa hsr have hk:(ts.length:ℝ)<=n:=by exact_mod_cast hlen have hk0:(0:ℝ)<=ts.length:=Nat.cast_nonneg _ have hnR:(n:ℝ)+1<=2^20:=by exact_mod_cast hn have hz:=qBi have hz1:=qAl have hz2:A_z<=1:=by have:(1/2^200*(1/2^200):ℝ)<=1 :=ב linarith have hA0:0<=(ts.map λt=>|p t|).sum := List.sum_nonneg (by simp only[List.mem_map]; rintro _ ⟨t,_,rfl⟩; exact abs_nonneg _) have hJ0:0<=(ts.map λt=>|a t|).sum := List.sum_nonneg (by simp only[List.mem_map]; rintro _ ⟨t,_,rfl⟩; exact abs_nonneg _) have hJl:=qCw ts (λt=>|a t|) _ (λt ht=>(hv t ht).2.2) have hAJ:=qD7 ts (λt=>|p t|) (λt=>|a t|) H (λt ht=>(hg t ht).2.2) have hvl:(ts.map λt=>(v t).abs)=(ts.map v).map Float.abs:=by simp[List.map_map,Function.comp_def] have hvf:∀ q∈ts.map v,q.isFinite=true:=by intro q hq obtain ⟨t,ht,rfl⟩:=List.mem_map.mp hq exact (hv t ht).1 obtain ⟨hv1,hv2⟩:=qCz (ts.map v) hvf have hJ1:A_sa (ts.map v)=(ts.map λt=>|a t|).sum:=by simp only[A_sa,List.map_map] congr 1 apply List.map_congr_left intro t ht simp[(hv t ht).2.1] rw[hvl] at hbig ⊢ rw[hJ1] at hv1 hv2 set A:=(ts.map λt=>|p t|).sum set J:=(ts.map λt=>|a t|).sum set k:ℝ:=(ts.length:ℝ) have hBl:=qA0 have hB8:(1:ℝ)<=A_B/8:=by have:(1:ℝ)<=2^256*2^42/8 :=ב linarith have hkR:k<=2^20 :=ד have hJ2:J<=2^20*2^128 := hJl.trans (mul_le_mul_of_nonneg_right hkR ב) have hlenv:((ts.map v).map Float.abs).length<=2^21:=by simp; omega obtain ⟨hjf,hje⟩:=qAf ((ts.map v).map Float.abs) (by intro q hq obtain ⟨x,hx,rfl⟩:=List.mem_map.mp hq exact (qAv x (hvf x hx)).1) hlenv (by rw[hv1] have:(2:ℝ)^20*2^128<=2^256*2^42/4 :=ב linarith) rw[hv1,hv2] at hje have hl3:(((ts.map v).map Float.abs).length:ℝ)=k:=by simp[k] rw[hl3] at hje generalize hjD:A_fsum ((ts.map v).map Float.abs)=j at * have hk2:2*k*(1/2^53)<=1:=by norm_num at hkR ⊢ linarith have hje2 : |R j-J| ≤ J+1 := calc |R j-J| ≤ 2*k*(1/2^53*(J+A_z)):=hje _=(2*k*(1/2^53))*(J+A_z):=by ring _<=1*(J+A_z):=mul_le_mul_of_nonneg_right hk2 ד _<=J+1 :=ד have hRj : |R j| ≤ 2^150:=by have e:R j=(R j-J)+J:=by ring have h1:=abs_add_le (R j-J) J rw[<-e,abs_of_nonneg hJ0] at h1 have:(2:ℝ)*(2^20*2^128)+1<=2^150 :=ב linarith have h150:(2:ℝ)^150<=A_B:=by have:(2:ℝ)^150<=2^256*2^42 :=ב linarith obtain ⟨hgf,hge⟩:=qBq f j hf hjf (by rw[hH,abs_of_nonneg hH0]; linarith [qBr]) (hRj.trans h150) rw[hH] at hge have hHj : |H*R j| ≤ 2^128*2^150:=by rw[abs_mul,abs_of_nonneg hH0] exact mul_le_mul hHl hRj (abs_nonneg _) ב have hgb : |R (f*j)| ≤ A_B:=by have e:R (f*j)=(R (f*j)-H*R j)+H*R j:=by ring have h1:=abs_add_le (R (f*j)-H*R j) (H*R j) rw[<-e] at h1 have:(2:ℝ)^128*2^150*2+1<=2^256*2^42 :=ב have h2:(1/2^53:ℝ)*(|H*R j| + A_z) ≤ |H*R j| + 1:=by have:=abs_nonneg (H*R j) linarith linarith obtain ⟨haf,hav⟩:=qAv b hbf rw[hbv] at hav obtain ⟨htf,hte⟩:=qBn (f*j) b.abs hgf haf hgb (by rw[hav,abs_abs]; linarith [qBr]) rw[hav] at hte have key2:=qFk H J (R j) (R (f*j)) (R (f*j+b.abs)) |bv| A_z k hH0 hHl hJ0 (abs_nonneg _) hz.le hz1 hkR hje hge hte have hHJ:H*J<=2^128*(2^20*2^128):=mul_le_mul hHl hJ2 hJ0 ב have hHJ0:0<=H*J:=mul_nonneg hH0 hJ0 have hbv0:=abs_nonneg bv have hkz:k*A_z<=2^20*A_z:=mul_le_mul_of_nonneg_right hkR hz.le have hYB:H*J + |bv| + A_z<=A_B/8:=by have:(2:ℝ)^128*(2^20*2^128)+2^128+1<=2^256*2^42/8 :=ב linarith have hsaY:A_sa (ts.map g ++ [b])+A_z<=3/2*(H*J + |bv| + A_z):=by linarith have hlen1:(ts.map g ++ [b]).length<=2^21:=by simp; omega obtain ⟨hf1,he1⟩:=qAf _ hfq hlen1 ד have hl1:(((ts.map g ++ [b]).length:ℕ):ℝ)=k+1:=by simp[k] rw[hl1] at he1 have hS1:=qBy (ts.map g ++ [b]) set Y:=H*J + |bv| + A_z with hYdef have hY0:0<=Y :=ד have hUY:0<=(1/2^53:ℝ)*Y:=mul_nonneg ב hY0 have hD1:2*(k+1)*(1/2^53*(A_sa (ts.map g ++ [b])+A_z)) ≤ 3*(k+1)*(1/2^53*Y) := calc 2*(k+1)*(1/2^53*(A_sa (ts.map g ++ [b])+A_z)) <=2*(k+1)*(1/2^53*(3/2*Y)):=by apply mul_le_mul_of_nonneg_left _ ד exact mul_le_mul_of_nonneg_left hsaY ב _=_:=by ring have hkY:A+k*A_z<=(k+1)*Y:=by have h1:A+A_z<=Y :=ד have h2:=mul_le_mul_of_nonneg_left h1 (show 0<=k+1 by linarith) have h3:=mul_nonneg hk0 hA0 linarith have hD2:(1/2^53:ℝ)*(A+k*A_z)<=(k+1)*(1/2^53*Y) := calc (1/2^53:ℝ)*(A+k*A_z)<=1/2^53*((k+1)*Y) := mul_le_mul_of_nonneg_left hkY ב _=_:=by ring have hn4:4*(k+1)*(1/2^53*Y)<=4*((n:ℝ)+1)*(1/2^53*Y) := mul_le_mul_of_nonneg_right ד hUY have hK3:3*(k+1)*(1/2^53*Y)<=Y/2:=by have h:k+1<=2^20 :=ד have:=mul_le_mul_of_nonneg_right h hUY norm_num at this ⊢ linarith obtain ⟨he1a,he1b⟩:=abs_le.mp he1 obtain ⟨hA1a,hA1b⟩:=abs_le.mp hA1 refine qDh n hn _ _ hf1 htf _ Y hY0 hYB ?_ key2 ?_ hbig . apply abs_le.mpr constructor <;> linarith . have e:R (A_fsum (ts.map g ++ [b])) = (R (A_fsum (ts.map g ++ [b]))-A_sr (ts.map g ++ [b]))+A_sr (ts.map g ++ [b]):=by ring have h1:=abs_add_le (R (A_fsum (ts.map g ++ [b]))-A_sr (ts.map g ++ [b])) (A_sr (ts.map g ++ [b])) rw[<-e] at h1 linarith lemma qCn (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw hh:UInt32) (hx:∀ t,t< n->good (xw t)=true) (hw:∀ t,t< n->good (ww t)=true) (hb:good bw=true) (hg:good hh=true) (hm:∀ t,t< n->xw t &&& 0x7FFFFFFF<=hh) (hp:hh<=0x7FFFFFFF) (s e:Float) (hs:let r:=(List.range n).foldl (λ(acc:F1) t=>let v:=dv (ww t) F1.mk (acc.s+v*dv (xw t)) (acc.t+v.abs)) ⟨0,0⟩;s=r.s+dv bw∧e=nfOf n*(dv hh*r.t+(dv bw).abs)) (hbig:(2:ℝ)^(-127:ℤ) ≤ |R (s+e)|) : R (s-e)< exactS n xw ww bw∧exactS n xw ww bw< R (s+e):=by set g:ℕ->Float:=λt=>dv (ww t)*dv (xw t) with hgd set p:ℕ->ℝ:=λt=>wv (ww t)*wv (xw t) with hpd set v:ℕ->Float:=λt=>dv (ww t) with hvd have hfold:(List.range n).foldl (λ(acc:F1) t=>let v:=dv (ww t) F1.mk (acc.s+v*dv (xw t)) (acc.t+v.abs)) ⟨0,0⟩ = ⟨((List.range n).map g).foldl (.+·) 0, ((List.range n).map λt=>(v t).abs).foldl (.+·) 0⟩ := qD4 g (λt=>(v t).abs) (List.range n) 0 0 obtain ⟨hs1,hs2⟩:=hs rw[hfold] at hs1 hs2 have hhN:hh.toNat<2^31:=by have:=UInt32.le_iff_toNat_le.mp hp change hh.toNat<=2147483647 at this omega have hHeq:wv hh=A_mag hh.toNat:=by rw[qA6 hh hg,Nat.mod_eq_of_lt hhN] simp only[show ¬ 2^31<=hh.toNat by omega,↓reduceIte,one_mul] have hH0:0<=wv hh:=by rw[hHeq]; exact qAt _ have hHl:wv hh<=2^128:=le_trans (le_abs_self _) (qA5 hh hg) have hle:∀ t,t< n->|wv (xw t)| ≤ wv hh:=by intro t ht have hg1:=hx t ht have h1:=UInt32.le_iff_toNat_le.mp (hm t ht) rw[qBh] at h1 rw[qB0 _ hg1,hHeq] apply qA4 _ _ h1 rcases qBg _ hg1 with h | h . exact Or.inl h . exact Or.inr h.1 have hgt:∀ t∈List.range n,(g t).isFinite=true ∧ |R (g t)-p t| ≤ 1/2^53*(|p t| + A_z)∧|p t| ≤ wv hh * |wv (ww t)|:=by intro t ht have ht':=List.mem_range.mp ht obtain ⟨h1,h2,-⟩:=qEi _ _ (hw t ht') (hx t ht') refine ⟨h1,h2,?_⟩ simp only[hpd,abs_mul] rw[mul_comm] exact mul_le_mul_of_nonneg_right (hle t ht') (abs_nonneg _) have hvt:∀ t∈List.range n,(v t).isFinite=true∧R (v t)=wv (ww t) ∧ |wv (ww t)| ≤ 2^128:=by intro t ht have ht':=List.mem_range.mp ht obtain ⟨h1,h2⟩:=qA3 _ (hw t ht') exact ⟨h1,h2,qA5 _ (hw t ht')⟩ obtain ⟨hbf,hbv⟩:=qA3 bw hb obtain ⟨hhf,hhv⟩:=qA3 hh hg have hS:s=A_fsum ((List.range n).map g ++ [dv bw]):=by rw[hs1,qAy]; rfl have hE:e=nfOf n*(dv hh*A_fsum ((List.range n).map λt=>(v t).abs)+(dv bw).abs):=by rw[hs2]; rfl rw[hS,hE] at hbig ⊢ have hX:exactS n xw ww bw=((List.range n).map p).sum+wv bw:=by rw[qBl n xw ww bw hx (List.range n) List.nodup_range (λt ht=>List.mem_range.mp ht) (λt ht h=>absurd (List.mem_range.mpr ht) h)] simp only[hpd,mul_comm] rw[hX] exact qCo n hn (List.range n) ג g v p (λt=>wv (ww t)) (dv bw) (dv hh) (wv bw) (wv hh) hgt hvt hbf hbv (qA5 bw hb) hhf hhv hH0 hHl hbig end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open FloatLib.Floats.ExecFloat.Binary section open Float.Model Float.Model.UnpackedFloat lemma qFg (m K:Nat) : (ExtendedMantissa.ofMantissaAndAccuracy m .exact >>> (K+1)) = ⟨m/2^(K+1),(m/2^K)%2 != 0,decide (m%2^K≠0)⟩:=by show Nat.repeat ExtendedMantissa.shiftRightOne (K+1) _=_ induction K with | zero => simp[Nat.repeat,ExtendedMantissa.shiftRightOne,ExtendedMantissa.ofMantissaAndAccuracy, Nat.mod_one] | succ K ih => show ExtendedMantissa.shiftRightOne (Nat.repeat _ (K+1) _)=_ rw[ih] simp only[ExtendedMantissa.shiftRightOne,ExtendedMantissa.mk.injEq] refine ⟨?_,?_,?_⟩ . rw[Nat.div_div_eq_div_mul,<-Nat.pow_succ] . trivial . rw[Nat.mod_pow_succ] have h:0<2^K:=by positivity by_cases h1:m%2^K=0 <;> by_cases h2:m/2^K%2=0 <;> simp[h1,h2] omega lemma qC1 (H a b:Nat) (hb:b< H):(H*a+b)/H=a∧(H*a+b)%H=b:=by have hH:0< H :=א constructor . rw[Nat.mul_add_div hH,Nat.div_eq_of_lt hb,Nat.add_zero] . rw[Nat.mul_add_mod,Nat.mod_eq_of_lt hb] lemma qEb (m K r:Nat) (h1:2*r*2^K< m+2^K) (h2:m<(2*r+1)*2^K) : (ExtendedMantissa.ofMantissaAndAccuracy m .exact >>> (K+1)).roundedMantissa=r:=by rw[qFg,Nat.pow_succ] have hH:0<2^K:=by positivity generalize 2^K=H at * have hdm:=Nat.div_add_mod m (H*2) have hlt:m%(H*2)< H*2:=Nat.mod_lt _ א generalize m/(H*2)=q at * generalize m%(H*2)=t at * subst hdm have hq:q=r∨q+1=r:=by rcases Nat.lt_trichotomy q r with h | h | h . right by_contra hne have:q+2<=r :=א have h3:(q+2)*H<=r*H:=Nat.mul_le_mul_right H this nlinarith . exact Or.inl h . exfalso have h3:(r+1)*H<=q*H:=Nat.mul_le_mul_right H h nlinarith rcases hq with rfl | rfl . have ht:t< H:=by nlinarith obtain ⟨d1,d2⟩:=qC1 H (2*q) t ht rw[show H*2*q+t=H*(2*q)+t by ring,d1,d2] by_cases h0:t=0 <;> simp[ExtendedMantissa.roundedMantissa,ExtendedMantissa.accuracy, Accuracy.roundToNearestEven,h0] . have ht:H< t:=by nlinarith obtain ⟨t',rfl⟩:∃ t',t=H+t':=⟨t-H,by omega⟩ have ht':t'< H :=א obtain ⟨d1,d2⟩:=qC1 H (2*q+1) t' ht' rw[show H*2*q+(H+t')=H*(2*q+1)+t' by ring,d1,d2] have h0:t'≠0 :=א have h2':(2*q+1)%2=1 :=א simp[ExtendedMantissa.roundedMantissa,ExtendedMantissa.accuracy, Accuracy.roundToNearestEven,h0,h2'] lemma qB3 (t:Int):Format.binary32.targetExponent t=max (t-24) (-149):=by simp[Format.targetExponent,Format.mantissaBits,Format.minExponent] lemma qBp (m L:Nat) (h1:2^L<=m) (h2:m<2^(L+1)):m.log2=L:=by have hne:m≠0:=by have:0<2^L:=by positivity omega apply le_antisymm . have:=(Nat.log2_lt hne).2 h2; omega . exact (Nat.le_log2 hne).2 h1 lemma qBa (s:Sign) (m:Nat) (e T:Int) (K r:Nat) (hT:Format.binary32.targetExponent (totalExponent m e)=T) (hK:T=e+(K+1:Nat)) (h1:2*r*2^K< m+2^K) (h2:m<(2*r+1)*2^K) : UnpackedFloat.round Format.binary32 s m e = let p:=shiftToTargetExponent Format.binary32 r T .exact if h:p.1.mantissa=0 then .zero s else .finite s p.1.mantissa p.2 (Nat.pos_of_ne_zero h):=by unfold UnpackedFloat.round decreaseExponent roundWithAccuracy simp only[hT] have h0:(e-T).toNat=0 :=א have hs:shiftToTargetExponent Format.binary32 m e .exact = (ExtendedMantissa.ofMantissaAndAccuracy m .exact >>> (K+1),T):=by unfold shiftToTargetExponent shiftToExponent simp only[hT] have h3:(T-e).toNat=K+1 :=א rw[h3,hK] simp only[h0,Nat.shiftLeft_zero,Int.natCast_zero,Int.sub_zero,hs,qEb m K r h1 h2] lemma qFm (r:Nat) (T:Int) (h1:2^23<=r) (h2:r<2^24) (hT:-149<=T) : shiftToTargetExponent Format.binary32 r T .exact = (ExtendedMantissa.ofMantissaAndAccuracy r .exact,T):=by have hl:=qBp r 23 h1 h2 unfold shiftToTargetExponent shiftToExponent simp only[totalExponent,hl,qB3] have h3:max (((23:Nat):Int)+1+T-24) (-149)=T :=א simp only[h3,sub_self,Int.toNat_zero,Int.natCast_zero,Int.add_zero] rfl lemma qEw (T:Int) (hT:-150<=T) : shiftToTargetExponent Format.binary32 (2^24) T .exact = (ExtendedMantissa.ofMantissaAndAccuracy (2^23) .exact,T+1):=by have hl:(2^24:Nat).log2=24:=qBp _ 24 ב ב unfold shiftToTargetExponent shiftToExponent simp only[totalExponent,hl,qB3] have h3:max (((24:Nat):Int)+1+T-24) (-149)-T=1 :=א rw[h3] rfl lemma qDd (s:Sign) (P:Nat) (E:Int) (hP1:2^23<=P) (hP2:P<2^24) (hE:-149<=E) (hp:0< P) : (let p:=shiftToTargetExponent Format.binary32 P E .exact if h:p.1.mantissa=0 then UnpackedFloat.zero s else .finite s p.1.mantissa p.2 (Nat.pos_of_ne_zero h))=.finite s P E hp:=by have hne:P≠0 :=א simp only[qFm P E hP1 hP2 hE,ExtendedMantissa.ofMantissaAndAccuracy,hne,dite_false] lemma qFb (s:Sign) (E:Int) (hE:-148<=E) (hp:0<2^23) : (let p:=shiftToTargetExponent Format.binary32 (2^24) (E-1) .exact if h:p.1.mantissa=0 then UnpackedFloat.zero s else .finite s p.1.mantissa p.2 (Nat.pos_of_ne_zero h))=.finite s (2^23) E hp:=by have hne:(2^23:Nat)≠0 :=א simp only[qEw (E-1) א,ExtendedMantissa.ofMantissaAndAccuracy,hne,dite_false, sub_add_cancel] lemma qCy (s:Sign) (m:Nat) (e:Int) (P:Nat) (E:Int) (g:Nat) (hp:0< P) (hP1:2^23<=P) (hP2:P<2^24) (hE:-149<=E) (hg:e+(g+2:Nat)=E) (hhi:2*m<(2*P+1)*2^(g+2)) (hlo1:P≠2^23->2*P*2^(g+2)<2*m+2^(g+2)) (hlo2:P=2^23->33554431*2^(g+2)<4*m) : UnpackedFloat.round Format.binary32 s m e=.finite s P E hp:=by have e1:2^(g+2)=4*2^g:=by rw[Nat.pow_add]; ring have e2:2^(g+1)=2*2^g:=by rw[Nat.pow_succ]; ring have e3:2^(g+25)=2^25*2^g:=by rw[Nat.pow_add]; ring have e4:2^(g+25+1)=2^26*2^g:=by rw[Nat.pow_add,Nat.pow_add]; ring have e5:2^(g+24)=2^24*2^g:=by rw[Nat.pow_add]; ring have hG:0<2^g:=by positivity rw[e1] at hhi by_cases hc:2^(g+25)<=m . -- `m` is in the binade of `P . 2^E`: target `E`,mantissa `P`. have hL:m.log2=g+25:=by apply qBp m _ hc rw[e4] have:(2*P+1)*(4*2^g)<=(2^25-1)*(4*2^g) := Nat.mul_le_mul_right _ א omega have hT:Format.binary32.targetExponent (totalExponent m e)=E:=by simp only[totalExponent,hL,qB3]; omega rw[qBa s m e E (g+1) P hT א ?_ ?_] . exact qDd s P E hP1 hP2 hE hp . rw[e2] by_cases hP:P=2^23 . subst hP; rw[e3] at hc; omega . have:=hlo1 hP; rw[e1] at this; nlinarith . rw[e2]; nlinarith . -- Just below a power of two. have hP:P=2^23:=by by_contra hne have h1:=hlo1 hne rw[e1] at h1 have h2:2*(2^23+1)*(4*2^g)<=2*P*(4*2^g) := Nat.mul_le_mul_right _ א rw[e3] at hc omega have h1:=hlo2 hP subst hP rw[e1] at h1 rw[e3] at hc have hL:m.log2=g+24:=by apply qBp m _ (by rw[e5]; omega) rw[show g+24+1=g+25 from rfl,e3]; omega by_cases hE':-148<=E . have hT:Format.binary32.targetExponent (totalExponent m e)=E-1:=by simp only[totalExponent,hL,qB3]; omega rw[qBa s m e (E-1) g (2^24) hT א א א] exact qFb s E hE' hp . have hE2:E=-149 :=א have hT:Format.binary32.targetExponent (totalExponent m e)=E:=by simp only[totalExponent,hL,qB3]; omega rw[qBa s m e E (g+1) (2^23) hT א (by rw[e2]; omega) (by rw[e2]; omega)] exact qDd s _ E ב ב hE hp lemma qB1 (neg:Bool) (m:Nat) (e:Int) : Model.roundDyadic Fmt ⟨neg,m,e⟩ = Model.ofModel Fmt (UnpackedFloat.round Format.binary32 (Model.modelSign neg) m e):=by simp[Model.roundDyadic,Model.ieeeRoundDyadic] rfl lemma qDr (s:Sign):s.toBitVec.toNat=if s=.negative then 1 else 0:=by cases s <;> rfl lemma qCm (s:Sign) (M:Nat) (E:Int) (h:0< M) (hM1:2^23<=M) (hM2:M<2^24) (hb1:1<=E+150) (hb2:E+150<=254) : (UnpackedFloat.pack Format.binary32 (.finite s M E h)).toNat = (if s=.negative then 2^31 else 0)+(E+150).toNat*2^23+M%2^23:=by have hl:M.log2=23:=qBp M 23 hM1 hM2 simp only[UnpackedFloat.pack,hl] have hbias:(E+↑Format.binary32.exponentBias + ↑Format.binary32.mantissaBitsWithoutImplicit).toNat=(E+150).toNat:=by simp only[Format.exponentBias]; norm_num; ring_nf rw[hbias] have hno:¬ (2^Format.binary32.exponentBits<=(E+150).toNat+1):=by show ¬ (2^8<=(E+150).toNat+1); omega simp only[hno,ite_false] have hnorm:(23+1=Format.binary32.mantissaBits):=rfl simp only[hnorm,ite_true,packComponents,BitVec.toNat_append,qDr,BitVec.toNat_ofNat] have h8:(E+150).toNat%2^8=(E+150).toNat:=Nat.mod_eq_of_lt א rw[h8,<-Nat.shiftLeft_add_eq_or_of_lt (by omega:(E+150).toNat<2^8), <-Nat.shiftLeft_add_eq_or_of_lt (Nat.mod_lt _ (by positivity):M%2^23<2^23)] split_ifs <;> simp[Nat.shiftLeft_eq] omega lemma qEe (neg:Bool) (m:Nat) (e:Int) (P:Nat) (E:Int) (hm:m≠0) (hP1:2^23<=P) (hP2:P<2^24) (hE:-149<=E) (hE2:E+150<=254) (hhi:2*((m:ℝ)*2^e)<(2*P+1)*2^E) (hlo1:P≠2^23->(2*P-1)*2^E<2*((m:ℝ)*2^e)) (hlo2:P=2^23->33554431*2^E<4*((m:ℝ)*2^e)) : toWord (Model.roundDyadic Fmt ⟨neg,m,e⟩) = UInt32.ofNat ((if neg then 2^31 else 0)+(E+150).toNat*2^23+P%2^23):=by have hp:0< P :=א obtain ⟨k,hk⟩:∃ k:Nat,e-E+2<=k:=⟨(e-E+2).toNat,by omega⟩ obtain ⟨g,hg⟩:∃ g:Nat,(e-k)+(g+2:Nat)=E:=⟨(E-(e-k)-2).toNat,by omega⟩ have hb:(0:ℝ)<2^(e-k):=zpow_pos ב _ have hV:(m:ℝ)*2^e=((m*2^k:Nat):ℝ)*2^(e-k):=by push_cast rw[mul_assoc,<-zpow_natCast,<-zpow_add₀ two_ne_zero] congr 2; ring have hEE:(2:ℝ)^E=((2^(g+2):Nat):ℝ)*2^(e-k):=by push_cast rw[<-zpow_natCast,<-zpow_add₀ two_ne_zero,<-hg] congr 1; push_cast; ring rw[hV,hEE] at hhi have h1:2*(m*2^k)<(2*P+1)*2^(g+2):=by have:(2:ℝ)*((m*2^k:Nat):ℝ)<(2*P+1)*((2^(g+2):Nat):ℝ) := lt_of_mul_lt_mul_right ד hb.le exact_mod_cast this have h2:P≠2^23->2*P*2^(g+2)<2*(m*2^k)+2^(g+2):=by intro hne have h3:=hlo1 hne rw[hV,hEE] at h3 have:(2:ℝ)*P*((2^(g+2):Nat):ℝ) < 2*((m*2^k:Nat):ℝ)+((2^(g+2):Nat):ℝ) := lt_of_mul_lt_mul_right ד hb.le exact_mod_cast this have h3:P=2^23->33554431*2^(g+2)<4*(m*2^k):=by intro hne have h3:=hlo2 hne rw[hV,hEE] at h3 have:(33554431:ℝ)*((2^(g+2):Nat):ℝ)<4*((m*2^k:Nat):ℝ) := lt_of_mul_lt_mul_right ד hb.le exact_mod_cast this rw[qB1,<-ExactRuntime.round_scale _ _ m e k hm, qCy _ (m*2^k) (e-k) P E g hp hP1 hP2 hE hg h1 h2 h3] simp only[toWord,Model.toNatBits,Model.ofModel,Model.ofModelBits] congr 1 show (UnpackedFloat.pack Format.binary32 _).toNat=_ rw[qCm _ _ _ _ hP1 hP2 א א] cases neg <;> simp[Model.modelSign] end abbrev B_D:=ExecFloat.Binary.format (exponentBits:=11) (fractionBits:=52) lemma qG3 (f:Float) : Model.expField (toModel (ofFloat f))=f.toBits.toNat/2^52%2^11:=by show ((f.toBits.toBitVec >>> 52) &&& BitVec.ofNat 64 2047).toNat=_ rw[BitVec.toNat_and,BitVec.toNat_ushiftRight,BitVec.toNat_ofNat,Nat.shiftRight_eq_div_pow] exact Nat.and_two_pow_sub_one_eq_mod _ 11 lemma qGa (f:Float):Model.fracField (toModel (ofFloat f))=f.toBits.toNat%2^52:=by show (f.toBits.toBitVec &&& BitVec.ofNat 64 (2^52-1)).toNat=_ rw[BitVec.toNat_and,BitVec.toNat_ofNat] exact Nat.and_two_pow_sub_one_eq_mod _ 52 lemma qE0 (f:Float):Model.signBit (toModel (ofFloat f))=decide (2^63<=f.toBits.toNat):=by rw[Model.signBit_eq_msb] show f.toBits.toBitVec.msb=_ rw[BitVec.msb_eq_decide] rfl lemma qHi (f:Float) (s:Bool) (E F:Nat) (hE1:1<=E) (hE:E<2047) (hF:F<2^52) (h:f.toBits.toNat=(if s then 2^63 else 0)+E*2^52+F) : Model.toDyadic? (toModel (ofFloat f))=some ⟨s,2^52+F,(E:Int)-1075⟩:=by have he:=qG3 f have hf:=qGa f have hs:=qE0 f have he':f.toBits.toNat/2^52%2^11=E:=by split at h <;> omega have hf':f.toBits.toNat%2^52=F:=by split at h <;> omega have hs':decide (2^63<=f.toBits.toNat)=s:=by cases s . simp only[Bool.false_eq_true,ite_false] at h; simp; omega . simp only[ite_true] at h; simp; omega rw[he'] at he rw[hf'] at hf rw[hs'] at hs have hx:=Model.ofFields_signBit_expField_fracField (toModel (ofFloat f)) rw[he,hf,hs] at hx rw[<-hx] have hfin:Model.isFinite (Model.ofFields B_D s E F)=true:=by rw[Model.isFinite_ofFields B_D _ _ _ (by show E<2^11; omega) hF] show (E != 2047)=true simp; omega rw[Model.toDyadic?_ofFields_of_isFinite B_D _ _ _ (by show E<2^11; omega) hF hfin] have hE0:E≠0 :=א simp only[hE0,ite_false,show B_D.exponentBias=1023 from rfl, show B_D.fracWidth=52 from rfl] simp only[show Model.pow2 52=2^52 from rfl] congr 2 simp only[Int.ofNat_eq_natCast] push_cast ring lemma qDz (f:Float) (d:FloatLib.Numerics.Dyadic) (h:Model.toDyadic? (toModel (ofFloat f))=some d):f.isFinite=true:=by rw[Model.toDyadic?_ieee_eq_model _ (by decide)] at h show (Model.toModel (toModel (ofFloat f))).isFinite=true revert h generalize Model.toModel (toModel (ofFloat f))=u cases u <;> simp[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.isFinite] lemma B_R (f:Float) (s:Bool) (E F:Nat) (hE1:1<=E) (hE:E<2047) (hF:F<2^52) (h:f.toBits.toNat=(if s then 2^63 else 0)+E*2^52+F) : f.isFinite=true ∧ R f=(if s then -1 else 1)*((2^52+F:Nat):ℝ)*2^((E:Int)-1075):=by have hd:=qHi f s E F hE1 hE hF h refine ⟨qDz f _ hd,?_⟩ rw[R,Model.toReal_eq,hd] cases s <;> simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand] def B_near (A:Nat) (S:Bool) (ex fr:Nat):Prop := ∃ M,A=(if S then 2^63 else 0)+M∧(ex*2^23+fr)*2^29< M+2^28 ∧ M<=(ex*2^23+fr)*2^29+2^28 lemma B_x (A x:Nat) (hA:A<2^64) (hx:x=(A+268435455)%2^64/2^29) (h1:897<=x/2^23%2^11) (h2:x/2^23%2^11<1151) : B_near A (decide (2^34<=x)) (x/2^23%2^11) (x%2^23):=by unfold B_near by_cases h:2^34<=x . simp only[h,decide_true,ite_true] exact ⟨A-2^63,by omega,by omega,by omega⟩ . simp only[h,decide_false,Bool.false_eq_true,ite_false] exact ⟨A,by omega,by omega,by omega⟩ lemma qCl (A:UInt64) : ((A+(0x0FFFFFFF:UInt64)) >>> (29:UInt64)).toNat=(A.toNat+268435455)%2^64/2^29:=by rw[UInt64.toNat_shiftRight,UInt64.toNat_add] norm_num [Nat.shiftRight_eq_div_pow] lemma qD2 (x:UInt64) : ((x >>> (23:UInt64)) &&& (0x7FF:UInt64)).toNat=x.toNat/2^23%2^11:=by rw[UInt64.toNat_and,UInt64.toNat_shiftRight] have:=Nat.and_two_pow_sub_one_eq_mod (x.toNat >>> 23) 11 norm_num [Nat.shiftRight_eq_div_pow] at this ⊢ exact this lemma qFu (v:UInt64) (h:v-(897:UInt64)<(254:UInt64)) : 897<=v.toNat∧v.toNat<1151:=by rw[UInt64.lt_iff_toNat_lt,UInt64.toNat_sub] at h have hv:=v.toNat_lt norm_num at h hv omega lemma qGy (x:UInt64) (hx:x.toNat<2^35) (h1:897<=x.toNat/2^23%2^11) (h2:x.toNat/2^23%2^11<1151) : (((x >>> (34:UInt64)) <<< (31:UInt64)) ||| ((x &&& (0x3FFFFFFFF:UInt64))-((896:UInt64) <<< (23:UInt64)))).toUInt32 = UInt32.ofNat ((if decide (2^34<=x.toNat) then 2^31 else 0) + (x.toNat/2^23%2^11-896)*2^23+x.toNat%2^23):=by have ha:((x >>> (34:UInt64)) <<< (31:UInt64)).toNat=(x.toNat/2^34)*2^31:=by rw[UInt64.toNat_shiftLeft,UInt64.toNat_shiftRight] norm_num [Nat.shiftRight_eq_div_pow,Nat.shiftLeft_eq] omega have hb:((x &&& (0x3FFFFFFFF:UInt64))-((896:UInt64) <<< (23:UInt64))).toNat = x.toNat%2^34-896*2^23:=by have h2:(x &&& (0x3FFFFFFFF:UInt64)).toNat=x.toNat%2^34:=by rw[UInt64.toNat_and] exact Nat.and_two_pow_sub_one_eq_mod _ 34 have h3:((896:UInt64) <<< (23:UInt64))=7516192768:=by decide rw[h3,UInt64.toNat_sub_of_le] . rw[h2]; rfl . rw[UInt64.le_iff_toNat_le,h2] norm_num omega have hc:(x.toNat/2^34)*2^31 ||| (x.toNat%2^34-896*2^23) = (x.toNat/2^34)*2^31+(x.toNat%2^34-896*2^23):=by rw[Nat.mul_comm (x.toNat/2^34)] exact (Nat.two_pow_add_eq_or_of_lt א _).symm apply UInt32.toNat_inj.mp rw[UInt64.toNat_toUInt32,UInt64.toNat_or,ha,hb,hc,UInt32.toNat_ofNat'] by_cases h:2^34<=x.toNat . simp only[h,decide_true,ite_true] omega . simp only[h,decide_false,Bool.false_eq_true,ite_false] omega lemma qBk (s e:Float) (h:ziv s e≠0xFFFFFFFF) : ∃ (S:Bool) (ex fr:Nat),897<=ex∧ex<1151∧fr<2^23 ∧ ziv s e=UInt32.ofNat ((if S then 2^31 else 0)+(ex-896)*2^23+fr) ∧ B_near (s+e).toBits.toNat S ex fr∧B_near (s-e).toBits.toNat S ex fr:=by unfold ziv at h ⊢ dsimp only at h ⊢ generalize (s+e).toBits=A at h ⊢ generalize (s-e).toBits=B at h ⊢ have hAn:=qCl A have hBn:=qCl B generalize (A+(0x0FFFFFFF:UInt64)) >>> (29:UInt64)=x at h hAn ⊢ generalize (B+(0x0FFFFFFF:UInt64)) >>> (29:UInt64)=y at h hBn ⊢ have hex:=qD2 x generalize (x >>> (23:UInt64)) &&& (0x7FF:UInt64)=ex at h hex ⊢ split at h . rename_i hc have hc0:=hc obtain ⟨hxy,hc⟩:=Bool.and_eq_true_iff.mp hc have hxy:x=y:=by simpa using hxy obtain ⟨h1,h2⟩:=qFu ex (by simpa using hc) rw[hex] at h1 h2 subst hxy have hA:=A.toNat_lt have hB:=B.toNat_lt have hx35:x.toNat<2^35 :=א simp only[hc0,ite_true] exact ⟨_,_,_,h1,h2,by omega,qGy x hx35 h1 h2,B_x A.toNat x.toNat hA hAn h1 h2, B_x B.toNat x.toNat hB hBn h1 h2⟩ . exact absurd rfl h set_option maxRecDepth 8192 in lemma qAm (f:Float) (S:Bool) (ex fr:Nat) (h1:897<=ex) (h2:ex<1151) (hfr:fr<2^23) (hn:B_near f.toBits.toNat S ex fr) : f.isFinite=true∧∃ v:ℝ,R f=(if S then -v else v) ∧ v<=(2^53+fr*2^30+2^29)*2^((ex:Int)-1076) ∧ (fr≠0->(2^53+fr*2^30-2^29)*2^((ex:Int)-1076)< v) ∧ (2^53-2^28)*2^((ex:Int)-1076)< v:=by obtain ⟨M,hA,hl,hu⟩:=hn have hF:M%2^52<2^52:=Nat.mod_lt _ ב have hM:M=(M/2^52)*2^52+M%2^52 :=א generalize M/2^52=E at hM generalize M%2^52=F at hM hF subst hM have hb:(0:ℝ)<2^((ex:Int)-1076):=zpow_pos ב _ have hE:E=ex∨(E+1=ex∧fr=0) :=א obtain ⟨hfin,hR⟩:=B_R f S E F א א hF (by rw[hA,Nat.add_assoc]) refine ⟨hfin,((2^52+F:Nat):ℝ)*2^((E:Int)-1075),?_,?_⟩ . rw[hR]; cases S <;> simp ring rcases hE with rfl | ⟨rfl,rfl⟩ . have e:(2:ℝ)^((E:Int)-1075)=2*2^((E:Int)-1076):=by rw[show (E:Int)-1075=1+((E:Int)-1076) by ring,zpow_add₀ two_ne_zero,zpow_one] rw[e] generalize (2:ℝ)^((E:Int)-1076)=b at hb ⊢ have h3:(F:ℝ)<=fr*2^29+2^28:=by exact_mod_cast (by omega:F<=fr*2^29+2^28) have h4':fr*2^29< F+2^28:=by have e1:(E*2^23+fr)*2^29=E*2^52+fr*2^29:=by ring rw[e1] at hl exact Nat.lt_of_add_lt_add_left (by rw[Nat.add_assoc] at hl; exact hl) have h4:(fr:ℝ)*2^29< F+2^28:=by exact_mod_cast h4' have h5:(0:ℝ)<=F:=Nat.cast_nonneg _ have h6:(0:ℝ)<=fr:=Nat.cast_nonneg _ have h7:=mul_le_mul_of_nonneg_right h3 hb.le have h8:=mul_lt_mul_of_pos_right h4 hb have h9:=mul_nonneg h5 hb.le have h10:=mul_nonneg h6 hb.le push_cast refine ⟨?_,?_,?_⟩ . linarith . intro _; linarith . linarith . have e:(2:ℝ)^(((E+1:Nat):Int)-1076)=2^((E:Int)-1075):=by congr 1; push_cast; ring rw[e] at hb ⊢ generalize (2:ℝ)^((E:Int)-1075)=b at hb ⊢ have h3:(F:ℝ)<=2^52:=by exact_mod_cast hF.le have h4:(2:ℝ)^52< F+2^28:=by exact_mod_cast (by omega:2^52< F+2^28) have h7:=mul_le_mul_of_nonneg_right h3 hb.le have h8:=mul_lt_mul_of_pos_right h4 hb push_cast refine ⟨?_,?_,?_⟩ . linarith . intro h0; exact absurd rfl h0 . linarith lemma qBs (s e:Float) (h:ziv s e≠0xFFFFFFFF) : (s+e).isFinite=true∧(s-e).isFinite=true∧(2:ℝ)^(-127:ℤ) ≤ |R (s+e)|:=by obtain ⟨S,ex,fr,h1,h2,h3,-,ha,hb⟩:=qBk s e h obtain ⟨f1,v,hv,-,-,h5⟩:=qAm _ S ex fr h1 h2 h3 ha obtain ⟨f2,-⟩:=qAm _ S ex fr h1 h2 h3 hb refine ⟨f1,f2,?_⟩ have hb0:(2:ℝ)^(-179:ℤ)<=2^((ex:Int)-1076) := zpow_le_zpow_right₀ ב א have hpos:(0:ℝ)<2^(-179:ℤ):=zpow_pos ב _ have e1:(2:ℝ)^(-127:ℤ)=2^52*2^(-179:ℤ):=by rw[<-zpow_natCast,<-zpow_add₀ two_ne_zero]; norm_num have hv1:(2:ℝ)^(-127:ℤ)<=v:=by rw[e1] nlinarith have hv0:0< v:=lt_of_lt_of_le (zpow_pos ב _) hv1 have : |R (s+e)| = v:=by rw[hv]; cases S <;> simp[abs_of_pos hv0] rwa [this] lemma qA7 (w:UInt32) (h:expOf w≠255):wv w=(rationalWord w:ℝ):=by rw[wv,Model.toReal_eq,ofW,toDyadic_ofUInt32 w h] simp only[rationalWord,FloatLib.Numerics.Dyadic.cast_toRat] lemma qAh (w:UInt32) (h:good w=true):expOf w≠255:=by intro he have he':w.toNat/2^23%2^8=255:=by have:=congrArg UInt32.toNat he rw[expOf,UInt32.toNat_and,UInt32.toNat_shiftRight, show (255:UInt32).toNat=2^8-1 from rfl,Nat.and_two_pow_sub_one_eq_mod] at this simpa [Nat.shiftRight_eq_div_pow] using this have hv:(w &&& 0x7FFFFFFF).toNat=w.toNat%2^31:=by rw[UInt32.toNat_and,show (0x7FFFFFFF:UInt32).toNat=2^31-1 from rfl, Nat.and_two_pow_sub_one_eq_mod] simp only[good,Bool.or_eq_true,beq_iff_eq,decide_eq_true_eq] at h rcases h with h | h . have:=congrArg UInt32.toNat h rw[hv] at this have h0:(0:UInt32).toNat=0:=rfl omega . rw[UInt32.le_iff_toNat_le,UInt32.toNat_sub,hv] at h norm_num at h omega lemma qEu (a b:UInt32) : ((sv a:ℚ)*sv b*(2:ℚ)^(idxOf a+idxOf b))*2^(-298:Int) = rationalWord a*rationalWord b:=by simp only[rationalWord,decodeD_toRat] rw[show (-298:Int)=-149+-149 by norm_num,zpow_add₀ two_ne_zero] rw[zpow_sub₀ two_ne_zero,zpow_sub₀ two_ne_zero,zpow_natCast,zpow_natCast,pow_add] norm_num [zpow_neg,zpow_natCast] ring lemma qC5 (a b:Array UInt32) (start n:Nat) : (dsum a b start n:ℚ)*2^(-298:Int) = ∑ j∈Finset.range n,rationalWord a[start+j]! * rationalWord b[start+j]!:=by induction n generalizing start with | zero=>simp[dsum] | succ n ih => rw[dsum,Int.cast_add,Int.cast_mul,Int.cast_mul,Int.cast_pow,Int.cast_ofNat,add_mul,ih] conv_rhs=>rw[Finset.sum_range_succ'] simp only[Nat.add_zero] rw[qEu] have ht:(∑ j∈Finset.range n, rationalWord a[start+1+j]! * rationalWord b[start+1+j]!) = ∑ j∈Finset.range n, rationalWord a[start+(j+1)]! * rationalWord b[start+(j+1)]!:=by apply Finset.sum_congr rfl intro j _ simp[Nat.add_comm,Nat.add_left_comm] rw[ht] ring lemma qEk (a b:Array UInt32) (hs:a.size=b.size) (hf:∀ j,j< a.size->expOf a[j]!≠255∧expOf b[j]!≠255) (hn:(dsum a b 0 a.size:ℚ)*2^(-298:Int)≠0) : ∃ d:FloatLib.Numerics.Dyadic,d.toRat=(dsum a b 0 a.size:ℚ)*2^(-298:Int) ∧ dotSpec a b=toWord (Model.roundDyadic Fmt d):=by let L:=a.map (Model.ofUInt32 (fmt:=Fmt)) let K:=b.map (Model.ofUInt32 (fmt:=Fmt)) have hLK:L.size=K.size:=by simp[L,K,hs] have hLf:∀ j (hj:j< L.size),Model.isFinite L[j]=true:=by intro j hj have hj':j< a.size:=by simpa [L] using hj have he:=(hf j hj').1 rw[getElem!_pos a j hj'] at he simp[L,isFinite_ofUInt32,he] have hKf:∀ j (hj:j< K.size),Model.isFinite K[j]=true:=by intro j hj have hj':j< b.size:=by simpa [K] using hj have he:=(hf j א).2 rw[getElem!_pos b j hj'] at he simp[K,isFinite_ofUInt32,he] have hex:=Model.Reduction.Internal.dotState_exact_toRat (destination:=Fmt) L K hLK hLf hKf have hmath:Model.Reduction.Semantics.finiteDotSlice L K 0 L.size ג (by simp[hLK])=(dsum a b 0 a.size:ℚ)*2^(-298:Int):=by simpa [L,K] using finiteDotSlice_eq a b 0 a.size ג (by simp[hs]) (by intro j _ hj; exact hf j א) have hn':Model.Reduction.Semantics.finiteDot L.toList K.toList≠.ok 0:=by rw[Model.Reduction.Semantics.finiteDot_toList_eq_slice L K hLK,hmath] simpa using hn refine ⟨(Model.Reduction.Internal.dotState L K hLK : Model.Reduction.Internal.State Fmt).exact,hex.trans hmath,?_⟩ unfold dotSpec Model.dot rw[Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L K .nearestEven hLK hLf hKf hn'] rfl lemma qDu (n:Nat) (fa fb:Nat->UInt32) (hf:∀ j,j< n->expOf (fa j)≠255∧expOf (fb j)≠255) (hn:(∑ j∈Finset.range n,rationalWord (fa j)*rationalWord (fb j))≠0) : ∃ d:FloatLib.Numerics.Dyadic, d.toRat=(∑ j∈Finset.range n,rationalWord (fa j)*rationalWord (fb j)) ∧ dotOf n fa fb=toWord (Model.roundDyadic Fmt d):=by have hsum:(dsum (Array.ofFn (n:=n) λi=>fa i) (Array.ofFn (n:=n) λi=>fb i) 0 n:ℚ) *2^(-298:Int)=∑ j∈Finset.range n,rationalWord (fa j)*rationalWord (fb j):=by rw[qC5] apply Finset.sum_congr rfl intro j hj have hj':=Finset.mem_range.mp hj rw[Nat.zero_add,qAb n fa j hj',qAb n fb j hj'] have hs:(Array.ofFn (n:=n) λi=>fa i).size=n:=by simp obtain ⟨d,hd,hw⟩:=qEk (Array.ofFn (n:=n) λi=>fa i) (Array.ofFn (n:=n) λi=>fb i) ג (by intro j hj have hj':j< n:=by simpa using hj rw[qAb n fa j hj',qAb n fb j hj'] exact hf j hj') (by rw[hs,hsum]; exact hn) rw[hs,hsum] at hd exact ⟨d,hd,hw⟩ lemma qE7:rationalWord oneW=1:=by have he:expOf oneW=127:=by decide have hf:fracOf oneW=0:=by decide have hs:signOf oneW=false:=by decide norm_num [rationalWord,decodeD,he,hf,hs,FloatLib.Numerics.Dyadic.toRat, FloatLib.Numerics.Dyadic.signedSignificand] lemma qGw (n:Nat) (xw ww:Nat->UInt32) (bw:UInt32) (hx:∀ t,t< n->good (xw t)=true) (hw:∀ t,t< n->good (ww t)=true) (hb:good bw=true) : ((∑ j∈Finset.range (n+1),rationalWord (if j< n then xw j else oneW) * rationalWord (if j< n then ww j else bw):ℚ):ℝ)=exactS n xw ww bw:=by rw[Finset.sum_range_succ] simp only[lt_self_iff_false,ite_false,qE7,one_mul] rw[Rat.cast_add,Rat.cast_sum,exactS,qA7 bw (qAh bw hb)] congr 1 apply Finset.sum_congr rfl intro t ht have ht':=Finset.mem_range.mp ht simp only[ht',ite_true] rw[qA7 _ (qAh _ (hx t ht')),qA7 _ (qAh _ (hw t ht')),Rat.cast_mul] lemma qDm (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw:UInt32) (hx:∀ t,t< n->good (xw t)=true) (hw:∀ t,t< n->good (ww t)=true) (hb:good bw=true) (s e:Float) (hlo:R (s-e)< exactS n xw ww bw) (hhi:exactS n xw ww bw< R (s+e)) (h:ziv s e≠0xFFFFFFFF) : ziv s e=dotOf (n+1) (λt=>if t< n then xw t else oneW) (λt=>if t< n then ww t else bw):=by obtain ⟨S,ex,fr,h1,h2,h3,hz,ha,hb'⟩:=qBk s e h obtain ⟨-,va,hva,hia,loa1,loa⟩:=qAm _ S ex fr h1 h2 h3 ha obtain ⟨-,vb,hvb,hib,lob1,lob⟩:=qAm _ S ex fr h1 h2 h3 hb' have hsum:=qGw n xw ww bw hx hw hb generalize exactS n xw ww bw=V at hlo hhi hsum have hb0:(0:ℝ)<2^((ex:Int)-1076):=zpow_pos ב _ have hE:(2:ℝ)^((ex:Int)-1046)=2^30*2^((ex:Int)-1076):=by rw[<-zpow_natCast,<-zpow_add₀ two_ne_zero] congr 1; push_cast; ring rw[hva] at hhi rw[hvb] at hlo obtain ⟨W,hVW,hW1,hW2,hW3⟩:∃ W:ℝ,V=(if S then -W else W) ∧ W<(2^53+fr*2^30+2^29)*2^((ex:Int)-1076) ∧ (fr≠0->(2^53+fr*2^30-2^29)*2^((ex:Int)-1076)< W) ∧ (2^53-2^28)*2^((ex:Int)-1076)< W:=by cases S . simp only[Bool.false_eq_true,ite_false] at hhi hlo ⊢ exact ⟨V,rfl,lt_of_lt_of_le hhi hia,λh=>(lob1 h).trans hlo,lob.trans hlo⟩ . simp only[ite_true] at hhi hlo ⊢ exact ⟨-V,by simp,by linarith,λh=>by linarith [loa1 h],by linarith⟩ have hW0:0< W:=by refine lt_of_le_of_lt ?_ hW3 exact mul_nonneg ב hb0.le have hne:(∑ j∈Finset.range (n+1),rationalWord (if j< n then xw j else oneW) * rationalWord (if j< n then ww j else bw):ℚ)≠0:=by intro h0 rw[h0,Rat.cast_zero] at hsum rw[<-hsum] at hVW cases S . simp only[Bool.false_eq_true,ite_false] at hVW; linarith . simp only[ite_true] at hVW; linarith obtain ⟨⟨neg,m,q⟩,hd,hw'⟩:=qDu (n+1) (λt=>if t< n then xw t else oneW) (λt=>if t< n then ww t else bw) (by intro j _ have hone:expOf oneW≠255:=by decide by_cases hj:j< n . simp only[hj,ite_true] exact ⟨qAh _ (hx j hj),qAh _ (hw j hj)⟩ . simp only[hj,ite_false] exact ⟨hone,qAh _ hb⟩) hne have hdV:(FloatLib.Numerics.Dyadic.mk neg m q).toReal=V:=by rw[<-FloatLib.Numerics.Dyadic.cast_toRat,hd,hsum] have hq:(0:ℝ)<2^q:=zpow_pos ב _ have hm0:(0:ℝ)<=m:=Nat.cast_nonneg _ have hmq:=mul_nonneg hm0 hq.le have hMW:(m:ℝ)*2^q=W∧neg=S:=by simp only[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand] at hdV cases neg <;> cases S <;> simp only[Bool.false_eq_true,ite_false,ite_true,Int.ofNat_eq_natCast,Int.cast_neg, Int.cast_natCast] at hdV hVW . exact ⟨by linarith,rfl⟩ . exfalso; linarith . exfalso; linarith . exact ⟨by linarith,rfl⟩ obtain ⟨hMW,rfl⟩:=hMW have hm:m≠0:=by rintro rfl simp at hMW linarith have hword:=qEe neg m q (2^23+fr) ((ex:Int)-1046) hm א א א א (by rw[hMW,hE]; push_cast; linarith) (by intro hfr have hfr':fr≠0:=by intro h0; exact hfr א have:=hW2 hfr' rw[hMW,hE]; push_cast; linarith) (by intro _ rw[hMW,hE]; linarith) have e1:((ex:Int)-1046+150).toNat=ex-896 :=א have e2:(2^23+fr)%2^23=fr :=א rw[hz,hw',hword,e1,e2] end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open FloatLib.Floats.ExecFloat.Binary lemma qDt (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw:UInt32) (hx:∀ t,t< n->good (xw t)=true) (hw:∀ t,t< n->good (ww t)=true) (hb:good bw=true) (l:List Nat) (hl:l.Nodup) (hl2:∀ t∈l,t< n) (hz:∀ t,t< n->t∉l->xw t &&& 0x7FFFFFFF=0) (s e:Float) (hs:let r:=l.foldl (λ(acc:F1) t=>let q:=dv (xw t)*dv (ww t) F1.mk (acc.s+q) (acc.t+q.abs)) ⟨0,0⟩;s=r.s+dv bw∧e=nfOf n*(r.t+(dv bw).abs)) (h:ziv s e≠0xFFFFFFFF) : ziv s e=dotOf (n+1) (λt=>if t< n then xw t else oneW) (λt=>if t< n then ww t else bw):=by obtain ⟨-,-,hbig⟩:=qBs s e h obtain ⟨hlo,hhi⟩:=qCb n hn xw ww bw hx hw hb l hl hl2 hz s e hs hbig exact qDm n hn xw ww bw hx hw hb s e hlo hhi h lemma qC8 (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw hh:UInt32) (hx:∀ t,t< n->good (xw t)=true) (hw:∀ t,t< n->good (ww t)=true) (hb:good bw=true) (hg:good hh=true) (hm:∀ t,t< n->xw t &&& 0x7FFFFFFF<=hh) (hp:hh<=0x7FFFFFFF) (s e:Float) (hs:let r:=(List.range n).foldl (λ(acc:F1) t=>let v:=dv (ww t) F1.mk (acc.s+v*dv (xw t)) (acc.t+v.abs)) ⟨0,0⟩;s=r.s+dv bw∧e=nfOf n*(dv hh*r.t+(dv bw).abs)) (h:ziv s e≠0xFFFFFFFF) : ziv s e=dotOf (n+1) (λt=>if t< n then xw t else oneW) (λt=>if t< n then ww t else bw):=by obtain ⟨-,-,hbig⟩:=qBs s e h obtain ⟨hlo,hhi⟩:=qCn n hn xw ww bw hh hx hw hb hg hm hp s e hs hbig exact qDm n hn xw ww bw hx hw hb s e hlo hhi h end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open FloatLib.Floats.ExecFloat.Binary lemma qAu (k:Nat) (h:k<2^32):k.toUSize.toNat=k:=by rw[Nat.toUSize_eq]; exact uk k h lemma qC6 (a b:USize) (h:a.toNat*b.toNat<2^32) : (a*b).toNat=a.toNat*b.toNat:=by have h1:2^32<=USize.size:=USize.le_size have h3:USize.size=2^System.Platform.numBits:=rfl rw[USize.toNat_mul]; exact Nat.mod_eq_of_lt א lemma qCh {α:Type} (a:Array α) (h:a.size<2^32):a.usize.toNat=a.size := qAu _ h lemma qAx (a:Array UInt32) (i:USize) (hs:a.size<2^32):rdW a i=a[i.toNat]!:=by unfold rdW split . rename_i h have h2:=qAn a i h rw[getElem!_pos a i.toNat h2]; rfl . rename_i h have h':¬ i.toNat< a.size:=by intro h2; apply h; rw[USize.lt_iff_toNat_lt,qCh a hs]; exact h2 rw[getElem!_neg a i.toNat h']; rfl lemma qB9 (a:Array UInt32) (i:USize) (v:UInt32):(wrW a i v).size=a.size:=by unfold wrW; split <;> simp lemma qCk (a:Array UInt32) (i:USize) (v:UInt32) (q:Nat) (hs:a.size<2^32) (hi:i.toNat< a.size):(wrW a i v)[q]! = if q=i.toNat then v else a[q]!:=by have h:i< a.usize:=by rw[USize.lt_iff_toNat_lt,qCh a hs]; exact hi unfold wrW; rw[dite_eq_left h] by_cases hq:q< a.size . have h3:q<(a.uset i v (qAn a i h)).size:=by simpa using hq rw[getElem!_pos _ q h3,getElem!_pos a q hq] simp only[Array.uset,Array.getElem_set] by_cases e:q=i.toNat <;> simp[e,eq_comm] . have h3:¬ q<(a.uset i v (qAn a i h)).size:=by simpa using hq rw[getElem!_neg _ q h3,getElem!_neg a q hq,ite_eq_right א] def C_Inv (N:Nat) (sp:Nat->Word) (S:Nat->Prop) (out:Array Word):Prop := out.size=N∧∀ q,q< N->S q->out[q]! = sp q lemma qAj {N:Nat} {sp:Nat->Word} {S:Nat->Prop} {out:Array Word} (hN:N<2^32) (h:C_Inv N sp S out) {u:USize} {p:Nat} {v:Word} (hu:u.toNat=p) (hp:p< N) (hv:v=sp p):C_Inv N sp (λq=>q=p∨S q) (wrW out u v):=by obtain ⟨h1,h2⟩:=h refine ⟨by rw[qB9,h1],λq hq hS=>?_⟩ rw[qCk _ _ _ _ א א,hu] by_cases e:q=p . rw[ite_eq_left e,e,hv] . rw[ite_eq_right e]; exact h2 q hq (hS.resolve_left e) lemma qB4 {N:Nat} {sp:Nat->Word} {S S':Nat->Prop} {out:Array Word} (h:C_Inv N sp S out) (hS:∀ q,q< N->S' q->S q):C_Inv N sp S' out := ⟨h.1,λq hq h'=>h.2 q hq (hS q hq h')⟩ lemma qEc {N:Nat} {sp:Nat->Word} {S:Nat->Prop} {out:Array Word} (h:C_Inv N sp S out) (hS:∀ q,q< N->S q) : out=Array.ofFn (n:=N) λq=>sp q.val:=by obtain ⟨h1,h2⟩:=h apply Array.ext . simp[h1] . intro q h3 h4 have h5:q< N :=א have:=h2 q h5 (hS q h5) rw[getElem!_pos out q h3] at this simp[this] lemma qEn (v:UInt32) (h1:(0x7FFFFF:UInt32)<=v-1) (h2:v<0x7F800000) : (v == 0 || v-(0x00800000:UInt32)<=(0x7EFFFFFF:UInt32))=true:=by have a1:(0x7FFFFF:UInt32).toNat=0x7FFFFF:=rfl have a2:(0x7F800000:UInt32).toNat=0x7F800000:=rfl have a3:(0x00800000:UInt32).toNat=0x00800000:=rfl have a4:(0x7EFFFFFF:UInt32).toNat=0x7EFFFFFF:=rfl have a5:(1:UInt32).toNat=1:=rfl by_cases h0:v=0 . simp[h0] . have h3:(1:UInt32)<=v:=by rw[UInt32.le_iff_toNat_le] have:v.toNat≠0:=λh=>h0 (UInt32.toNat_inj.mp h) omega rw[UInt32.le_iff_toNat_le,UInt32.toNat_sub_of_le _ _ h3] at h1 rw[UInt32.lt_iff_toNat_lt] at h2 have h4:(0x00800000:UInt32)<=v:=by rw[UInt32.le_iff_toNat_le]; omega simp only[Bool.or_eq_true,decide_eq_true_eq] right rw[UInt32.le_iff_toNat_le,UInt32.toNat_sub_of_le _ _ h4] omega lemma qGt (c u lo:UInt32) (h:c<=if u< lo then u else lo):c<=u∧c<=lo:=by simp only[UInt32.le_iff_toNat_le,UInt32.lt_iff_toNat_lt] at * split at h <;> omega lemma qGx (c v hi:UInt32) (h:(if hi< v then v else hi)< c):v< c∧hi< c:=by simp only[UInt32.lt_iff_toNat_lt] at * split at h <;> omega lemma qGe (A:Array UInt32) (n:USize) (hn:n.toNat<=A.size) (d:Nat) : ∀ (i:USize) (lo hi:UInt32),i.toNat+d=n.toNat->scan A n i hn lo hi=true → (0x7FFFFF:UInt32)<=lo∧hi<0x7F800000 ∧ ∀ k,i.toNat<=k->k< n.toNat->good A[k]! = true:=by induction d with | zero => intro i lo hi he h rw[scan,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; omega)] at h simp only[Bool.and_eq_true,decide_eq_true_eq] at h exact ⟨h.1,h.2,λk h1 h2=>by omega⟩ | succ d ih => intro i lo hi he h have hi':i< n:=by rw[USize.lt_iff_toNat_lt]; omega rw[scan,dite_eq_left hi'] at h obtain ⟨h1,h2,h3⟩:=ih (i+1) _ _ (by rw[usz i n hi']; omega) h obtain ⟨h4,h5⟩:=qGt _ _ _ h1 obtain ⟨h6,h7⟩:=qGx _ _ _ h2 refine ⟨h5,h7,λk hk1 hk2=>?_⟩ by_cases e:k=i.toNat . subst e have hb:i.toNat< A.size :=א rw[getElem!_pos A i.toNat hb] exact qEn _ h4 h6 . exact h3 k (by rw[usz i n hi']; omega) hk2 lemma qBj (A:Array UInt32) (hs:A.size<2^32) (h:scan A A.usize 0 (qBc A) 0xFFFFFFFF 0=true) : ∀ k,k< A.size->good A[k]! = true:=by have e:=qCh A hs have h0:(0:USize).toNat=0:=rfl obtain ⟨-,-,h3⟩:=qGe A A.usize (qBc A) A.size 0 _ _ (by rw[h0,e]; omega) h intro k hk exact h3 k א א lemma qDa (w:UInt32) (h:good w=true):good (w &&& 0x7FFFFFFF)=true:=by have e:(w &&& 0x7FFFFFFF) &&& 0x7FFFFFFF=w &&& 0x7FFFFFFF:=by rw[UInt32.and_assoc,UInt32.and_self] unfold good at h ⊢ simpa only [e] using h lemma qD8 (w:UInt32):w &&& 0x7FFFFFFF<=0x7FFFFFFF:=by rw[UInt32.le_iff_toNat_le,UInt32.toNat_and] exact Nat.and_le_right def C_hok (w:Nat->Word) (t:Nat) (h:Word):Prop := good h=true∧(∀ k,k< t->w k &&& 0x7FFFFFFF<=h)∧h<=0x7FFFFFFF lemma qDp {w:Nat->Word} {t:Nat} {h:Word} (hg:good (w t)=true) (H:C_hok w t h):C_hok w (t+1) (mx h (w t)):=by obtain ⟨h1,h2,hp⟩:=H have hm:=qDa _ hg unfold mx dsimp only by_cases e:w t &&& 0x7FFFFFFF<=h . rw[ite_eq_left e] refine ⟨h1,λk hk=>?_,hp⟩ by_cases e2:k=t . rw[e2]; exact e . exact h2 k א . rw[ite_eq_right e] refine ⟨hm,λk hk=>?_,qD8 _⟩ by_cases e2:k=t . rw[e2]; exact UInt32.le_refl _ . have h3:=h2 k א simp only[UInt32.le_iff_toNat_le] at * omega def C_out (inW:Nat) (relu:Bool) (X W b:Array Word) (i j:Nat):Word := act relu (dotOf (inW+1) (λt=>if t< inW then X[i*inW+t]! else oneW) (λt=>if t< inW then W[j*inW+t]! else b[j]!)) structure C_G (rows inW outW:Nat) (X W b:Array Word):Prop where hX:rows*inW=X.size hW:outW*inW=W.size hb:outW=b.size pi:0< inW po:0< outW ni:inW<2^20 sX:X.size<2^32 sW:W.size<2^32 sb:b.size<2^32 sO:rows*outW<2^32 gX:∀ q,q< X.size->good X[q]! = true gW:∀ q,q< W.size->good W[q]! = true gb:∀ q,q< b.size->good b[q]! = true lemma qDy {rows inW i t:Nat} (hi:i< rows) (ht:t< inW):i*inW+t< rows*inW:=by have h:(i+1)*inW<=rows*inW:=Nat.mul_le_mul_right _ hi rw[Nat.add_mul,Nat.one_mul] at h; omega lemma qB5 {rows inW i t:Nat} (hi:i< rows) (ht:t<=inW) : i*inW+t<=rows*inW:=by have h:(i+1)*inW<=rows*inW:=Nat.mul_le_mul_right _ hi rw[Nat.add_mul,Nat.one_mul] at h; omega section variable {rows inW outW:Nat} {X W b:Array Word} lemma C_G.gx (G:C_G rows inW outW X W b) {i:Nat} (hi:i< rows) : ∀ t,t< inW->good X[i*inW+t]! = true := λ_ ht=>G.gX _ (by rw[<-G.hX]; exact qDy hi ht) lemma C_G.gw (G:C_G rows inW outW X W b) {j:Nat} (hj:j< outW) : ∀ t,t< inW->good W[j*inW+t]! = true := λ_ ht=>G.gW _ (by rw[<-G.hW]; exact qDy hj ht) lemma qEz (G:C_G rows inW outW X W b) (relu:Bool) {i j:Nat} (hi:i< rows) (hj:j< outW) (L:List Nat) (hl:L.Nodup) (hl2:∀ t∈L,t< inW) (hz:∀ t,t< inW->t∉L->X[i*inW+t]! &&& 0x7FFFFFFF=0) {s e:Float} (hs:let r:=L.foldl (λ(acc:F1) t=>let q:=dv X[i*inW+t]! * dv W[j*inW+t]! F1.mk (acc.s+q) (acc.t+q.abs)) ⟨0,0⟩;s=r.s∧e=r.t) : fin inW relu X W b i j s (nfOf inW) e b[j]! = C_out inW relu X W b i j:=by obtain ⟨h1,h2⟩:=hs unfold fin dsimp only by_cases h:ziv (s+dv b[j]!) (nfOf inW*(e+(dv b[j]!).abs))=0xFFFFFFFF . rw[ite_eq_left (by simpa using h)] unfold slowOut C_out rw[qBf] . rw[ite_eq_right (by simpa using h)] unfold C_out congr 1 exact qDt inW G.ni (λt=>X[i*inW+t]!) (λt=>W[j*inW+t]!) b[j]! (G.gx hi) (G.gw hj) (G.gb j (by rw[<-G.hb]; exact hj)) L hl hl2 hz _ _ ⟨by rw[h1],by rw[h2]⟩ h lemma qD6 {X W:Array UInt32} {xo wo n:USize} (hX:X.size<2^32) (hW:W.size<2^32) (h1:xo.toNat+n.toNat<=X.size) (h2:wo.toNat+n.toNat<=W.size) (d:Nat):∀ (t:USize) (s a:Float),t.toNat+d=n.toNat → tightGo X W xo wo n t s a=(List.range' t.toNat d).foldl (λ(acc:F1) k => let q:=dv X[xo.toNat+k]! * dv W[wo.toNat+k]! F1.mk (acc.s+q) (acc.t+q.abs)) ⟨s,a⟩:=by induction d with | zero => intro t s a he rw[tightGo,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; omega)] rfl | succ d ih => intro t s a he have ht:t< n:=by rw[USize.lt_iff_toNat_lt]; omega rw[tightGo,dite_eq_left ht,List.range'_succ,List.foldl_cons] dsimp only rw[qAx _ _ hX,qAx _ _ hW,qAe _ _ א,qAe _ _ א] rw[ih (t+1) _ _ (by rw[usz t n ht]; omega),usz t n ht] lemma qF4 (G:C_G rows inW outW X W b) (relu:Bool) {i j:Nat} (hi:i< rows) (hj:j< outW) {s a:Float} {hh:Word} (hg:good hh=true) (hm:∀ t,t< inW->X[i*inW+t]! &&& 0x7FFFFFFF<=hh) (hp:hh<=0x7FFFFFFF) (hs:let r:=(List.range inW).foldl (λ(acc:F1) t=>let v:=dv W[j*inW+t]! F1.mk (acc.s+v*dv X[i*inW+t]!) (acc.t+v.abs)) ⟨0,0⟩;s=r.s∧a=r.t) : fin8 inW relu X W b i j s (nfOf inW) a hh b[j]! inW.toUSize=C_out inW relu X W b i j:=by obtain ⟨h1,h2⟩:=hs have hb:good b[j]! = true:=G.gb j (by rw[<-G.hb]; exact hj) have hin:inW<2^32:=lt_trans G.ni ב have hX1:i*inW+inW<=X.size:=by rw[<-G.hX]; exact qB5 hi (le_refl _) have hW1:j*inW+inW<=W.size:=by rw[<-G.hW]; exact qB5 hj (le_refl _) have sX:=G.sX have sW:=G.sW have e1:(i*inW).toUSize.toNat=i*inW:=qAu _ א have e2:(j*inW).toUSize.toNat=j*inW:=qAu _ א have e3:inW.toUSize.toNat=inW:=qAu _ hin unfold fin8 dsimp only by_cases h:ziv (s+dv b[j]!) (nfOf inW*(dv hh*a+(dv b[j]!).abs))=0xFFFFFFFF . rw[ite_eq_left (by simpa using h)] have e:=qD6 (xo:=(i*inW).toUSize) (wo:=(j*inW).toUSize) (n:=inW.toUSize) G.sX G.sW (by rw[e1,e3]; exact hX1) (by rw[e2,e3]; exact hW1) inW 0 0 0 (by rw[e3,show (0:USize).toNat=0 from rfl,Nat.zero_add]) rw[show (0:USize).toNat=0 from rfl,e1,e2,<-List.range_eq_range'] at e rw[qEz G relu hi hj (List.range inW) List.nodup_range (λt ht=>List.mem_range.mp ht) (λt ht h3=>absurd (List.mem_range.mpr ht) h3) (s:=(tightGo X W (i*inW).toUSize (j*inW).toUSize inW.toUSize 0 0 0).s) (e:=(tightGo X W (i*inW).toUSize (j*inW).toUSize inW.toUSize 0 0 0).t) ⟨by rw[e],by rw[e]⟩] . rw[ite_eq_right (by simpa using h)] unfold C_out congr 1 exact qC8 inW G.ni (λt=>X[i*inW+t]!) (λt=>W[j*inW+t]!) b[j]! hh (G.gx hi) (G.gw hj) hb hg hm hp _ _ ⟨by rw[h1],by rw[h2]⟩ h end lemma qF7 (x:FloatArray) (i:USize) (h:i.toNat< x.size) : x.uget i h=x.data[i.toNat]!:=by obtain ⟨ds⟩:=x have h':i.toNat< ds.size:=h rw[getElem!_pos ds i.toNat h']; rfl lemma qEs (a:Array UInt32) (i:USize) (h:i.toNat< a.size) : a.uget i h=a[i.toNat]!:=by rw[getElem!_pos a i.toNat h]; rfl lemma qD1 (a:FloatArray) (i:USize) (v:Float):(wrF a i v).size=a.size:=by unfold wrF; split . obtain ⟨ds⟩:=a; exact Array.size_uset _ . rfl lemma qD5 (a:FloatArray) (i:USize) (v:Float) (q:Nat) (hs:a.size<2^32) (hi:i.toNat< a.size) : (wrF a i v).data[q]! = if q=i.toNat then v else a.data[q]!:=by have h:i< a.usize:=by rw[USize.lt_iff_toNat_lt,FloatArray.usize]; rwa [qAu _ hs] unfold wrF; rw[dite_eq_left h] obtain ⟨ds⟩:=a have hi':i.toNat< ds.size:=hi show (ds.set i.toNat v hi')[q]! = if q=i.toNat then v else ds[q]! by_cases hq:q< ds.size . have h3:q<(ds.set i.toNat v hi').size:=by simpa using hq rw[getElem!_pos _ q h3,getElem!_pos ds q hq] simp only[Array.getElem_set] by_cases e:q=i.toNat <;> simp[e,eq_comm] . have h3:¬ q<(ds.set i.toNat v hi').size:=by simpa using hq rw[getElem!_neg _ q h3,getElem!_neg ds q hq,ite_eq_right א] def C_keep (xw:Nat->Word) (t:Nat):List Nat := (List.range t).filter (λp=>xw p &&& 0x7FFFFFFF != 0) lemma qB6 (xw:Nat->Word) (t:Nat):(C_keep xw t).length<=t:=by have h:=List.length_filter_le (λp=>xw p &&& 0x7FFFFFFF != 0) (List.range t) simpa [C_keep] using h lemma qC9 (xw:Nat->Word) (t:Nat) (h:xw t &&& 0x7FFFFFFF=0) : C_keep xw (t+1)=C_keep xw t:=by simp[C_keep,List.range_succ,List.filter_append,h] lemma qDq (xw:Nat->Word) (t:Nat) (h:¬ xw t &&& 0x7FFFFFFF=0) : C_keep xw (t+1)=C_keep xw t ++ [t]:=by simp[C_keep,List.range_succ,List.filter_append,h] def C_Dec (xw:Nat->Word) (sz t:Nat) (ix:Array UInt32) (buf:FloatArray) (c:USize):Prop := c.toNat=(C_keep xw t).length∧ix.size=sz∧buf.size=sz ∧ ∀ k p:Nat,(C_keep xw t)[k]?=some p->(ix[k]! : UInt32).toNat=p∧buf.data[k]! = dv (xw p) lemma qF5 {X:Array UInt32} {o n:USize} (xw:Nat->Word) (hn:n.toNat<2^32) (hxw:∀ t:USize,t< n->rdW X (o+t)=xw t.toNat) (d:Nat) : ∀ (t:USize) (ix:Array UInt32) (buf:FloatArray) (c:USize),t.toNat+d=n.toNat → C_Dec xw n.toNat t.toNat ix buf c → C_Dec xw n.toNat n.toNat (decR X o n t ix buf c).ix (decR X o n t ix buf c).buf (decR X o n t ix buf c).c:=by induction d with | zero => intro t ix buf c he H rw[decR,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; omega)] have e:t.toNat=n.toNat :=א rw[e] at H; exact H | succ d ih => intro t ix buf c he H have ht:t< n:=by rw[USize.lt_iff_toNat_lt]; omega have hu:=usz t n ht rw[decR,dite_eq_left ht] dsimp only rw[hxw t ht] obtain ⟨h1,h2,h3,h4⟩:=H by_cases hz:xw t.toNat &&& 0x7FFFFFFF=0 . rw[ite_eq_left (by simpa using hz)] apply ih (t+1) _ _ _ א rw[hu,C_Dec,qC9 xw _ hz] exact ⟨h1,h2,h3,h4⟩ . rw[ite_eq_right (by simpa using hz)] apply ih (t+1) _ _ _ א have hk:=qB6 xw t.toNat have hc:c.toNat< t.toNat+1 :=א rw[hu,C_Dec,qDq xw _ hz] have hcn:c.toNat< n.toNat :=א refine ⟨?_,by rw[qB9]; exact h2,by rw[qD1]; exact h3,λk p hk2=>?_⟩ . rw[qAe _ _ (by rw[USize.toNat_one]; omega),USize.toNat_one,h1]; simp . rw[qCk _ _ _ _ א א,qD5 _ _ _ _ א א] rw[List.getElem?_append,<-h1] at hk2 by_cases e:k=c.toNat . subst e simp at hk2 subst hk2 simp omega . rw[ite_eq_right e,ite_eq_right e] by_cases e2:k< c.toNat . rw[ite_eq_left e2] at hk2; exact h4 k p hk2 . rw[ite_eq_right e2] at hk2 obtain ⟨m,hm⟩:∃ m,k-c.toNat=m+1:=⟨k-c.toNat-1,by omega⟩ rw[hm] at hk2 simp at hk2 lemma qAr (a:FloatArray) (v:Float):(a.push v).size=a.size+1:=by obtain ⟨ds⟩:=a exact Array.size_push _ lemma qFc (n:USize) (d:Nat):∀ (k:USize) (a:FloatArray),k.toNat+d=n.toNat → (pushZ n k a).size=a.size+d:=by induction d with | zero => intro k a he rw[pushZ,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; omega)]; rfl | succ d ih => intro k a he have ht:k< n:=by rw[USize.lt_iff_toNat_lt]; omega rw[pushZ,dite_eq_left ht,ih (k+1) _ (by rw[usz k n ht]; omega),qAr] omega lemma qG7 {x:FloatArray} {ix W:Array UInt32} {w0 m n:USize} (hx:n.toNat<=x.size) (hi:n.toNat<=ix.size) (hs:W.size<2^32) (h0:w0.toNat+m.toNat<=W.size) (xf:Nat->Float) (ww:Nat->Word) (hww:∀ p,p< m.toNat->W[w0.toNat+p]! = ww p) (L:List Nat):∀ (t:USize) (a t0:Float),t.toNat+L.length=n.toNat → (∀ k p:Nat,L[k]?=some p->p< m.toNat∧(ix[t.toNat+k]! : UInt32).toNat=p ∧ x.data[t.toNat+k]! = xf p) → go1 x ix W w0 m n t hx hi hs h0 a t0=L.foldl (λ(acc:F1) p => let q:=xf p*dv (ww p) F1.mk (acc.s+q) (acc.t+q.abs)) ⟨a,t0⟩:=by induction L with | nil => intro t a t0 he _ rw[go1,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; simp at he; omega)] rfl | cons p L ih => intro t a t0 he H simp only[List.length_cons] at he have ht:t< n:=by rw[USize.lt_iff_toNat_lt]; omega have htn:t.toNat< n.toNat :=א obtain ⟨h1,h2,h3⟩:=H 0 p rfl rw[Nat.add_zero] at h2 h3 have hit:t.toNat< ix.size :=א have e0:(ix.uget t hit).toUSize.toNat=p:=by rw[UInt32.toNat_toUSize,qEs]; exact h2 have hm:(ix.uget t hit).toUSize< m:=by rw[USize.lt_iff_toNat_lt,e0]; exact h1 have e1:x.uget t א=xf p:=by rw[qF7,h3] have e2:∀ pf,W.uget (w0+(ix.uget t hit).toUSize) pf=ww p:=by intro pf rw[qEs,qAe _ _ (by rw[e0]; omega),e0,hww p h1] rw[go1,dite_eq_left ht] dsimp only rw[dite_eq_left hm] rw[e1,e2,ih (t+1) _ _ (by rw[usz t n ht]; omega),List.foldl_cons] intro k q hq have:=H (k+1) q (by simpa using hq) rw[usz t n ht,show t.toNat+1+k=t.toNat+(k+1) by omega] exact this lemma qGu {x:FloatArray} {ix W:Array UInt32} {w0 w1 w2 w3 m n:USize} (hx:n.toNat<=x.size) (hi:n.toNat<=ix.size) (hs:W.size<2^32) (h0:w0.toNat+m.toNat<=W.size) (h1:w1.toNat+m.toNat<=W.size) (h2:w2.toNat+m.toNat<=W.size) (h3:w3.toNat+m.toNat<=W.size) (k:Nat) : ∀ (t:USize) (a b c d t0 t1 t2 t3:Float),t.toNat+k=n.toNat → go4 x ix W w0 w1 w2 w3 m n t hx hi hs h0 h1 h2 h3 a b c d t0 t1 t2 t3 = ⟨(go1 x ix W w0 m n t hx hi hs h0 a t0).s,(go1 x ix W w1 m n t hx hi hs h1 b t1).s, (go1 x ix W w2 m n t hx hi hs h2 c t2).s,(go1 x ix W w3 m n t hx hi hs h3 d t3).s, (go1 x ix W w0 m n t hx hi hs h0 a t0).t,(go1 x ix W w1 m n t hx hi hs h1 b t1).t, (go1 x ix W w2 m n t hx hi hs h2 c t2).t,(go1 x ix W w3 m n t hx hi hs h3 d t3).t⟩:=by induction k with | zero => intro t a b c d t0 t1 t2 t3 he have hn:¬ t< n:=by rw[USize.lt_iff_toNat_lt]; omega rw[go4,go1.eq_1 x ix W w0,go1.eq_1 x ix W w1,go1.eq_1 x ix W w2,go1.eq_1 x ix W w3] simp only[dite_eq_right hn] | succ k ih => intro t a b c d t0 t1 t2 t3 he have ht:t< n:=by rw[USize.lt_iff_toNat_lt]; omega have htn:t.toNat< n.toNat :=א rw[go4,go1.eq_1 x ix W w0,go1.eq_1 x ix W w1,go1.eq_1 x ix W w2,go1.eq_1 x ix W w3] simp only[dite_eq_left ht] by_cases hm:(ix.uget t א).toUSize< m . simp only[dite_eq_left hm] exact ih (t+1) _ _ _ _ _ _ _ _ (by rw[usz t n ht]; omega) . simp only[dite_eq_right hm] exact ih (t+1) _ _ _ _ _ _ _ _ (by rw[usz t n ht]; omega) def C_sp (inW outW:Nat) (relu:Bool) (X W b:Array Word) (q:Nat):Word := C_out inW relu X W b (q/outW) (q%outW) lemma qDn (inW outW:Nat) (relu:Bool) (X W b:Array Word) {i j:Nat} (hj:j< outW) : C_sp inW outW relu X W b (i*outW+j)=C_out inW relu X W b i j:=by unfold C_sp have h0:0< outW :=א rw[Nat.mul_comm i outW,Nat.mul_add_div h0,Nat.mul_add_mod,Nat.div_eq_of_lt hj, Nat.mod_eq_of_lt hj,Nat.add_zero] lemma qA1 {N:Nat} {sp:Nat->Word} {p:Nat} {out:Array Word} (hN:N<2^32) (h:C_Inv N sp (λq=>q< p) out) {u:USize} {v:Word} (hu:u.toNat=p) (hp:p< N) (hv:v=sp p):C_Inv N sp (λq=>q< p+1) (wrW out u v) := qB4 (qAj hN h hu hp hv) (λq _ (hq:q< p+1) => (by omega:q=p∨q< p)) structure C_Row (inW:Nat) (X:Array Word) (i:Nat) (ix:Array UInt32) (x:FloatArray) (c:USize) (L:List Nat):Prop where len:c.toNat=L.length cle:L.length<=inW six:ix.size=inW sx:x.size=inW nd:L.Nodup lt:∀ t∈L,t< inW hz:∀ t,t< inW->t∉L->X[i*inW+t]! &&& 0x7FFFFFFF=0 rd:∀ k p:Nat,L[k]?=some p → (ix[k]! : UInt32).toNat=p∧x.data[k]! = dv X[i*inW+p]! section variable {rows inW outW:Nat} {X W b:Array Word} lemma C_G.nm (G:C_G rows inW outW X W b):inW.toUSize.toNat=inW := qAu _ (lt_trans G.ni ב) lemma C_G.wj (G:C_G rows inW outW X W b) {j:Nat} {u:USize} (hu:u.toNat=j) (hj:j< outW):(u*inW.toUSize).toNat=j*inW ∧ (u*inW.toUSize).toNat+inW.toUSize.toNat<=W.size:=by have h1:j*inW+inW<=outW*inW:=qB5 hj (le_refl _) have h2:=G.hW have h3:=G.sW have e:(u*inW.toUSize).toNat=j*inW:=by rw[qC6 _ _ (by rw[hu,G.nm]; omega),hu,G.nm] exact ⟨e,by rw[e,G.nm]; omega⟩ lemma qCd (G:C_G rows inW outW X W b) (relu:Bool) {i j:Nat} (hi:i< rows) (hj:j< outW) {ix:Array UInt32} {x:FloatArray} {c:USize} {L:List Nat} (Rw:C_Row inW X i ix x c L) {u:USize} (hu:u.toNat=j) (hx:c.toNat<=x.size) (hi':c.toNat<=ix.size) (hs:W.size<2^32) (h0:(u*inW.toUSize).toNat+inW.toUSize.toNat<=W.size) : fin inW relu X W b i j (go1 x ix W (u*inW.toUSize) inW.toUSize c 0 hx hi' hs h0 0 0).s (nfOf inW) (go1 x ix W (u*inW.toUSize) inW.toUSize c 0 hx hi' hs h0 0 0).t (rdW b u) = C_out inW relu X W b i j:=by have e:=qG7 hx hi' hs h0 (λp=>dv X[i*inW+p]!) (λp=>W[j*inW+p]!) (λp _=>by rw[(G.wj hu hj).1]) L 0 0 0 (by rw[show (0:USize).toNat=0 from rfl,Nat.zero_add]; exact Rw.len.symm) (λk p hk=>by have h1:=Rw.rd k p hk rw[show (0:USize).toNat=0 from rfl,Nat.zero_add,G.nm] exact ⟨Rw.lt p (List.mem_of_getElem? hk),h1⟩) rw[qAx _ _ G.sb,hu] exact qEz G relu hi hj L Rw.nd Rw.lt Rw.hz ⟨by rw[e],by rw[e]⟩ lemma qFf (G:C_G rows inW outW X W b) (relu:Bool) {i:Nat} (hi:i< rows) {ix:Array UInt32} {x:FloatArray} {c:USize} {L:List Nat} (Rw:C_Row inW X i ix x c L) {base:USize} (hb:base.toNat=i*outW) (d:Nat) : ∀ (j:Nat) (out:Array Word),j+d=outW → C_Inv (rows*outW) (C_sp inW outW relu X W b) (λq=>q< i*outW+j) out → C_Inv (rows*outW) (C_sp inW outW relu X W b) (λq=>q< i*outW+outW) (cols1 inW outW relu X W b i ix x (nfOf inW) inW.toUSize c j base out):=by induction d using Nat.strong_induction_on with | _ d ih => intro j out he H have hN:=G.sO have sW:=G.sW have hbs:=G.sb have hob:=G.hb have hle:=Rw.cle have h1c:c.toNat<=x.size:=by rw[Rw.sx,Rw.len]; exact hle have h2c:c.toNat<=ix.size:=by rw[Rw.six,Rw.len]; exact hle have l2:(2:USize).toNat=2:=uk 2 ב have l3:(3:USize).toNat=3:=uk 3 ב have hsp:=λ{i' j':Nat} (h:j'< outW) => (qDn inW outW relu X W b (i:=i') (j:=j') h).symm by_cases h4:j+4<=outW . have hP:=qDy hi (show j+3< outW by omega) have e0:j.toUSize.toNat=j:=qAu _ א have e1:(j.toUSize+1).toNat=j+1:=by rw[qAe _ _ (by rw[e0,USize.toNat_one]; omega),e0,USize.toNat_one] have e2:(j.toUSize+2).toNat=j+2:=by rw[qAe _ _ (by rw[e0,l2]; omega),e0,l2] have e3:(j.toUSize+3).toNat=j+3:=by rw[qAe _ _ (by rw[e0,l3]; omega),e0,l3] have g0:=(G.wj e0 א).2 have g1:=(G.wj e1 א).2 have g2:=(G.wj e2 א).2 have g3:=(G.wj e3 א).2 have a0:(base+j.toUSize).toNat=i*outW+j:=by rw[qAe _ _ (by rw[hb,e0]; omega),hb,e0] have a1:(base+j.toUSize+1).toNat=i*outW+j+1:=by rw[qAe _ _ (by rw[a0,USize.toNat_one]; omega),a0,USize.toNat_one] have a2:(base+j.toUSize+2).toNat=i*outW+j+1+1:=by rw[qAe _ _ (by rw[a0,l2]; omega),a0,l2] have a3:(base+j.toUSize+3).toNat=i*outW+j+1+1+1:=by rw[qAe _ _ (by rw[a0,l3]; omega),a0,l3] have o0:=qCd G relu hi (show j< outW by omega) Rw e0 h1c h2c sW g0 have o1:=qCd G relu hi (show j+1< outW by omega) Rw e1 h1c h2c sW g1 have o2:=qCd G relu hi (show j+2< outW by omega) Rw e2 h1c h2c sW g2 have o3:=qCd G relu hi (show j+3< outW by omega) Rw e3 h1c h2c sW g3 rw[cols1,dite_eq_left h4] dsimp only rw[dite_eq_left ⟨h1c,h2c,sW,g0,g1,g2,g3⟩] rw[qGu _ _ _ _ _ _ _ c.toNat 0 _ _ _ _ _ _ _ _ (by rw[show (0:USize).toNat=0 from rfl,Nat.zero_add])] dsimp only rw[o0,o1,o2,o3] refine ih (d-4) א (j+4) _ א ?_ have s1:C_out inW relu X W b i (j+1)=C_sp inW outW relu X W b (i*outW+j+1):=by rw[Nat.add_assoc]; exact hsp א have s2:C_out inW relu X W b i (j+2) = C_sp inW outW relu X W b (i*outW+j+1+1):=by rw[show i*outW+j+1+1=i*outW+(j+2) by omega]; exact hsp א have s3:C_out inW relu X W b i (j+3) = C_sp inW outW relu X W b (i*outW+j+1+1+1):=by rw[show i*outW+j+1+1+1=i*outW+(j+3) by omega]; exact hsp א rw[show i*outW+(j+4)=i*outW+j+1+1+1+1 by omega] exact qA1 hN (qA1 hN (qA1 hN (qA1 hN H a0 א (hsp א)) a1 א s1) a2 א s2) a3 א s3 . by_cases h1:j< outW . have hP:=qDy hi h1 have e0:j.toUSize.toNat=j:=qAu _ א have g0:=(G.wj e0 h1).2 have a0:(base+j.toUSize).toNat=i*outW+j:=by rw[qAe _ _ (by rw[hb,e0]; omega),hb,e0] have o0:=qCd G relu hi h1 Rw e0 h1c h2c sW g0 rw[cols1,dite_eq_right h4,dite_eq_left h1] dsimp only rw[dite_eq_left ⟨h1c,h2c,sW,g0⟩] rw[o0] exact ih (d-1) א (j+1) _ א (qA1 hN H a0 hP (hsp h1)) . rw[cols1,dite_eq_right h4,dite_eq_right h1] have e:j=outW :=א rw[e] at H; exact H lemma qFl (G:C_G rows inW outW X W b) (relu:Bool) (d:Nat) : ∀ (i:Nat) (ix:Array UInt32) (buf:FloatArray) (out:Array Word),i+d=rows → ix.size=inW->buf.size=inW → C_Inv (rows*outW) (C_sp inW outW relu X W b) (λq=>q< i*outW) out → C_Inv (rows*outW) (C_sp inW outW relu X W b) (λq=>q< rows*outW) (rows1 rows inW outW relu X W b (nfOf inW) inW.toUSize i ix buf out):=by induction d with | zero => intro i ix buf out he _ _ H rw[rows1,dite_eq_right א] have e:i=rows :=א rw[e] at H; exact H | succ d ih => intro i ix buf out he h1 h2 H have hi:i< rows :=א have hin:inW<2^32:=lt_trans G.ni ב have hN:=G.sO have sX:=G.sX have hX:=G.hX have hP:i*inW+inW<=rows*inW:=qB5 hi (le_refl _) have ho:(i*inW).toUSize.toNat=i*inW:=qAu _ א have hbs:(i*outW).toUSize.toNat=i*outW:=by have h3:i*outW+outW<=rows*outW:=qB5 hi (le_refl _) exact qAu _ א have D:=qF5 (X:=X) (o:=(i*inW).toUSize) (n:=inW.toUSize) (λp=>X[i*inW+p]!) (by rw[G.nm]; exact hin) (λt ht=>by have h4:=USize.lt_iff_toNat_lt.mp ht rw[G.nm] at h4 rw[qAx _ _ sX,qAe _ _ (by rw[ho]; omega),ho]) inW 0 ix buf 0 (by rw[show (0:USize).toNat=0 from rfl,G.nm,Nat.zero_add]) ⟨by simp[C_keep],by rw[G.nm]; exact h1,by rw[G.nm]; exact h2, λk p hk=>by simp[C_keep] at hk⟩ rw[G.nm] at D obtain ⟨d1,d2,d3,d4⟩:=D have Rw:C_Row inW X i (decR X (i*inW).toUSize inW.toUSize 0 ix buf 0).ix (decR X (i*inW).toUSize inW.toUSize 0 ix buf 0).buf (decR X (i*inW).toUSize inW.toUSize 0 ix buf 0).c (C_keep (λp=>X[i*inW+p]!) inW) := ⟨d1,qB6 _ _,d2,d3,(List.nodup_range).filter _, λt ht=>List.mem_range.mp (List.mem_filter.mp ht).1, λt ht hn=>by by_contra hc exact hn (List.mem_filter.mpr ⟨List.mem_range.mpr ht,by simpa using hc⟩),d4⟩ rw[rows1,dite_eq_left hi] dsimp only refine ih (i+1) _ _ _ א d2 d3 ?_ have h5:=qFf G relu hi Rw hbs outW 0 out א (by rw[Nat.add_zero]; exact H) rw[show (i+1)*outW=i*outW+outW by rw[Nat.add_mul,Nat.one_mul]] exact h5 end lemma qE1 (xs:FloatArray) (v:Float) (q:Nat) : (xs.push v).data[q]! = if q=xs.size then v else xs.data[q]!:=by obtain ⟨ds⟩:=xs show (ds.push v)[q]! = if q=ds.size then v else ds[q]! by_cases hq:q< ds.size . have h3:q<(ds.push v).size:=by simp; omega rw[getElem!_pos _ q h3,getElem!_pos ds q hq,ite_eq_right א,Array.getElem_push_lt] . by_cases e:q=ds.size . subst e have h3:ds.size<(ds.push v).size:=by simp rw[getElem!_pos (ds.push v) ds.size h3,ite_eq_left rfl,Array.getElem_push_eq] . have h3:¬ q<(ds.push v).size:=by simp; omega rw[getElem!_neg _ q h3,getElem!_neg ds q hq,ite_eq_right e] lemma qEy (xs:FloatArray) (a:Nat->Float) (r:Nat) (hr:r<8) : (((((((((xs.push (a 0)).push (a 1)).push (a 2)).push (a 3)).push (a 4)).push (a 5)).push (a 6)).push (a 7))).data[xs.size+r]! = a r:=by simp only[qE1,qAr] interval_cases r <;> repeat (first | rw[ite_eq_left א] | rw[ite_eq_right א]) lemma qEr (xs:FloatArray) (a0 a1 a2 a3 a4 a5 a6 a7:Float) (q:Nat) (hq:q< xs.size) : (((((((((xs.push a0).push a1).push a2).push a3).push a4).push a5).push a6).push a7)).data[q]! = xs.data[q]!:=by simp only[qE1,qAr] rw[ite_eq_right א,ite_eq_right א,ite_eq_right א,ite_eq_right א, ite_eq_right א,ite_eq_right א,ite_eq_right א,ite_eq_right א] def C_hf (d:H8):Nat->UInt32 | 0=>d.h0 | 1=>d.h1 | 2=>d.h2 | 3=>d.h3 | 4=>d.h4 | 5=>d.h5 | 6=>d.h6 | _=>d.h7 def C_fs (d:F8):Nat->Float | 0=>d.s0 | 1=>d.s1 | 2=>d.s2 | 3=>d.s3 | 4=>d.s4 | 5=>d.s5 | 6=>d.s6 | _=>d.s7 def C_D8 (X:Array Word) (m t:Nat) (d:H8):Prop := d.xs.size=8*t∧(∀ k r:Nat,k< t->r<8->d.xs.data[8*k+r]! = dv X[r*m+k]!) ∧ ∀ r:Nat,r<8->C_hok (λk=>X[r*m+k]!) t (C_hf d r) lemma qBz {n t c:USize} {k:Nat} (hc:c.toNat=k) (h:k*n.toNat+t.toNat<2^32) : (c*n+t).toNat=k*n.toNat+t.toNat:=by have h0:k*n.toNat<2^32 :=א rw[qAe _ _ (by rw[qC6 _ _ (by rw[hc]; exact h0),hc]; exact h), qC6 _ _ (by rw[hc]; exact h0),hc] lemma qCg {X:Array Word} {n t c:USize} {k:Nat} (hs:X.size<2^32) (hc:c.toNat=k) (h:k*n.toNat+t.toNat<2^32) : rdW X (c*n+t)=X[k*n.toNat+t.toNat]!:=by rw[qAx _ _ hs,qBz hc h] lemma qFy {X:Array Word} {n:USize} (hs:X.size<2^32) (h8:8*n.toNat<=X.size) (hg:∀ q,q< X.size->good X[q]! = true) (d:Nat) : ∀ (t:USize) (xs:FloatArray) (h0 h1 h2 h3 h4 h5 h6 h7:UInt32),t.toNat+d=n.toNat → C_D8 X n.toNat t.toNat ⟨xs,h0,h1,h2,h3,h4,h5,h6,h7⟩ → C_D8 X n.toNat n.toNat (dec8 X n t xs h0 h1 h2 h3 h4 h5 h6 h7):=by induction d with | zero => intro t xs h0 h1 h2 h3 h4 h5 h6 h7 he H rw[dec8,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; omega)] have e:t.toNat=n.toNat :=א rw[e] at H; exact H | succ d ih => intro t xs h0 h1 h2 h3 h4 h5 h6 h7 he H have ht:t< n:=by rw[USize.lt_iff_toNat_lt]; omega have hu:=usz t n ht have l2:(2:USize).toNat=2:=uk 2 ב have l3:(3:USize).toNat=3:=uk 3 ב have l4:(4:USize).toNat=4:=uk 4 ב have l5:(5:USize).toNat=5:=uk 5 ב have l6:(6:USize).toNat=6:=uk 6 ב have l7:(7:USize).toNat=7:=uk 7 ב have r0:rdW X t=X[0*n.toNat+t.toNat]!:=by rw[qAx _ _ hs,Nat.zero_mul,Nat.zero_add] have r1:rdW X (n+t)=X[1*n.toNat+t.toNat]!:=by rw[qAx _ _ hs,qAe _ _ א,Nat.one_mul] rw[dec8,dite_eq_left ht] dsimp only rw[r0,r1,qCg hs l2 א,qCg hs l3 א,qCg hs l4 א, qCg hs l5 א,qCg hs l6 א,qCg hs l7 א] obtain ⟨H1,H2,H3⟩:=H have hgood:∀ r,r<8->good X[r*n.toNat+t.toNat]! = true:=by intro r hr apply hg interval_cases r <;> omega dsimp only at H1 H2 refine ih (t+1) _ _ _ _ _ _ _ _ _ א ⟨?_,?_,?_⟩ . simp only[qAr,H1,hu]; omega . intro k r hk hr rw[hu] at hk by_cases e:k=t.toNat . subst e have h9:=qEy xs (λr=>dv X[r*n.toNat+t.toNat]!) r hr rw[H1] at h9 exact h9 . have h10:8*k+r< xs.size :=א rw[qEr _ _ _ _ _ _ _ _ _ _ h10] exact H2 k r א hr . intro r hr have h9:=H3 r hr have h10:=hgood r hr rw[hu] interval_cases r <;> exact qDp h10 h9 def C_cf (xf:Nat->Float) (ww:Nat->Word) (l:List Nat) (acc:F1):F1 := l.foldl (λ(acc:F1) t=>let v:=dv (ww t) F1.mk (acc.s+v*xf t) (acc.t+v.abs)) acc lemma qBm {xs:FloatArray} {i t n:USize} {xf:Nat->Nat->Float} (hxf:∀ r k:Nat,r<8->k< n.toNat->xs.data[8*k+r]! = xf r k) (hi:i.toNat=8*t.toNat) (ht:t.toNat< n.toNat) (hsx:xs.size<2^32) (hx:8*n.toNat<=xs.size) (r:Nat) (hr:r<8) (pf:(i+USize.ofNat r).toNat< xs.size) : xs.uget (i+USize.ofNat r) pf=xf r t.toNat:=by rw[qF7,qAe _ _ (by rw[uk r א]; omega),uk r א,hi,hxf r _ hr ht] lemma qG4 {xs:FloatArray} {W:Array UInt32} {wo n:USize} (hx:8*n.toNat<=xs.size) (hsx:xs.size<2^32) (hs:W.size<2^32) (hw:wo.toNat+n.toNat<=W.size) (xf:Nat->Nat->Float) (ww:Nat->Word) (hxf:∀ r k:Nat,r<8->k< n.toNat->xs.data[8*k+r]! = xf r k) (hww:∀ k,k< n.toNat->W[wo.toNat+k]! = ww k) (d:Nat) : ∀ (t i:USize) (hi:i.toNat=8*t.toNat) (s0 s1 s2 s3 s4 s5 s6 s7 a:Float), t.toNat+d=n.toNat->∀ r,r<8 → F1.mk (C_fs (go8 xs W wo n t i hx hsx hs hw hi s0 s1 s2 s3 s4 s5 s6 s7 a) r) (go8 xs W wo n t i hx hsx hs hw hi s0 s1 s2 s3 s4 s5 s6 s7 a).t = C_cf (xf r) ww (List.range' t.toNat d) ⟨C_fs ⟨s0,s1,s2,s3,s4,s5,s6,s7,a⟩ r,a⟩:=by induction d with | zero => intro t i hi s0 s1 s2 s3 s4 s5 s6 s7 a he r hr rw[go8,dite_eq_right (by rw[USize.lt_iff_toNat_lt]; omega)] rfl | succ d ih => intro t i hi s0 s1 s2 s3 s4 s5 s6 s7 a he r hr have ht:t< n:=by rw[USize.lt_iff_toNat_lt]; omega have htn:t.toNat< n.toNat :=א have hu:=usz t n ht have e:dv (W.uget (wo+t) (wi wo t n W hw hs htn))=dv (ww t.toNat):=by rw[qEs,qAe _ _ א,hww _ htn] rw[go8,dite_eq_left ht] dsimp only rw[e,qBm hxf hi htn hsx hx 0 א,qBm hxf hi htn hsx hx 1 א, qBm hxf hi htn hsx hx 2 א,qBm hxf hi htn hsx hx 3 א, qBm hxf hi htn hsx hx 4 א,qBm hxf hi htn hsx hx 5 א, qBm hxf hi htn hsx hx 6 א,qBm hxf hi htn hsx hx 7 א] rw[ih (t+1) _ _ _ _ _ _ _ _ _ _ _ א r hr,hu,List.range'_succ] unfold C_cf rw[List.foldl_cons] interval_cases r <;> rfl lemma qFn {outW q j:Nat} (hj:j< outW) (hq:q<8*outW) (h:q%outW< j+1) : q=7*outW+j∨q=6*outW+j∨q=5*outW+j∨q=4*outW+j ∨ q=3*outW+j∨q=2*outW+j∨q=1*outW+j∨q=0*outW+j ∨ q%outW< j:=by by_cases e:q%outW< j . simp only[e,or_true] . have e2:q%outW=j :=א have e3:=Nat.div_add_mod q outW have e4:q/outW<8:=Nat.div_lt_of_lt_mul (by rwa [Nat.mul_comm]) rw[e2,Nat.mul_comm] at e3 generalize q/outW=a at e3 e4 interval_cases a <;> omega section variable {inW outW:Nat} {X W b:Array Word} lemma qFd (G:C_G 8 inW outW X W b) (relu:Bool) {d:H8} (D:C_D8 X inW inW d) (k:Nat):∀ (j:Nat) (out:Array Word),j+k=outW → C_Inv (8*outW) (C_sp inW outW relu X W b) (λq=>q%outW< j) out → C_Inv (8*outW) (C_sp inW outW relu X W b) (λq=>q%outW< outW) (cols8 inW outW relu X W b d (nfOf inW) inW.toUSize j out):=by induction k with | zero => intro j out he H rw[cols8,dite_eq_right א] have e:j=outW :=א rw[e] at H; exact H | succ k ih => intro j out he H have hj:j< outW :=א have hN:=G.sO have hbs:=G.sb have hob:=G.hb have hnm:=G.nm have hin:=G.ni have sxs:8*inW<=8*2^20 :=א have e0:j.toUSize.toNat=j:=qAu _ א have eo:outW.toUSize.toNat=outW:=qAu _ א have g0:=G.wj e0 hj have hx:8*inW.toUSize.toNat<=d.xs.size:=by rw[hnm,D.1] have hsx:d.xs.size<2^32:=by rw[D.1]; omega have sW:=G.sW have hg:=g0.2 have h8:8*outW<2^32:=hN have l2:(2:USize).toNat=2:=uk 2 ב have l3:(3:USize).toNat=3:=uk 3 ב have l4:(4:USize).toNat=4:=uk 4 ב have l5:(5:USize).toNat=5:=uk 5 ב have l6:(6:USize).toNat=6:=uk 6 ב have l7:(7:USize).toNat=7:=uk 7 ב have hi0:(0:USize).toNat=8*(0:USize).toNat:=by rw[show (0:USize).toNat=0 from rfl] have key:=qG4 hx hsx sW hg (λr k=>dv X[r*inW+k]!) (λk=>W[j*inW+k]!) (λr k hr hk=>by rw[hnm] at hk; exact D.2.1 k r hk hr) (λk _=>by rw[g0.1]) inW 0 0 hi0 0 0 0 0 0 0 0 0 0 (by rw[hnm,show (0:USize).toNat=0 from rfl,Nat.zero_add]) rw[show (0:USize).toNat=0 from rfl,<-List.range_eq_range'] at key rw[cols8,dite_eq_left hj] dsimp only rw[dite_eq_left ⟨hx,hsx,sW,hg⟩] generalize go8 d.xs W (j.toUSize*inW.toUSize) inW.toUSize 0 0 hx hsx sW hg hi0 0 0 0 0 0 0 0 0 0=R at key ⊢ have O:∀ r,r<8->fin8 inW relu X W b r j (C_fs R r) (nfOf inW) R.t (C_hf d r) b[j]! inW.toUSize=C_sp inW outW relu X W b (r*outW+j):=by intro r hr rw[qDn _ _ _ _ _ _ hj] have k1:=key r hr have e1:C_fs ⟨0,0,0,0,0,0,0,0,0⟩ r=0:=by interval_cases r <;> rfl rw[e1] at k1 have H1:=D.2.2 r hr exact qF4 G relu hr hj H1.1 H1.2.1 H1.2.2 ⟨(congrArg F1.s k1 :),(congrArg F1.t k1 :)⟩ have o0:fin8 inW relu X W b 0 j R.s0 (nfOf inW) R.t d.h0 b[j]! inW.toUSize=_ := O 0 א have o1:fin8 inW relu X W b 1 j R.s1 (nfOf inW) R.t d.h1 b[j]! inW.toUSize=_ := O 1 א have o2:fin8 inW relu X W b 2 j R.s2 (nfOf inW) R.t d.h2 b[j]! inW.toUSize=_ := O 2 א have o3:fin8 inW relu X W b 3 j R.s3 (nfOf inW) R.t d.h3 b[j]! inW.toUSize=_ := O 3 א have o4:fin8 inW relu X W b 4 j R.s4 (nfOf inW) R.t d.h4 b[j]! inW.toUSize=_ := O 4 א have o5:fin8 inW relu X W b 5 j R.s5 (nfOf inW) R.t d.h5 b[j]! inW.toUSize=_ := O 5 א have o6:fin8 inW relu X W b 6 j R.s6 (nfOf inW) R.t d.h6 b[j]! inW.toUSize=_ := O 6 א have o7:fin8 inW relu X W b 7 j R.s7 (nfOf inW) R.t d.h7 b[j]! inW.toUSize=_ := O 7 א rw[qAx _ _ hbs,e0,o0,o1,o2,o3,o4,o5,o6,o7] have u0:j.toUSize.toNat=0*outW+j:=by rw[e0]; omega have u1:(outW.toUSize+j.toUSize).toNat=1*outW+j:=by rw[qAe _ _ (by rw[eo,e0]; omega),eo,e0]; omega have a2:=qBz (n:=outW.toUSize) (t:=j.toUSize) l2 (by rw[eo,e0]; omega) have a3:=qBz (n:=outW.toUSize) (t:=j.toUSize) l3 (by rw[eo,e0]; omega) have a4:=qBz (n:=outW.toUSize) (t:=j.toUSize) l4 (by rw[eo,e0]; omega) have a5:=qBz (n:=outW.toUSize) (t:=j.toUSize) l5 (by rw[eo,e0]; omega) have a6:=qBz (n:=outW.toUSize) (t:=j.toUSize) l6 (by rw[eo,e0]; omega) have a7:=qBz (n:=outW.toUSize) (t:=j.toUSize) l7 (by rw[eo,e0]; omega) rw[eo,e0] at a2 a3 a4 a5 a6 a7 have I0:=qAj h8 H u0 א rfl have I1:=qAj h8 I0 u1 א rfl have I2:=qAj h8 I1 a2 א rfl have I3:=qAj h8 I2 a3 א rfl have I4:=qAj h8 I3 a4 א rfl have I5:=qAj h8 I4 a5 א rfl have I6:=qAj h8 I5 a6 א rfl have I7:=qAj h8 I6 a7 א rfl exact ih (j+1) _ א (qB4 I7 (λq hq hq'=>qFn hj hq hq')) end lemma qEj:linF=linearSpec:=by funext rows inW outW relu X W b unfold linF split . rename_i h obtain ⟨h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11,h12,h13⟩:=h have G:C_G rows inW outW X W b:=⟨h1,h2,h3,h4,h5,h6,h7,h8,h9,h10, qBj X h7 h11,qBj W h8 h12,qBj b h9 h13⟩ have e:linearSpec rows inW outW relu X W b=Array.ofFn (n:=rows*outW) λq => C_sp inW outW relu X W b q.val:=rfl have hnf:(inW.toUInt64+8).toFloat*Float.ofBits 0x3CC0000000000000=nfOf inW:=rfl rw[e] dsimp only rw[hnf] split . rename_i hr have hr8:rows=8:=by simpa using hr subst hr8 have H0:C_Inv (8*outW) (C_sp inW outW relu X W b) (λq=>q%outW<0) (Array.replicate (8*outW) 0) := ⟨by simp,λq _ h=>absurd h (Nat.not_lt_zero _)⟩ have D0:C_D8 X inW.toUSize.toNat (0:USize).toNat ⟨FloatArray.emptyWithCapacity (8*inW),0,0,0,0,0,0,0,0⟩:=by have e0:(0:USize).toNat=0:=rfl rw[e0] refine ⟨rfl,λk r hk=>absurd hk (Nat.not_lt_zero _),λr hr=>?_⟩ have g0:good 0=true:=rfl interval_cases r <;> exact ⟨g0,λk hk=>absurd hk (Nat.not_lt_zero _),(show (0:UInt32)<=0x7FFFFFFF from by decide)⟩ have D:=qFy (n:=inW.toUSize) G.sX (by rw[G.nm]; exact G.hX.le) G.gX inW 0 _ 0 0 0 0 0 0 0 0 (by rw[G.nm,show (0:USize).toNat=0 from rfl,Nat.zero_add]) D0 rw[G.nm] at D exact qEc (qFd G relu D outW 0 _ א H0) (λq _=>Nat.mod_lt _ G.po) . have H0:C_Inv (rows*outW) (C_sp inW outW relu X W b) (λq=>q<0*outW) (Array.replicate (rows*outW) 0) := ⟨by simp,λq _ h=>by rw[Nat.zero_mul] at h; exact absurd h (Nat.not_lt_zero _)⟩ have P0:(pushZ inW.toUSize 0 (FloatArray.emptyWithCapacity inW)).size=inW:=by rw[qFc inW.toUSize inW 0 _ (by rw[G.nm,show (0:USize).toNat=0 from rfl, Nat.zero_add])] exact Nat.zero_add _ exact qEc (qFl G relu rows 0 _ _ _ א ג P0 H0) (λq hq=>hq) . rw[qBf]; rfl end lemma qDl:linF=linearSpec:=qEj @[inline] def sm (w:UInt32):Bool:=good w && (w &&& 0x7FFFFFFF)<=0x70FFFFFF @[noinline] def addSlow (relu:Bool) (x y:Word):Word := act relu (toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.add (ofW x) (ofW y))) @[inline] def addOne (relu:Bool) (nf:Float) (x y:Word):Word := if sm x && sm y then let q:=dv x*dv oneW let c:=dv y let r:=ziv ((0+q)+c) (nf*((0+q.abs)+c.abs)) if r == 0xFFFFFFFF then addSlow relu x y else act relu r else addSlow relu x y def addF (relu:Bool) (a b:Array Word):Array Word := let nf:=nfOf 1 Array.ofFn (n:=a.size) λi=>addOne relu nf a[i] b[i.val]! def gemmF (batch m k n:Nat) (A B:Array Word):Array Word := if batch == 1 && A.size == m*k && B.size == k*n && decide (0< n) && decide (0< k) && A.all finiteWord && B.all finiteWord then linF m k n false A (Array.ofFn (n:=n*k) λq=>B[(q.val%k)*n+q.val/k]!) (Array.replicate n 0x80000000) else gemmSpec batch m k n A B structure LnS where fast:Bool m:Float ir:Float em:Float den:UInt32 deriving Inhabited def lnSum (x:Array Word) (base n i:USize) (s t:Float):F1 := if h:i< n then let v:=dv (rdW x (base+i)) lnSum x base n (i+1) (s+v) (t+v.abs) else ⟨s,t⟩ termination_by n.toNat-i.toNat decreasing_by rw[usz i n h]; have:=USize.lt_iff_toNat_lt.mp h; omega def lnVar (x:Array Word) (base n i:USize) (m v:Float):Float := if h:i< n then let d:=dv (rdW x (base+i))-m lnVar x base n (i+1) m (v+d*d) else v termination_by n.toNat-i.toNat decreasing_by rw[usz i n h]; have:=USize.lt_iff_toNat_lt.mp h; omega @[inline] def invOK (a b:Float):Bool := decide ((a.toBits >>> 52)-1<1222) && decide ((((a*b-Float.ofBits 0x3FF0000000000000)+Float.ofBits 0x3CD0000000000000).toBits >>> 52)-972<2) def lnStat (n:Nat) (eps:Word) (x:Array Word) (r:Nat):LnS := let base:=(r*n).toUSize let nu:=n.toUSize let nd:=n.toUInt64.toFloat let nf:=(n.toUInt64+8).toFloat*Float.ofBits 0x3CE0000000000000 let ind:=1.0/nd let a:=lnSum x base nu 0 0 0 let m:=a.s*ind let v:=lnVar x base nu 0 m 0 let em:=(nf*a.t)*ind+Float.ofBits 0x3370000000000000 let tt:=v*ind+dv eps let d:=Float.sqrt tt let z:=ziv d ((nf+nf)*d+em) let ir:=1.0/dv z if sm z && decide ((0x1F800000:UInt32)<=z) && decide (z<=(0x70FFFFFF:UInt32)) && decide ((tt.toBits >>> 52)-1<1222) && invOK ind nd && invOK ir (dv z) then ⟨true,m,ir,em,z⟩ else ⟨false,0,0,0,sqrtRational (rowVariance n x r (rowMean n x r)+rationalWord eps)⟩ @[noinline] def lnSlow (x g b den:Word) (mean:Unit->ℚ):Word := roundRational ((rationalWord x-mean ())*rationalWord g/rationalWord den+rationalWord b) @[inline] def lnOut (s:LnS) (w gw bw:Word) (mean:Unit->ℚ):Word := if s.fast then let bv:=dv bw let gd:=dv gw*s.ir let q:=(dv w-s.m)*gd let r:=ziv (q+bv) (Float.ofBits 0x3D10000000000000*(q.abs+bv.abs)+s.em*gd.abs) if 0x7EFFFFFF<(r &&& 0x7FFFFFFF) then lnSlow w gw bw s.den mean else r else lnSlow w gw bw s.den mean def lnF (rows n:Nat) (eps:Word) (x g b:Array Word):Array Word := if stableNormDomain rows n eps x g && b.size == n && b.all finiteWord && x.all sm && g.all sm && b.all sm && sm eps && decide (n<2^20) && decide (rows*n<2^32) then let st:=Array.ofFn (n:=rows) λr=>lnStat n eps x r.val Array.ofFn (n:=rows*n) λq => lnOut st[q.val/n]! x[q.val]! g[q.val%n]! b[q.val%n]! (λ_=>rowMean n x (q.val/n)) else layernormSpec rows n eps x g b section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open FloatLib.Floats.ExecFloat.Binary lemma qC4 (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:ziv s e≠0xFFFFFFFF) : ∃ (S:Bool) (ex fr:Nat) (W:ℝ),897<=ex∧ex<1151∧fr<2^23 ∧ ziv s e=UInt32.ofNat ((if S then 2^31 else 0)+(ex-896)*2^23+fr) ∧ V=(if S then -W else W) ∧ W<(2^53+fr*2^30+2^29)*2^((ex:Int)-1076) ∧ (fr≠0->(2^53+fr*2^30-2^29)*2^((ex:Int)-1076)< W) ∧ (2^53-2^28)*2^((ex:Int)-1076)< W:=by obtain ⟨S,ex,fr,h1,h2,h3,hz,ha,hb'⟩:=qBk s e h obtain ⟨-,va,hva,hia,loa1,loa⟩:=qAm _ S ex fr h1 h2 h3 ha obtain ⟨-,vb,hvb,hib,lob1,lob⟩:=qAm _ S ex fr h1 h2 h3 hb' rw[hva] at hhi rw[hvb] at hlo refine ⟨S,ex,fr,if S then -V else V,h1,h2,h3,hz,?_,?_,?_,?_⟩ all_goals cases S all_goals simp only[Bool.false_eq_true,ite_false,ite_true,neg_neg] at hhi hlo ⊢ . exact lt_of_lt_of_le hhi hia . linarith . exact λh=>(lob1 h).trans hlo . exact λh=>by linarith [loa1 h] . exact lob.trans hlo . linarith lemma qHd (ex:Nat) (h1:897<=ex) (h2:ex<1151):((ex:Int)-1046+150).toNat=ex-896:=by omega lemma qFz (S:Bool) (ex fr m:Nat) (q:Int) (h1:897<=ex) (h2:ex<1151) (h3:fr<2^23) (hm:m≠0) (hW1:(m:ℝ)*2^q<(2^53+fr*2^30+2^29)*2^((ex:Int)-1076)) (hW2:fr≠0->(2^53+fr*2^30-2^29)*2^((ex:Int)-1076)<(m:ℝ)*2^q) (hW3:(2^53-2^28)*2^((ex:Int)-1076)<(m:ℝ)*2^q) : toWord (Model.roundDyadic Fmt ⟨S,m,q⟩) = UInt32.ofNat ((if S then 2^31 else 0)+(ex-896)*2^23+fr):=by have hE:(2:ℝ)^((ex:Int)-1046)=2^30*2^((ex:Int)-1076):=by rw[<-zpow_natCast,<-zpow_add₀ two_ne_zero] congr 1; push_cast; ring have hword:=qEe S m q (2^23+fr) ((ex:Int)-1046) hm א א א א (by rw[hE]; push_cast; linarith) (by intro hfr have hfr':fr≠0:=by intro h0; exact hfr א have:=hW2 hfr' rw[hE]; push_cast; linarith) (by intro _; rw[hE]; linarith) have e2:(2^23+fr)%2^23=fr :=א rw[hword,qHd ex h1 h2,e2] lemma qE4 (a b:ℝ) (ha:0<=a) (h:a< b) : ∃ (m:Nat) (q:Int),m≠0∧a<(m:ℝ)*2^q∧(m:ℝ)*2^q<=b:=by obtain ⟨k,hk⟩:=exists_pow_lt_of_lt_one (show 0< b-a by linarith) (show (1/2:ℝ)<1 by norm_num) have h2:(0:ℝ)<2^k:=by positivity have hk':1/(2:ℝ)^k< b-a:=by simpa [one_div,inv_pow] using hk have hb:0<=b*2^k:=by have:0<=b :=ד positivity refine ⟨⌊b*2^k⌋₊,-(k:Int),?_,?_,?_⟩ . intro h0 have h1:=Nat.lt_floor_add_one (b*2^k) rw[h0] at h1 simp only[Nat.cast_zero,zero_add] at h1 have:b*2^k*(1/2^k)<1*(1/2^k):=mul_lt_mul_of_pos_right h1 (by positivity) rw[mul_assoc,mul_one_div_cancel h2.ne',mul_one,one_mul] at this linarith . have h1:=Nat.lt_floor_add_one (b*2^k) rw[zpow_neg,zpow_natCast,<-div_eq_mul_inv,lt_div_iff₀ h2] have:a*2^k<(b-1/2^k)*2^k:=mul_lt_mul_of_pos_right ד h2 rw[sub_mul,one_div,inv_mul_cancel₀ h2.ne'] at this linarith . have h1:=Nat.floor_le hb rw[zpow_neg,zpow_natCast,<-div_eq_mul_inv,div_le_iff₀ h2] exact h1 lemma qGf (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 lemma qHb (w:UInt32) (h0:expOf w≠0) (h1:expOf w≠255):wv w≠0:=by rw[qA7 w h1] have hm:mantOf w≠0:=by have:=fracOf_toNat_lt w unfold mantOf simp[h0] have hs:sv w≠0:=by unfold sv; split <;> simp[hm] have hr:rationalWord w≠0:=by simp only[rationalWord,decodeD_toRat] exact mul_ne_zero (by exact_mod_cast hs) (zpow_ne_zero _ two_ne_zero) exact_mod_cast hr lemma qCe (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:ziv s e≠0xFFFFFFFF) (M:Model Fmt) (hf:Model.isFinite M=true) (hM:Model.toReal M=Model.roundAt Fmt V):toWord M=ziv s e:=by obtain ⟨S,ex,fr,W,h1,h2,h3,hz,hV,hW1,hW2,hW3⟩:=qC4 s e V hlo hhi h have hb0:(0:ℝ)<2^((ex:Int)-1076):=zpow_pos ב _ have hA2:(0:ℝ)<=(2^53-2^28)*2^((ex:Int)-1076) := mul_nonneg ב hb0.le obtain ⟨Lo,hLo0,hLoW,hLo1,hLo2⟩:∃ Lo:ℝ,0<=Lo∧Lo< W ∧ (fr≠0->(2^53+fr*2^30-2^29)*2^((ex:Int)-1076)<=Lo) ∧ (2^53-2^28)*2^((ex:Int)-1076)<=Lo:=by by_cases hfr:fr=0 . exact ⟨_,hA2,hW3,λh=>absurd hfr h,le_rfl⟩ . have hfr1:(1:ℝ)<=fr:=by exact_mod_cast Nat.one_le_iff_ne_zero.mpr hfr refine ⟨_,?_,hW2 hfr,λ_=>le_rfl,?_⟩ . exact mul_nonneg (by nlinarith) hb0.le . exact mul_le_mul_of_nonneg_right (by nlinarith) hb0.le have hW0:0< W:=lt_of_le_of_lt hLo0 hLoW obtain ⟨m1,q1,hm1,hd1,hd1'⟩:=qE4 Lo W hLo0 hLoW set B:ℝ:=(2^53+fr*2^30+2^29)*2^((ex:Int)-1076) with hB obtain ⟨m2,q2,hm2,hd2,hd2'⟩:=qE4 W ((W+B)/2) hW0.le ד have w1:=qFz S ex fr m1 q1 h1 h2 h3 hm1 ד (λh=>lt_of_le_of_lt (hLo1 h) hd1) (lt_of_le_of_lt hLo2 hd1) have w2:=qFz S ex fr m2 q2 h1 h2 h3 hm2 ד (λh=>by exact lt_of_le_of_lt (hLo1 h) ד) (lt_of_le_of_lt hLo2 ד) rw[hz] set z:=UInt32.ofNat ((if S then 2^31 else 0)+(ex-896)*2^23+fr) with hzd have hzn:z.toNat=(if S then 2^31 else 0)+(ex-896)*2^23+fr:=by rw[hzd,UInt32.toNat_ofNat',Nat.mod_eq_of_lt] . split <;> omega have hexp:(expOf z).toNat=ex-896:=by rw[qE8,hzn]; split <;> omega have he0:expOf z≠0:=λh=>by rw[h] at hexp; simp at hexp; omega have he1:expOf z≠255:=λh=>by rw[h] at hexp; simp at hexp; omega have r1:Model.roundDyadic Fmt ⟨S,m1,q1⟩=ofW z:=by rw[<-w1,qGf] have r2:Model.roundDyadic Fmt ⟨S,m2,q2⟩=ofW z:=by rw[<-w2,qGf] have fz:Model.isFinite (ofW z)=true:=by simp[ofW,isFinite_ofUInt32,he1] have t1:=Model.toReal_roundDyadic_eq_roundAt Fmt (by decide) ⟨S,m1,q1⟩ (by rw[r1]; exact fz) have t2:=Model.toReal_roundDyadic_eq_roundAt Fmt (by decide) ⟨S,m2,q2⟩ (by rw[r2]; exact fz) rw[r1] at t1 rw[r2] at t2 have hv:Model.toReal (ofW z)=Model.roundAt Fmt V:=by apply le_antisymm . cases S . rw[t1]; apply Model.roundAt_mono; simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand,hV]; linarith . rw[t2]; apply Model.roundAt_mono; simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand,hV]; linarith . cases S . rw[t2]; apply Model.roundAt_mono; simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand,hV]; linarith . rw[t1]; apply Model.roundAt_mono; simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand,hV]; linarith have hnz:Model.toReal M≠0:=by rw[hM,<-hv] exact qHb z he0 he1 have:=Model.eq_of_toReal_eq_of_nonzero hf fz (hM.trans hv.symm) hnz rw[this] have hr:toWord (ofW z)=z:=by rw[<-r1,w1] exact hr lemma qGh:(2:ℝ)^(127:ℤ)<=Model.toReal (Model.posMaxFinite Fmt):=by rw[Model.toReal_posMaxFinite] have h1:Model.pow2 Fmt.fracWidth+Fmt.maxFiniteFracField=2^24-1:=by decide +kernel have h2:Fmt.maxNormalExponent-Int.ofNat Fmt.fracWidth=104:=by decide +kernel rw[h1,h2] have h3:Model.bpow 104=(2:ℝ)^(104:ℤ):=by simp only[Model.bpow,qAs] rw[h3,show (127:ℤ)=23+104 from rfl,zpow_add₀ ב] apply mul_le_mul_of_nonneg_right _ (by positivity) norm_num lemma qHn (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:ziv s e≠0xFFFFFFFF):V≠0:=by obtain ⟨S,ex,fr,W,-,-,-,-,hV,-,-,hW3⟩:=qC4 s e V hlo hhi h have hb0:(0:ℝ)<2^((ex:Int)-1076):=zpow_pos ב _ have hA:(0:ℝ)<=(2^53-2^28)*2^((ex:Int)-1076):=mul_nonneg ב hb0.le intro h0 rw[h0] at hV cases S . simp only[Bool.false_eq_true,ite_false] at hV; linarith . simp only[ite_true] at hV; linarith lemma qE2 (q:ℚ) : Model.signedScaledRatToReal (decide (q<0)) q.num.natAbs q.den 0=(q:ℝ):=by have hd:(q.den:ℝ)≠0:=by exact_mod_cast q.den_nz rw[Model.signedScaledRatToReal,Model.scaledRatToReal] by_cases hq:q<0 . have hn:q.num<0:=Rat.num_neg.mpr hq have:((q.num.natAbs:ℕ):ℝ)=-(q.num:ℝ):=by rw[Nat.cast_natAbs,abs_of_neg hn]; push_cast; rfl simp[hq,this,Rat.cast_def] ring . have hn:0<=q.num:=Rat.num_nonneg.mpr (not_lt.1 hq) have:((q.num.natAbs:ℕ):ℝ)=(q.num:ℝ):=by rw[Nat.cast_natAbs,abs_of_nonneg hn] simp[hq,this,Rat.cast_def] lemma qGo (s e:Float) (q:ℚ) (hlo:R (s-e)<(q:ℝ)) (hhi:(q:ℝ)< R (s+e)) (h:ziv s e≠0xFFFFFFFF) (hb : |(q:ℝ)| ≤ 2^(127:ℤ)):roundRational q=ziv s e:=by have hq0:(q:ℝ)≠0:=qHn s e q hlo hhi h have hq:q≠0:=λh0=>hq0 (by rw[h0]; simp) have hnum:q.num.natAbs≠0:=by simpa using hq have hden:q.den≠0:=q.den_nz have hf:Model.isFinite (Model.roundRatScaled Fmt (decide (q<0)) q.num.natAbs q.den 0)=true := Model.isFinite_roundRatScaled_of_abs_le_posMaxFinite Fmt _ _ _ 0 (by decide) hden (by rw[qE2]; exact hb.trans qGh) have hM:=Model.toReal_roundRatScaled_eq_roundAt Fmt (decide (q<0)) _ _ 0 (by decide) hnum hden hf rw[qE2] at hM exact qCe s e q hlo hhi h _ hf hM lemma qG0 (N d:Nat) (x:Int) (hr:sqrtLower N d≠0) (hd:0< d) (hs:x<=(FloatFormat.toModel Fmt).targetExponent (Float.Model.totalExponent (sqrtLower N d) x)) (hb:Real.sqrt ((N:ℝ)/d)*FloatLib.Floats.Formats.Flocq.bpow FloatLib.Numerics.binaryRadix x < 2^(127:ℤ)) : Model.isFinite (Model.ofModel Fmt (Float.Model.UnpackedFloat.roundWithAccuracy (FloatFormat.toModel Fmt) .positive (sqrtLower N d) x (sqrtAccuracy N d)))=true:=by refine Model.isFinite_ofModel_roundWithAccuracy_of_lt_bpow Fmt rfl .positive _ _ _ (Real.sqrt ((N:ℝ)/d)) hr (sqrtAccuracy_correct N d hd) hs ?_ have h7:FloatFormat.ieeeMaxNormalExponent Fmt=127:=rfl rw[h7,qAs] exact hb lemma qHk (q:ℚ) (hq:0< q) (hb:Real.sqrt (q:ℝ)<2^(127:ℤ)) : Model.isFinite (sqrtModel q)=true := qG0 _ _ _ (ne_of_gt (sqrtRoot_pos q hq)) q.pos (sqrtStep_le_target q) (by rw[sqrtScale_correct q hq]; exact hb) lemma qGj (s e:Float) (q:ℚ) (hq:0< q) (hlo:R (s-e)< Real.sqrt (q:ℝ)) (hhi:Real.sqrt (q:ℝ)< R (s+e)) (h:ziv s e≠0xFFFFFFFF) (hb:Real.sqrt (q:ℝ)<2^(127:ℤ)):sqrtRational q=ziv s e:=by have hf:=qHk q hq hb have hs:sqrtRational q=toWord (sqrtModel q):=if_neg (not_le.2 hq) rw[hs] exact qCe s e _ hlo hhi h _ hf (sqrtModel_correct q hq hf) lemma qE3 (x:UInt64):(x >>> 52).toNat=x.toNat/2^52:=by rw[UInt64.toNat_shiftRight,Nat.shiftRight_eq_div_pow]; rfl lemma qD0 (x k N:UInt64) (h:x-k< N) (hN:k.toNat+N.toNat<2^64) : k.toNat<=x.toNat∧x.toNat< k.toNat+N.toNat:=by have h1:=UInt64.lt_iff_toNat_lt.mp h rw[UInt64.toNat_sub] at h1 have h2:=x.toNat_lt have h3:=k.toNat_lt omega lemma qCs (f:Float) (E:Nat) (hE1:1<=E) (hE:E<2047) (h:(f.toBits >>> 52).toNat=E) : f.isFinite=true∧(2:ℝ)^((E:ℤ)-1023)<=R f∧R f<2^((E:ℤ)-1022):=by rw[qE3] at h have hM:f.toBits.toNat=E*2^52+f.toBits.toNat%2^52 :=א have hF:=Nat.mod_lt f.toBits.toNat (by norm_num:0<2^52) generalize f.toBits.toNat%2^52=F at hM hF obtain ⟨h1,h2⟩:=B_R f false E F hE1 hE hF (by simpa using hM) have hb:(0:ℝ)<2^((E:ℤ)-1075):=zpow_pos ב _ have e1:(2:ℝ)^((E:ℤ)-1023)=2^52*2^((E:ℤ)-1075):=by rw[show (E:ℤ)-1023=52+((E:ℤ)-1075) by ring,zpow_add₀ two_ne_zero]; norm_num have e2:(2:ℝ)^((E:ℤ)-1022)=2^53*2^((E:ℤ)-1075):=by rw[show (E:ℤ)-1022=53+((E:ℤ)-1075) by ring,zpow_add₀ two_ne_zero]; norm_num have hF0:(0:ℝ)<=F:=Nat.cast_nonneg _ have hF1:(F:ℝ)<=2^52:=by exact_mod_cast hF.le have hF2:(F:ℝ)<2^52:=by exact_mod_cast hF refine ⟨h1,?_,?_⟩ . rw[h2,e1]; simp only[Bool.false_eq_true,ite_false,one_mul]; push_cast exact mul_le_mul_of_nonneg_right ד hb.le . rw[h2,e2]; simp only[Bool.false_eq_true,ite_false,one_mul]; push_cast exact mul_lt_mul_of_pos_right ד hb lemma L_k (c:UInt64) (E:Nat) (hE1:1<=E) (hE:E<2047) (h:(Float.ofBits c).toBits.toNat=E*2^52) : (Float.ofBits c).isFinite=true∧R (Float.ofBits c)=2^((E:ℤ)-1023):=by obtain ⟨h1,h2⟩:=B_R (Float.ofBits c) false E 0 hE1 hE ב (by simpa using h) refine ⟨h1,?_⟩ rw[h2,show (E:ℤ)-1023=52+((E:ℤ)-1075) by ring,zpow_add₀ two_ne_zero] norm_num lemma qHp:(Float.ofBits 0x3FF0000000000000).isFinite=true ∧ R (Float.ofBits 0x3FF0000000000000)=1:=by have:=L_k 0x3FF0000000000000 1023 ב ב (by rfl) simpa using this lemma qGv:(Float.ofBits 0x3CD0000000000000).isFinite=true ∧ R (Float.ofBits 0x3CD0000000000000)=1/2^50:=by have:=L_k 0x3CD0000000000000 973 ב ב (by rfl) refine ⟨this.1,this.2.trans ב⟩ lemma qG8:(Float.ofBits 0x3D10000000000000).isFinite=true ∧ R (Float.ofBits 0x3D10000000000000)=1/2^46:=by have:=L_k 0x3D10000000000000 977 ב ב (by rfl) refine ⟨this.1,this.2.trans ב⟩ lemma qGn:(Float.ofBits 0x3CE0000000000000).isFinite=true ∧ R (Float.ofBits 0x3CE0000000000000)=1/2^49:=by have:=L_k 0x3CE0000000000000 974 ב ב (by rfl) refine ⟨this.1,this.2.trans ב⟩ lemma qFp:(Float.ofBits 0x3370000000000000).isFinite=true ∧ R (Float.ofBits 0x3370000000000000)=1/2^200:=by have:=L_k 0x3370000000000000 823 ב ב (by rfl) refine ⟨this.1,this.2.trans ב⟩ lemma qFh (f:Float) (E:Nat) (hE1:1<=E) (hE:E<2047) (h:(f.toBits >>> 52).toNat=E) : (Float.sqrt f).isFinite=true∧0< R f ∧ |R (Float.sqrt f)-Real.sqrt (R f)| ≤ 1/2^53*(Real.sqrt (R f)+A_z):=by obtain ⟨hf,hl,-⟩:=qCs f E hE1 hE h have hp:0< R f:=lt_of_lt_of_le (zpow_pos ב _) hl rw[qE3] at h have hs:Model.signBit (toModel (ofFloat f))=false:=by rw[qE0]; simp only[decide_eq_false_iff_not,not_le]; omega have hm:toModel (ofFloat f)=A_M f:=toModel_ofFloat f have hfm:Model.isFinite (A_M f)=true:=by rw[qAc,hf] rw[hm] at hs have hr:=Model.toReal_sqrt_eq_roundAt (A_M f) (by decide) hfm (Or.inr hs) have hq:=Model.isFinite_sqrt_of_isFinite (A_M f) (by decide) hfm (Or.inr hs) have hd:A_M (Float.sqrt f)=Model.canonicalizeModel (Model.sqrt (A_M f)):=by have h3:=toModel_ofFloat_sqrt f rw[hm,toModel_ofFloat] at h3 exact h3 have ht:Model.toModel (A_M (Float.sqrt f))=Model.toModel (Model.sqrt (A_M f)):=by rw[hd,Model.toModel_canonicalizeModel] have hR:R (Float.sqrt f)=Model.roundAt FloatFormat.binary64 (Real.sqrt (R f)):=by rw[A_R,Model.toReal_eq_unpackedToReal_toModel qAi,ht,<-Model.toReal_eq_unpackedToReal_toModel qAi] exact hr refine ⟨?_,hp,?_⟩ . rw[<-qAc,qAz,ht,<-qAz]; exact hq . rw[hR] have:=qCr (Real.sqrt (R f)) rwa [abs_of_nonneg (Real.sqrt_nonneg _)] at this lemma qAa (x y:ℝ) : |x| ≤ |y| + |x-y|:=by have:=abs_sub_abs_le_abs_sub x y; linarith lemma qA2:A_B=2^256*2^44:=by unfold A_B rw[show (300:ℤ)=256+44 from rfl,zpow_add₀ ב] norm_num lemma qDx (P rp rs rc z:ℝ) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (h1 : |rp-P| ≤ 1/2^53*(|P| + z)) (h2 : |rs-(rp-1)| ≤ 1/2^53*(|rp-1| + z)) (h3 : |rc-(rs+1/2^50)| ≤ 1/2^53*(|rs+1/2^50| + z)) (lo:1/2^51<=rc) (hi:rc<=1/2^49) : |P-1| ≤ 1/2^48:=by have hz1:z<=1/2^240:=le_trans hz ב have a1:=qAa (rs+1/2^50) rc rw[abs_sub_comm (rs+1/2^50) rc] at a1 have a2 : |rc| = rc:=abs_of_nonneg (le_trans ב lo) obtain ⟨c1,c2⟩:=abs_le.mp h3 have a3 : |rs| ≤ 1/2^49:=by rw[abs_le]; constructor <;> linarith [abs_nonneg (rs+1/2^50)] have b1:=qAa (rp-1) rs rw[abs_sub_comm (rp-1) rs] at b1 have b2 : |rp-1| ≤ 1/2^48:=by linarith [abs_nonneg (rp-1)] have c3:=qAa (P-1) (rp-1) have e:P-1-(rp-1)=-(rp-P):=by ring rw[e,abs_neg] at c3 have c4 : |P| ≤ 1 + |P-1|:=by have:=qAa P 1 rw[abs_one] at this; exact this linarith [abs_nonneg (P-1)] lemma qE6 (a b:Float) (hb:b.isFinite=true) (hb2 : |R b| ≤ 2^99) (h:invOK a b=true) : a.isFinite=true∧0< R a∧R a<=2^200∧|R a*R b-1| ≤ 1/2^48:=by unfold invOK at h simp only[Bool.and_eq_true,decide_eq_true_eq] at h obtain ⟨h1,h2⟩:=h obtain ⟨r1,r2⟩:=qD0 _ 1 1222 h1 (by decide) obtain ⟨r3,r4⟩:=qD0 _ 972 2 h2 (by decide) have e1:(1:UInt64).toNat=1:=rfl have e2:(1222:UInt64).toNat=1222:=rfl have e3:(972:UInt64).toNat=972:=rfl have e4:(2:UInt64).toNat=2:=rfl rw[e1] at r1 rw[e1,e2] at r2 rw[e3] at r3 rw[e3,e4] at r4 obtain ⟨f1,l1,u1⟩:=qCs a _ r1 א rfl have hp:0< R a:=lt_of_lt_of_le (zpow_pos ב _) l1 have ha2:R a<=2^200:=by refine u1.le.trans ?_ have:(2:ℝ)^(200:ℕ)=2^(200:ℤ) :=ב rw[this] exact zpow_le_zpow_right₀ ב א obtain ⟨k1,k2⟩:=qHp obtain ⟨k3,k4⟩:=qGv have hz0:=qBi.le have hzl:=qAl have hAB:=qA2 have nA : |R a| ≤ A_B:=by rw[abs_of_pos hp,hAB]; refine ha2.trans ב have nB : |R b| ≤ A_B:=by rw[hAB]; refine hb2.trans ב have hP : |R a*R b| ≤ 2^200*2^99:=by rw[abs_mul,abs_of_pos hp] exact mul_le_mul ha2 hb2 (abs_nonneg _) (by positivity) obtain ⟨f2,g1⟩:=qBq a b f1 hb nA nB have q1:=qAa (R (a*b)) (R a*R b) have nC : |R (a*b)| ≤ A_B:=by rw[hAB]; norm_num at hP q1 g1 hzl ⊢; linarith have nO : |R (Float.ofBits 0x3FF0000000000000)| ≤ A_B:=by rw[k2,hAB]; norm_num obtain ⟨f3,g2⟩:=qC2 _ _ f2 k1 nC nO rw[k2] at g2 have q2:=qAa (R (a*b-Float.ofBits 0x3FF0000000000000)) (R (a*b)-1) have q3:=abs_sub (R (a*b)) 1 rw[abs_one] at q3 have nD : |R (a*b-Float.ofBits 0x3FF0000000000000)| ≤ A_B:=by rw[hAB]; norm_num at hP q1 g1 q2 q3 g2 hzl ⊢; linarith have nH : |R (Float.ofBits 0x3CD0000000000000)| ≤ A_B:=by rw[k4,hAB]; norm_num obtain ⟨f4,g3⟩:=qBn _ _ f3 k3 nD nH rw[k4] at g3 obtain ⟨-,l2,u2⟩:=qCs (a*b-Float.ofBits 0x3FF0000000000000+Float.ofBits 0x3CD0000000000000) _ א א rfl refine ⟨f1,hp,ha2,?_⟩ refine qDx _ _ _ _ _ hz0 hzl g1 g2 g3 ?_ ?_ . refine le_trans ?_ l2 have:(1/2^51:ℝ)=2^(-51:ℤ) :=ב rw[this] exact zpow_le_zpow_right₀ ב א . refine u2.le.trans ?_ have:(1/2^49:ℝ)=2^(-49:ℤ) :=ב rw[this] exact zpow_le_zpow_right₀ ב א lemma qHm (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:¬ (0x7EFFFFFF:UInt32)<(ziv s e &&& 0x7FFFFFFF)) : ziv s e≠0xFFFFFFFF∧|V| ≤ 2^(127:ℤ):=by have h0:ziv s e≠0xFFFFFFFF:=by intro e0; rw[e0] at h; exact h (by decide) refine ⟨h0,?_⟩ obtain ⟨S,ex,fr,W,h1,h2,h3,hz,hV,hW1,-,hW3⟩:=qC4 s e V hlo hhi h0 have hb:(0:ℝ)<2^((ex:Int)-1076):=zpow_pos ב _ have hW0:0< W:=lt_trans (mul_pos ב hb) hW3 have hN:((if S then 2^31 else 0)+(ex-896)*2^23+fr)<2^32:=by split <;> omega have hex:ex<=1149:=by by_contra hc apply h apply UInt32.lt_iff_toNat_lt.mpr rw[qBh,hz,UInt32.toNat_ofNat_of_lt' hN] have e:ex=1150 :=א subst e show 2130706431< _ split <;> omega have hF:(fr:ℝ)<=2^23-1:=by have:fr+1<=2^23 :=א have h':((fr+1:ℕ):ℝ)<=((2^23:ℕ):ℝ):=by exact_mod_cast this push_cast at h'; linarith have hz1:(2:ℝ)^((ex:Int)-1076)<=2^(73:ℤ) := zpow_le_zpow_right₀ ב א have hW:W<=2^(127:ℤ):=by have e:(2:ℝ)^(127:ℤ)=2^54*2^(73:ℤ):=by rw[show (127:ℤ)=54+73 from rfl,zpow_add₀ ב]; norm_num rw[e] refine hW1.le.trans (mul_le_mul ?_ hz1 hb.le (by positivity)) have:(fr:ℝ)*2^30<=(2^23-1)*2^30:=by gcongr norm_num at this ⊢; linarith rw[hV] split . rw[abs_neg,abs_of_pos hW0]; exact hW . rw[abs_of_pos hW0]; exact hW lemma qGi (a Mr Rm Em g D b I RA Rg Rq RY RE Rsa Rcs Reg Hi Lo z:ℝ) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (hE0:0<=Em) (hE1:Em<=2^120) (hM:2 * |Mr-Rm| ≤ Em) (hD:1/2^64<=D) (ha : |a| ≤ 2^99) (hg : |g| ≤ 2^99) (hm : |Rm| ≤ 2^110) (h1 : |RA-(a-Rm)| ≤ 1/2^53*(|a-Rm| + z)) (h2 : |I*D-1| ≤ 1/2^48) (h3 : |Rg-g*I| ≤ 1/2^53*(|g*I| + z)) (h4 : |Rq-RA*Rg| ≤ 1/2^53*(|RA*Rg| + z)) (h5 : |RY-(Rq+b)| ≤ 1/2^53*(|Rq+b| + z)) (h6 : |Rsa-(|Rq| + |b|)| ≤ 1/2^53*(|(|Rq| + |b|)| + z)) (h7 : |Rcs-1/2^46*Rsa| ≤ 1/2^53*(|1/2^46*Rsa| + z)) (h8 : |Reg-Em*(|Rg|)| ≤ 1/2^53*(|Em*(|Rg|)| + z)) (h9 : |RE-(Rcs+Reg)| ≤ 1/2^53*(|Rcs+Reg| + z)) (h10 : |Hi-(RY+RE)| ≤ 1/2^53*(|RY+RE| + z)) (h11 : |Lo-(RY-RE)| ≤ 1/2^53*(|RY-RE| + z)) (hbig:1/2^127 ≤ |Hi|) : Lo<(a-Mr)*g/D+b∧(a-Mr)*g/D+b< Hi:=by have hDp:0< D:=lt_of_lt_of_le (by positivity) hD obtain ⟨G,hG⟩:∃ G,G=g/D:=⟨_,rfl⟩ obtain ⟨X,hX⟩:∃ X,X=a-Rm:=⟨_,rfl⟩ have hV:(a-Mr)*g/D+b=X*G+(Rm-Mr)*G+b:=by rw[hG,hX]; field_simp; ring rw[hV] have hGb : |G| ≤ 2^163:=by rw[hG,abs_div,abs_of_pos hDp,div_le_iff₀ hDp] calc |g| ≤ 2^99:=hg _=2^163*(1/2^64) :=ב _<=2^163*D:=by gcongr have hXb : |X| ≤ 2^111:=by have h:=qAa a Rm have h':=qAa X a have e:X-a=-Rm:=by rw[hX]; ring rw[e,abs_neg] at h' linarith rw[<-hX] at h1 have hgI : |g*I-G| ≤ 1/2^48 * |G|:=by have e:g*I-G=G*(I*D-1):=by rw[hG]; field_simp rw[e,abs_mul,mul_comm] exact mul_le_mul_of_nonneg_right h2 (abs_nonneg _) obtain ⟨Y,hY⟩:∃ Y,Y=g*I:=⟨_,rfl⟩ rw[<-hY] at h3 hgI clear hV hG hX hY hDp hD ha hg hm h2 have hz1:z<=1/2^240:=le_trans hz ב have hz2:z*2^165<=1/2^235:=by calc z*2^165<=1/2^200*(1/2^200)*2^165:=by gcongr _=_ :=ב have nX:=abs_nonneg X have nG:=abs_nonneg G have nA:=abs_nonneg RA have nR:=abs_nonneg Rg have a1:=qAa X RA rw[abs_sub_comm X RA] at a1 have a3 : |X| ≤ (1+2/2^53) * |RA| + 2/2^53*z :=ד have a4 : |X-RA| ≤ 2/2^53 * |RA| + 2/2^53*z:=by rw[abs_sub_comm]; linarith have a5 : |RA| ≤ 2^165:=by have:=qAa RA X; linarith have b1:=qAa Y G have b2:=qAa G Rg have b3 : |G-Rg| ≤ |Rg-Y| + |Y-G|:=by have e:G-Rg=-((Rg-Y)+(Y-G)):=by ring rw[e,abs_neg]; exact abs_add_le _ _ have b4 : |G| ≤ (1+1/2^47) * |Rg| + 2/2^53*z :=ד have b5 : |G-Rg| ≤ 2/2^48 * |Rg| + 2/2^53*z :=ד have c1 : |Rg| ≤ 2^165:=by have:=qAa Rg G; rw[abs_sub_comm] at this; linarith have f1 : |X*G-RA*Rg| ≤ |X-RA| * |G| + |RA| * |G-Rg|:=by have e:X*G-RA*Rg=(X-RA)*G+RA*(G-Rg):=by ring rw[e] calc _ ≤ |(X-RA)*G| + |RA*(G-Rg)|:=abs_add_le _ _ _=_:=by rw[abs_mul,abs_mul] have f2 : |X-RA| * |G| ≤ (2/2^53 * |RA| + 2/2^53*z)*((1+1/2^47) * |Rg| + 2/2^53*z) := mul_le_mul a4 b4 nG ד have f3 : |RA| * |G-Rg| ≤ |RA| * (2/2^48 * |Rg| + 2/2^53*z) := mul_le_mul_of_nonneg_left b5 nA have zr:z * |RA| ≤ z*2^165:=mul_le_mul_of_nonneg_left a5 hz0 have zg:z * |Rg| ≤ z*2^165:=mul_le_mul_of_nonneg_left c1 hz0 have zz:z*z<=z*2^165:=mul_le_mul_of_nonneg_left ד hz0 have ze:z*Em<=z*2^165:=mul_le_mul_of_nonneg_left ד hz0 have nzr:=mul_nonneg hz0 nA have nzg:=mul_nonneg hz0 nR have nzz:=mul_nonneg hz0 hz0 have nP:=mul_nonneg nA nR have f4 : |X*G-RA*Rg| ≤ 9/2^50*(|RA| * |Rg|)+1/2^230:=by have e:(2/2^53 * |RA| + 2/2^53*z)*((1+1/2^47) * |Rg| + 2/2^53*z) + |RA| * (2/2^48 * |Rg| + 2/2^53*z) = (2/2^53*(1+1/2^47)+2/2^48)*(|RA| * |Rg|) + (4/2^106+2/2^53)*(z * |RA|)+(2/2^53*(1+1/2^47))*(z * |Rg|) + 4/2^106*(z*z):=by ring linarith have p1 : |RA*Rg| ≤ (1+2/2^53) * |Rq| + 2/2^53*z:=by have:=qAa (RA*Rg) Rq rw[abs_sub_comm (RA*Rg) Rq] at this have nq:=abs_nonneg (RA*Rg) linarith rw[<-abs_mul] at f4 have q1 : |X*G-Rq| ≤ 5/2^49 * |Rq| + 1/2^229:=by have e:X*G-Rq=(X*G-RA*Rg)-(Rq-RA*Rg):=by ring have:=abs_sub (X*G-RA*Rg) (Rq-RA*Rg) rw[<-e] at this have nq:=abs_nonneg Rq linarith obtain ⟨T,hT⟩:∃ T,T=Em * |Rg|:=⟨_,rfl⟩ have nT:0<=T:=by rw[hT]; exact mul_nonneg hE0 nR have e1 : |(Rm-Mr)*G| ≤ 5/2^3*T+1/2^230:=by rw[abs_mul,abs_sub_comm] have h : |Mr-Rm| * |G| ≤ (Em/2)*((1+1/2^47) * |Rg| + 2/2^53*z) := mul_le_mul ד b4 nG ד have e:(Em/2)*((1+1/2^47) * |Rg| + 2/2^53*z) = (1+1/2^47)/2*(Em * |Rg|)+1/2^53*(z*Em):=by ring rw[<-hT] at e have:=mul_nonneg hz0 hE0 linarith rw[<-hT] at h8 rw[abs_of_nonneg nT] at h8 have nq:=abs_nonneg Rq have nb:=abs_nonneg b have nS:0 ≤ |Rq| + |b| :=ד rw[abs_of_nonneg nS] at h6 have s0 : |Rq+b| ≤ |Rq| + |b|:=abs_add_le _ _ have s1 : |Rsa| ≤ 2*(|Rq| + |b|)+z:=by have:=qAa Rsa (|Rq| + |b|); rw[abs_of_nonneg nS] at this; linarith have h7' : |1/2^46*Rsa| = 1/2^46 * |Rsa|:=by rw[abs_mul,abs_of_pos (by positivity:(0:ℝ)<1/2^46)] rw[h7'] at h7 have s2 : |Rcs| ≤ 1/2^44*(|Rq| + |b|)+z:=by have:=qAa Rcs (1/2^46*Rsa); rw[h7'] at this; linarith have s3 : |Reg| ≤ 2*T+z:=by have:=qAa Reg T; rw[abs_of_nonneg nT] at this; linarith have s4 : |RY| ≤ 2*(|Rq| + |b|)+z:=by have:=qAa RY (Rq+b); linarith have s5 : |Rcs+Reg| ≤ |Rcs| + |Reg|:=abs_add_le _ _ have s6 : |RE| ≤ 1/2^43*(|Rq| + |b|)+4*T+4*z:=by have:=qAa RE (Rcs+Reg); linarith have s7 : |RY+RE| ≤ |RY| + |RE|:=abs_add_le _ _ have s8 : |RY-RE| ≤ |RY| + |RE|:=abs_sub _ _ have big:1/2^130 ≤ |Rq| + |b| + T:=by have:=qAa Hi (RY+RE); linarith obtain ⟨u1,u2⟩:=abs_le.mp q1 obtain ⟨v1,v2⟩:=abs_le.mp e1 obtain ⟨w1,w2⟩:=abs_le.mp h5 obtain ⟨x1,x2⟩:=abs_le.mp h6 obtain ⟨y1,y2⟩:=abs_le.mp h7 obtain ⟨z1,z2⟩:=abs_le.mp h8 obtain ⟨o1,o2⟩:=abs_le.mp h9 obtain ⟨r1,r2⟩:=abs_le.mp h10 obtain ⟨t1,t2⟩:=abs_le.mp h11 constructor <;> linarith lemma qGb (n r Sb Rs Rt I Rm N Y Em c z:ℝ) (hn1:1<=n) (hn2:n<=2^20) (hc:c=(n+8)/2^49) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (hr : |r| ≤ Sb) (hS:Sb<=2^99) (h1 : |Rs-n*r| ≤ 2*n*(1/2^53*(n*Sb+z))) (h2 : |Rt-n*Sb| ≤ 2*n*(1/2^53*(n*Sb+z))) (h3:0< I) (h4 : |I*n-1| ≤ 1/2^48) (h5 : |Rm-Rs*I| ≤ 1/2^53*(|Rs*I| + z)) (h6 : |N-c*Rt| ≤ 1/2^53*(|c*Rt| + z)) (h7 : |Y-N*I| ≤ 1/2^53*(|N*I| + z)) (h8 : |Em-(Y+1/2^200)| ≤ 1/2^53*(|Y+1/2^200| + z)) : 2 * |r-Rm| ≤ Em∧Em<=2^120∧1/2^201<=Em∧|Rm| ≤ 2^110:=by have hS0:0<=Sb:=le_trans (abs_nonneg _) hr have nS:0<=n*Sb:=mul_nonneg ד hS0 have nSb:n*Sb<=2^20*2^99:=mul_le_mul hn2 hS hS0 ב have hz1:z<=1/2^240:=le_trans hz ב obtain ⟨W,hW⟩:∃ W,W=n*Sb+z:=⟨_,rfl⟩ have nW:0<=W :=ד rw[<-hW] at h1 h2 obtain ⟨j1,j2⟩:=abs_le.mp h4 have hIn1:I*n<=1+1/2^48 :=ד have hI2:I<=2:=by have:I*1<=I*n:=mul_le_mul_of_nonneg_left hn1 h3.le linarith obtain ⟨E,hE⟩:∃ E,E=201/100/2^53*W+Sb/2^48:=⟨_,rfl⟩ have key:∀ v t:ℝ,|t| ≤ Sb->|v-n*t| ≤ 2*n*(1/2^53*W)->|v*I-t| ≤ E:=by intro v t ht hv have e:v*I-t=(v-n*t)*I+t*(I*n-1):=by ring have a1 : |(v-n*t)*I| ≤ 2*(1/2^53*W)*(I*n):=by rw[abs_mul,abs_of_pos h3] calc _<=(2*n*(1/2^53*W))*I:=mul_le_mul_of_nonneg_right hv h3.le _=_:=by ring have a2:2*(1/2^53*W)*(I*n)<=2*(1/2^53*W)*(1+1/2^48) := mul_le_mul_of_nonneg_left hIn1 ד have a3 : |t*(I*n-1)| ≤ Sb*(1/2^48):=by rw[abs_mul]; exact mul_le_mul ht h4 (abs_nonneg _) hS0 have a4:=abs_add_le ((v-n*t)*I) (t*(I*n-1)) rw[e,hE] linarith have hr1:=key Rs r hr h1 have hA1:=key Rt Sb (by rw[abs_of_nonneg hS0]) h2 obtain ⟨A,hA⟩:∃ A,A=Rt*I:=⟨_,rfl⟩ rw[<-hA] at hA1 have hE0:0<=E:=by rw[hE]; positivity have hEb:E<=2^80:=by rw[hE]; norm_num at nSb hS hz1 ⊢; linarith have hc0:0<=c:=by rw[hc]; positivity have hc1:c<=1/2^28:=by rw[hc]; norm_num at hn2 ⊢; linarith have b0:=qAa A Sb rw[abs_of_nonneg hS0] at b0 have b1 : |N*I-c*A| ≤ 1/2^53*(|c*A| + 2*z):=by have e:N*I-c*A=(N-c*Rt)*I:=by rw[hA]; ring rw[e,abs_mul,abs_of_pos h3] have e2 : |c*Rt| * I = |c*A|:=by rw[hA,abs_mul,abs_mul,abs_mul,abs_of_pos h3]; ring calc _<=(1/2^53*(|c*Rt| + z))*I:=mul_le_mul_of_nonneg_right h6 h3.le _=1/2^53*(|c*Rt| * I+z*I):=by ring _<=_:=by rw[e2] have:z*I<=z*2:=mul_le_mul_of_nonneg_left hI2 hz0 linarith have b2 : |c*A| ≤ 1/2^28*(Sb+E):=by rw[abs_mul,abs_of_nonneg hc0] exact mul_le_mul hc1 ד (abs_nonneg _) ב have b3:c*Sb-1/2^28*E<=c*A:=by have h9 : |c*(A-Sb)| ≤ 1/2^28*E:=by rw[abs_mul,abs_of_nonneg hc0] exact mul_le_mul hc1 hA1 (abs_nonneg _) ב have:=(abs_le.mp h9).1 have e:c*(A-Sb)=c*A-c*Sb:=by ring linarith have b4:c*Sb=(n*Sb+8*Sb)/2^49:=by rw[hc]; ring have c1:=qAa (N*I) (c*A) have c2:=qAa Y (N*I) have c3:=abs_add_le Y (1/2^200) rw[abs_of_pos (by norm_num:(0:ℝ)<1/2^200)] at c3 have d1:=qAa Rm (Rs*I) have d2:=qAa (Rs*I) r have d3 : |r-Rm| ≤ |Rm-Rs*I| + |Rs*I-r|:=by have e:r-Rm=-((Rm-Rs*I)+(Rs*I-r)):=by ring rw[e,abs_neg]; exact abs_add_le _ _ obtain ⟨e1,e2⟩:=abs_le.mp b1 obtain ⟨e3,e4⟩:=abs_le.mp h7 obtain ⟨e5,e6⟩:=abs_le.mp h8 rw[hE] at hr1 subst hW rw[hE] at b2 b3 hEb have ha:=abs_nonneg r have g1:=le_abs_self (c*A) refine ⟨?_,?_,?_,?_⟩ . linarith . norm_num at nSb hS hz1 hr ⊢; linarith . norm_num at nSb hS hz1 hr ⊢; linarith . norm_num at nSb hS hz1 hr ⊢; linarith lemma qF6 (T s c Em lo hi:ℝ) (hT:0< T) (hs:0< s) (hc0:0< c) (hc1:c<=1/2^20) (hE:0<=Em) (h1:T<=s^2*(1+c)) (h2:s^2*(1-c)-Em^2/4<=T) (h3:s*(1+3/2*c)+9/10*Em<=hi) (h4:lo<=s*(1-3/2*c)-9/10*Em) : lo< Real.sqrt T∧Real.sqrt T< hi:=by have hsT:=Real.sqrt_pos.mpr hT have hq:0< s^2*c:=by positivity constructor . by_cases hl:lo<0 . linarith . rw[not_lt] at hl rw[Real.lt_sqrt hl] obtain ⟨k,hk⟩:∃ k,k=s*(1-3/2*c):=⟨_,rfl⟩ rw[<-hk] at h4 have hk0:0<=k-9/10*Em :=ד have q1:lo^2<=(k-9/10*Em)^2:=pow_le_pow_left₀ hl h4 2 have q2:(k-9/10*Em)^2=k^2-9/5*(Em*(k-9/10*Em))-81/100*Em^2:=by ring have q3:0<=Em*(k-9/10*Em):=mul_nonneg hE hk0 have q4:k^2<=s^2*(1-3/2*c):=by have h5:(1-3/2*c)^2<=1-3/2*c:=by nlinarith calc k^2=s^2*(1-3/2*c)^2:=by rw[hk]; ring _<=_:=mul_le_mul_of_nonneg_left h5 (sq_nonneg _) have q5:=sq_nonneg Em nlinarith . have hh:0< hi:=by have h5:0< s*(1+3/2*c):=by positivity linarith rw[Real.sqrt_lt' hh] have q0:0<=s*(1+3/2*c)+9/10*Em:=by positivity have q1:=pow_le_pow_left₀ q0 h3 2 have q2:s^2*(1+3*c)<=(s*(1+3/2*c)+9/10*Em)^2:=by have e:(s*(1+3/2*c)+9/10*Em)^2=s^2*(1+3*c)+9/4*(s^2*c^2) + 9/5*(s*Em*(1+3/2*c))+81/100*Em^2:=by ring have r1:0<=s^2*c^2:=by positivity have r2:0<=s*Em*(1+3/2*c):=by positivity have r3:=sq_nonneg Em rw[e]; linarith nlinarith lemma qF3 (s c Em dd Rn2 Rmu ee hi lo z:ℝ) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (hs0:0<=s) (hs1:s<=2^101) (hc0:9/2^49<=c) (hc1:c<=1/2^20) (hE:1/2^201<=Em) (hE1:Em<=2^120) (h1 : |dd-s| ≤ 1/2^53*(s+z)) (h2 : |Rn2-(c+c)| ≤ 1/2^53*(|c+c| + z)) (h3 : |Rmu-Rn2*dd| ≤ 1/2^53*(|Rn2*dd| + z)) (h4 : |ee-(Rmu+Em)| ≤ 1/2^53*(|Rmu+Em| + z)) (h5 : |hi-(dd+ee)| ≤ 1/2^53*(|dd+ee| + z)) (h6 : |lo-(dd-ee)| ≤ 1/2^53*(|dd-ee| + z)) : s*(1+3/2*c)+9/10*Em<=hi∧lo<=s*(1-3/2*c)-9/10*Em:=by have hz1:z<=1/2^240:=le_trans hz ב have hcp:0< c:=lt_of_lt_of_le ב hc0 have hcs:0<=c*s:=mul_nonneg hcp.le hs0 have hcs2:9/2^49*s<=c*s:=mul_le_mul_of_nonneg_right hc0 hs0 have hcc : |c+c| = c+c:=abs_of_pos ד rw[hcc] at h2 have d1:=qAa dd s rw[abs_of_nonneg hs0] at d1 have d2 : |dd| ≤ 3*s+z :=ד have d3 : |dd| ≤ 2^103:=by norm_num at hs1 hz1 d2 ⊢; linarith have m1 : |Rn2*dd-(c+c)*s| ≤ |Rn2-(c+c)| * |dd| + (c+c) * |dd-s|:=by have e:Rn2*dd-(c+c)*s=(Rn2-(c+c))*dd+(c+c)*(dd-s):=by ring rw[e] calc _ ≤ |(Rn2-(c+c))*dd| + |(c+c)*(dd-s)|:=abs_add_le _ _ _=_:=by rw[abs_mul,abs_mul,hcc] have m2 : |Rn2-(c+c)| * |dd| ≤ (1/2^53*(c+c+z))*(3*s+z) := mul_le_mul h2 d2 (abs_nonneg _) (by positivity) have m3:(c+c) * |dd-s| ≤ (c+c)*(1/2^53*(s+z)) := mul_le_mul_of_nonneg_left h1 ד have zs:z*s<=1/2^200*(1/2^200)*2^101:=mul_le_mul hz hs1 hs0 ב have zc:z*c<=z*1:=mul_le_mul_of_nonneg_left ד hz0 have zz:z*z<=z*1:=mul_le_mul_of_nonneg_left ד hz0 have nzs:=mul_nonneg hz0 hs0 have nzc:=mul_nonneg hz0 hcp.le have nzz:=mul_nonneg hz0 hz0 have m4 : |Rn2*dd-(c+c)*s| ≤ 1/2^49*(c*s)+1/2^230:=by have e:(1/2^53*(c+c+z))*(3*s+z)+(c+c)*(1/2^53*(s+z)) = 8/2^53*(c*s)+4/2^53*(z*c)+3/2^53*(z*s)+1/2^53*(z*z):=by ring norm_num at zs ⊢ linarith obtain ⟨M,hM⟩:∃ M,M=Rn2*dd:=⟨_,rfl⟩ rw[<-hM] at h3 m4 have e5:(c+c)*s=2*(c*s):=by ring rw[e5] at m4 have n1:=qAa M (2*(c*s)) rw[abs_of_nonneg (by linarith:0<=2*(c*s))] at n1 have n2:=qAa Rmu M have n3:=abs_add_le Rmu Em rw[abs_of_pos (by linarith [(by norm_num:(0:ℝ)<1/2^201)]:0< Em)] at n3 have n4:=qAa ee (Rmu+Em) have n5:=abs_add_le dd ee have n6:=abs_sub dd ee obtain ⟨a1,a2⟩:=abs_le.mp h1 obtain ⟨b1,b2⟩:=abs_le.mp m4 obtain ⟨c1,c2⟩:=abs_le.mp h3 obtain ⟨d4,d5⟩:=abs_le.mp h4 obtain ⟨e1,e2⟩:=abs_le.mp h5 obtain ⟨f1,f2⟩:=abs_le.mp h6 have hcs3:c*s<=1/2^20*s:=mul_le_mul_of_nonneg_right hc1 hs0 have e3:s*(1+3/2*c)=s+3/2*(c*s):=by ring have e4:s*(1-3/2*c)=s-3/2*(c*s):=by ring rw[e3,e4] constructor <;> linarith lemma qHo (x Rd RQ z:ℝ) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (hx : |x| ≤ 2^111) (h1 : |Rd-x| ≤ 1/2^53*(|x| + z)) (h2 : |RQ-Rd*Rd| ≤ 1/2^53*(|Rd*Rd| + z)) : |RQ-x^2| ≤ 4/2^53*x^2+1/2^250:=by have hz1:z<=1/2^240:=le_trans hz ב have nA:=abs_nonneg x have zA:z * |x| ≤ 1/2^200*(1/2^200)*2^111:=mul_le_mul hz hx nA ב have zz:z*z<=z*1:=mul_le_mul_of_nonneg_left ד hz0 have nzA:=mul_nonneg hz0 nA have nzz:=mul_nonneg hz0 hz0 have hsq : |x| ^ 2=x^2:=sq_abs x obtain ⟨e,he⟩:∃ e,e=Rd-x:=⟨_,rfl⟩ rw[<-he] at h1 have hR:Rd=x+e:=by rw[he]; ring have e0:e*e = |e| ^ 2:=by rw[sq_abs]; ring have nE:=abs_nonneg e have q1 : |e| ^ 2<=(1/2^53*(|x| + z))^2:=pow_le_pow_left₀ nE h1 2 have q2:(1/2^53*(|x| + z))^2=1/2^106*(|x| ^ 2+2*(z * |x|)+z*z):=by ring have q3 : |2*x*e| ≤ 2 * |x| * (1/2^53*(|x| + z)):=by rw[abs_mul,abs_mul,abs_two] exact mul_le_mul_of_nonneg_left h1 (by positivity) have q4:2 * |x| * (1/2^53*(|x| + z))=2/2^53 * |x| ^ 2+2/2^53*(z * |x|):=by ring have q5:Rd*Rd=x^2+2*x*e+e*e:=by rw[hR]; ring have q6 : |Rd*Rd-x^2| ≤ |2*x*e| + |e*e|:=by have e7:Rd*Rd-x^2=2*x*e+e*e:=by rw[q5]; ring rw[e7]; exact abs_add_le _ _ have q7 : |e*e| = e*e:=abs_of_nonneg (mul_self_nonneg e) have q8:=qAa (Rd*Rd) (x^2) rw[abs_of_nonneg (sq_nonneg x)] at q8 have q9:=qAa (RQ-x^2) (RQ-Rd*Rd) have e8:RQ-x^2-(RQ-Rd*Rd)=Rd*Rd-x^2:=by ring rw[e8] at q9 have nX:=sq_nonneg x rw[hsq] at q2 q4 rw[q7,e0] at q6 have s1 : |Rd*Rd-x^2| ≤ 201/100/2^53*x^2+1/2^254:=by rw[q2] at q1 rw[q4] at q3 linarith have s2 : |Rd*Rd| ≤ 2*x^2+1:=by have:(201/100/2^53:ℝ)*x^2<=1*x^2:=mul_le_mul_of_nonneg_right ב nX linarith have s3:1/2^53 * |Rd*Rd| ≤ 1/2^53*(x^2+(201/100/2^53*x^2+1/2^254)):=by apply mul_le_mul_of_nonneg_left _ ב linarith have s4:1/2^53*z<=1/2^254:=by have:(1/2^53:ℝ)*z<=1*z:=mul_le_mul_of_nonneg_right ב hz0 have h3:(1/2^200*(1/2^200):ℝ)<=1/2^254 :=ב linarith linarith lemma qGz (n Ws Rv I Rp Rt ep c tau z:ℝ) (hn1:1<=n) (hn2:n<=2^20) (hc:c=(n+8)/2^49) (hWs:0<=Ws) (hep:1/2^126<=ep) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (ht0:0<=tau) (ht:tau<=1/2^229) (h1 : |Rv-n*Ws| ≤ (2*n+6)/2^53*(n*Ws)+tau) (h3:0< I) (h4 : |I*n-1| ≤ 1/2^48) (h5 : |Rp-Rv*I| ≤ 1/2^53*(|Rv*I| + z)) (h6 : |Rt-(Rp+ep)| ≤ 1/2^53*(|Rp+ep| + z)) : |Rt-(Ws+ep)| ≤ c/2*(Ws+ep):=by have hz1:z<=1/2^240:=le_trans hz ב have hep0:0< ep:=lt_of_lt_of_le ב hep obtain ⟨j1,j2⟩:=abs_le.mp h4 have hIn1:I*n<=1+1/2^48 :=ד have hI2:I<=2:=by have:I*1<=I*n:=mul_le_mul_of_nonneg_left hn1 h3.le linarith have e:Rv*I-Ws=(Rv-n*Ws)*I+Ws*(I*n-1):=by ring have a1 : |(Rv-n*Ws)*I| ≤ (2*n+6)/2^53*Ws*(I*n)+tau*I:=by rw[abs_mul,abs_of_pos h3] calc _<=((2*n+6)/2^53*(n*Ws)+tau)*I:=mul_le_mul_of_nonneg_right h1 h3.le _=_:=by ring have nW2:0<=(2*n+6)/2^53*Ws:=by have:0<=2*n+6 :=ד positivity have a2:(2*n+6)/2^53*Ws*(I*n)<=(2*n+6)/2^53*Ws*(1+1/2^48) := mul_le_mul_of_nonneg_left hIn1 nW2 have a3:tau*I<=tau*2:=mul_le_mul_of_nonneg_left hI2 ht0 have a4 : |Ws*(I*n-1)| ≤ Ws*(1/2^48):=by rw[abs_mul,abs_of_nonneg hWs]; exact mul_le_mul_of_nonneg_left h4 hWs have a5:=abs_add_le ((Rv-n*Ws)*I) (Ws*(I*n-1)) rw[<-e] at a5 obtain ⟨X,hX⟩:∃ X,X=(2*n+6)/2^53*Ws:=⟨_,rfl⟩ have hX1:X=n*Ws/2^52+3*Ws/2^52:=by rw[hX]; ring rw[<-hX] at a1 a2 have b1 : |Rv*I-Ws| ≤ X*(1+1/2^48)+2*tau+Ws/2^48 :=ד have nnW:0<=n*Ws:=mul_nonneg ד hWs have nnE:0<=n*ep:=mul_nonneg ד hep0.le have nnW2:n*Ws<=2^20*Ws:=mul_le_mul_of_nonneg_right hn2 hWs have b2:=qAa (Rv*I) Ws rw[abs_of_nonneg hWs] at b2 have b3:=abs_add_le Rp ep rw[abs_of_pos hep0] at b3 have b4:=qAa Rp (Rv*I) have b5 : |Rt-(Ws+ep)| ≤ |Rt-(Rp+ep)| + |Rp-Rv*I| + |Rv*I-Ws|:=by have e2:Rt-(Ws+ep)=(Rt-(Rp+ep))+(Rp-Rv*I)+(Rv*I-Ws):=by ring rw[e2] exact (abs_add_le _ _).trans (add_le_add_left (abs_add_le _ _) _) have e3:c/2*(Ws+ep)=(n*Ws+8*Ws+n*ep+8*ep)/2^50:=by rw[hc]; ring rw[e3] rw[hX1] at b1 linarith lemma qF0 (l:List ℕ) (a:ℕ->ℝ) (c:ℝ) : (l.map λj=>(a j-c)^2).sum = (l.map λj=>a j^2).sum-2*c*(l.map a).sum+l.length*c^2:=by induction l with | nil=>simp | cons j l ih => simp only[List.map_cons,List.sum_cons,List.length_cons,ih] push_cast ring lemma qE9 (l:List ℕ) (a:ℕ->ℝ) (m:ℝ) (hl:(l.length:ℝ)≠0) : (l.map λj=>(a j-m)^2).sum = (l.map λj=>(a j-(l.map a).sum/l.length)^2).sum + l.length*((l.map a).sum/l.length-m)^2:=by rw[qF0,qF0] field_simp ring lemma qF1 (l:List ℕ) (f w:ℕ->ℝ) (u t:ℝ) (hw:∀ j∈l,0<=w j) (h:∀ j∈l,|f j-w j| ≤ u*w j+t) (hu:0<=u) (ht:0<=t) : |(l.map f).sum-(l.map w).sum| ≤ u*(l.map w).sum+l.length*t ∧ (l.map λj=>|f j|).sum<=(1+u)*(l.map w).sum+l.length*t∧0<=(l.map w).sum:=by induction l with | nil=>simp | cons j l ih => obtain ⟨i1,i2,i3⟩:=ih (λk hk=>hw k (List.mem_cons_of_mem _ hk)) (λk hk=>h k (List.mem_cons_of_mem _ hk)) have h0:=hw j List.mem_cons_self have h1:=h j List.mem_cons_self simp only[List.map_cons,List.sum_cons,List.length_cons] push_cast have e:f j+(l.map f).sum-(w j+(l.map w).sum) = (f j-w j)+((l.map f).sum-(l.map w).sum):=by ring have a1:=abs_add_le (f j-w j) ((l.map f).sum-(l.map w).sum) rw[<-e] at a1 have a2:=qAa (f j) (w j) rw[abs_of_nonneg h0] at a2 refine ⟨?_,?_,by linarith⟩ . nlinarith . nlinarith lemma qA9 (w:UInt32) (h:sm w=true):good w=true∧|wv w| ≤ 2^99:=by unfold sm at h simp only[Bool.and_eq_true,decide_eq_true_eq] at h obtain ⟨hg,hl⟩:=h refine ⟨hg,?_⟩ have h1:w.toNat%2^31<=0x70FFFFFF:=by have:=UInt32.le_iff_toNat_le.mp hl rwa [qBh] at this have h2:=qBg w hg rw[qB0 w hg] refine (qA4 _ _ h1 א).trans ?_ have:A_mag 0x70FFFFFF=(16777215:ℝ)*2^(75:ℤ):=by unfold A_mag; norm_num rw[this] norm_num lemma qCt (w:UInt32) (h:good w=true):Model.isFinite (ofW w)=true:=by have he:=qAh w h simp[ofW,isFinite_ofUInt32,he] lemma qGm:wv oneW=1:=by rw[qA7 oneW (by decide),qE7]; simp lemma qEf (relu:Bool) (x y:Word) : addOne relu (nfOf 1) x y=act relu (toWord (Model.add (ofW x) (ofW y))):=by unfold addOne split . rename_i hc simp only[Bool.and_eq_true] at hc obtain ⟨gx,lx⟩:=qA9 x hc.1 obtain ⟨gy,ly⟩:=qA9 y hc.2 dsimp only split . rfl . rename_i hr have hn:ziv ((0+dv x*dv oneW)+dv y) (nfOf 1*((0+(dv x*dv oneW).abs)+(dv y).abs))≠0xFFFFFFFF:=λh=>hr (by simp[h]) generalize hs:(0+dv x*dv oneW)+dv y=S at hn generalize he:nfOf 1*((0+(dv x*dv oneW).abs)+(dv y).abs)=E at hn obtain ⟨-,-,hbig⟩:=qBs S E hn obtain ⟨hlo,hhi⟩:=qCb 1 ב (λ_=>x) (λ_=>oneW) y (λ_ _=>gx) (λ_ _=>by decide) gy [0] ג ג (λt ht h=>absurd (by simp; omega) h) S E (by simp only[List.foldl_cons,List.foldl_nil]; exact ⟨hs.symm,he.symm⟩) hbig have hv:exactS 1 (λ_=>x) (λ_=>oneW) y=Model.toReal (ofW x)+Model.toReal (ofW y):=by simp only[exactS,Finset.sum_range_one,qGm,mul_one]; rfl rw[hv] at hlo hhi have hb : |Model.toReal (ofW x)| + |Model.toReal (ofW y)| ≤ Model.toReal (Model.posMaxFinite Fmt):=by have e:(2:ℝ)^99+2^99<=2^(127:ℤ) :=ב exact (add_le_add lx ly).trans (e.trans qGh) have hf:=Model.isFinite_add_of_abs_add_le_posMaxFinite _ _ rfl (qCt x gx) (qCt y gy) hb have hM:=Model.toReal_add_eq_roundAt_of_abs_add_le_posMaxFinite _ _ rfl (qCt x gx) (qCt y gy) hb have:=qCe S E _ hlo hhi hn _ hf hM rw[this] . rfl lemma qEo:addF=addReluSpec:=by funext relu a b simp only[addF,addReluSpec,qEf] lemma qHf (d e:FloatLib.Numerics.Dyadic) (h:d.toRat=e.toRat) (hn:d.toRat≠0) : toWord (Model.roundDyadic Fmt d)=toWord (Model.roundDyadic Fmt e):=by have h1:d.significand≠0:=λh0=>hn (by rw[FloatLib.Numerics.Dyadic.toRat_eq_zero_iff]; exact h0) have h2:e.significand≠0:=λh0=>hn (by rw[h,FloatLib.Numerics.Dyadic.toRat_eq_zero_iff]; exact h0) rw[roundDyadic_congr Fmt (by decide) d e h1 h2 h] lemma qFs:rationalWord (0x80000000:UInt32)=0:=by have he:expOf (0x80000000:UInt32)=0:=by decide have hf:fracOf (0x80000000:UInt32)=0:=by decide have hm:mantOf (0x80000000:UInt32)=0:=by decide have hv:sv (0x80000000:UInt32)=0:=by decide simp only[rationalWord,decodeD_toRat,hv] simp lemma qHa (a b:Array UInt32) (r i:Nat) : dallNZ a b i (r+1)=(dallNZ a b i r && (decide (mantOf a[i+r]! * mantOf b[i+r]! = 0) && Bool.xor (signOf a[i+r]!) (signOf b[i+r]!))):=by induction r generalizing i with | zero=>simp[dallNZ] | succ r ih => rw[dallNZ,ih (i+1),dallNZ] simp only[Bool.and_assoc,show i+1+r=i+(r+1) by omega] lemma qG2 (a b u v:Array UInt32) (r i:Nat) (h:∀ j,i<=j->j< i+r->a[j]! = u[j]!∧b[j]! = v[j]!) : dallNZ a b i r=dallNZ u v i r:=by induction r generalizing i with | zero=>rfl | succ r ih => rw[dallNZ,dallNZ,ih (i+1) (λj h1 h2=>h j א א), (h i א א).1,(h i א א).2] lemma qEm (a b:Array UInt32) (hs:a.size=b.size) (hf:∀ j,j< a.size->expOf a[j]!≠255∧expOf b[j]!≠255) (hz:(dsum a b 0 a.size:ℚ)*2^(-298:Int)=0) : dotSpec a b=toWord (Model.zero Fmt (decide (a.size≠0) && dallNZ a b 0 a.size)):=by let L:=a.map (Model.ofUInt32 (fmt:=Fmt)) let R:=b.map (Model.ofUInt32 (fmt:=Fmt)) have hLR:L.size=R.size:=by simp[L,R,hs] have hLf:∀ j (hj:j< L.size),Model.isFinite L[j]=true:=by intro j hj have hj':j< a.size:=by simpa [L] using hj have he:=(hf j hj').1 rw[getElem!_pos a j hj'] at he simp[L,isFinite_ofUInt32,he] have hRf:∀ j (hj:j< R.size),Model.isFinite R[j]=true:=by intro j hj have hj':j< b.size:=by simpa [R] using hj have he:=(hf j א).2 rw[getElem!_pos b j hj'] at he simp[R,isFinite_ofUInt32,he] let state:Model.Reduction.Internal.State Fmt:=Model.Reduction.Internal.dotState L R hLR have hex:=Model.Reduction.Internal.dotState_exact_toRat (destination:=Fmt) L R hLR hLf hRf have hmath:=finiteDotSlice_eq a b 0 a.size ג (by simp[hs]) (by intro j _ hj; exact hf j א) have hzero:state.exact.significand=0:=by rw[<-FloatLib.Numerics.Dyadic.toRat_eq_zero_iff] exact (hex.trans (by simpa [L,R] using hmath)).trans hz have flags:=dotStateLoop_flags a b {} 0 a.size ג (by simp[hs]) (by intro j _ hj; exact hf j א) have hflags:state.sawFiniteTerm=decide (a.size≠0) ∧ state.allTermsNegativeZero=dallNZ a b 0 a.size:=by simpa [state,Model.Reduction.Internal.dotState,L,R] using flags unfold dotSpec Model.dot rw[Model.Reduction.dotWithStatus_eq_zero_of_finite Fmt L R .nearestEven hLR hLf hRf hzero] simp only[Except.map] change toWord (Model.zero Fmt (state.sawFiniteTerm && (state.allTermsNegativeZero || !state.allTermsPositiveZero && (Model.IEEERoundingMode.nearestEven == Model.IEEERoundingMode.towardNegativeInfinity))))=_ simp[hflags.1,hflags.2] lemma qGr (k:Nat) (a b:Nat->UInt32) (hk:0< k) (hf:∀ t,t< k->expOf (a t)≠255∧expOf (b t)≠255) : dotOf (k+1) (λt=>if t< k then a t else oneW) (λt=>if t< k then b t else 0x80000000)=dotOf k a b:=by have hf':∀ j,j< k+1->expOf (if j< k then a j else oneW)≠255 ∧ expOf (if j< k then b j else 0x80000000)≠255:=by intro j hj by_cases h:j< k . simpa [h] using hf j h . simp only[h,ite_false]; exact ⟨by decide,by decide⟩ have hsum:(∑ j∈Finset.range (k+1),rationalWord (if j< k then a j else oneW) * rationalWord (if j< k then b j else 0x80000000)) = ∑ j∈Finset.range k,rationalWord (a j)*rationalWord (b j):=by rw[Finset.sum_range_succ] simp only[lt_self_iff_false,ite_false,qFs,mul_zero,add_zero] apply Finset.sum_congr rfl intro j hj simp[Finset.mem_range.mp hj] by_cases hS:(∑ j∈Finset.range k,rationalWord (a j)*rationalWord (b j))=0 . let A:=Array.ofFn (n:=k) λi=>a i.val let B:=Array.ofFn (n:=k) λi=>b i.val let A':=Array.ofFn (n:=k+1) λi=>(if i.val< k then a i.val else oneW) let B':=Array.ofFn (n:=k+1) λi=>(if i.val< k then b i.val else 0x80000000) have gA:∀ j,j< k->A[j]! = a j:=λj hj=>qAb k a j hj have gB:∀ j,j< k->B[j]! = b j:=λj hj=>qAb k b j hj have gA':∀ j,j< k+1->A'[j]! = if j< k then a j else oneW := λj hj=>qAb (k+1) (λt=>if t< k then a t else oneW) j hj have gB':∀ j,j< k+1->B'[j]! = if j< k then b j else 0x80000000 := λj hj=>qAb (k+1) (λt=>if t< k then b t else 0x80000000) j hj have sA:A.size=k:=by simp[A] have sA':A'.size=k+1:=by simp[A'] have d1:(dsum A B 0 A.size:ℚ)*2^(-298:Int)=0:=by rw[sA,qC5,<-hS] apply Finset.sum_congr rfl intro j hj have:=Finset.mem_range.mp hj rw[Nat.zero_add,gA j this,gB j this] have d2:(dsum A' B' 0 A'.size:ℚ)*2^(-298:Int)=0:=by rw[sA',qC5,<-hS,<-hsum] apply Finset.sum_congr rfl intro j hj have:=Finset.mem_range.mp hj rw[Nat.zero_add,gA' j this,gB' j this] change dotSpec A' B'=dotSpec A B rw[qEm A B (by simp[A,B]) (λj hj=>by rw[sA] at hj; rw[gA j hj,gB j hj]; exact hf j hj) d1, qEm A' B' (by simp[A',B']) (λj hj=>by rw[sA'] at hj; rw[gA' j hj,gB' j hj]; exact hf' j hj) d2,sA,sA',qHa] have hl1:=gA' (0+k) א have hl2:=gB' (0+k) א simp only[Nat.zero_add,lt_self_iff_false,ite_false] at hl1 hl2 simp only[Nat.zero_add,hl1,hl2] rw[qG2 A' B' A B k 0 (λj _ h2=>by have h3:j< k :=א rw[gA' j א,gB' j א,gA j h3,gB j h3] simp[h3])] have hm:mantOf (0x80000000:UInt32)=0:=by decide have hs1:signOf oneW=false:=by decide have hs2:signOf (0x80000000:UInt32)=true:=by decide simp[hm,hs1,hs2,show k≠0 by omega] . obtain ⟨d,hd,hw⟩:=qDu k a b hf hS obtain ⟨e,he,hw'⟩:=qDu (k+1) _ _ hf' (by rw[hsum]; exact hS) rw[hw,hw'] exact qHf e d (by rw[he,hd,hsum]) (by rw[he,hsum]; exact hS) lemma qEd:gemmF=gemmSpec:=by funext batch m k n A B unfold gemmF split . rename_i hc simp only[Bool.and_eq_true,beq_iff_eq,decide_eq_true_eq] at hc obtain ⟨⟨⟨⟨⟨⟨h1,h2⟩,h3⟩,h4⟩,h5⟩,h6⟩,h7⟩:=hc subst h1 rw[qDl] unfold linearSpec linearWith gemmSpec gemmWith apply Array.ext ג intro q h8 h9 simp only[Array.getElem_ofFn,Array.size_ofFn] at h8 h9 ⊢ have fA:∀ t,expOf A[t]!≠255:=λt=>by by_cases ht:t< A.size . rw[getElem!_pos A t ht] have:=(Array.all_eq_true.1 h6) t ht simpa [finiteWord] using this . rw[getElem!_neg A t ht]; decide have fB:∀ t,expOf B[t]!≠255:=λt=>by by_cases ht:t< B.size . rw[getElem!_pos B t ht] have:=(Array.all_eq_true.1 h7) t ht simpa [finiteWord] using this . rw[getElem!_neg B t ht]; decide have hq:q< m*n:=by simpa using h9 have e1:q/(m*n)=0:=Nat.div_eq_of_lt hq have e2:q/n%m=q/n:=Nat.mod_eq_of_lt (Nat.div_lt_of_lt_mul (by rwa [Nat.mul_comm])) have hj:q%n< n:=Nat.mod_lt _ h4 simp only[act,Bool.false_eq_true,ite_false] rw[<-qGr k (λt=>A[(q/(m*n)*m+q/n%m)*k+t]!) (λt=>B[(q/(m*n)*k+t)*n+q%n]!) h5 (λt _=>⟨fA _,fB _⟩)] congr 1 . funext t by_cases ht:t< k . simp[ht,e1,e2] . simp[ht] . funext t by_cases ht:t< k . simp only[ht,if_true] have hi:q%n*k+t< n*k:=by have:=Nat.mul_le_mul_right k (show q%n+1<=n by omega) rw[Nat.add_mul,Nat.one_mul] at this omega rw[qAb (n*k) (λu=>B[u%k*n+u/k]!) _ hi] have i1:(q%n*k+t)%k=t:=by rw[Nat.mul_comm,Nat.mul_add_mod,Nat.mod_eq_of_lt ht] have i2:(q%n*k+t)/k=q%n:=by rw[Nat.mul_comm,Nat.mul_add_div h5,Nat.div_eq_of_lt ht,Nat.add_zero] simp[i1,i2,e1] . simp only[ht,if_false] simp[hj] . rfl lemma qFt (x:Array UInt32) (hx:x.size<2^32) (base nu:USize) (hb:base.toNat+nu.toNat<2^32) : ∀ (d:ℕ) (i:USize) (s t:Float),i.toNat+d=nu.toNat → lnSum x base nu i s t = ⟨((List.range' i.toNat d).map λj=>dv x[base.toNat+j]!).foldl (.+·) s, ((List.range' i.toNat d).map λj=>(dv x[base.toNat+j]!).abs).foldl (.+·) t⟩:=by intro d induction d with | zero => intro i s t h have hn:¬ i< nu:=by rw[USize.lt_iff_toNat_lt]; omega rw[lnSum,dif_neg hn]; simp | succ d ih => intro i s t h have hn:i< nu:=by rw[USize.lt_iff_toNat_lt]; omega rw[lnSum,dif_pos hn] have e1:=usz i nu hn rw[ih (i+1) _ _ (by rw[e1]; omega),e1] have e2:(base+i).toNat=base.toNat+i.toNat:=qAe base i א rw[qAx x _ hx,e2] simp[List.range'_succ] lemma qFx (x:Array UInt32) (hx:x.size<2^32) (base nu:USize) (m:Float) (hb:base.toNat+nu.toNat<2^32) : ∀ (d:ℕ) (i:USize) (v:Float),i.toNat+d=nu.toNat → lnVar x base nu i m v = ((List.range' i.toNat d).map λj => (dv x[base.toNat+j]! - m)*(dv x[base.toNat+j]! - m)).foldl (.+·) v:=by intro d induction d with | zero => intro i v h have hn:¬ i< nu:=by rw[USize.lt_iff_toNat_lt]; omega rw[lnVar,dif_neg hn]; simp | succ d ih => intro i v h have hn:i< nu:=by rw[USize.lt_iff_toNat_lt]; omega rw[lnVar,dif_pos hn] have e1:=usz i nu hn rw[ih (i+1) _ (by rw[e1]; omega),e1] have e2:(base+i).toNat=base.toNat+i.toNat:=qAe base i א rw[qAx x _ hx,e2] simp[List.range'_succ] lemma qD3 (l:List ℕ) (f:ℕ->ℚ) (c:ℚ) : ((l.foldl (λt j=>t+f j) c:ℚ):ℝ)=c+(l.map λj=>(f j:ℝ)).sum:=by induction l generalizing c with | nil=>simp | cons j l ih => simp only[List.foldl_cons,List.map_cons,List.sum_cons,ih] push_cast ring lemma qG5 (w:UInt32) (hg:good w=true) (h1:(0x1F800000:UInt32)<=w) (h2:w<=(0x70FFFFFF:UInt32)):1/2^64<=wv w:=by have a1:=UInt32.le_iff_toNat_le.mp h1 have a2:=UInt32.le_iff_toNat_le.mp h2 have e1:(0x1F800000:UInt32).toNat=528482304:=rfl have e2:(0x70FFFFFF:UInt32).toNat=1895825407:=rfl rw[e1] at a1 rw[e2] at a2 rw[qA6 w hg,if_neg א,one_mul] have h3:A_mag 528482304<=A_mag (w.toNat%2^31) := qA4 _ _ א א have:A_mag 528482304=1/2^64:=by unfold A_mag; norm_num rwa [this] at h3 lemma qG6 (w:UInt32) (hg:good w=true) (h0:0< wv w):1/2^126<=wv w:=by have hn:=qBg w hg rw[qA6 w hg] at h0 ⊢ rcases hn with hn | ⟨hn,-⟩ . rw[hn] at h0 have:A_mag 0=0:=by simp[A_mag] rw[this] at h0 simp at h0 . have hs:¬ 2^31<=w.toNat:=by intro hc rw[if_pos hc] at h0 have:=qAt (w.toNat%2^31) linarith rw[if_neg hs,one_mul] have h3:A_mag (2^23)<=A_mag (w.toNat%2^31):=qA4 _ _ hn א have:A_mag (2^23)=1/2^126:=by unfold A_mag; norm_num rwa [this] at h3 lemma qHe (n:ℕ) (hn:n<2^20) : ((n.toUInt64+8).toFloat*Float.ofBits 0x3CE0000000000000).isFinite=true ∧ R ((n.toUInt64+8).toFloat*Float.ofBits 0x3CE0000000000000)=((n:ℝ)+8)/2^49:=by have ht:(n.toUInt64+8).toNat=n+8:=by have h8:(8:UInt64).toNat=8:=rfl simp[UInt64.toNat_add,h8] omega have h1:=qCf (n.toUInt64+8) (by rw[ht]; omega) obtain ⟨h2,h3⟩:=qGn have h4:(n:ℝ)+8<=2^21:=by have:n+8<=2^21 :=א exact_mod_cast this obtain ⟨hf,he⟩:=qCu _ _ h1.1 h2 (by rw[h1.2,h3,ht] refine le_trans (mul_le_mul ?_ ?_ (abs_nonneg _) qCi.le) qB8 . rw[Nat.cast_add,abs_of_nonneg (by positivity),qA2] push_cast have h7:(2:ℝ)^21<=2^256*2^44 :=ב linarith . rw[abs_of_nonneg (by positivity),qA2] norm_num) refine ⟨hf,?_⟩ rw[he,h1.2,h3,ht] have:=qAk ((n:ℤ)+8) (-49) א ב push_cast at this ⊢ have e:(2:ℝ)^(-49:ℤ)=1/2^49 :=ב rw[e] at this rw[this] ring lemma qAq (x y:Float) (B:ℝ) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ B) (h2 : |R y| ≤ B) (hB:B<=A_B) : (x+y).isFinite=true∧|R (x+y)-(R x+R y)| ≤ 1/2^53*(|R x+R y| + A_z) ∧ |R (x+y)| ≤ 3*B+A_z:=by obtain ⟨f,e⟩:=qBn x y hx hy (h1.trans hB) (h2.trans hB) refine ⟨f,e,?_⟩ have a1:=qAa (R (x+y)) (R x+R y) have a2:=abs_add_le (R x) (R y) have hB0:0<=B:=(abs_nonneg _).trans h1 have hz:=qBi.le have a3 : |R x+R y| ≤ 2*B :=ד have a4:1/2^53*(|R x+R y| + A_z)<=1*(|R x+R y| + A_z) := mul_le_mul_of_nonneg_right ב (by positivity) linarith lemma qB7 (x y:Float) (B:ℝ) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ B) (h2 : |R y| ≤ B) (hB:B<=A_B) : (x-y).isFinite=true∧|R (x-y)-(R x-R y)| ≤ 1/2^53*(|R x-R y| + A_z) ∧ |R (x-y)| ≤ 3*B+A_z:=by obtain ⟨f,e⟩:=qC2 x y hx hy (h1.trans hB) (h2.trans hB) refine ⟨f,e,?_⟩ have a1:=qAa (R (x-y)) (R x-R y) have a2:=abs_sub (R x) (R y) have hB0:0<=B:=(abs_nonneg _).trans h1 have hz:=qBi.le have a3 : |R x-R y| ≤ 2*B :=ד have a4:1/2^53*(|R x-R y| + A_z)<=1*(|R x-R y| + A_z) := mul_le_mul_of_nonneg_right ב (by positivity) linarith lemma qAo (x y:Float) (B C:ℝ) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ B) (h2 : |R y| ≤ C) (hB:B<=A_B) (hC:C<=A_B) : (x*y).isFinite=true∧|R (x*y)-R x*R y| ≤ 1/2^53*(|R x*R y| + A_z) ∧ |R (x*y)| ≤ 2*(B*C)+A_z:=by obtain ⟨f,e⟩:=qBq x y hx hy (h1.trans hB) (h2.trans hC) refine ⟨f,e,?_⟩ have a1:=qAa (R (x*y)) (R x*R y) have a2 : |R x*R y| ≤ B*C:=by rw[abs_mul] exact mul_le_mul h1 h2 (abs_nonneg _) ((abs_nonneg _).trans h1) have hz:=qBi.le have a3:1/2^53*(|R x*R y| + A_z)<=1*(|R x*R y| + A_z) := mul_le_mul_of_nonneg_right ב (by positivity) linarith lemma qFo (l:List ℕ) (f:ℕ->ℝ) : |(l.map f).sum| ≤ (l.map λj=>|f j|).sum:=by induction l with | nil=>simp | cons j l ih => simp only[List.map_cons,List.sum_cons] exact (abs_add_le _ _).trans (add_le_add le_rfl ih) lemma qDk (l:List ℕ) (f:ℕ->ℝ) (B:ℝ) (h:∀ j∈l,f j<=B) : (l.map f).sum<=l.length*B:=by induction l with | nil=>simp | cons j l ih => simp only[List.map_cons,List.sum_cons,List.length_cons] have a:=h j List.mem_cons_self have b:=ih (λk hk=>h k (List.mem_cons_of_mem _ hk)) push_cast linarith lemma qGg (n:ℕ) (hn:n<2^20) (g:ℕ->Float) (hg:∀ j,j< n->(g j).isFinite=true∧|R (g j)| ≤ 2^99) : (A_fsum ((List.range n).map g)).isFinite=true ∧ (A_fsum ((List.range n).map λj=>(g j).abs)).isFinite=true ∧ |((List.range n).map λj=>R (g j)).sum| ≤ ((List.range n).map λj=>|R (g j)|).sum ∧ ((List.range n).map λj=>|R (g j)|).sum<=n*2^99 ∧ |R (A_fsum ((List.range n).map g))-((List.range n).map λj=>R (g j)).sum| ≤ 2*n*(1/2^53*(((List.range n).map λj=>|R (g j)|).sum+A_z)) ∧ |R (A_fsum ((List.range n).map λj=>(g j).abs)) - ((List.range n).map λj=>|R (g j)|).sum| ≤ 2*n*(1/2^53*(((List.range n).map λj=>|R (g j)|).sum+A_z)):=by have hA:((List.range n).map λj=>|R (g j)|).sum<=n*2^99:=by have:=qDk (List.range n) (λj=>|R (g j)|) (2^99) (λj hj=>(hg j (List.mem_range.1 hj)).2) simpa using this have hnR:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have hA2:((List.range n).map λj=>|R (g j)|).sum<=A_B/4:=by have:(n:ℝ)*2^99<=2^20*2^99:=by gcongr rw[qA2]; norm_num at this ⊢; linarith have s1:A_sa ((List.range n).map g)=((List.range n).map λj=>|R (g j)|).sum:=by simp only[A_sa,List.map_map,Function.comp_def] have s2:A_sr ((List.range n).map g)=((List.range n).map λj=>R (g j)).sum:=by simp only[A_sr,List.map_map,Function.comp_def] have s3:A_sa ((List.range n).map λj=>(g j).abs) = ((List.range n).map λj=>|R (g j)|).sum:=by simp only[A_sa,List.map_map,Function.comp_def] congr 1 apply List.map_congr_left intro j hj rw[(qAv _ (hg j (List.mem_range.1 hj)).1).2,abs_abs] have s4:A_sr ((List.range n).map λj=>(g j).abs) = ((List.range n).map λj=>|R (g j)|).sum:=by simp only[A_sr,List.map_map,Function.comp_def] congr 1 apply List.map_congr_left intro j hj rw[(qAv _ (hg j (List.mem_range.1 hj)).1).2] obtain ⟨f1,e1⟩:=qAf ((List.range n).map g) (by intro q hq obtain ⟨j,hj,rfl⟩:=List.mem_map.1 hq exact (hg j (List.mem_range.1 hj)).1) (by simp; omega) (by rw[s1]; exact hA2) obtain ⟨f2,e2⟩:=qAf ((List.range n).map λj=>(g j).abs) (by intro q hq obtain ⟨j,hj,rfl⟩:=List.mem_map.1 hq exact (qAv _ (hg j (List.mem_range.1 hj)).1).1) (by simp; omega) (by rw[s3]; exact hA2) rw[s1,s2] at e1 rw[s3,s4] at e2 simp only[List.length_map,List.length_range] at e1 e2 exact ⟨f1,f2,qFo _ _,hA,e1,e2⟩ lemma qFr (n W Rv Sq Si z:ℝ) (hn1:1<=n) (hn2:n<=2^20) (hW:0<=W) (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) (h1 : |Rv-Sq| ≤ 2*n*(1/2^53*(Si+z))) (h2 : |Sq-W| ≤ 4/2^53*W+n*(1/2^250)) (h3:Si<=(1+4/2^53)*W+n*(1/2^250)) : |Rv-W| ≤ (2*n+6)/2^53*W+1/2^229:=by have hn0:0<=n :=ד have a1:2*n*(1/2^53*(Si+z)) ≤ 2*n*(1/2^53*((1+4/2^53)*W+n*(1/2^250)+z)):=by apply mul_le_mul_of_nonneg_left _ ד apply mul_le_mul_of_nonneg_left _ ב linarith have a2:2*n*(1/2^53*((1+4/2^53)*W+n*(1/2^250)+z)) = (2/2^53*(1+4/2^53))*(n*W)+(2/2^53*(1/2^250))*(n*n) + 2/2^53*(n*z):=by ring have a3:n*W<=2^20*W:=mul_le_mul_of_nonneg_right hn2 hW have a4:n*n<=2^20*2^20:=mul_le_mul hn2 hn2 hn0 ב have a5:n*z<=2^20*(1/2^200*(1/2^200)):=mul_le_mul hn2 hz hz0 ב have a6 : |Rv-W| ≤ |Rv-Sq| + |Sq-W|:=abs_sub_le _ _ _ have a7:(2*n+6)/2^53*W=2/2^53*(n*W)+6/2^53*W:=by ring rw[a7] linarith lemma qGl (n:ℕ) (hn:n<2^20) (hn0:0< n) (g:ℕ->Float) (m:Float) (hg:∀ j,j< n->(g j).isFinite=true∧|R (g j)| ≤ 2^99) (hm:m.isFinite=true) (hm2 : |R m| ≤ 2^110) : (A_fsum ((List.range n).map λj=>(g j-m)*(g j-m))).isFinite=true ∧ |R (A_fsum ((List.range n).map λj=>(g j-m)*(g j-m))) - ((List.range n).map λj=>(R (g j)-R m)^2).sum| ≤ (2*n+6)/2^53*((List.range n).map λj=>(R (g j)-R m)^2).sum+1/2^229 ∧ ((List.range n).map λj=>(R (g j)-R m)^2).sum<=n*2^222:=by have hz0:=qBi.le have hzl:=qAl have hq:∀ j,j< n->((g j-m)*(g j-m)).isFinite=true ∧ |R ((g j-m)*(g j-m))-(R (g j)-R m)^2| ≤ 4/2^53*(R (g j)-R m)^2+1/2^250∧(R (g j)-R m)^2<=2^222:=by intro j hj obtain ⟨f,b⟩:=hg j hj have B1 : |R (g j)| ≤ 2^110:=b.trans ב obtain ⟨f1,e1,b1⟩:=qB7 (g j) m (2^110) f hm B1 hm2 (by rw[qA2]; norm_num) have b2 : |R (g j-m)| ≤ 2^112:=by norm_num at hzl b1 ⊢; linarith obtain ⟨f2,e2,-⟩:=qAo _ _ (2^112) (2^112) f1 f1 b2 b2 (by rw[qA2]; norm_num) (by rw[qA2]; norm_num) have hx : |R (g j)-R m| ≤ 2^111:=(abs_sub _ _).trans (by norm_num at B1 hm2 ⊢; linarith) refine ⟨f2,qHo _ _ _ _ hz0 hzl hx e1 e2,?_⟩ have:=pow_le_pow_left₀ (abs_nonneg _) hx 2 rw[sq_abs] at this exact this.trans ב obtain ⟨a1,a2,a3⟩:=qF1 (List.range n) (λj=>R ((g j-m)*(g j-m))) (λj=>(R (g j)-R m)^2) (4/2^53) (1/2^250) (λj _=>sq_nonneg _) (λj hj=>(hq j (List.mem_range.1 hj)).2.1) ב ב simp only[List.length_range] at a1 a2 have hW:((List.range n).map λj=>(R (g j)-R m)^2).sum<=n*2^222:=by have:=qDk (List.range n) (λj=>(R (g j)-R m)^2) (2^222) (λj hj=>(hq j (List.mem_range.1 hj)).2.2) simpa using this have hnR:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have hnR1:(1:ℝ)<=n:=by exact_mod_cast hn0 have s1:A_sa ((List.range n).map λj=>(g j-m)*(g j-m)) = ((List.range n).map λj=>|R ((g j-m)*(g j-m))|).sum:=by simp only[A_sa,List.map_map,Function.comp_def] have s2:A_sr ((List.range n).map λj=>(g j-m)*(g j-m)) = ((List.range n).map λj=>R ((g j-m)*(g j-m))).sum:=by simp only[A_sr,List.map_map,Function.comp_def] have hb:((List.range n).map λj=>|R ((g j-m)*(g j-m))|).sum<=A_B/4:=by have h1:(n:ℝ)*2^222<=2^20*2^222:=by gcongr have h2:(n:ℝ)*(1/2^250)<=2^20*(1/2^250):=by gcongr rw[qA2] norm_num at h1 h2 hW a2 ⊢ linarith obtain ⟨f2,e2⟩:=qAf ((List.range n).map λj=>(g j-m)*(g j-m)) (by intro q hq' obtain ⟨j,hj,rfl⟩:=List.mem_map.1 hq' exact (hq j (List.mem_range.1 hj)).1) (by simp; omega) (by rw[s1]; exact hb) rw[s1,s2] at e2 simp only[List.length_map,List.length_range] at e2 exact ⟨f2,qFr _ _ _ _ _ _ hnR1 hnR a3 hz0 hzl e2 a1 a2,hW⟩ def L_ok (n:ℕ) (eps:Word) (x:Array Word) (r:ℕ) (s:LnS):Prop := s.den=sqrtRational (rowVariance n x r (rowMean n x r)+rationalWord eps) ∧ (s.fast=true->s.m.isFinite=true∧s.ir.isFinite=true∧s.em.isFinite=true ∧ R s.em<=2^120∧1/2^201<=R s.em∧2 * |((rowMean n x r:ℚ):ℝ)-R s.m| ≤ R s.em ∧ |R s.m| ≤ 2^110∧good s.den=true∧1/2^64<=wv s.den ∧ |R s.ir*wv s.den-1| ≤ 1/2^48) lemma qGd (n r:ℕ) (x:Array Word) (g:ℕ->Float) (h:∀ j,j< n → R (g j)=(rationalWord x[r*n+j]! : ℝ)) (q:ℚ) : ((rowMean n x r:ℚ):ℝ)=((List.range n).map λj=>R (g j)).sum/n ∧ ((rowVariance n x r q:ℚ):ℝ) = ((List.range n).map λj=>(R (g j)-(q:ℝ))^2).sum/n:=by constructor . unfold rowMean have e:=qD3 (List.range n) (λj=>rationalWord x[r*n+j]!) 0 beta_reduce at e rw[Rat.cast_div,e] push_cast rw[zero_add] congr 2 apply List.map_congr_left intro j hj exact (h j (List.mem_range.1 hj)).symm . unfold rowVariance have e:=qD3 (List.range n) (λj=>(rationalWord x[r*n+j]! - q)^2) 0 beta_reduce at e rw[Rat.cast_div,e] push_cast rw[zero_add] congr 2 apply List.map_congr_left intro j hj rw[h j (List.mem_range.1 hj)] lemma qG9 (n:ℕ) (hn0:0< n) (hn:n<2^20) (Fs Ft ind nf m em:Float) (S Sa c:ℝ) (hc:c=((n:ℝ)+8)/2^49) (o1:Fs.isFinite=true) (o2:Ft.isFinite=true) (o3 : |S| ≤ Sa) (o4:Sa<=n*2^99) (o5 : |R Fs-S| ≤ 2*n*(1/2^53*(Sa+A_z))) (o6 : |R Ft-Sa| ≤ 2*n*(1/2^53*(Sa+A_z))) (fnf:nf.isFinite=true) (Rnf:R nf=c) (fi:ind.isFinite=true) (pi:0< R ind) (ei : |R ind*n-1| ≤ 1/2^48) (hm:Fs*ind=m) (hem:nf*Ft*ind+Float.ofBits 0x3370000000000000=em) : m.isFinite=true∧em.isFinite=true∧R em<=2^120∧1/2^201<=R em ∧ 2 * |S/n-R m| ≤ R em∧|R m| ≤ 2^110:=by have hnR1:(1:ℝ)<=n:=by exact_mod_cast hn0 have hnR2:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have hnp:(n:ℝ)≠0:=by intro h0; rw[h0] at hnR1; norm_num at hnR1 have hz0:=qBi.le have hzl:=qAl have hzb:A_z<=1:=hzl.trans ב have hc0:0< c:=by rw[hc]; positivity have hc1:c<=1/2^20:=by rw[hc]; linarith have hI2:R ind<=2:=by have h1:R ind*1<=R ind*n:=mul_le_mul_of_nonneg_left hnR1 pi.le have h2:=(abs_le.mp ei).2 linarith have bI : |R ind| ≤ 2:=by rw[abs_of_pos pi]; exact hI2 have hSa0:0<=Sa:=(abs_nonneg _).trans o3 have hSb:Sa<=2^119:=by have:(n:ℝ)*2^99<=2^20*2^99:=mul_le_mul_of_nonneg_right hnR2 ב linarith have o7:2*(n:ℝ)*(1/2^53*(Sa+A_z))<=2^90:=by have a1:(n:ℝ)*(1/2^53*(Sa+A_z))<=2^20*(1/2^53*(2^119+1)) := mul_le_mul hnR2 (mul_le_mul_of_nonneg_left ד ב) (mul_nonneg ב ד) ב have e:2*(n:ℝ)*(1/2^53*(Sa+A_z))=2*((n:ℝ)*(1/2^53*(Sa+A_z))):=by ring rw[e]; linarith have AB:∀ k:ℝ,k<=2^256*2^44->k<=A_B:=λk h=>by rw[qA2]; exact h have bs : |R Fs| ≤ 2^120:=by have:=qAa (R Fs) S linarith have bt : |R Ft| ≤ 2^120:=by have:=qAa (R Ft) Sa rw[abs_of_nonneg hSa0] at this linarith have bnf : |R nf| ≤ 1:=by rw[Rnf,abs_of_pos hc0]; linarith obtain ⟨fm,em1,-⟩:=qAo Fs ind (2^120) 2 o1 fi bs bI (AB _ ב) (AB _ ב) rw[hm] at fm em1 obtain ⟨fN,emN,bN⟩:=qAo nf Ft 1 (2^120) fnf o2 bnf bt (AB _ ב) (AB _ ב) rw[Rnf] at emN obtain ⟨fY,emY,bY⟩:=qAo (nf*Ft) ind (2^122) 2 fN fi ד bI (AB _ ב) (AB _ ב) obtain ⟨k1,k2⟩:=qFp obtain ⟨fE,emE,-⟩:=qAq (nf*Ft*ind) (Float.ofBits 0x3370000000000000) (2^125) fY k1 ד (by rw[k2,abs_of_pos ב]; norm_num) (AB _ ב) rw[k2,hem] at emE rw[hem] at fE have hnpos:(0:ℝ)< n :=ד have eS:(n:ℝ)*(S/n)=S:=by field_simp have eA:(n:ℝ)*(Sa/n)=Sa:=by field_simp obtain ⟨m1,m2,m3,m4⟩:=qGb n (S/n) (Sa/n) (R Fs) (R Ft) (R ind) (R m) (R (nf*Ft)) (R (nf*Ft*ind)) (R em) c A_z hnR1 hnR2 hc hz0 hzl (by rw[abs_div,abs_of_pos hnpos]; exact div_le_div_of_nonneg_right o3 hnpos.le) (by rw[div_le_iff₀ hnpos]; linarith) (by rw[eS,eA]; exact o5) (by rw[eA]; exact o6) pi ei em1 emN emY emE exact ⟨fm,fE,m2,m3,m1,m4⟩ lemma qHl (n:ℕ) (hn0:0< n) (hn:n<2^20) (v ind tt:Float) (eps:Word) (W c:ℝ) (hc:c=((n:ℝ)+8)/2^49) (p1:v.isFinite=true) (p2 : |R v-W| ≤ (2*n+6)/2^53*W+1/2^229) (p3:W<=n*2^222) (hW0:0<=W) (fi:ind.isFinite=true) (pi:0< R ind) (ei : |R ind*n-1| ≤ 1/2^48) (gE:good eps=true) (bE : |wv eps| ≤ 2^99) (hep0:0< wv eps) (htt:v*ind+dv eps=tt) : tt.isFinite=true∧|R tt-(W/n+wv eps)| ≤ c/2*(W/n+wv eps):=by have hnR1:(1:ℝ)<=n:=by exact_mod_cast hn0 have hnR2:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have hnpos:(0:ℝ)< n :=ד have hnp:(n:ℝ)≠0:=hnpos.ne' have hz0:=qBi.le have hzl:=qAl have hzb:A_z<=1:=hzl.trans ב have AB:∀ k:ℝ,k<=2^256*2^44->k<=A_B:=λk h=>by rw[qA2]; exact h have hI2:R ind<=2:=by have h1:R ind*1<=R ind*n:=mul_le_mul_of_nonneg_left hnR1 pi.le have h2:=(abs_le.mp ei).2 linarith have bI : |R ind| ≤ 2:=by rw[abs_of_pos pi]; exact hI2 have bW:W<=2^243:=by have:(n:ℝ)*2^222<=2^20*2^222:=mul_le_mul_of_nonneg_right hnR2 ב linarith have bv : |R v| ≤ 2^250:=by have a1:=qAa (R v) W rw[abs_of_nonneg hW0] at a1 have a2:(2*(n:ℝ)+6)/2^53<=1 :=ד have a3:(2*(n:ℝ)+6)/2^53*W<=1*W:=mul_le_mul_of_nonneg_right a2 hW0 linarith obtain ⟨fp,ep1,bp⟩:=qAo v ind (2^250) 2 p1 fi bv bI (AB _ ב) (AB _ ב) obtain ⟨de1,de2⟩:=qA3 eps gE have hep1:=qG6 eps gE hep0 obtain ⟨ft,et,-⟩:=qAq (v*ind) (dv eps) (2^253) fp de1 ד (by rw[de2]; exact bE.trans ב) (AB _ ב) rw[de2,htt] at et rw[htt] at ft exact ⟨ft,qGz n (W/n) (R v) (R ind) (R (v*ind)) (R tt) (wv eps) c (1/2^229) A_z hnR1 hnR2 hc (div_nonneg hW0 hnpos.le) hep1 hz0 hzl ב le_rfl (by rw[show (n:ℝ)*(W/n)=W by field_simp]; exact p2) pi ei ep1 et⟩ lemma qHj (tt nf em:Float) (E:ℕ) (hE1:1<=E) (hE:E<=1222) (hEe:(tt.toBits >>> 52).toNat=E) (c P δ T:ℝ) (hc1:c<=1/2^20) (hc2:9/2^49<=c) (fnf:nf.isFinite=true) (Rnf:R nf=c) (fE:em.isFinite=true) (m2:R em<=2^120) (m3:1/2^201<=R em) (hP0:0< P) (hq1 : |R tt-P| ≤ c/2*P) (m1:2 * |δ| ≤ R em) (hT:T=P-δ^2) (hT0:0< T) : R (Float.sqrt tt-((nf+nf)*Float.sqrt tt+em))< Real.sqrt T ∧ Real.sqrt T< R (Float.sqrt tt+((nf+nf)*Float.sqrt tt+em)) ∧ Real.sqrt T<2^(127:ℤ):=by have hz0:=qBi.le have hzl:=qAl have hzb:A_z<=1:=hzl.trans ב have AB:∀ k:ℝ,k<=2^256*2^44->k<=A_B:=λk h=>by rw[qA2]; exact h have hc0:0< c:=lt_of_lt_of_le ב hc2 obtain ⟨-,-,u1⟩:=qCs tt E hE1 א hEe obtain ⟨fd,ptt,ed⟩:=qFh tt E hE1 א hEe obtain ⟨d,hd⟩:∃ d,d=Float.sqrt tt:=⟨_,rfl⟩ rw[<-hd] at fd ed ⊢ have ht2:R tt<=2^200:=by refine u1.le.trans ?_ have:(2:ℝ)^(200:ℕ)=2^(200:ℤ) :=ב rw[this] exact zpow_le_zpow_right₀ ב א obtain ⟨s',hs'⟩:∃ s',s'=Real.sqrt (R tt):=⟨_,rfl⟩ rw[<-hs'] at ed have hs0:0< s':=by rw[hs']; exact Real.sqrt_pos.mpr ptt have hsq:s'^2=R tt:=by rw[hs']; exact Real.sq_sqrt ptt.le have hs1:s'<=2^100:=by rw[hs',Real.sqrt_le_iff] refine ⟨by norm_num,ht2.trans ב⟩ have bd : |R d| ≤ 2^102:=by have a1:=qAa (R d) s' rw[abs_of_pos hs0] at a1 linarith have bnf : |R nf| ≤ 1:=by rw[Rnf,abs_of_pos hc0]; linarith obtain ⟨f2n,e2n,b2n⟩:=qAq nf nf 1 fnf fnf bnf bnf (AB _ ב) rw[Rnf] at e2n obtain ⟨fmu,emu,bmu⟩:=qAo (nf+nf) d 4 (2^102) f2n fd ד bd (AB _ ב) (AB _ ב) have hEm0:0<=R em:=le_trans ב m3 have bEm : |R em| ≤ 2^120:=by rw[abs_of_nonneg hEm0]; exact m2 obtain ⟨fe,ee,be⟩:=qAq ((nf+nf)*d) em (2^120) fmu fE ד bEm (AB _ ב) obtain ⟨fh,eh,-⟩:=qAq d _ (2^123) fd fe (bd.trans ב) ד (AB _ ב) obtain ⟨fl,el,-⟩:=qB7 d _ (2^123) fd fe (bd.trans ב) ד (AB _ ב) obtain ⟨hhi,hlo⟩:=qF3 s' c (R em) (R d) (R (nf+nf)) (R ((nf+nf)*d)) (R ((nf+nf)*d+em)) _ _ A_z hz0 hzl hs0.le (hs1.trans ב) hc2 hc1 m3 m2 ed e2n emu ee eh el obtain ⟨b1,b2⟩:=abs_le.mp hq1 have hδ2:δ^2<=R em^2/4:=by have a1:(2 * |δ|)^2<=R em^2:=pow_le_pow_left₀ (by positivity) m1 2 rw[mul_pow,sq_abs] at a1 linarith have nP:0<=c*P:=(mul_pos hc0 hP0).le have a3:c*(c*P)<=1*(c*P):=mul_le_mul_of_nonneg_right ד nP have a4:0<=c*(c*P):=mul_nonneg hc0.le nP have nd2:=sq_nonneg δ have h1':T<=s'^2*(1+c):=by rw[hsq,hT] have a1:(P-c/2*P)*(1+c)<=R tt*(1+c) := mul_le_mul_of_nonneg_right ד ד linarith have h2':s'^2*(1-c)-R em^2/4<=T:=by rw[hsq,hT] have a1:R tt*(1-c)<=(P+c/2*P)*(1-c) := mul_le_mul_of_nonneg_right ד ד linarith obtain ⟨l1,l2⟩:=qF6 T s' c (R em) _ _ hT0 hs0 hc0 hc1 hEm0 h1' h2' hhi hlo refine ⟨l1,l2,?_⟩ rw[Real.sqrt_lt' (by positivity)] have e:((2:ℝ)^(127:ℤ))^2=2^254 :=ב rw[e] have a1:s'^2*(1+c)<=2^200*2 := mul_le_mul (by rw[hsq]; exact ht2) ד ד ב linarith lemma qGk (rows n:ℕ) (eps:Word) (x:Array Word) (r:ℕ) (hr:r< rows) (hn0:0< n) (hn:n<2^20) (hs:x.size=rows*n) (hrn:rows*n<2^32) (hx:x.all sm=true) (he:sm eps=true) (he0:0< rationalWord eps) : L_ok n eps x r (lnStat n eps x r):=by have hmul:r*n+n<=rows*n:=by have:(r+1)*n<=rows*n:=Nat.mul_le_mul_right n hr rwa [Nat.succ_mul] at this have hsm:∀ j,j< n->sm x[r*n+j]! = true:=by intro j h have h2:r*n+j< x.size :=א rw[getElem!_pos x _ h2] have:=(Array.all_eq_true.1 hx) _ h2 simpa using this obtain ⟨g,hgd⟩:∃ g:ℕ->Float,g=λj=>dv x[r*n+j]!:=⟨_,rfl⟩ have hg0:∀ j,j< n->(g j).isFinite=true∧|R (g j)| ≤ 2^99 ∧ R (g j)=(rationalWord x[r*n+j]! : ℝ):=by intro j h obtain ⟨a1,a2⟩:=qA9 _ (hsm j h) obtain ⟨a3,a4⟩:=qA3 _ a1 rw[hgd] beta_reduce rw[a4] exact ⟨a3,a2,qA7 _ (qAh _ a1)⟩ have hg:∀ j,j< n->(g j).isFinite=true∧|R (g j)| ≤ 2^99 := λj h=>⟨(hg0 j h).1,(hg0 j h).2.1⟩ obtain ⟨o1,o2,o3,o4,o5,o6⟩:=qGg n hn g hg obtain ⟨hMc,hVc⟩:=qGd n r x g (λj h=>(hg0 j h).2.2) (rowMean n x r) rw[hMc] at hVc obtain ⟨S,hS⟩:∃ S,S=((List.range n).map λj=>R (g j)).sum:=⟨_,rfl⟩ obtain ⟨Sa,hSa⟩:∃ A,A=((List.range n).map λj=>|R (g j)|).sum:=⟨_,rfl⟩ rw[<-hS,<-hSa] at o3 o5 rw[<-hSa] at o4 o6 rw[<-hS] at hMc hVc unfold lnStat dsimp only generalize hnu:n.toUSize=nu generalize hbase:(r*n).toUSize=base generalize hnd:n.toUInt64.toFloat=nd generalize hnf:(n.toUInt64+8).toFloat*Float.ofBits 0x3CE0000000000000=nf generalize hind:(1.0:Float)/nd=ind generalize ha:lnSum x base nu 0 0 0=a generalize hm:a.s*ind=m generalize hv:lnVar x base nu 0 m 0=v generalize hem:nf*a.t*ind+Float.ofBits 0x3370000000000000=em generalize htt:v*ind+dv eps=tt generalize hd:Float.sqrt tt=d generalize hz:ziv d ((nf+nf)*d+em)=z generalize hir:(1.0:Float)/dv z=ir split . rename_i hc simp only[Bool.and_eq_true,decide_eq_true_eq] at hc obtain ⟨⟨⟨⟨⟨c1,c2⟩,c3⟩,c4⟩,c5⟩,c6⟩:=hc have hnR1:(1:ℝ)<=n:=by exact_mod_cast hn0 have hnR2:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have hnp:(n:ℝ)≠0:=by intro h0; rw[h0] at hnR1; norm_num at hnR1 have hz0:=qBi.le have hzl:=qAl have hzb:A_z<=1:=hzl.trans ב have hu:nu.toNat=n:=by rw[<-hnu]; exact qAu n א have hb:base.toNat=r*n:=by rw[<-hbase]; exact qAu _ א have hxs:x.size<2^32 :=א have hA:a=⟨A_fsum ((List.range n).map g),A_fsum ((List.range n).map λj=>(g j).abs)⟩:=by rw[<-ha,qFt x hxs base nu א n 0 0 0 (by simp[hu])] simp only[USize.toNat_zero,hb,hgd,A_fsum,List.range_eq_range'] obtain ⟨Fs,hFs⟩:∃ q,q=A_fsum ((List.range n).map g):=⟨_,rfl⟩ obtain ⟨Ft,hFt⟩:∃ q,q=A_fsum ((List.range n).map λj=>(g j).abs):=⟨_,rfl⟩ rw[<-hFs,<-hFt] at hA rw[<-hFs] at o1 o5 rw[<-hFt] at o2 o6 subst hA dsimp only at hm hem obtain ⟨fnf,Rnf⟩:nf.isFinite=true∧R nf=((n:ℝ)+8)/2^49:=by rw[<-hnf]; exact qHe n hn obtain ⟨c,hc⟩:∃ c:ℝ,c=((n:ℝ)+8)/2^49:=⟨_,rfl⟩ rw[<-hc] at Rnf have hc1:c<=1/2^20:=by rw[hc]; linarith have hc2:9/2^49<=c:=by rw[hc]; linarith obtain ⟨fnd,Rnd⟩:nd.isFinite=true∧R nd=n:=by rw[<-hnd] have e:n.toUInt64.toNat=n:=by simp; omega have:=qCf n.toUInt64 א rwa [e] at this obtain ⟨fi,pi,bi,ei⟩:=qE6 ind nd fnd (by rw[Rnd,abs_of_nonneg ד]; exact hnR2.trans ב) c5 rw[Rnd] at ei obtain ⟨fm,fE,m2,m3,m1,m4⟩ := qG9 n hn0 hn Fs Ft ind nf m em S Sa c hc o1 o2 o3 o4 o5 o6 fnf Rnf fi pi ei hm hem have hV:v=A_fsum ((List.range n).map λj=>(g j-m)*(g j-m)):=by rw[<-hv,qFx x hxs base nu m א n 0 0 (by simp[hu])] simp only[USize.toNat_zero,hb,hgd,A_fsum,List.range_eq_range'] obtain ⟨p1,p2,p3⟩:=qGl n hn hn0 g m hg fm m4 rw[<-hV] at p1 p2 obtain ⟨W,hW⟩:∃ W,W=((List.range n).map λj=>(R (g j)-R m)^2).sum:=⟨_,rfl⟩ rw[<-hW] at p2 p3 have hW0:0<=W:=by rw[hW] apply List.sum_nonneg intro y hy obtain ⟨j,-,rfl⟩:=List.mem_map.1 hy exact sq_nonneg _ have hs2:=qE9 (List.range n) (λj=>R (g j)) (R m) (by simpa using hnp) simp only[List.length_range] at hs2 rw[<-hS,<-hW] at hs2 obtain ⟨V0,hV0⟩:∃ V,V=((List.range n).map λj=>(R (g j)-S/n)^2).sum:=⟨_,rfl⟩ rw[<-hV0] at hVc hs2 obtain ⟨δ,hδ⟩:∃ δ,δ=S/n-R m:=⟨_,rfl⟩ rw[<-hδ] at hs2 m1 have hnpos:(0:ℝ)< n :=ד have hWs:W/n=V0/n+δ^2:=by rw[hs2]; field_simp obtain ⟨gE,bE⟩:=qA9 eps he have epsv:wv eps=(rationalWord eps:ℝ):=qA7 _ (qAh _ gE) have hep0:0< wv eps:=by rw[epsv]; exact_mod_cast he0 obtain ⟨ft,hq1⟩:=qHl n hn0 hn v ind tt eps W c hc p1 p2 p3 hW0 fi pi ei gE bE hep0 htt obtain ⟨q,hq⟩:∃ q,q=rowVariance n x r (rowMean n x r)+rationalWord eps:=⟨_,rfl⟩ have hV1:0<=V0/n:=by rw[hV0] apply div_nonneg _ hnpos.le apply List.sum_nonneg intro y hy obtain ⟨j,-,rfl⟩:=List.mem_map.1 hy exact sq_nonneg _ have hT:(q:ℝ)=(W/n+wv eps)-δ^2:=by rw[hq,Rat.cast_add,hVc,epsv,hWs]; ring have hT0:(0:ℝ)< q:=by rw[hT,hWs]; linarith have hP0:0< W/n+wv eps:=by have:=div_nonneg hW0 hnpos.le; linarith obtain ⟨r1,r2⟩:=qD0 _ 1 1222 c4 (by decide) have e1:(1:UInt64).toNat=1:=rfl have e2:(1222:UInt64).toNat=1222:=rfl rw[e1] at r1 rw[e1,e2] at r2 obtain ⟨l1,l2,hb127⟩:=qHj tt nf em _ r1 א rfl c _ δ (q:ℝ) hc1 hc2 fnf Rnf fE m2 m3 hP0 hq1 m1 hT hT0 rw[hd] at l1 l2 have hq0:0< q:=by exact_mod_cast hT0 have hzne:ziv d ((nf+nf)*d+em)≠0xFFFFFFFF:=by rw[hz] intro e0 rw[e0] at c3 exact absurd c3 (by decide) have hden:z=sqrtRational q:=((qGj d _ q hq0 l1 l2 hzne hb127).trans hz).symm obtain ⟨gZ,bZ⟩:=qA9 z c1 obtain ⟨dz1,dz2⟩:=qA3 z gZ obtain ⟨fi2,-,-,ei2⟩:=qE6 ir (dv z) dz1 (by rw[dz2]; exact bZ) c6 rw[dz2] at ei2 unfold L_ok dsimp only rw[<-hq,hMc,<-hδ] exact ⟨hden,λ_=>⟨fm,fi2,fE,m2,m3,m1,m4,gZ,qG5 z gZ c2 c3,ei2⟩⟩ . exact ⟨rfl,by simp⟩ lemma qHh (m ir em:Float) (w gw bw:Word) (M D:ℝ) (fm:m.isFinite=true) (fi:ir.isFinite=true) (fe:em.isFinite=true) (e1:R em<=2^120) (e2:1/2^201<=R em) (e3:2 * |M-R m| ≤ R em) (e4 : |R m| ≤ 2^110) (hD:1/2^64<=D) (hI : |R ir*D-1| ≤ 1/2^48) (hw:sm w=true) (hg:sm gw=true) (hb:sm bw=true) (s e:Float) (hs:s=(dv w-m)*(dv gw*ir)+dv bw) (he:e=Float.ofBits 0x3D10000000000000*(((dv w-m)*(dv gw*ir)).abs+(dv bw).abs) + em*(dv gw*ir).abs) (hne:ziv s e≠0xFFFFFFFF) : R (s-e)<(wv w-M)*wv gw/D+wv bw∧(wv w-M)*wv gw/D+wv bw< R (s+e):=by have hz0:=qBi.le have hzl:=qAl have hzb:A_z<=1:=hzl.trans ב have AB:∀ k:ℝ,k<=2^256*2^44->k<=A_B:=λk h=>by rw[qA2]; exact h obtain ⟨gw1,bw1⟩:=qA9 w hw obtain ⟨gg1,bg1⟩:=qA9 gw hg obtain ⟨gb1,bb1⟩:=qA9 bw hb obtain ⟨fw,Rw⟩:=qA3 w gw1 obtain ⟨fg,Rg⟩:=qA3 gw gg1 obtain ⟨fb,Rb⟩:=qA3 bw gb1 have hD0:0< D:=lt_of_lt_of_le ב hD have bI : |R ir| ≤ 2^65:=by have a1 : |R ir*D| ≤ 2:=by have:=qAa (R ir*D) 1 rw[abs_one] at this linarith rw[abs_mul,abs_of_pos hD0] at a1 have a2 : |R ir| * (1/2^64) ≤ |R ir| * D := mul_le_mul_of_nonneg_left hD (abs_nonneg _) linarith obtain ⟨f1,h1,b1⟩:=qB7 (dv w) m (2^111) fw fm (by rw[Rw]; exact bw1.trans ב) (e4.trans ב) (AB _ ב) rw[Rw] at h1 obtain ⟨f2,h3,b2⟩:=qAo (dv gw) ir (2^99) (2^65) fg fi (by rw[Rg]; exact bg1) bI (AB _ ב) (AB _ ב) rw[Rg] at h3 obtain ⟨f3,h4,b3⟩:=qAo _ _ (2^113) (2^166) f1 f2 ד ד (AB _ ב) (AB _ ב) obtain ⟨Q,hQ⟩:∃ Q,Q=(dv w-m)*(dv gw*ir):=⟨_,rfl⟩ obtain ⟨G,hG⟩:∃ G,G=dv gw*ir:=⟨_,rfl⟩ rw[<-hQ] at hs he f3 h4 b3 rw[<-hG] at he f2 h3 b2 h4 hQ obtain ⟨f4,h5,b4⟩:=qAq Q (dv bw) (2^250*2^31) f3 fb (by norm_num at b3 hzb ⊢; linarith) (by rw[Rb]; exact bb1.trans ב) (AB _ ב) rw[Rb,<-hs] at h5 rw[<-hs] at f4 b4 obtain ⟨fa1,Ra1⟩:=qAv Q f3 obtain ⟨fa2,Ra2⟩:=qAv (dv bw) fb rw[Rb] at Ra2 obtain ⟨fa3,Ra3⟩:=qAv G f2 obtain ⟨f5,h6,b5⟩:=qAq Q.abs (dv bw).abs (2^250*2^31) fa1 fa2 (by rw[Ra1,abs_abs]; norm_num at b3 hzb ⊢; linarith) (by rw[Ra2,abs_abs]; exact bb1.trans ב) (AB _ ב) rw[Ra1,Ra2] at h6 obtain ⟨k1,k2⟩:=qG8 obtain ⟨f6,h7,b6⟩:=qAo _ _ 1 (2^250*2^33) k1 f5 (by rw[k2,abs_of_pos ב]; norm_num) (by norm_num at b5 hzb ⊢; linarith) (AB _ ב) (AB _ ב) rw[k2] at h7 have bE : |R em| ≤ 2^120:=by rw[abs_of_nonneg (le_trans ב e2)]; exact e1 obtain ⟨f7,h8,b7⟩:=qAo em G.abs (2^120) (2^166) fe fa3 bE (by rw[Ra3,abs_abs]; linarith) (AB _ ב) (AB _ ב) rw[Ra3] at h8 obtain ⟨f8,h9,b8⟩:=qAq _ _ (2^250*2^38) f6 f7 (by norm_num at b6 hzb ⊢; linarith) (by norm_num at b7 hzb ⊢; linarith) (AB _ ב) rw[<-he] at f8 h9 b8 obtain ⟨f9,h10,-⟩:=qAq s e (2^250*2^41) f4 f8 (by norm_num at b4 hzb ⊢; linarith) (by norm_num at b8 hzb ⊢; linarith) (AB _ ב) obtain ⟨f10,h11,-⟩:=qB7 s e (2^250*2^41) f4 f8 (by norm_num at b4 hzb ⊢; linarith) (by norm_num at b8 hzb ⊢; linarith) (AB _ ב) obtain ⟨-,-,big⟩:=qBs s e hne have e0:(2:ℝ)^(-127:ℤ)=1/2^127 :=ב rw[e0] at big exact qGi _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ hz0 hzl (le_trans ב e2) e1 e3 hD bw1 bg1 e4 h1 hI h3 h4 h5 h6 h7 h8 h9 h10 h11 big lemma qFq (s:LnS) (M:ℚ) (mean:Unit->ℚ) (hmean:mean ()=M) (w gw bw:Word) (hw:sm w=true) (hg:sm gw=true) (hb:sm bw=true) (h:s.fast=true->s.m.isFinite=true∧s.ir.isFinite=true∧s.em.isFinite=true ∧ R s.em<=2^120∧1/2^201<=R s.em∧2 * |(M:ℝ)-R s.m| ≤ R s.em ∧ |R s.m| ≤ 2^110∧good s.den=true∧1/2^64<=wv s.den ∧ |R s.ir*wv s.den-1| ≤ 1/2^48) : lnOut s w gw bw mean = roundRational ((rationalWord w-M)*rationalWord gw/rationalWord s.den+rationalWord bw):=by unfold lnOut split . rename_i hf obtain ⟨fm,fi,fe,e1,e2,e3,e4,gd,hD,hI⟩:=h hf dsimp only split . unfold lnSlow; rw[hmean] . rename_i hc have hne:ziv ((dv w-s.m)*(dv gw*s.ir)+dv bw) (Float.ofBits 0x3D10000000000000*(((dv w-s.m)*(dv gw*s.ir)).abs+(dv bw).abs) + s.em*(dv gw*s.ir).abs)≠0xFFFFFFFF:=by intro e0 rw[e0] at hc exact hc (by decide) obtain ⟨l1,l2⟩:=qHh s.m s.ir s.em w gw bw M (wv s.den) fm fi fe e1 e2 e3 e4 hD hI hw hg hb _ _ rfl rfl hne have ew:=qA7 w (qAh _ (qA9 w hw).1) have eg:=qA7 gw (qAh _ (qA9 gw hg).1) have eb:=qA7 bw (qAh _ (qA9 bw hb).1) have ed:=qA7 s.den (qAh _ gd) have hV:(((rationalWord w-M)*rationalWord gw/rationalWord s.den+rationalWord bw:ℚ):ℝ) = (wv w-M)*wv gw/wv s.den+wv bw:=by rw[ew,eg,eb,ed]; push_cast; ring rw[<-hV] at l1 l2 obtain ⟨-,hb2⟩:=qHm _ _ _ l1 l2 hc exact (qGo _ _ _ l1 l2 hne hb2).symm . unfold lnSlow; rw[hmean] lemma qCv {α:Type} [Inhabited α] (rows k:ℕ) (f:ℕ->α) (hk:k< rows) : (Array.ofFn (n:=rows) λr=>f r.val)[k]! = f k:=by rw[getElem!_pos _ k (by simpa using hk),Array.getElem_ofFn] lemma qDs (a:Array UInt32) (p:UInt32->Bool) (h:a.all p=true) (i:ℕ) (hi:i< a.size) : p a[i]! = true:=by rw[getElem!_pos a i hi] have:=(Array.all_eq_true.1 h) i hi simpa using this lemma qFj:lnF=layernormSpec:=by funext rows n eps x g b unfold lnF split . rename_i hc simp only[Bool.and_eq_true,beq_iff_eq,decide_eq_true_eq] at hc obtain ⟨⟨⟨⟨⟨⟨⟨⟨hD,h2⟩,h3⟩,h4⟩,h5⟩,h6⟩,h7⟩,h8⟩,h9⟩:=hc have hs:(stableNormDomain rows n eps x g && b.size == n && b.all finiteWord)=true:=by simp only[Bool.and_eq_true,beq_iff_eq] exact ⟨⟨hD,h2⟩,h3⟩ unfold layernormSpec layernormWith rw[if_pos hs] unfold layernormStable dsimp only unfold stableNormDomain at hD simp only[Bool.and_eq_true,beq_iff_eq,gt_iff_lt,decide_eq_true_eq] at hD obtain ⟨⟨⟨⟨⟨⟨⟨h10,h11⟩,h12⟩,h13⟩,-⟩,-⟩,-⟩,h14⟩:=hD apply Array.ext ג intro q h1 h1' simp only[Array.getElem_ofFn,Array.size_ofFn] at h1 h1' ⊢ have hr:q/n< rows:=Nat.div_lt_of_lt_mul (by rwa [Nat.mul_comm]) have hj:q%n< n:=Nat.mod_lt _ h11 have e1:=qCv rows (q/n) (λr=>lnStat n eps x r) hr have e2:=qCv rows (q/n) (λr=>rowMean n x r) hr have e3:=qCv rows (q/n) (λr=>sqrtRational (rowVariance n x r ((Array.ofFn (n:=rows) λr=>rowMean n x r.val)[r]!)+rationalWord eps)) hr beta_reduce at e1 e2 e3 rw[e1,e3,e2] obtain ⟨o1,o2⟩:=qGk rows n eps x (q/n) hr h11 h8 h12 h9 h4 h7 h14 rw[qFq _ (rowMean n x (q/n)) _ rfl _ _ _ (qDs x sm h4 q א) (qDs g sm h5 _ א) (qDs b sm h6 _ א) o2,o1] . rfl end lemma qFa:addF=addReluSpec:=qEo lemma qEx:gemmF=gemmSpec:=qEd lemma qFw:lnF=layernormSpec:=qFj def kernels:Kernels where core:=specCore dense:=⟨linF,gemmF⟩ conv:=specConv elem:=⟨avgpoolSpec,maxpoolSpec,addF,scaleShiftSpec⟩ norm:=⟨rmsnormSpec,lnF⟩ lemma correct:Obligation kernels:=by simp only[Obligation,kernels,specKernels,specDense,specElem,specNorm,qDl,qFa,qEx,qFw] end Submission