import ContractExact namespace Public99 structure Acc where (pos neg:Array Nat) (special negZero:Bool) end Public99 namespace Public99 structure F1 where (s t:Float) end Public99 namespace Public99 structure R1 where (ix:Array UInt32) (buf:FloatArray) (c:USize) (hi:UInt32) end Public99 namespace Public99 structure F4 where (a b c d:Float) end Public99 namespace Public99 structure LnS where fast:Bool m:Float ir:Float em:Float den:UInt32 deriving Inhabited end Public99 namespace Submission.FP64 structure GR4 where s0:Float s1:Float s2:Float s3:Float end Submission.FP64 namespace Submission.FP64 structure GR8 where s0:Float s1:Float s2:Float s3:Float s4:Float s5:Float s6:Float s7:Float end Submission.FP64 namespace Submission.FP64 structure GR12 where s0:Float s1:Float s2:Float s3:Float s4:Float s5:Float s6:Float s7:Float s8:Float s9:Float s10:Float s11:Float end Submission.FP64 namespace Public99 open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Floats.ExecFloat.Binary local notation"А"=>USize.lt_iff_toNat_lt local notation"Б"=>mul_le_mul_of_nonneg_right local notation"В"=>0x7FFFFFFF local notation"Г"=>mul_le_mul_of_nonneg_left local notation"Д"=>rationalWord local notation"Е"=>0xFFFFFFFF local notation"Ж"=>abs_of_nonneg local notation"З"=>Nat.mod_eq_of_lt local notation"И"=>Array.replicate local notation"Й"=>abs_nonneg local notation"К"=>List.range local notation"Л"=>Nat.zero_add local notation"М"=>UInt32.le_iff_toNat_le local notation"Н"=>mul_nonneg local notation"О"=>Nat.and_two_pow_sub_one_eq_mod local notation"П"=>Float.ofBits local notation"Р"=>two_ne_zero local notation"С"=>mul_le_mul local notation"Т"=>Nat.mul_le_mul_right local notation"У"=>dite_eq_left local notation"Ф"=>FloatArray.emptyWithCapacity local notation"Х"=>ite_eq_right local notation"Ц"=>0x7F800000 local notation"Ч"=>Model.roundDyadic local notation"Ш"=>zpow_le_zpow_right₀ local notation"Щ"=>UInt32.toNat_inj local notation"Ъ"=>dite_eq_right local notation"Ы"=>toDyadic_ofUInt32 local notation"Ь"=>abs_add_le local notation"Э"=>getElem!_pos local notation"Ю"=>Nat.cast_nonneg local notation"Я"=>Model.isFinite local notation"а"=>zpow_add₀ local notation"б"=>mul_lt_mul_of_pos_right local notation"в"=>Model.toReal local notation"г"=>abs_of_pos local notation"д"=>FloatLib.Numerics.Dyadic.cast_toRat local notation"е"=>abs_mul local notation"ж"=>Nat.mul_comm local notation"з"=>ite_eq_left local notation"и"=>abs_sub_comm local notation"й"=>List.mem_range local notation"к"=>zpow_natCast local notation"л"=>UInt64.toNat_add local notation"м"=>Nat.div_lt_of_lt_mul local notation"н"=>UInt32.toNat_toUSize local notation"о"=>Model.toReal_eq_unpackedToReal_toModel local notation"п"=>Real.sqrt local notation"р"=>Finset.range local notation"с"=>Nat.add_assoc local notation"т"=>Nat.shiftRight_eq_div_pow local notation"у"=>Nat.add_zero local notation"ф"=>Float.sqrt local notation"х"=>0x80000000 local notation"ц"=>lt_of_le_of_lt local notation"ч"=>lt_of_lt_of_le local notation"ш"=>Nat.div_eq_of_lt local notation"щ"=>Nat.shiftLeft_eq local notation"ъ"=>UInt64.toNat_shiftRight local notation"ы"=>zpow_pos local notation"ь"=>FloatLib.Numerics.binaryRadix local notation"э"=>Nat.mod_lt local notation"ю"=>UInt32.lt_iff_toNat_lt local notation"я"=>UInt64.lt_iff_toNat_lt local notation"ذ"=>Bool.and_eq_true_iff local notation"ر"=>Finset.sum_congr local notation"ز"=>UInt32.toNat_and local notation"س"=>UInt32.toNat_ofNat' local notation"ش"=>USize.toNat_one local notation"ص"=>Nat.pos_of_ne_zero local notation"ض"=>pow_le_pow_left₀ local notation"ط"=>0x3CE0000000000000 local notation"ظ"=>Model.modelSignBit local notation"ع"=>Nat.le_mul_of_pos_right local notation"غ"=>getElem!_neg local notation"ػ"=>Nat.succ_mul local notation"ؼ"=>Float.Model.UnpackedFloat.unpack local notation"ؽ"=>Finset.mem_range local notation"ؾ"=>le_trans local notation"ؿ"=>List.mem_of_getElem? local notation"ـ"=>Nat.mul_add_div local notation"ف"=>Nat.mul_add_mod local notation"ق"=>sq_nonneg local notation"ك"=>0x3370000000000000 local notation"ل"=>Model.toModel_ofFloatModel local notation"م"=>Nat.add_mul local notation"ن"=>zpow_sub₀ local notation"ه"=>Array.ext local notation"و"=>UInt64.toNat_and local notation"ى"=>FloatLib.Numerics.Dyadic.toRat_eq_zero_iff local notation"ي"=>UInt32.toNat_sub_of_le local notation"Ա"=>List.foldl_cons local notation"Բ"=>List.mem_cons_of_mem local notation"Գ"=>List.range_eq_range' local notation"Դ"=>Nat.one_mul local notation"Ե"=>abs_sub local notation"Զ"=>List.map_congr_left local notation"Է"=>List.mem_cons_self local notation"א"=>by omega local notation"ב"=>by norm_num local notation"ג"=>by simp local notation"ד"=>by linarith section open FloatLib.Numerics end lemma qAa (n:Nat) (f:Nat->UInt32) (k:Nat) (hk:k< n) : (Array.ofFn (n:=n) λi=>f i.val)[k]! = f k:=by rw[Э _ k (by simpa using hk),Array.getElem_ofFn] lemma qBl (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 qDs {w:UInt32} (h:expOf w≠255):Я (ofW w)=true:=by simp[ofW,isFinite_ofUInt32,h] lemma qEt (A B:Array UInt32) (hB:B.size=A.size) (hall:∀ k,k< A.size->expOf A[k]!≠255∧expOf B[k]!≠255) : finishWord (dsum A B 0 A.size) (-298) (A.size≠0 && dallNZ A B 0 A.size)=dotSpec A B:=by set L:=A.map (Model.ofUInt32 (fmt:=Fmt)) with hL;set R:=B.map (Model.ofUInt32 (fmt:=Fmt)) with hR;have hLR:L.size=R.size:=by simp[hL,hR,hB] have hS:L.size=A.size:=by simp[hL] have hLf:∀ k (hk:k< L.size),Я L[k]=true:=λk hk=>by simpa [hL,ofW] using qDs (getElem!_pos A k א ▸ (hall k א).1) have hRf:∀ k (hk:k< R.size),Я R[k]=true:=λk hk=>by simpa [hR,ofW] using qDs (getElem!_pos B k א ▸ (hall k א).2) have f k (_:0<=k) (h:k<0+L.size):=hall k א;have s:=(finiteDotSlice_eq A B 0 L.size (by simp[hL]) (by simp[hL,hB]) f).trans (by rw[hS]);have x:=(Model.Reduction.Internal.dotState_exact_toRat (destination:=Fmt) L R hLR hLf hRf).trans s;unfold dotSpec Model.dot;by_cases h0:dsum A B 0 A.size=0;. rw[Model.Reduction.dotWithStatus_eq_zero_of_finite Fmt L R .nearestEven hLR hLf hRf ((ى _).1 (by simp[x,h0])),h0,finishWord_zero];obtain ⟨h1,h2⟩:=dotStateLoop_flags A B {} 0 L.size (by simp[hL]) (by simp[hL,hB]) f;simp only[Except.map,Model.Reduction.Internal.dotState];rw[h1,h2];simp[hS] . rw[Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L R .nearestEven hLR hLf hRf (by rw[Model.Reduction.Semantics.finiteDot_toList_eq_slice L R hLR,s] simpa using h0)] exact finishWord_of_ne _ _ _ _ h0 x 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⟩ 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 @[inline] def dotStep (acc:Acc) (wa wb:UInt32):Acc := if expOf wa=255∨expOf wb=255 then ⟨acc.pos,acc.neg,true,acc.negZero⟩ 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 lemma qCf (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.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 qDk (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) : (dotLoop fa fb acc.pos acc.neg acc.special acc.negZero index remaining).pos.size=18 ∧ (dotLoop fa fb acc.pos acc.neg acc.special acc.negZero index remaining).neg.size=18 ∧ 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] 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[qCf] 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 ⟨hP,hN,hs,hall,hD,hz⟩:=ih _ (index+1) א h1 h2 hfin;refine ⟨hP,hN,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 א . have sv2:(if Bool.xor (signOf (fa index)) (signOf (fb index)) then -((mantOf (fa index)*mantOf (fb index):Nat):Int) else ((mantOf (fa index)*mantOf (fb index):Nat):Int)) =sv (fa index)*sv (fb index):=by unfold sv;cases signOf (fa index)<;>cases signOf (fb index)<;>simp rw[hD,h5,dsum,ha,hb,sv2];ring . rw[hz,h4,dallNZ,ha,hb];simp[Bool.and_assoc] def Y_low (p q:Array Nat) (k:Nat):Nat->Nat | 0=>k | f+1=>if p[k]! = 0 && q[k]! = 0 then Y_low p q (k+1) f else k lemma qEb (p q:Array Nat):∀ f k,(∀ j,j< k->p[j]! = 0∧q[j]! = 0) → ∀ j,j< Y_low p q k f->p[j]! = 0∧q[j]! = 0:=by intro f;induction f with | zero=>exact λk h j hj=>h j hj | succ f ih => intro k h j hj;unfold Y_low at hj;split at hj . rename_i hk;simp only[Bool.and_eq_true,decide_eq_true_eq] at hk;refine ih (k+1) (λi hi=>?_) j hj;rcases Nat.lt_or_ge i k with h1 | h1;. exact h i h1 . have:i=k :=א;subst this;exact hk . exact h j hj lemma qH1 (L:List Nat):∀ l,(∀ j,j< l->L[j]! = 0) → limbVal L=2^(32*l)*limbVal (L.drop l):=by induction L with | nil=>simp[limbVal] | cons x xs ih => intro l h;cases l with | zero=>simp | succ l => have h0:x=0:=by simpa using h 0 א have:=ih l (λj hj=>by simpa using h (j+1) א);simp only[limbVal,List.drop_succ_cons,h0,this];rw[Nat.mul_add 32 l 1,pow_add];ring lemma qGq (A:Array Nat) (l:Nat) (h:∀ j,j< l->A[j]! = 0) : limbVal A.toList=2^(32*l)*limbValA (A.extract l A.size):=by rw[limbValA_eq,Array.toList_extract,List.extract_eq_drop_take,<-Array.length_toList];rw[List.take_of_length_le ג];refine qH1 _ l λj hj=>?_;have:=h j hj;rw[getElem!_def] at this;simp only[Array.getElem!_toList,getElem!_def] at *;cases e:A[j]?<;>simp_all lemma qKh (S:Int) (l:Nat) (e:Int) (z:Bool) : finishWord S (e+32*l) z=finishWord (2^(32*l)*S) e z:=by by_cases hS:S=0;. simp[hS,finishWord] have h2:(2:Int)^(32*l)*S≠0:=mul_ne_zero (by positivity) hS rw[finishWord_of_ne (ofIntDyadic (2^(32*l)*S) e) S (e+32*l) z hS (by rw[toRat_ofIntDyadic,а ב,show (32:ℤ)*l=((32*l:ℕ):ℤ) by push_cast;ring,к];push_cast;ring)] simp[finishWord,h2] @[inline] def dotFn (n:Nat) (fa fb:Nat->UInt32):UInt32 := let acc:=dotLoop fa fb (И 18 0) (И 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 let l:=Y_low acc.pos acc.neg 0 18 finishWord ((limbValA (acc.pos.extract l 18):Int)-limbValA (acc.neg.extract l 18)) (-298+32*l) (n≠0 && acc.negZero) lemma qAe:dotFn=dotOf:=by funext n fa fb;unfold dotFn dotOf;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 (И 18 0) (И 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 have hF:=qDk fa fb A B n (qAa n fa) (qAa n fb) ⟨И 18 0,И 18 0,false,true⟩ 0 n א ג ג hsp';obtain ⟨hP,hN,-,hall,hD,hz⟩:=hF;have hAs:A.size=n:=by simp[hA] have hBs:B.size=n:=by simp[hB] have hL:=qEb acc.pos acc.neg 18 0 (λj hj=>absurd hj (Nat.not_lt_zero _));simp only[hsp',Bool.false_eq_true,ite_false];have e0:(⟨И 18 0,И 18 0,false,true⟩:Acc).total=0:=by decide rw[e0,Int.zero_add] at hD;rw[Bool.true_and] at hz;generalize Y_low acc.pos acc.neg 0 18=l at hL ⊢;have h1:=qGq acc.pos l (λj hj=>(hL j hj).1);have h2:=qGq acc.neg l (λj hj=>(hL j hj).2);rw[hP] at h1;rw[hN] at h2;rw[qKh,<-qEt A B א (λk hk=>hall k א א),hAs,<-hD,<-hz];congr 1;have:acc.total=(limbVal acc.pos.toList:Int)-limbVal acc.neg.toList:=rfl;rw[this,h1,h2];push_cast;ring lemma usz (t n:USize) (h:t< n):(t+1).toNat=t.toNat+1:=by have h1:t.toNat< n.toNat:=А.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,ش];exact З א lemma qAo (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 З א 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 З א lemma qBg (a:Array UInt32) (i:USize) (h:i< a.usize):i.toNat< a.size:=by have h1:=А.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 (qBg a i h) else 0 @[inline] def wrW (a:Array UInt32) (i:USize) (v:UInt32):Array UInt32 := if h:i< a.usize then a.uset i v (qBg 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 П s else П (s ||| ((e+873) <<< (52:UInt64))) def pw:FloatArray := (К 512).foldl (λa i=>a.push (pwEntry i)) (Ф 512) lemma qD1:pw.data=(К 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 qHk:pw.size=512:=by simp[FloatArray.size,qD1] lemma qDo (w:UInt32):(w >>> (23:UInt32)).toUSize.toNat< pw.size:=by rw[qHk];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 (qDo w) @[inline] def good (w:UInt32):Bool := let v:=w &&& В v == 0 || v-(0x00800000:UInt32)<=(0x7EFFFFFF:UInt32) def C_hok (w:Nat->Word) (t:Nat) (h:Word):Prop := good h=true∧(∀ k,k< t->w k &&& В<=h)∧h<=В structure C_G (R I O:Nat) (X W b:Array Word):Prop where hX:R*I=X.size hW:O*I=W.size hb:O=b.size pi:0< I po:0< O ni:I<2^20 sX:X.size<2^32 sW:W.size<2^32 sb:b.size<2^32 sO:R*O<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 structure C_Row (I:Nat) (X:Array Word) (i:Nat) (ix:Array UInt32) (x:FloatArray) (c:USize) (L:List Nat) (hh:Word):Prop where len:c.toNat=L.length cle:L.length<=I six:ix.size=I sx:x.size=I nd:L.Nodup lt:∀ t∈L,t< I hz:∀ t,t< I->t∉L->X[i*I+t]! &&& В=0 rd:∀ k p:Nat,L[k]?=some p → (ix[k]! : UInt32).toNat=p∧x.data[k]! = dv X[i*I+p]! ok:C_hok (λt=>X[i*I+t]!) I hh def scan (A:Array UInt32) (n i:USize) (hn:n.toNat<=A.size) (lo hi:UInt32):UInt32 := if h:i< n then have ht:=А.mp h let v:=A.uget i א &&& В 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 if 0x007FFFFF<=lo∧hi<Ц then hi else Е termination_by n.toNat-i.toNat decreasing_by rw[usz i n h];omega lemma qAf (a:Array UInt32):a.usize.toNat<=a.size:=by simp only[Array.usize,Nat.toUSize_eq,USize.toNat_ofNat'];exact Nat.mod_le _ _ @[inline] def zivW (A B:UInt64):UInt32 := let x:UInt64:=(A+(0x0FFFFFFF:UInt64)) >>> (29:UInt64) let y:UInt64:=(B+(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 Е @[inline] def ziv (s e:Float):UInt32 := zivW (s+e).toBits (s-e).toBits @[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 == Е then slowOut inW relu X W b i j else act relu r 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:=А.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 == Е 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 section local notation:max x:max "ᶠ"=>Float.isFinite x=true local notation "⟡"=>FloatFormat.binary64 local notation "⟠"=>Float.Model.Format.binary64 noncomputable def R (f:Float):ℝ:=в (toModel (ofFloat f)) noncomputable def wv (w:UInt32):ℝ:=в (ofW w) noncomputable def exactS (n:Nat) (xw ww:Nat->UInt32) (bw:UInt32):ℝ := (р n).sum (λt=>wv (xw t)*wv (ww t))+wv bw def nfOf (n:Nat):Float:=(n.toUInt64+8).toFloat*П 0x3CC0000000000000 lemma qAm:⟡.isIEEE=true:=by decide lemma qA2 (a:Model ⟡) : Я a=(Model.toModel a).isFinite:=by rw[<-Model.toDyadic?_isSome_eq_isFinite,Model.toDyadic?_ieee_eq_model _ qAm];cases Model.toModel a<;>rfl abbrev A_M (x:Float):Model ⟡:=Model.ofFloatModel x.toModel lemma A_R (x:Float):R x=в (A_M x):=rfl lemma qAk (x:Float):Я (A_M x)=x.isFinite:=by rw[qA2,ل];rfl lemma qA5 {x:Float} (h:xᶠ):Я (A_M x)=true :=(qAk x).trans h lemma qA4 (e:ℤ):Formats.Flocq.bpow ь e=(2:ℝ)^e:=by simp[Formats.Flocq.bpow,FloatLib.Numerics.binaryRadix,FloatLib.Numerics.Radix.toReal] lemma qCl:(2:ℝ)^(1000:ℤ)<=в (Model.posMaxFinite ⟡):=by rw[Model.toReal_posMaxFinite,show Model.pow2 ⟡.fracWidth + ⟡.maxFiniteFracField=2^53-1 by decide +kernel, show ⟡.maxNormalExponent-Int.ofNat ⟡.fracWidth=971 by decide +kernel,Model.bpow,qA4,show (1000:ℤ)=29+971 from rfl,а Р] exact Б ב (by positivity) open Float.Model.UnpackedFloat in lemma qD3 {b:BitVec 64} {s m e h} (a:unpack ⟠ b=.finite s m e h) : 2^52<=m∨e=-1074:=by unfold Float.Model.UnpackedFloat.unpack at a;simp only at a;rw[show (⟠.exponentBias:ℤ)=1023 by decide] at a;split_ifs at a with h1 h2 h3;. injection a with _ _ he;rw[show (unpackExponent (spec:=⟠) b).toNat=0 by simp[h3]] at he;omega . injection a with _ hm;rw[<-hm,BitVec.toNat_append];exact .inl (ؾ (by simp[Nat.shiftLeft_eq]) Nat.left_le_or) open Float.Model.UnpackedFloat in lemma qJh {s₁ s₂ m₁ m₂ e₁ e₂ h₁ h₂} {f g:BitVec 64} (e:unpack ⟠ f=.finite s₁ m₁ e₁ h₁) (b:unpack ⟠ g=.finite s₂ m₂ e₂ h₂) : e₁+e₂<=⟠.targetExponent (Float.Model.totalExponent (m₁*m₂) (e₁+e₂)):=by have a:2^52<=m₁*m₂->52<=(m₁*m₂).log2:=(Nat.le_log2 (Nat.mul_ne_zero h₁.ne' h₂.ne')).2 simp only[Float.Model.Format.targetExponent,Float.Model.totalExponent,Float.Model.Format.mantissaBits,Float.Model.Format.minExponent] norm_num rcases qD3 e with c | c . have:=a (c.trans (ع _ h₂));omega rcases qD3 b with d | d . have:=a (d.trans (Nat.le_mul_of_pos_left _ h₁));omega omega lemma qB5 (x y:Float) (a:xᶠ) (b:yᶠ) : A_M (x*y)=Model.mul (A_M x) (A_M y):=by 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];simp only[Model.toDyadic?_ieee_eq_model _ qAm,Model.toModel_ofFloatModel];change x.toModel.unpack.isFinite=true at a;change y.toModel.unpack.isFinite=true at b;have c:∀ s t:Float.Model.UnpackedFloat.Sign,Model.ofModel ⟡ (.zero (s*t)) =Model.zero _ (ظ s ^^ ظ t):=λs t=>by cases s<;>cases t<;>simp[Model.modelSignBit] <;>first | exact (Model.negZero_eq_ofModel_zero _).symm | exact (Model.posZero_eq_ofModel_zero _).symm cases hxm:x.toModel.unpack<;>cases hym:y.toModel.unpack <;>simp only[hxm,hym,Float.Model.UnpackedFloat.isFinite,Bool.false_eq_true] at a b case finite.finite s₁ m₁ e₁ h₁ s₂ m₂ e₂ h₂ => have d:(m₁ == 0 || m₂ == 0)=false:=by simp[h₁.ne',h₂.ne'] have e:Model.modelSign (ظ s₁ ^^ ظ s₂)=s₁*s₂:=by cases s₁<;>cases s₂<;>rfl simp only[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.mul];rw[Model.roundWithAccuracy_exact_eq_round_of_le_targetExponent _ _ _ _ (qJh hxm hym),d];simp only[Bool.false_eq_true,ite_false,Model.roundDyadic,qAm,ite_true,Model.ieeeRoundDyadic,e];rfl all_goals simp[Model.unpackedToDyadic?,Float.Model.UnpackedFloat.mul,c] lemma A_E (z:Float) {a:Model ⟡} {c:ℝ} (h:A_M z=a) (b:Я a=true) (d:в a=Model.roundAt ⟡ c) : zᶠ∧R z=Model.roundAt ⟡ c:=by subst h;exact ⟨(qAk z).symm.trans b,d⟩ lemma qC7 (x y:Float) (hx:xᶠ) (hy:yᶠ) (hb : |R x| * |R y| ≤ 2^(1000:ℤ)) : (x*y)ᶠ ∧ R (x*y)=Model.roundAt ⟡ (R x*R y) := A_E _ (qB5 x y hx hy) (Model.isFinite_mul_of_abs_mul_le_posMaxFinite _ _ qAm (qA5 hx) (qA5 hy) (hb.trans qCl)) (Model.toReal_mul_eq_roundAt_of_abs_mul_le_posMaxFinite _ _ qAm (qA5 hx) (qA5 hy) (hb.trans qCl)) noncomputable def A_z:ℝ:=2^(-1021:ℤ) noncomputable def A_B:ℝ:=2^(300:ℤ) lemma qAs:0< A_z:=by unfold A_z;positivity lemma A_p (a b c d:ℤ) (h:a+b<=c+d):(2:ℝ)^a*2^b<=2^c*2^d:=by rw[<-а Р,<-а Р];exact Ш one_le_two h lemma qAx:A_z<=1/2^200*(1/2^200):=by simpa [A_z] using A_p (-1021) 0 (-200) (-200) ב lemma qKo:0< A_B:=by unfold A_B;positivity lemma qBv:(2:ℝ)^256*2^42<=A_B:=by simpa [A_B] using A_p 256 42 300 0 ב lemma qAh:(2:ℝ)^128<=A_B :=(by norm_num:(2:ℝ)^128<=2^256*2^42).trans qBv lemma qGl {k:ℕ} (h:k<=2^128):(k:ℝ)<=A_B :=(show (k:ℝ)<=2^128 by exact_mod_cast h).trans qAh lemma qFa:A_B*2<=2^(1000:ℤ):=by simpa [A_B] using A_p 300 1 1000 0 ב lemma qCb:A_B*A_B<=2^(1000:ℤ):=by simpa [A_B] using A_p 300 300 1000 0 ב lemma qGx (x:ℝ) : |Model.roundAt ⟡ x-x| ≤ 1/2^53*(|x| + A_z):=by rw[show (1/2^53*(|x| + A_z):ℝ)=2^(-53:ℤ) * |x| + 2^(-1074:ℤ) by rw[show (1/2^53:ℝ)=2^(-53:ℤ) by norm_num,show (-1074:ℤ)=-53+-1021 from rfl,а Р (-53),mul_add] rfl] by_cases a:x=0 . rw[a,Model.roundAt_zero,sub_self,abs_zero];positivity refine (Model.abs_roundAt_sub_le _ x).trans ?_ change Formats.Flocq.ulp _ (Model.fexpOf ⟡) x/2<=_ rw[Formats.Flocq.ulp.of_ne_zero _ _ x a] simp only[Formats.Flocq.cexp,Model.fexpOf,Formats.Flocq.fltExp] have b:=Formats.Flocq.bpow_magnitude_sub_one_le ь x a rw[qA4] at b rw[qA4,show ((⟡.fracWidth:ℤ)+1)=53 from rfl,show ⟡.minSubnormalExponent=-1074 from rfl] generalize Formats.Flocq.magnitude ь x=M at b ⊢ have d:(0:ℝ)<=2^(-53:ℤ) * |x|:=by positivity have c:(0:ℝ)<2^(-1074:ℤ):=by positivity rcases le_total (-1074) (M-53) with h | h . rw[max_eq_left h,show (2:ℝ)^(M-53)/2=2^(-53:ℤ)*2^(M-1) by rw[<-а Р,show (-53:ℤ)+(M-1)=M-53-1 by ring,ن Р _ 1,zpow_one]] linarith [Г b (show (0:ℝ)<=2^(-53:ℤ) by positivity)] . rw[max_eq_right h];exact (half_le_self c.le).trans (le_add_of_nonneg_left d) lemma qGg {z:Float} {c:ℝ} (h:zᶠ∧R z=Model.roundAt ⟡ c) : zᶠ∧|R z-c| ≤ 1/2^53*(|c| + A_z) :=⟨h.1,h.2 ▸ qGx c⟩ lemma qEa {a b:ℝ} (d : |a| ≤ A_B) (c : |b| ≤ A_B) : |a| + |b| ≤ в (Model.posMaxFinite ⟡):=by have:=qFa have:=qCl linarith lemma qBa (x y:Float) (hx:xᶠ) (hy:yᶠ) (h1 : |R x| ≤ A_B) (h2 : |R y| ≤ A_B) : (x+y)ᶠ∧|R (x+y)-(R x+R y)| ≤ 1/2^53*(|R x+R y| + A_z) := qGg (A_E _ (toModel_ofFloat_add_of_isFinite x y hx hy) (Model.isFinite_add_of_abs_add_le_posMaxFinite _ _ qAm (qA5 hx) (qA5 hy) (qEa h1 h2)) (Model.toReal_add_eq_roundAt_of_abs_add_le_posMaxFinite _ _ qAm (qA5 hx) (qA5 hy) (qEa h1 h2))) lemma qDc (x y:Float) (hx:xᶠ) (hy:yᶠ) (h1 : |R x| ≤ A_B) (h2 : |R y| ≤ A_B) : (x-y)ᶠ∧|R (x-y)-(R x-R y)| ≤ 1/2^53*(|R x-R y| + A_z) := qGg (A_E _ (toModel_ofFloat_sub_of_isFinite x y hx hy) (Model.isFinite_sub_of_abs_add_le_posMaxFinite _ _ qAm (qA5 hx) (qA5 hy) (qEa h1 h2)) (Model.toReal_sub_eq_roundAt_of_abs_add_le_posMaxFinite _ _ qAm (qA5 hx) (qA5 hy) (qEa h1 h2))) lemma qBw (x y:Float) (hx:xᶠ) (hy:yᶠ) (h1 : |R x| ≤ A_B) (h2 : |R y| ≤ A_B) : (x*y)ᶠ∧|R (x*y)-R x*R y| ≤ 1/2^53*(|R x*R y| + A_z) :=qGg (qC7 x y hx hy ((С h1 h2 (Й _) qKo.le).trans qCb)) lemma qAu (m k:ℤ) (hm:m.natAbs<2^53) (hk:-1074<=k) : Model.roundAt ⟡ ((m:ℝ)*2^k)=(m:ℝ)*2^k:=by apply Formats.Flocq.round_preserves_generic;exact (Formats.Flocq.generic_format_FLT_iff (⟡.minSubnormalExponent) (⟡.fracWidth+1) (by decide) _).2 ⟨by decide,⟨m,k⟩,by simp[Formats.Flocq.toReal,qA4],hm,hk⟩ lemma qBm (x:Float):R x=Model.unpackedToReal x.toModel.unpack:=by rw[A_R,о qAm,ل] lemma qFf {f:Float} {s m e h} (c:f.toModel.unpack=.finite s m e h) : (Model.ofModel ⟡ (.finite .positive m e h)).toModel=.finite .positive m e h:=by have a:Model.toModel (A_M f)=.finite s m e h:=(ل _).trans c;cases s;. have b:=Model.toModel_neg_of_isFinite qAm (A_M f) (by rw[a];rfl);rw[a] at b;change _=Float.Model.UnpackedFloat.finite .positive m e h at b;rw[<-b];exact Model.toModel_canonicalizeModel _ . rw[<-a];exact Model.toModel_canonicalizeModel _ lemma qBk (f:Float) (hf:fᶠ):f.absᶠ∧R f.abs = |R f|:=by have a:A_M f.abs=Model.ofModel ⟡ f.toModel.unpack.abs :=Model.ofFloatModel_pack _;change f.toModel.unpack.isFinite=true at hf;cases hu:f.toModel.unpack with | notANumber | infinity _=>simp[hu,Float.Model.UnpackedFloat.isFinite] at hf | zero s => rw[hu] at a;refine ⟨by rw[<-qAk,a];exact Model.isFinite_ofModel_zero _ qAm _,?_⟩;rw[A_R f.abs,a,qBm f,hu];simp[Float.Model.UnpackedFloat.abs,Model.toReal_ofModel_zero _ qAm] | finite s m e h => have b:=qFf hu;rw[hu] at a;have c:A_M f.abs=Model.ofModel ⟡ (.finite .positive m e h):=a;refine ⟨by rw[<-qAk,c,qA2,b];rfl,?_⟩;rw[A_R f.abs,c,qBm f,hu,о qAm,b];simp only[Model.unpackedToReal_finite,qA4];cases s<;>simp[Model.modelSignBit,abs_of_nonneg (by positivity:(0:ℝ)<=(m:ℝ)*2^e)] lemma qCw (f:Float) (k:ℕ) (g:k<2^53) (e:f.toModel=Float.Model.pack (Float.Model.UnpackedFloat.ofNat ⟠ k)) : fᶠ∧R f=k:=by obtain ⟨d,b,c⟩:∃ d,A_M f=Ч ⟡ d∧d.toReal=k:=by refine ⟨.ofScaledInt k 0,?_,?_⟩;. change Model.ofFloatModel f.toModel=_;rw[e,Model.ofFloatModel_pack];exact Model.ofModel_ofInt_eq_roundDyadic _ qAm (k:ℤ) . rw[<-д,FloatLib.Numerics.Dyadic.ofScaledInt_toRat];simp have a:Я (A_M f)=true:=by rw[b];apply Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite _ qAm;rw[c,Ж (Ю _)];exact ((qGl (א:k<=2^128)).trans ((le_mul_of_one_le_right qKo.le one_le_two).trans qFa)).trans qCl refine ⟨(qAk f).symm.trans a,?_⟩;rw[A_R,b,Model.toReal_roundDyadic_eq_roundAt _ qAm _ (b ▸ a),c];simpa using qAu k 0 (by simpa using g) ב lemma qB0 (m:UInt64) (h:m.toNat<2^53):m.toFloatᶠ∧R m.toFloat=m.toNat :=qCw _ _ h rfl lemma qI0:(0:Float)ᶠ∧R 0=0:=by simpa using qCw 0 0 ב rfl 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 qC1 (i:ℕ):pwEntry i=П (A_bits i):=by unfold pwEntry A_bits;dsimp only;split<;>rfl def A_chk (i:ℕ):Bool := match ؼ ⟠ (A_bits i).toBitVec with | .finite s m e _=>(ظ s == decide (256<=i)) && m == 2^52 && e == ((i%256:ℕ):ℤ)-202 && (i%256 != 0) | .zero _=>i%256 == 0 | _=>false lemma qFg:∀ i,i<512->A_chk i=true:=by decide +kernel lemma qDa (i:ℕ) (b:i<512) : (pwEntry i)ᶠ∧R (pwEntry i) =if i%256=0 then 0 else (if 256<=i then -1 else 1)*2^(((i%256:ℕ):ℤ)-150):=by have a:=qFg i b unfold A_chk at a rw[qC1,qBm] change (П (A_bits i)).toModel.unpack.isFinite=true∧_ rw[show (П (A_bits i)).toModel.unpack =ؼ ⟠ (A_bits i).toBitVec from Model.unpack_pack_unpack _ _] generalize ؼ ⟠ (A_bits i).toBitVec=u at a cases u with | notANumber | infinity _=>simp at a | zero s => simp only[beq_iff_eq] at a exact ⟨rfl,by simp[a]⟩ | finite s m e h => simp only[Bool.and_eq_true,beq_iff_eq,bne_iff_ne] at a obtain ⟨⟨⟨g,d⟩,f⟩,c⟩:=a refine ⟨rfl,?_⟩ rw[Model.unpackedToReal_finite,qA4,f,g,d,mul_assoc, show ((2^52:ℕ):ℝ)*2^(((i%256:ℕ):ℤ)-202) =2^(((i%256:ℕ):ℤ)-150) by rw[Nat.cast_pow,Nat.cast_ofNat,<-к,<-а Р] congr 1 push_cast ring] simp only[decide_eq_true_eq,c,↓reduceIte] lemma qC4 (i:ℕ) (a:i<512):∃ σ:ℤ,σ.natAbs<=1 ∧ R (pwEntry i)=σ*2^(((i%256:ℕ):ℤ)-150):=by rw[(qDa i a).2];split_ifs;exacts [⟨0,by norm_num,by simp⟩,⟨-1,by norm_num,by simp⟩,⟨1,by norm_num,by simp⟩] lemma qCt (f:Float) (i:ℕ) (g:i<512) (q:fᶠ) (c k:ℤ) (r:c.natAbs<2^53) (s:-900<=k) (m : |R f| ≤ A_B) (l:R f=c*2^k) : (f*pwEntry i)ᶠ∧R (f*pwEntry i)=R f*R (pwEntry i):=by obtain ⟨b,a,d⟩:=qC4 i g;have o:((i%256:ℕ):ℤ)-150<=128∧-150<=((i%256:ℕ):ℤ)-150 :=א;generalize ((i%256:ℕ):ℤ)-150=E at o d;have p : |(b:ℝ)| ≤ 1:=by rw[<-Int.cast_abs,<-Nat.cast_natAbs];exact_mod_cast a have e:=ы (two_pos (α:=ℝ)) E;have h : |R (pwEntry i)| ≤ A_B:=by rw[d,е,г e,<-one_mul A_B];exact С p (Ш one_le_two א) e.le zero_le_one obtain ⟨j,n⟩:=qC7 f _ q (qDa i g).1 ((С m h (Й _) qKo.le).trans qCb);refine ⟨j,?_⟩ have:=qAu (c*b) (k+E) (by rw[Int.natAbs_mul];have:=Nat.mul_le_mul_left c.natAbs a omega) א rw[а Р] at this;push_cast at this;rw[n,d,l,show (c:ℝ)*2^k*(b*2^E)=c*b*(2^k*2^E) by ring];exact this lemma qF2 (i:USize) (h:i.toNat< pw.size):pw.uget i h=pwEntry i.toNat:=by simp[FloatArray.uget,qD1] lemma qAt (w:UInt32):(w &&& В).toNat=w.toNat%2^31:=by rw[ز];exact О w.toNat 31 lemma qBj (w:UInt32):(w &&& 0x7FFFFF).toNat=w.toNat%2^23:=by rw[ز];exact О w.toNat 23 lemma qGs (w:UInt32):(w >>> 23).toNat=w.toNat/2^23:=by rw[UInt32.toNat_shiftRight,т];rfl lemma qA0 (w:UInt32):(expOf w).toNat=w.toNat/2^23%2^8:=by unfold expOf;rw[ز,qGs];exact О _ 8 lemma qDl (w:UInt32):signOf w=decide (2^31<=w.toNat):=by have b:=w.toNat_lt;unfold signOf;have h:((w &&& х).toNat)=(w.toNat/2^31%2)*2^31:=by rw[ز];show w.toNat &&& 2^31=_;rw[Nat.and_two_pow,Nat.testBit_eq_decide_div_mod_eq];have a:w.toNat/2^31%2=0∨w.toNat/2^31%2=1 :=א;rcases a with a | a<;>rw[a]<;>rfl rw[Bool.eq_iff_iff];simp only[bne_iff_ne,ne_eq,decide_eq_true_eq];rw[<-Щ,h];simp only[UInt32.toNat_zero];omega lemma qIx (w:UInt32) : ((w &&& 0x7FFFFF) ||| 0x800000).toNat=2^23+w.toNat%2^23:=by rw[UInt32.toNat_or,qBj,Nat.or_comm];simpa using (Nat.two_pow_add_eq_or_of_lt (Nat.mod_lt w.toNat (by positivity:2^23 > 0)) 1).symm lemma qA3 (w:UInt32) (h:good w=true) : w.toNat%2^31=0∨(2^23<=w.toNat%2^31∧w.toNat%2^31<Ц):=by have a:=qAt w;have b:=(w &&& В).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[<-a,h];rfl . right;rw[М,UInt32.toNat_sub] at h;rw[<-a];generalize (w &&& В).toNat=v at *;simp at h;omega lemma qAd (w:UInt32) (h:good w=true):expOf w≠255:=by intro he;have a:=qA0 w;rw[he] at a;change 255=_ at a;have:=qA3 w h;have:=w.toNat_lt;omega noncomputable def A_mag (v:ℕ):ℝ := if v=0 then 0 else ((2^23+v%2^23:ℕ):ℝ)*2^(((v/2^23:ℕ):ℤ)-150) lemma qAv (v:ℕ):0<=A_mag v:=by unfold A_mag;split_ifs<;>positivity lemma qAz (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 g:=w.toNat_lt;have:=qA3 w hg;have a:=qA0 w;have d:(fracOf w).toNat=w.toNat%2^23:=qBj w;have f:wv w=(decodeD w).toReal:=by unfold wv ofW;rw[Model.toReal_eq,Ы w (qAd w hg)] rw[f];unfold decodeD A_mag;by_cases c:w.toNat%2^31=0;. have b:expOf w=0:=Щ.mp (by rw[a];show _=0;omega);have e:fracOf w=0:=Щ.mp (by rw[d];show _=0;omega);simp only[b,e,c,↓reduceIte];simp[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand] . have b:expOf w≠0:=λh=>by rw[h] at a;change 0=_ at a;omega simp only[b,c,↓reduceIte];rw[show w.toNat%2^31%2^23=(fracOf w).toNat by rw[d];omega,show w.toNat%2^31/2^23=(expOf w).toNat by rw[a];omega];simp only[FloatLib.Numerics.Dyadic.toReal,FloatLib.Numerics.Dyadic.signedSignificand,qDl];simp;split_ifs<;>ring lemma qGf (v:ℕ) (h:v<Ц):A_mag v<=2^128:=by unfold A_mag;split_ifs with h0;. positivity . exact (С (show ((2^23+v%2^23:ℕ):ℝ)<=((2^24:ℕ):ℝ) from Nat.cast_le.2 א) (Ш one_le_two (by omega:_<=(104:ℤ))) (by positivity) (by positivity)).trans_eq ב lemma qA7 (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 qAv b unfold A_mag;simp only[show ¬ a=0 by omega,show ¬ b=0 by omega,↓reduceIte];have c:a/2^23<=b/2^23:=Nat.div_le_div_right hab;rcases c.eq_or_lt with d | g;. rw[d];exact Б (Nat.cast_le.2 א) (by positivity) . have e:(2:ℝ)^(((a/2^23:ℕ):ℤ)-150)*2<=2^(((b/2^23:ℕ):ℤ)-150):=by rw[<-zpow_add_one₀ Р];exact Ш one_le_two א have f:((2^23:ℕ):ℝ)<=((2^23+b%2^23:ℕ):ℝ):=Nat.cast_le.2 א calc _<=((2^23*2:ℕ):ℝ)*2^(((a/2^23:ℕ):ℤ)-150) := Б (Nat.cast_le.2 א) (by positivity) _=((2^23:ℕ):ℝ)*(2^(((a/2^23:ℕ):ℤ)-150)*2):=by push_cast;ring _<=_:=С f e (by positivity) (by positivity) abbrev A_mf (w:UInt32):Float:=((w &&& 0x7FFFFF) ||| 0x800000).toFloat lemma qEe (w:UInt32):pw.uget (w >>> 23).toUSize (qDo w) =pwEntry (w.toNat/2^23)∧w.toNat/2^23<512∧(A_mf w)ᶠ ∧ (A_mf w*pwEntry (w.toNat/2^23))ᶠ ∧ R (A_mf w*pwEntry (w.toNat/2^23))=R (A_mf w)*R (pwEntry (w.toNat/2^23)) ∧ R (A_mf w)=((2^23+w.toNat%2^23:ℕ):ℝ):=by have g:=w.toNat_lt;have c:=qIx w;obtain ⟨d,a⟩:=qCw (A_mf w) _ (by rw[c];omega) rfl;rw[c] at a;have b:w.toNat/2^23<512 :=א obtain ⟨f,e⟩:=qCt _ _ b d ((2^23+w.toNat%2^23:ℕ):ℤ) 0 א ב (by rw[a,Ж (Ю _)] exact qGl א) (by rw[a,zpow_zero,mul_one,Int.cast_natCast]) refine ⟨?_,b,d,f,e,a⟩;rw[qF2,н,qGs] lemma qAl (w:UInt32) (hg:good w=true):(dv w)ᶠ∧R (dv w)=wv w:=by obtain ⟨g,a,-,e,d,c⟩:=qEe w;have j:=w.toNat_lt;unfold dv;rw[g];refine ⟨e,?_⟩;rw[d,c,(qDa _ a).2,qAz w hg];have b:=qA3 w hg;generalize w.toNat=v at *;rcases b with h | ⟨l,k⟩;. rw[h];simp only[show v/2^23%256=0 by omega,↓reduceIte,mul_zero,show A_mag 0=0 by simp[A_mag]] . have f:(256<=v/2^23) ↔ 2^31<=v :=א;unfold A_mag;rw[(א:v%2^31/2^23=v/2^23%256),(א:v%2^31%2^23=v%2^23),if_neg (א:¬ v/2^23%256=0),if_neg (א:¬ v%2^31=0)];by_cases i:2^31<=v<;>simp only[f,i,↓reduceIte]<;>ring 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 qDb {a:Type} (l:List a) (f:a->ℝ):0<=(l.map λq=>|f q|).sum :=List.sum_nonneg (by simp only[List.mem_map];rintro _ ⟨q,_,rfl⟩;exact Й _) lemma qC9 (l:List Float):0<=A_sa l:=qDb l R lemma qI4 (l:List Float) (q:Float):A_sa (l ++ [q])=A_sa l + |R q| ∧ A_sr (l ++ [q])=A_sr l+R q∧A_fsum (l ++ [q])=A_fsum l+q:=by simp[A_sa,A_sr,A_fsum] lemma qDd (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 (Ь _ _).trans ד lemma qBx:A_z<=1:=qAx.trans ב lemma qBf (l:List Float) (hf:∀ q∈l,qᶠ) (hlen:l.length<=2^21) (hb:A_sa l<=A_B/4) : (A_fsum l)ᶠ ∧ |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=>exact ⟨qI0.1,by simp[A_fsum,qI0.2,A_sr]⟩ | append_singleton l q ih => obtain ⟨e,f,n⟩:=qI4 l q rw[e] at hb rw[List.length_append,List.length_singleton] at hlen have t:=qC9 l have j:=Й (R q) obtain ⟨h,v⟩:=ih (λx i=>hf x (by simp[i])) א ד have u:(l.length:ℝ)+1<=2^21:=by exact_mod_cast hlen have d:(0:ℝ)<=l.length:=Ю _ have y:=qDd l have o:=qAs have m:=qBx have p:=qAh have s:=abs_sub_abs_le_abs_sub (R (A_fsum l)) (A_sr l) have w:=Б (show (l.length:ℝ)<=2^21 by linarith) (ד:0<=A_sa l+A_z) obtain ⟨b,z⟩:=qBa _ q h (hf q ג) ד ד rw[n,e,f,List.length_append,List.length_singleton] refine ⟨b,?_⟩ push_cast generalize R (A_fsum l)=r at * generalize R q=a at * generalize A_sa l=P at * generalize A_sr l=S at * generalize (l.length:ℝ)=k at * obtain ⟨W,g⟩:∃ W:ℝ,W=1/2^53*(P + |a| + A_z):=⟨_,rfl⟩ have c:0<=W :=ד rw[<-g] refine (abs_sub_le _ (r+a) (S+a)).trans ?_ rw[add_sub_add_right_eq_sub] linarith [Ь r a,Г (show 1/2^53*(P+A_z)<=W by linarith) d,Б (ד:k<=2^21) c] lemma qCj (l:List Float) (c:∀ q∈l,qᶠ) (d:l.length<=2^21) (f:A_sa l<=A_B/4) : (A_fsum (l.map Float.abs))ᶠ ∧ |R (A_fsum (l.map Float.abs))-A_sa l| ≤ 2*l.length*(1/2^53*(A_sa l+A_z)):=by have a:A_sa (l.map Float.abs)=A_sa l∧A_sr (l.map Float.abs)=A_sa l:=by constructor<;>simp only[A_sa,A_sr,List.map_map]<;>congr 1 <;>exact Զ λq b=>by simp[(qBk q (c q b)).2] have:=qBf (l.map Float.abs) (λq b=>by obtain ⟨x,e,rfl⟩:=List.mem_map.mp b exact (qBk x (c x e)).1) (by simpa) (a.1.symm ▸ f) rwa [a.1,a.2,List.length_map] at this lemma qKa (n:ℕ) (g:n<2^20) : (nfOf n)ᶠ∧R (nfOf n)=((n:ℝ)+8)/2^51:=by have b:(n.toUInt64+8).toNat=n+8:=by have c:(8:UInt64).toNat=8:=rfl;simp[UInt64.toNat_add,c];omega obtain ⟨f,a⟩:=qB0 (n.toUInt64+8) (by rw[b];omega);rw[b] at a obtain ⟨e,d⟩:=qCt _ 99 ב f ((n+8:ℕ):ℤ) 0 א ב (by rw[a,Ж (Ю _)] exact qGl א) (by rw[a];simp) push_cast at a;rw[show nfOf n=(n.toUInt64+8).toFloat*pwEntry 99 by rw[nfOf,qC1];rfl];refine ⟨e,?_⟩;rw[d,a,(qDa 99 ב).2];norm_num;ring lemma qHo {n:ℕ} (l:n<2^20) {s t:Float} (k:sᶠ) (m:tᶠ) {X Y:ℝ} (e:0<=Y) (v:Y<=A_B/8) (y : |R s-X| ≤ 4*((n:ℝ)+1)*(1/2^53*Y)) (u : |R t-Y| ≤ Y/2^30+1/2^250) (I : |R s| ≤ 2*Y) (c:(2:ℝ)^(-127:ℤ) ≤ |R (s+nfOf n*t)|) : R (s-nfOf n*t)< X∧X< R (s+nfOf n*t):=by have w:(8:ℝ)<=A_B:=(by norm_num:(8:ℝ)<=2^128).trans qAh;have A:(n:ℝ)+1<=2^20:=by exact_mod_cast l have o:(0:ℝ)<=n:=Ю n;obtain ⟨h,b⟩:=qKa n l;have E:=qAs;have B:=qAx;have a:0<=((n:ℝ)+8)/2^51:=by positivity have C:=abs_sub_abs_le_abs_sub (R t) Y;rw[Ж e] at C;have i : |R t| ≤ 2*Y+1/2^250 :=ד;have x : |R (nfOf n)*R t| ≤ 1/2^30*(2*Y+1/2^250):=by rw[е,b,Ж a];exact С ד i (Й _) ב obtain ⟨d,f⟩:=qBw _ _ h m (by rw[b,Ж a];linarith) ד;have D:=abs_sub_abs_le_abs_sub (R (nfOf n*t)) (R (nfOf n)*R t);obtain ⟨z,j⟩:=qBa s _ k d ד ד;obtain ⟨r,g⟩:=qDc s _ k d ד ד;have H:=abs_sub_abs_le_abs_sub (R (s+nfOf n*t)) (R s+R (nfOf n*t));have q:=Ь (R s) (R (nfOf n*t));have p:=Ե (R s) (R (nfOf n*t));rw[show (2:ℝ)^(-127:ℤ)=1/2^127 by norm_num] at c;have G:=Г (abs_le.mp u).1 a;have M:=Б (show (n:ℝ)<=2^20 by linarith) e;rw[b] at f x D;obtain ⟨K,J⟩:=abs_le.mp y;obtain ⟨O,N⟩:=abs_le.mp j;obtain ⟨F,L⟩:=abs_le.mp g;obtain ⟨P,-⟩:=abs_le.mp f;constructor<;>linarith lemma qIl (g h:ℕ->Float) (l:List ℕ) (a b:Float) : l.foldl (λ(d:F1) t=>F1.mk (d.s+g t) (d.t+h t)) ⟨a,b⟩ =⟨l.foldl (λ(c:Float) t=>c+g t) a,l.foldl (λ(c:Float) t=>c+h t) b⟩:=by induction l generalizing a b with | nil=>rfl | cons x l ih=>simp only[List.foldl_cons,ih] lemma qB7 (a:List ℕ) (f:ℕ->ℝ) (M:ℝ) (h:∀ t∈a,f t<=M) : (a.map f).sum<=a.length*M:=by simpa using List.sum_le_sum h lemma qCa (w:UInt32) (hg:good w=true) : |wv w| = A_mag (w.toNat%2^31):=by rw[qAz w hg,е,Ж (qAv _)];split_ifs<;>simp lemma qAi (w:UInt32) (hg:good w=true) : |wv w| ≤ 2^128:=by rw[qCa w hg];apply qGf;rcases qA3 w hg with h | h<;>omega lemma qBc (w:UInt32) (hg:good w=true) (h:w &&& В=0):wv w=0:=by rw[qAz w hg,<-qAt w,h];simp[A_mag] lemma qFn (a b:UInt32) (ha:good a=true) (hb:good b=true) : (dv a*dv b)ᶠ ∧ |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 ⟨j,g⟩:=qAl a ha obtain ⟨i,d⟩:=qAl b hb have c:=qAi a ha have e:=qAi b hb obtain ⟨h,f⟩:=qBw _ _ j i (g ▸ c.trans qAh) (d ▸ e.trans qAh) rw[g,d] at f exact ⟨h,f,by rw[е] exact (С c e (Й _) (by positivity)).trans_eq ב⟩ lemma qBt {n:ℕ} {a b:ℕ->UInt32} {f:UInt32} (g:∀ t,t< n->good (a t)=true) (j:∀ t,t< n->good (b t)=true) {l:List ℕ} (k:l.Nodup) (d:∀ t∈l,t< n) (i:∀ t,t< n->t∉l->a t &&& В=0∨b t &&& В=0) : exactS n a b f=(l.map λt=>wv (a t)*wv (b t)).sum+wv f:=by unfold exactS;congr 1;rw[<-List.sum_toFinset _ k];refine (Finset.sum_subset (λt c=>by simpa using d t (by simpa using c)) λt c h=>?_).symm;have e:=ؽ.mp c;rcases i t e (by simpa using h) with h | h;. simp[qBc (a t) (g t e) h] . simp[qBc (b t) (j t e) h] lemma qEo {n:ℕ} {l:List ℕ} (b:l.Nodup) (a:∀ t∈l,t< n):l.length<=n:=by simpa using (b.subperm λt h=>List.mem_range.2 (a t h)).length_le abbrev A_G (ts:List ℕ) (g:ℕ->Float) (p:ℕ->ℝ):Prop := ∀ t∈ts,(g t)ᶠ∧|R (g t)-p t| ≤ 1/2^53*(|p t| + A_z)∧|p t| ≤ 2^256 lemma qGe {b c:ℕ->UInt32} {l:List ℕ} {n:ℕ} (a:∀ t∈l,t< n) (e:∀ t,t< n->good (b t)=true) (f:∀ t,t< n->good (c t)=true) : A_G l (λt=>dv (b t)*dv (c t)) λt=>wv (b t)*wv (c t) :=λt d=>qFn _ _ (e t (a t d)) (f t (a t d)) lemma qCs {a:List ℕ} {g:ℕ->Float} {p:ℕ->ℝ} (b:Float) (c:A_G a g p) : let A:=(a.map λt=>|p t|).sum let L:=a.map g ++ [b] |A_sr L-((a.map p).sum+R b)| ≤ 1/2^53*(A+a.length*A_z) ∧ A_sa L<=A + |R b| + 1/2^53*(A+a.length*A_z)∧A<=2*A_sa L+a.length*A_z:=by induction a with | nil=>simp[A_sa,A_sr] | cons x a ih => obtain ⟨d,i,j⟩:=ih (λt e=>c t (by simp[e])) have f:=(c x ג).2.1 simp only[A_sa,A_sr,List.map_cons,List.sum_cons,List.length_cons,List.cons_append] at d i j ⊢ have m:=qAs obtain ⟨o,r⟩:=abs_le.mp f obtain ⟨n,q⟩:=abs_le.mp d have k:=Й (p x) have h:=abs_sub_abs_le_abs_sub (p x) (R (g x)) have l:=abs_sub_abs_le_abs_sub (R (g x)) (p x) rw[и] at h refine ⟨abs_le.mpr ⟨?_,?_⟩,?_,?_⟩<;>push_cast<;>linarith lemma qH2 (l:List ℕ) (g:ℕ->Float) (b:Float) : ((l.map g ++ [b]).length:ℝ)=l.length+1:=by simp lemma qHx {a:List ℕ} {g:ℕ->Float} {p:ℕ->ℝ} {b:Float} (d:A_G a g p) (c:bᶠ):∀ q∈a.map g ++ [b],qᶠ:=by simp only[List.mem_append,List.mem_map,List.mem_singleton];rintro q (⟨t,e,rfl⟩ | rfl);. exact (d t e).1 . exact c lemma qB1 {a:UInt32} (d:good a=true) (h:a<=В) : 0<=wv a∧wv a<=2^128 ∧ ∀ w,good w=true->w &&& В<=a->|wv w| ≤ wv a:=by have g:a.toNat<=2147483647:=М.mp h have b:wv a=A_mag a.toNat:=by rw[qAz a d,З א] simp only[show ¬ 2^31<=a.toNat by omega,↓reduceIte,one_mul] refine ⟨b ▸ qAv _,(le_abs_self _).trans (qAi a d),λw c f=>?_⟩ have e:=М.mp f rw[qAt] at e rw[qCa _ c,b] exact qA7 _ _ e ((qA3 _ c).imp_right (·.1)) section variable {n:ℕ} {ts:List ℕ} {g:ℕ->Float} {p:ℕ->ℝ} {bw hh:UInt32} {X Y J:ℝ} {s t a e:Float} (A:n<2^20) (B:ts.length<=n) (C:A_G ts g p) (D:good bw=true) (E:X=(ts.map p).sum+wv bw) (F:s=ts.foldl (λ(c:Float) t=>c+g t) 0+dv bw) (G:(2:ℝ)^(-127:ℤ) ≤ |R (s+e)|) include A B C D E F G lemma qFv (k:tᶠ) (b:Y<=A_B/8) (o:A_sa (ts.map g ++ [dv bw])+A_z<=3/2*Y) (u:2*((ts.length:ℝ)+1)*(A_sa (ts.map g ++ [dv bw])+A_z) + ((ts.map λt=>|p t|).sum+ts.length*A_z)<=4*((ts.length:ℝ)+1)*Y) (m : |R t-Y| ≤ Y/2^30+1/2^250) (h:e=nfOf n*t) : R (s-e)< X∧X< R (s+e):=by subst h obtain rfl:s=A_fsum (ts.map g ++ [dv bw]):=by simp[F,A_fsum,List.foldl_map] obtain ⟨c,d⟩:=qAl bw D obtain ⟨j,-,-⟩:=qCs (dv bw) C rw[d,<-E] at j have i:=qC9 (ts.map g ++ [dv bw]) have r:=qAs have l:(ts.length:ℝ)<=n:=by exact_mod_cast B have q:(n:ℝ)+1<=2^20:=by exact_mod_cast A have a:0<=Y :=ד obtain ⟨f,h⟩:=qBf _ (qHx C c) (by simp;omega) ד rw[qH2] at h generalize ts.map g ++ [dv bw]=L at * have x:=qDd L have y:=Б l a have v:=С (show (ts.length:ℝ)+1<=2^20 by linarith) o ד ב have w:=abs_sub_le (R (A_fsum L)) (A_sr L) X have z:=abs_sub_abs_le_abs_sub (R (A_fsum L)) (A_sr L) exact qHo A f k a b ד m ד G lemma qBu (P:good hh=true) (hp:hh<=В) (U:(ts.map λt=>|p t|).sum<=wv hh*J) (m:aᶠ) (d:0<=J) (z:J<=2^149) (v : |R a-J| ≤ (J+A_z)/2^32) (he:e=nfOf n*(dv hh*a+(dv bw).abs)) : R (s-e)< X∧X< R (s+e):=by obtain ⟨b,h,-⟩:=qB1 P hp;obtain ⟨Q,N⟩:=qAl hh P;obtain ⟨q,j⟩:=qAl bw D;obtain ⟨-,K,-⟩:=qCs (dv bw) C;rw[j] at K;have S:=qAi bw D;generalize wv hh=H at *;have hk:(ts.length:ℝ)+1<=2^20:=by exact_mod_cast (by omega:ts.length+1<=2^20) have L:(0:ℝ)<=ts.length:=Ю _;have M:=qAs;have x:=qAx;have r:=qDb ts p;have hBl:=qBv;have T:=qAh;have u:=abs_sub_abs_le_abs_sub (R a) J;rw[Ж d] at u;obtain ⟨e1,W⟩:=abs_le.mp v;have e3:=Г e1 b;have e4:=Г W b;have e5:=С h x M.le ב;have e6 : |H*R a| ≤ H*(J+(J+A_z)/2^32):=by rw[е,Ж b];exact Г ד b have hW:=Н b d;have hHJ:H*J<=2^128*2^149:=С h z d ב;obtain ⟨o,i⟩:=qBw _ a Q m (by rw[N,Ж b];linarith) ד;rw[N] at i;have e7:=abs_sub_abs_le_abs_sub (R (dv hh*a)) (H*R a);obtain ⟨w,f⟩:=qBk (dv bw) q;rw[j] at f;obtain ⟨y,k⟩:=qBa _ _ o w ד (by rw[f,abs_abs];linarith);rw[f] at k;have e8:=Ь (R (dv hh*a)) |wv bw|;rw[abs_abs] at e8;obtain ⟨e9,Z⟩:=abs_le.mp i;obtain ⟨e11,V⟩:=abs_le.mp k;have hkz:=Б (show (ts.length:ℝ)<=2^20 by linarith) M.le;have O:=Й (wv bw);obtain ⟨Y,hY⟩:∃ Y,Y=H*J + |wv bw| + A_z:=⟨_,rfl⟩;have c:A_sa (ts.map g ++ [dv bw])+A_z<=3/2*Y :=ד;have I:(ts.map λt=>|p t|).sum+A_z<=Y :=ד;have l : |R (dv hh*a+(dv bw).abs)-Y| ≤ Y/2^30+1/2^250 :=abs_le.mpr ⟨by linarith,by linarith⟩;refine qFv A B C D E F G y ד c ?_ l he;have h3:=Г c (show 0<=(ts.length:ℝ)+1 by linarith);have h4:=Н L r;have h5:=Г I (show 0<=(ts.length:ℝ)+1 by linarith);linarith end lemma qB3 (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 &&& В=0∨ww t &&& В=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 simp only[qIl] at hs obtain ⟨hs,E⟩:=hs have a:=qGe hl2 hx hw have f:=qEo hl hl2 obtain ⟨h,i⟩:=qAl bw hb obtain ⟨-,m,y⟩:=qCs (dv bw) a rw[i] at m have b:=qC9 (l.map (λt=>dv (xw t)*dv (ww t)) ++ [dv bw]) have k:=qB7 l _ _ λt u=>(a t u).2.2 have v:(l.length:ℝ)+1<=2^20:=by exact_mod_cast (by omega:l.length+1<=2^20) have o:(0:ℝ)<=l.length:=Ю _ have d:=qAs have D:=qAx have w:=qAi bw hb have z:=qBv have A:=qDb l λt=>wv (xw t)*wv (ww t) have p:=k.trans (Б (show (l.length:ℝ)<=2^20 by linarith) ב) have C:=Б (show (l.length:ℝ)<=2^20 by linarith) d.le have g:A_sa (l.map (λt=>dv (xw t)*dv (ww t)) ++ [dv bw])+A_z<=A_B/8 :=ד obtain ⟨j,c⟩:=qCj _ (qHx a h) (by simp;omega) ד rw[qH2] at c have B:=Н o b have x:=Б v (add_nonneg b d.le) obtain ⟨G,F⟩:=abs_le.mp c exact qFv hn f a hb (qBt hx hw hl hl2 hz) hs hbig j g ד ד (abs_le.mpr ⟨by linarith,by linarith⟩) (E.trans (by simp[A_fsum,List.foldl_map])) lemma qDv (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw hh hv: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) (hgv:good hv=true) (hm:∀ t,t< n->xw t &&& В<=hh) (hp:hh<=В) (hmv:∀ t,t< n->ww t &&& В<=hv) (hpv:hv<=В) (l:List Nat) (hl:l.Nodup) (hl2:∀ t∈l,t< n) (hz:∀ t,t< n->t∉l->xw t &&& В=0) (s e:Float) (hs:s=l.foldl (λ(acc:Float) t=>acc+dv (xw t)*dv (ww t)) 0+dv bw ∧ e=nfOf n*(dv hh*((n.toUInt64+1).toFloat*dv hv)+(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 obtain ⟨hs,B⟩:=hs obtain ⟨g,-,r⟩:=qB1 hg hp obtain ⟨a,u,j⟩:=qB1 hgv hpv obtain ⟨q,f⟩:=qAl hv hgv have w:(n.toUInt64+1).toNat=n+1:=by have i:(1:UInt64).toNat=1:=rfl simp[UInt64.toNat_add,i] omega obtain ⟨k,b⟩:=qB0 (n.toUInt64+1) (by rw[w];omega) rw[w] at b push_cast at b have m:(n:ℝ)+1<=2^20:=by exact_mod_cast hn have x:(0:ℝ)<=n:=Ю n have A:=qAs have v:=qAh obtain ⟨o,c⟩:=qBw _ _ k q (by rw[b,Ж ד];linarith) (by rw[f,Ж a];linarith) rw[b,f] at c have d:=Н (show 0<=(n:ℝ)+1 by linarith) a rw[Ж d] at c have p:=qEo hl hl2 have y:(l.length:ℝ)<=(n:ℝ)+1:=by exact_mod_cast (by omega:l.length<=n+1) refine qBu hn p (qGe hl2 hx hw) hb (qBt hx hw hl hl2 λt i z=>.inl (hz t i z)) hs hbig hg hp ?_ o d ((С m u a ב).trans ב) (c.trans ד) B refine (qB7 l _ (wv hh*wv hv) λt h=>?_).trans ((Б y (Н g a)).trans_eq (by ring)) rw[е] exact С (r _ (hx t (hl2 t h)) (hm t (hl2 t h))) (j _ (hw t (hl2 t h)) (hmv t (hl2 t h))) (Й _) g end section local notation:max x:max "ᶠ"=>Float.isFinite x=true end section section open Float.Model Float.Model.UnpackedFloat lemma qG6 (t:Int):Format.binary32.targetExponent t=max (t-24) (-149):=by simp[Format.targetExponent,Format.mantissaBits,Format.minExponent] lemma B_z (a b:ℤ) (n:ℕ) (h:a=n+b):(2:ℝ)^a=2^n*2^b:=by rw[h,а Р,к] lemma qDu (m L:Nat) (h1:2^L<=m) (h2:m<2^(L+1)):m.log2=L :=(Nat.log2_eq_iff (by have:=Nat.two_pow_pos L;omega)).2 ⟨h1,h2⟩ lemma qEv (M:Nat) (e T:Int) (K r:Nat) (d:T=e+(K+1:Nat)) (c:0< r) (f:2*(r*2^K)< M+2^K) (g:M<2*(r*2^K)+2^K) : Model.roundMantissaAtExponentEven M e T=r:=by have b:r <<< (K+1)=2*(r*2^K):=by rw[щ,Nat.pow_succ];ring have a:Model.pow2 (K+1-1)=2^K:=Model.pow2_eq_two_pow K;rw[Model.roundMantissaAtExponentEven,з א,show (T-e).toNat=K+1 by omega];rcases le_total (2*(r*2^K)) M with h | h;. have:=Model.roundShiftRightEven_shiftLeft_add_of_lt_half r (M-2*(r*2^K)) (K+1) א (by rw[a];omega);rwa [b,Nat.add_sub_cancel' h] at this . have:=Model.roundShiftRightEven_shiftLeft_sub_of_lt_half r (2*(r*2^K)-M) (K+1) c א (by rw[a];omega);rwa [b,Nat.sub_sub_self h] at this lemma qEq (s:Sign) (P:Nat) (E:Int) (h1:2^23<=P) (h2:P<2^24) (hE:-149<=E) (hp:0< P):Model.finishRoundedMantissa Format.binary32 s (P,E)=.finite s P E hp:=by have:=Model.finishRoundedMantissa_normalized FloatFormat.binary32 s P (E+23) h1 h2 (by show -126<=E+23;omega) rwa [show E+23-(FloatFormat.binary32.fracWidth:ℤ)=E from Int.add_sub_cancel E 23] at this lemma qBb (neg:Bool) (m:Nat) (e:Int) : Ч Fmt ⟨neg,m,e⟩ =Model.ofModel Fmt (UnpackedFloat.round Format.binary32 (Model.modelSign neg) m e):=by simp[Model.roundDyadic,Model.ieeeRoundDyadic] rfl lemma qBs (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 simp only[UnpackedFloat.pack,qDu M 23 hM1 hM2] rw[show (E+↑Format.binary32.exponentBias + ↑Format.binary32.mantissaBitsWithoutImplicit).toNat=(E+150).toNat by simp only[Format.exponentBias];norm_num;ring_nf] have c:¬ (2^Format.binary32.exponentBits<=(E+150).toNat+1):=by show ¬ (2^8<=(E+150).toNat+1);omega have a:(23+1=Format.binary32.mantissaBits):=rfl have b:s.toBitVec.toNat=if s=.negative then 1 else 0:=by cases s<;>rfl simp only[c,ite_false,a,ite_true,packComponents,BitVec.toNat_append,b,BitVec.toNat_ofNat] rw[З (by omega:(E+150).toNat<2^8), <-Nat.shiftLeft_add_eq_or_of_lt (by omega:(E+150).toNat<2^8), <-Nat.shiftLeft_add_eq_or_of_lt (э _ (by positivity):M%2^23<2^23)] split_ifs<;>simp[Nat.shiftLeft_eq] omega lemma qFe (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 (Ч Fmt ⟨neg,m,e⟩) =UInt32.ofNat ((if neg then 2^31 else 0)+(E+150).toNat*2^23+P%2^23):=by have l:0< P :=א obtain ⟨k,F⟩:∃ k:Nat,e-E+2<=k:=⟨(e-E+2).toNat,by omega⟩ obtain ⟨g,z⟩:∃ g:Nat,(e-k)+(g+2:Nat)=E:=⟨(E-(e-k)-2).toNat,by omega⟩ have u:(0:ℝ)<2^(e-k):=ы two_pos _ have s:(m:ℝ)*2^e=((m*2^k:Nat):ℝ)*2^(e-k):=by push_cast rw[mul_assoc,<-B_z e _ k א] have i:(2:ℝ)^E=4*((2^g:Nat):ℝ)*2^(e-k):=by rw[B_z E (e-k) (g+2) א] push_cast ring rw[qBb,<-ExactRuntime.round_scale _ _ m e k hm] have p:m*2^k≠0:=Nat.mul_ne_zero hm (by positivity) rw[s,i] at hhi rw[s,i] at hlo1 hlo2 have H:0<2^g:=by positivity generalize m*2^k=M at * generalize e-k=q at * generalize (2:ℝ)^q=b at * have f:∀ A B:ℕ,(A:ℝ)*b< B*b->A< B :=λA B h=>by exact_mod_cast lt_of_mul_lt_mul_right h u.le push_cast at hhi hlo1 hlo2 have G:M<4*(P*2^g)+2*2^g:=f _ _ (by push_cast;linarith) have t:P≠2^23->4*(P*2^g)< M+2*2^g :=λh=>f _ _ (by push_cast;linarith [hlo1 h]) have y:P=2^23->33554431*2^g< M :=λh=>f _ _ (by push_cast;linarith [hlo2 h]) have C:P*2^g<=(2^24-1)*2^g:=Т _ א have r:2*(P*2^(g+1))=4*(P*2^g):=by rw[Nat.pow_succ];ring have n:2^(g+1)=2*2^g:=by rw[Nat.pow_succ];ring have w:UnpackedFloat.round Format.binary32 (Model.modelSign neg) M q =.finite (Model.modelSign neg) P E l:=by rw[Model.round_exact_eq_finishRoundedMantissa _ _ _ _ p] have o:∀ (L:ℕ) (T:ℤ),2^L*2^g<=M->M<2^L*2^g*2 → max (((L+g:ℕ):ℤ)+1+q-24) (-149)=T → Format.binary32.targetExponent (totalExponent M q)=T:=λL T a c d=>by rw[<-Nat.pow_add] at a c simp only[totalExponent,qDu M _ a c,qG6];exact d by_cases v:2^25*2^g<=M . rw[o 25 E v א א,qEv M q E (g+1) P א l ?_ (by rw[r,n];omega)];. exact qEq _ P E hP1 hP2 hE l . rw[r,n];by_cases j:P=2^23;. subst j;omega . have:=t j;omega have j:P=2^23:=by by_contra hne have:=t hne have:(2^23+1)*2^g<=P*2^g:=Т _ א omega have D:=y j subst j by_cases x:-148<=E . rw[o 24 (E-1) א א א,qEv M q (E-1) g (2^24) א ב א א];have:=Model.finishRoundedMantissa_normalized_carry FloatFormat.binary32 (Model.modelSign neg) (E-1+23) (by show -126<=E-1+23;omega);rw[show (FloatFormat.binary32.fracWidth:ℤ)=23 from rfl] at this;rwa [(א:E-1+23-23=E-1),(א:E-1+23+1-23=E)] at this . rw[o 24 E א א א,qEv M q E (g+1) (2^23) א ב (by rw[n];omega) (by rw[n];omega)];exact qEq _ _ E ב ב hE l rw[w] simp only[toWord,Model.toNatBits,Model.ofModel,Model.ofModelBits] congr 1 show (UnpackedFloat.pack Format.binary32 _).toNat=_ rw[qBs _ _ _ _ hP1 hP2 א א] cases neg<;>simp[Model.modelSign] end abbrev B_D:=ExecFloat.Binary.format (exponentBits:=11) (fractionBits:=52) lemma qG4 (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 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 g: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,т] exact О _ 11 have e: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 О _ 52 have i:Model.signBit (toModel (ofFloat f))=s :=(qG4 f).trans (by cases s<;>simp at h ⊢<;>omega) have c:=Model.ofFields_signBit_expField_fracField (toModel (ofFloat f)) rw[g,e,i,show f.toBits.toNat/2^52%2^11=E by split at h<;>omega,show f.toBits.toNat%2^52=F by split at h<;>omega] at c have b:E<2^11 :=א have a:Я (Model.ofFields B_D s E F)=true:=by rw[Model.isFinite_ofFields B_D _ _ _ b hF] show (E != 2047)=true simp;omega have d:=Model.toDyadic?_ofFields_of_isFinite B_D _ _ _ b hF a rw[c,if_neg (א:¬ E=0)] at d rw[c] at a refine ⟨(qAk f).symm.trans a,?_⟩ rw[R,Model.toReal_eq,d] simp only[show Model.pow2 B_D.fracWidth=2^52 from rfl, show Int.ofNat E-Int.ofNat B_D.exponentBias-Int.ofNat B_D.fracWidth=(E:ℤ)-1075 by show (E:ℤ)-1023-52=_;omega] 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:UInt64) (x:UInt64) (hx:(A+0x0FFFFFFF) >>> 29=x) (h1:897<=x.toNat/2^23%2^11) (h2:x.toNat/2^23%2^11<1151) : x.toNat<2^35∧B_near A.toNat (decide (2^34<=x.toNat)) (x.toNat/2^23%2^11) (x.toNat%2^23):=by have a:=A.toNat_lt have e:x.toNat=(A.toNat+268435455)%2^64/2^29:=by rw[<-hx,ъ,л] norm_num [Nat.shiftRight_eq_div_pow] refine ⟨by omega,?_⟩ unfold B_near by_cases h:2^34<=x.toNat . simp only[h,decide_true,ite_true];exact ⟨A.toNat-2^63,by omega,by omega,by omega⟩ . simp only[h,decide_false,Bool.false_eq_true,ite_false];exact ⟨A.toNat,by omega,by omega,by omega⟩ lemma qJ0 (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) <<< 31) ||| ((x &&& (0x3FFFFFFFF:UInt64))-((896:UInt64) <<< 23))).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 b:((x >>> 34) <<< 31).toNat=(x.toNat/2^34)*2^31:=by rw[UInt64.toNat_shiftLeft,ъ] norm_num [Nat.shiftRight_eq_div_pow,Nat.shiftLeft_eq] omega have a:(x &&& (0x3FFFFFFFF:UInt64)).toNat=x.toNat%2^34:=by rw[و] exact О _ 34 have d:((x &&& (0x3FFFFFFFF:UInt64))-((896:UInt64) <<< 23)).toNat =x.toNat%2^34-896*2^23:=by rw[show ((896:UInt64) <<< 23)=7516192768 by decide,UInt64.toNat_sub_of_le,a] . rfl . rw[UInt64.le_iff_toNat_le,a];norm_num;omega have c:(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[ж (x.toNat/2^34)] exact (Nat.two_pow_add_eq_or_of_lt א _).symm apply Щ.mp rw[UInt64.toNat_toUInt32,UInt64.toNat_or,b,d,c,س] simp only[decide_eq_true_eq] split_ifs<;>omega lemma qDq (A B:UInt64) (h:zivW A B≠Е) : ∃ (S:Bool) (ex fr:Nat),897<=ex∧ex<1151∧fr<2^23 ∧ zivW A B=UInt32.ofNat ((if S then 2^31 else 0)+(ex-896)*2^23+fr) ∧ B_near A.toNat S ex fr∧B_near B.toNat S ex fr:=by unfold zivW at h ⊢ dsimp only at h ⊢ generalize hx:(A+(0x0FFFFFFF:UInt64)) >>> (29:UInt64)=x at h ⊢ generalize hy:(B+(0x0FFFFFFF:UInt64)) >>> (29:UInt64)=y at h ⊢ have hex:((x >>> (23:UInt64)) &&& (0x7FF:UInt64)).toNat=x.toNat/2^23%2^11:=by rw[و,ъ] have:=О (x.toNat >>> 23) 11 norm_num [Nat.shiftRight_eq_div_pow] at this ⊢ exact this generalize (x >>> (23:UInt64)) &&& (0x7FF:UInt64)=ex at h hex ⊢ split at h . rename_i hc;have hc0:=hc;obtain ⟨hxy,hc⟩:=ذ.mp hc;have hxy:x=y:=by simpa using hxy subst hxy;have hc:ex-(897:UInt64)<(254:UInt64):=by simpa using hc rw[я,UInt64.toNat_sub] at hc;have hv:=ex.toNat_lt;norm_num at hc hv;have h1:897<=x.toNat/2^23%2^11 :=א;have h2:x.toNat/2^23%2^11<1151 :=א;simp only[hc0,ite_true];obtain ⟨hx35,ha⟩:=B_x A x hx h1 h2;exact ⟨_,_,_,h1,h2,by omega,qJ0 x hx35 h1 h2,ha,(B_x B x hy h1 h2).2⟩ . exact absurd rfl h lemma qCk (s e:Float) (h:ziv s e≠Е) : ∃ (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 := qDq (s+e).toBits (s-e).toBits h set_option maxRecDepth 8192 in lemma qA9 (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,k,o,n⟩:=hn have d:M%2^52<2^52:=э _ ב have b:M=(M/2^52)*2^52+M%2^52 :=א generalize M/2^52=E at b generalize M%2^52=F at b d subst b have c:(0:ℝ)<2^((ex:Int)-1076):=ы ב _ have m:E=ex∨(E+1=ex∧fr=0) :=א obtain ⟨a,l⟩:=B_R f S E F א א d (by rw[k,с]) obtain ⟨w,j,i,e,g⟩:∃ w:ℕ,((2^52+F:Nat):ℝ)*2^((E:Int)-1075) =w*2^((ex:Int)-1076)∧w<=2^53+fr*2^30+2^29 ∧ (fr≠0->2^53+fr*2^30< w+2^29)∧2^53< w+2^28:=by rcases m with rfl | ⟨rfl,rfl⟩ . refine ⟨2*(2^52+F),?_,by omega,by omega,by omega⟩;rw[show (E:Int)-1075=1+((E:Int)-1076) by ring,а Р,zpow_one];push_cast;ring . exact ⟨2^52+F,by congr 2;push_cast;ring,by omega,by omega,by omega⟩ refine ⟨a,(w:ℝ)*2^((ex:Int)-1076),?_,Б ?_ c.le,λh=>б ?_ c,б ?_ c⟩ . rw[l,mul_assoc,j];cases S<;>simp . exact_mod_cast i . rw[sub_lt_iff_lt_add];exact_mod_cast e h . rw[sub_lt_iff_lt_add];exact_mod_cast g lemma qBh (s e:Float) (h:ziv s e≠Е) : (s+e).isFinite=true∧(s-e).isFinite=true∧(2:ℝ)^(-127:ℤ) ≤ |R (s+e)|:=by obtain ⟨S,f,c,b,d,a,-,j,k⟩:=qCk s e h;obtain ⟨g,v,i,-,-,l⟩:=qA9 _ S f c b d a j;refine ⟨g,(qA9 _ S f c b d a k).1,?_⟩ exact (show (2:ℝ)^(-127:ℤ)<=(2^53-2^28)*2^(-179:ℤ) by norm_num).trans ((Г (Ш one_le_two א) ב).trans (l.le.trans (by rw[i];cases S<;>simp[le_abs_self]))) lemma qAq (w:UInt32) (h:expOf w≠255):wv w=(Д w:ℝ):=by rw[wv,Model.toReal_eq,ofW,Ы w h];simp only[rationalWord,FloatLib.Numerics.Dyadic.cast_toRat] lemma qFl (a b:Array UInt32) (start n:Nat) : (dsum a b start n:ℚ)*2^(-298:Int) =∑ j∈р n,Д a[start+j]! * Д b[start+j]!:=by have c:∀ a b:UInt32,((sv a:ℚ)*sv b*(2:ℚ)^(idxOf a+idxOf b))*2^(-298:Int) =Д a*Д b:=λa b=>by simp only[rationalWord,decodeD_toRat] rw[show (-298:Int)=-149+-149 by norm_num,а Р] rw[ن Р,ن Р,к,к,pow_add] norm_num [zpow_neg,zpow_natCast] ring 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,Finset.sum_range_succ',у,c,add_comm] congr 1 apply ر rfl intro j _ rw[с,Nat.add_comm 1 j] lemma qCe (n:Nat) (fa fb:Nat->UInt32) (hf:∀ j,j< n->expOf (fa j)≠255∧expOf (fb j)≠255) (hn:(∑ j∈р n,Д (fa j)*Д (fb j))≠0) : ∃ d:FloatLib.Numerics.Dyadic, d.toRat=(∑ j∈р n,Д (fa j)*Д (fb j)) ∧ dotOf n fa fb=toWord (Ч Fmt d):=by let a:=Array.ofFn (n:=n) λi=>fa i let b:=Array.ofFn (n:=n) λi=>fb i have e:a.size=n:=by simp[a] have g:b.size=n:=by simp[b] have c:(dsum a b 0 n:ℚ)*2^(-298:Int) =∑ j∈р n,Д (fa j)*Д (fb j):=by rw[qFl] refine ر rfl λj m=>?_ have h:=ؽ.mp m rw[Л,qAa n fa j h,qAa n fb j h] have l:dsum a b 0 n≠0:=λh=>hn (by rw[<-c,h];simp) have Z:=qEt a b (by rw[e,g]) λk f=>by rw[e] at f rw[qAa n fa k f,qAa n fb k f];exact hf k f rw[e] at Z refine ⟨ofIntDyadic (dsum a b 0 n) (-298),by rw[toRat_ofIntDyadic,c],?_⟩ show dotSpec a b=_ rw[<-Z];simp[finishWord,l] lemma qG2:Д oneW=1:=by norm_num [rationalWord,decodeD,show expOf oneW=127 by decide,show fracOf oneW=0 by decide,show signOf oneW=false by decide,FloatLib.Numerics.Dyadic.toRat,FloatLib.Numerics.Dyadic.signedSignificand] lemma qJy (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∈р (n+1),Д (if j< n then xw j else oneW) * Д (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,qG2,one_mul] rw[Rat.cast_add,Rat.cast_sum,exactS,qAq bw (qAd bw hb)] congr 1 refine ر rfl λt b=>?_ have a:=ؽ.mp b simp only[a,ite_true] rw[qAq _ (qAd _ (hx t a)),qAq _ (qAd _ (hw t a)),Rat.cast_mul] lemma qCd (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:ziv s e≠Е) : ∃ (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'⟩:=qCk s e h obtain ⟨-,va,hva,hia,loa1,loa⟩:=qA9 _ S ex fr h1 h2 h3 ha obtain ⟨-,vb,hvb,hib,lob1,lob⟩:=qA9 _ 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 ч hhi hia . linarith . exact λh=>(lob1 h).trans hlo . exact λh=>by linarith [loa1 h] . exact lob.trans hlo . linarith lemma qF9 (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:ziv s e≠Е):V≠0:=by obtain ⟨S,ex,fr,W,-,-,-,-,hV,-,-,hW3⟩:=qCd s e V hlo hhi h;have hb0:(0:ℝ)<2^((ex:Int)-1076):=ы ב _;have hA:(0:ℝ)<=(2^53-2^28)*2^((ex:Int)-1076):=Н ב 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 qE8 (d:FloatLib.Numerics.Dyadic) (S:Bool) (ex fr:Nat) (h1:897<=ex) (h2:ex<1151) (h3:fr<2^23) (W:ℝ) (hd:(d.toRat:ℝ)=if S then -W else W) (hW1:W<(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)< W) (hW3:(2^53-2^28)*2^((ex:Int)-1076)< W) : toWord (Ч Fmt d) =UInt32.ofNat ((if S then 2^31 else 0)+(ex-896)*2^23+fr):=by have hb0:(0:ℝ)<2^((ex:Int)-1076):=ы ב _ have hE:(2:ℝ)^((ex:Int)-1046)=2^30*2^((ex:Int)-1076):=by rw[<-к,<-а Р] congr 1;push_cast;ring have hW0:0< W:=ц (Н ב hb0.le) hW3 obtain ⟨neg,m,q⟩:=d have hdV:(FloatLib.Numerics.Dyadic.mk neg m q).toReal=if S then -W else W:=by rw[<-д,hd] have hq:(0:ℝ)<2^q:=ы ב _ have hm0:(0:ℝ)<=m:=Ю _ have hmq:=Н 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 . 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:=qFe 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[hword,e1,e2] lemma qIa (s e:Float) (d:FloatLib.Numerics.Dyadic) (hlo:R (s-e)<(d.toRat:ℝ)) (hhi:(d.toRat:ℝ)< R (s+e)) (h:ziv s e≠Е) : ziv s e=toWord (Ч Fmt d):=by obtain ⟨S,ex,fr,W,h1,h2,h3,hz,hV,hW1,hW2,hW3⟩:=qCd s e _ hlo hhi h;rw[hz];exact (qE8 d S ex fr h1 h2 h3 W hV hW1 hW2 hW3).symm lemma qCq (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≠Е) : 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 have hsum:=qJy n xw ww bw hx hw hb obtain ⟨d,hd,hw'⟩:=qCe (n+1) (λt=>if t< n then xw t else oneW) (λt=>if t< n then ww t else bw) (λj _=>by by_cases hj:j< n . simp only[hj,ite_true];exact ⟨qAd _ (hx j hj),qAd _ (hw j hj)⟩ . simp only[hj,ite_false] exact ⟨by decide,qAd _ hb⟩) λh0=>qF9 s e _ hlo hhi h (by rw[<-hsum,h0,Rat.cast_zero]) have q:(d.toRat:ℝ)=exactS n xw ww bw:=by rw[hd,hsum] rw[hw'] exact qIa s e d (by rw[q];exact hlo) (by rw[q];exact hhi) h end section lemma qB4 (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 &&& В=0∨ww t &&& В=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≠Е) : 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⟩:=qBh s e h obtain ⟨hlo,hhi⟩:=qB3 n hn xw ww bw hx hw hb l hl hl2 hz s e hs hbig exact qCq n hn xw ww bw hx hw hb s e hlo hhi h end section lemma qDt (n:Nat) (hn:n<2^20) (xw ww:Nat->UInt32) (bw hh hv: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) (hgv:good hv=true) (hm:∀ t,t< n->xw t &&& В<=hh) (hp:hh<=В) (hmv:∀ t,t< n->ww t &&& В<=hv) (hpv:hv<=В) (l:List Nat) (hl:l.Nodup) (hl2:∀ t∈l,t< n) (hz:∀ t,t< n->t∉l->xw t &&& В=0) (s e:Float) (hs:s=l.foldl (λ(acc:Float) t=>acc+dv (xw t)*dv (ww t)) 0+dv bw ∧ e=nfOf n*(dv hh*((n.toUInt64+1).toFloat*dv hv)+(dv bw).abs)) (h:ziv s e≠Е) : 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⟩:=qBh s e h obtain ⟨hlo,hhi⟩:=qDv n hn xw ww bw hh hv hx hw hb hg hgv hm hp hmv hpv l hl hl2 hz s e hs hbig exact qCq n hn xw ww bw hx hw hb s e hlo hhi h end section lemma C_z:(0:USize).toNat=0:=rfl lemma qAc (k:Nat) (h:k<2^32):k.toUSize.toNat=k:=by rw[Nat.toUSize_eq];exact uk k h lemma qDh (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 З א lemma qCy {α:Type} (a:Array α) (h:a.size<2^32):a.usize.toNat=a.size :=qAc _ h lemma qAj (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:=qBg a i h;rw[Э a i.toNat h2];rfl . rename_i h;have h':¬ i.toNat< a.size:=by intro h2;apply h;rw[А,qCy a hs];exact h2 rw[غ a i.toNat h'];rfl lemma qA8 (a:Array UInt32) (i:USize) (v:UInt32):(wrW a i v).size=a.size:=by unfold wrW;split<;>simp lemma qGp {α:Type} [Inhabited α] (a:Array α) (i q:Nat) (v:α) (hi:i< a.size) : (a.set i v hi)[q]! = if q=i then v else a[q]!:=by by_cases hq:q< a.size . rw[Э _ q (by simpa using hq),getElem!_pos a q hq,Array.getElem_set];by_cases e:q=i;. simp[e] . rw[Х e,Х (λh=>e h.symm)] . rw[غ _ q (by simpa using hq),getElem!_neg a q hq,ite_eq_right א] lemma qBd (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[А,qCy a hs];exact hi unfold wrW;rw[У h];exact qGp a _ q v hi 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 qFz {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[qA8,h1],λq hq hS=>?_⟩;rw[qBd _ _ _ _ א א,hu];by_cases e:q=p;. rw[з e,e,hv] . rw[Х e];exact h2 q hq (hS.resolve_left e) lemma qEz {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 qDp {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 ه;. simp[h1] . intro q h3 h4;have h5:q< N :=א;have:=h2 q h5 (hS q h5);rw[Э out q h3] at this;simp[this] lemma qFi (v:UInt32) (h1:(0x7FFFFF:UInt32)<=v-1) (h2:v<Ц) : (v == 0 || v-(0x00800000:UInt32)<=(0x7EFFFFFF:UInt32))=true:=by have a1:(0x7FFFFF:UInt32).toNat=0x7FFFFF:=rfl;have a2:(Ц:UInt32).toNat=Ц:=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[М];have:v.toNat≠0:=λh=>h0 (Щ.mp h);omega rw[М,ي _ _ h3] at h1;rw[ю] at h2;have h4:(0x00800000:UInt32)<=v:=by rw[М];omega simp only[Bool.or_eq_true,decide_eq_true_eq];right;rw[М,ي _ _ h4];omega lemma qJm (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 qJp (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 qB2 (w:UInt32) (h:good w=true):good (w &&& В)=true:=by have e:(w &&& В) &&& В=w &&& В:=by rw[UInt32.and_assoc,UInt32.and_self] unfold good at h ⊢;simpa only [e] using h lemma qFs {h:UInt32} (h1:h<Ц):h<=В:=by have a1:(Ц:UInt32).toNat=Ц:=rfl;have a2:(В:UInt32).toNat=В:=rfl;rw[ю] at h1;rw[М];omega def C_Hv (A:Array Word) (h:Word):Prop := good h=true∧h<=В∧(∀ k,k< A.size->good A[k]! = true) ∧ ∀ k,k< A.size->A[k]! &&& В<=h lemma qF3 (r v hi:UInt32) (h:(if hi< v then v else hi)<=r):v<=r∧hi<=r:=by simp only[UInt32.le_iff_toNat_le,UInt32.lt_iff_toNat_lt] at *;split at h<;>omega lemma qIk (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≠Е → (0x7FFFFF:UInt32)<=lo∧hi<Ц∧hi<=scan A n i hn lo hi ∧ scan A n i hn lo hi<Ц∧(good hi=true->good (scan A n i hn lo hi)=true) ∧ ∀ k,i.toNat<=k->k< n.toNat → good A[k]! = true∧A[k]! &&& В<=scan A n i hn lo hi:=by induction d with | zero => intro i lo hi he h have e:scan A n i hn lo hi =if 0x007FFFFF<=lo∧hi<Ц then hi else Е:=by rw[scan,Ъ (by rw[А];omega)] rw[e] at h ⊢ by_cases c:0x007FFFFF<=lo∧hi<Ц . rw[з c];exact ⟨c.1,c.2,UInt32.le_refl _,c.2,id,λk h1 h2=>by omega⟩ . rw[Х c] at h;exact absurd rfl h | succ d ih => intro i lo hi he h have hi':i< n:=by rw[А];omega have hb:i.toNat< A.size :=א have e:scan A n i hn lo hi=scan A n (i+1) hn (if (A.uget i hb &&& В)-1< lo then (A.uget i hb &&& В)-1 else lo) (if hi< A.uget i hb &&& В then A.uget i hb &&& В else hi):=by rw[scan,У hi'] rw[e] at h ⊢ obtain ⟨h1,h2,h3,h4,h5,h6⟩:=ih (i+1) _ _ (by rw[usz i n hi'];omega) h obtain ⟨h7,h8⟩:=qJm _ _ _ h1 obtain ⟨h9,h10⟩:=qJp _ _ _ h2 obtain ⟨h11,h12⟩:=qF3 _ _ _ h3 have hg:good (A.uget i hb)=true:=qFi _ h7 h9 refine ⟨h8,h10,h12,h4,λg0=>h5 ?_,λk hk1 hk2=>?_⟩ . split;. exact qB2 _ hg . exact g0 . by_cases e2:k=i.toNat;. subst e2;rw[Э A i.toNat hb];exact ⟨hg,h11⟩ . exact h6 k (by rw[usz i n hi'];omega) hk2 lemma qAp (A:Array UInt32) (hs:A.size<2^32) (h:scan A A.usize 0 (qAf A) Е 0≠Е) : C_Hv A (scan A A.usize 0 (qAf A) Е 0):=by have e:=qCy A hs;have h0:(0:USize).toNat=0:=rfl;obtain ⟨-,-,-,h4,h5,h6⟩ :=qIk A A.usize (qAf A) A.size 0 _ _ (by rw[h0,e];omega) h;have h7:∀ k,k< A.size->good A[k]! = true ∧ A[k]! &&& В<=scan A A.usize 0 (qAf A) Е 0 :=λk hk=>h6 k א א;exact ⟨h5 rfl,qFs h4,λk hk=>(h7 k hk).1,λk hk=>(h7 k hk).2⟩ def C_out (I:Nat) (Y:Bool) (X W b:Array Word) (i j:Nat):Word := act Y (dotOf (I+1) (λt=>if t< I then X[i*I+t]! else oneW) (λt=>if t< I then W[j*I+t]! else b[j]!)) lemma qBe {R I i t:Nat} (hi:i< R) (ht:t< I):i*I+t< R*I:=by have h:(i+1)*I<=R*I:=Т _ hi;rw[م,Դ] at h;omega lemma qA1 {R I i t:Nat} (hi:i< R) (ht:t<=I) : i*I+t<=R*I:=by have h:(i+1)*I<=R*I:=Т _ hi;rw[م,Դ] at h;omega section variable {R I O:Nat} {X W b:Array Word} lemma C_G.gx (G:C_G R I O X W b) {i:Nat} (hi:i< R) : ∀ t,t< I->good X[i*I+t]! = true :=λ_ ht=>G.gX _ (by rw[<-G.hX];exact qBe hi ht) lemma C_G.gw (G:C_G R I O X W b) {j:Nat} (hj:j< O) : ∀ t,t< I->good W[j*I+t]! = true :=λ_ ht=>G.gW _ (by rw[<-G.hW];exact qBe hj ht) lemma qJ3 (G:C_G R I O X W b) (Y:Bool) {i j:Nat} (hi:i< R) (hj:j< O) {s e:Float} (hs:let r:=(К I).foldl (λ(acc:F1) t => let q:=dv X[i*I+t]! * dv W[j*I+t]! F1.mk (acc.s+q) (acc.t+q.abs)) ⟨0,0⟩;s=r.s∧e=r.t) : fin I Y X W b i j s (nfOf I) e b[j]! = C_out I Y X W b i j:=by obtain ⟨h1,h2⟩:=hs unfold fin dsimp only split . unfold slowOut C_out;rw[qAe] . rename_i h;unfold C_out;congr 1;exact qB4 I G.ni (λt=>X[i*I+t]!) (λt=>W[j*I+t]!) b[j]! (G.gx hi) (G.gw hj) (G.gb j (by rw[<-G.hb];exact hj)) _ List.nodup_range (λt ht=>й.mp ht) (λt ht h3=>absurd (й.mpr ht) h3) _ _ ⟨by rw[h1],by rw[h2]⟩ (by simpa using h) lemma qFm {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,Ъ (by rw[А];omega)] rfl | succ d ih => intro t s a he have ht:t< n:=by rw[А];omega rw[tightGo,У ht,List.range'_succ,Ա] dsimp only rw[qAj _ _ hX,qAj _ _ hW,qAo _ _ א,qAo _ _ א] rw[ih (t+1) _ _ (by rw[usz t n ht];omega),usz t n ht] lemma qHh (G:C_G R I O X W b) (Y:Bool) {i j:Nat} (hi:i< R) (hj:j< O) {s a:Float} {hh:Word} (hc:ziv (s+dv b[j]!) (nfOf I*(dv hh*a+(dv b[j]!).abs))≠Е → ziv (s+dv b[j]!) (nfOf I*(dv hh*a+(dv b[j]!).abs)) = dotOf (I+1) (λt=>if t< I then X[i*I+t]! else oneW) (λt=>if t< I then W[j*I+t]! else b[j]!)) : fin8 I Y X W b i j s (nfOf I) a hh b[j]! I.toUSize=C_out I Y X W b i j:=by have hin:I<2^32:=lt_trans G.ni ב have hX1:i*I+I<=X.size:=by rw[<-G.hX];exact qA1 hi (le_refl _) have hW1:j*I+I<=W.size:=by rw[<-G.hW];exact qA1 hj (le_refl _) have sX:=G.sX have sW:=G.sW have e1:(i*I).toUSize.toNat=i*I:=qAc _ א have e2:(j*I).toUSize.toNat=j*I:=qAc _ א have e3:I.toUSize.toNat=I:=qAc _ hin unfold fin8 dsimp only split . have e:=qFm (xo:=(i*I).toUSize) (wo:=(j*I).toUSize) (n:=I.toUSize) G.sX G.sW (by rw[e1,e3];exact hX1) (by rw[e2,e3];exact hW1) I 0 0 0 (by rw[e3,C_z,Л]);rw[C_z,e1,e2,<-Գ] at e;rw[qJ3 G Y hi hj (s:=(tightGo X W (i*I).toUSize (j*I).toUSize I.toUSize 0 0 0).s) (e:=(tightGo X W (i*I).toUSize (j*I).toUSize I.toUSize 0 0 0).t) ⟨by rw[e],by rw[e]⟩] . rename_i h;unfold C_out;congr 1;exact hc (by simpa using h) lemma qHj (G:C_G R I O X W b) (Y:Bool) {i j:Nat} (hi:i< R) (hj:j< O) {s:Float} {hh hv:Word} (hg:good hh=true) (hm:∀ t,t< I->X[i*I+t]! &&& В<=hh) (hp:hh<=В) (Hv:C_Hv W hv) (L:List Nat) (hl:L.Nodup) (hl2:∀ t∈L,t< I) (hz:∀ t,t< I->t∉L->X[i*I+t]! &&& В=0) (hs:s=L.foldl (λ(acc:Float) t=>acc+dv X[i*I+t]! * dv W[j*I+t]!) 0) : fin8 I Y X W b i j s (nfOf I) ((I.toUInt64+1).toFloat*dv hv) hh b[j]! I.toUSize=C_out I Y X W b i j:=by obtain ⟨g1,g2,-,g4⟩:=Hv have hW:∀ t,t< I->j*I+t< W.size :=λ_ ht=>by rw[<-G.hW];exact qBe hj ht exact qHh G Y hi hj λh => qDt I G.ni (λt=>X[i*I+t]!) (λt=>W[j*I+t]!) b[j]! hh hv (G.gx hi) (G.gw hj) (G.gb j (by rw[<-G.hb];exact hj)) hg g1 hm hp (λt ht=>g4 _ (hW t ht)) g2 L hl hl2 hz _ _ ⟨by rw[hs],rfl⟩ h end lemma qCn (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[Э ds i.toNat h'];rfl lemma qDm (a:Array UInt32) (i:USize) (h:i.toNat< a.size) : a.uget i h=a[i.toNat]!:=by rw[Э a i.toNat h];rfl section variable {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) end def C_sp (I O:Nat) (Y:Bool) (X W b:Array Word) (q:Nat):Word := C_out I Y X W b (q/O) (q%O) lemma qHi (I O:Nat) (Y:Bool) (X W b:Array Word) {i j:Nat} (hj:j< O) : C_sp I O Y X W b (i*O+j)=C_out I Y X W b i j:=by unfold C_sp;have h0:0< O :=א;rw[ж i O,ـ h0,ف,ш hj,З hj,у] lemma qAn {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) := qEz (qFz hN h hu hp hv) (λq _ (hq:q< p+1) =>(by omega:q=p∨q< p)) section variable {R I O:Nat} {X W b:Array Word} end end section end @[inline] def sm (w:UInt32):Bool:=good w && (w &&& В)<=0x70FFFFFF section open Float.Model Float.Model.UnpackedFloat end section open Float.Model Float.Model.UnpackedFloat end section lemma qI6 (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 (Ч 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[<-к,<-а Р] congr 1;omega rw[qFe S m q (2^23+fr) ((ex:Int)-1046) hm א א א א (by rw[hE];push_cast;linarith) (λ_=>by rw[hE];push_cast;linarith [hW2 א]) (λ_=>by rw[hE];linarith),show ((ex:Int)-1046+150).toNat=ex-896 by omega,show (2^23+fr)%2^23=fr by omega] lemma qGv (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 (sub_pos.2 h) one_half_lt_one;have h2:(0:ℝ)<2^k:=by positivity rw[one_div_pow,div_lt_iff₀ h2] at hk;refine ⟨⌊b*2^k⌋₊,-k,?_⟩;rw[zpow_neg,к,<-div_eq_mul_inv,lt_div_iff₀ h2,div_le_iff₀ h2];have h1:=Nat.lt_floor_add_one (b*2^k);have h5:a*2^k<⌊b*2^k⌋₊ :=ד;exact ⟨(Nat.cast_pos.1 ((Н ha h2.le).trans_lt h5)).ne',h5,Nat.floor_le (Н (ha.trans h.le) h2.le)⟩ lemma qIs (z:Model Fmt):ofW (toWord z)=z:=qBl z lemma qIz (w:UInt32) (h0:expOf w≠0) (h1:expOf w≠255):wv w≠0:=by have:sv w≠0:=by unfold sv mantOf;split<;>simp[h0]<;>omega simp[qAq w h1,rationalWord,decodeD_toRat,this,zpow_ne_zero] lemma qD8 (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h:ziv s e≠Е) (M:Model Fmt) (hf:Я M=true) (hM:в M=Model.roundAt Fmt V):toWord M=ziv s e:=by obtain ⟨S,ex,fr,W,h1,h2,h3,hz,hV,hW1,hW2,hW3⟩:=qCd s e V hlo hhi h;have hb0:(0:ℝ)<2^((ex:Int)-1076):=ы ב _;have hA2:(0:ℝ)<=(2^53-2^28)*2^((ex:Int)-1076) :=Н ב 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 Н (by linarith only[hfr1]) hb0.le . exact Б (by linarith only[hfr1]) hb0.le have hW0:0< W:=ц hLo0 hLoW;obtain ⟨m1,q1,hm1,hd1,hd1'⟩:=qGv 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'⟩:=qGv W ((W+B)/2) hW0.le ד;have w1:=qI6 S ex fr m1 q1 h1 h2 h3 hm1 ד (λh=>ц (hLo1 h) hd1) (ц hLo2 hd1) have w2:=qI6 S ex fr m2 q2 h1 h2 h3 hm2 ד (λh=>by exact ц (hLo1 h) ד) (ц 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,س,З];. split<;>omega have hexp:(expOf z).toNat=ex-896:=by rw[qA0,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:Ч Fmt ⟨S,m1,q1⟩=ofW z:=by rw[<-w1,qIs] have r2:Ч Fmt ⟨S,m2,q2⟩=ofW z:=by rw[<-w2,qIs] have fz:Я (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:в (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:в M≠0:=by rw[hM,<-hv];exact qIz 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 qKc:(2:ℝ)^(127:ℤ)<=в (Model.posMaxFinite Fmt):=by rw[Model.toReal_posMaxFinite,show Model.pow2 Fmt.fracWidth+Fmt.maxFiniteFracField=2^24-1 by decide +kernel,show Fmt.maxNormalExponent-Int.ofNat Fmt.fracWidth=104 by decide +kernel,Model.bpow,qA4];norm_num lemma qG1 (q:ℚ) : Model.signedScaledRatToReal (decide (q<0)) q.num.natAbs q.den 0=(q:ℝ):=by rw[Model.signedScaledRatToReal,Model.scaledRatToReal,Nat.cast_natAbs,Rat.cast_def];by_cases hq:q<0;. simp[hq,abs_of_neg (Rat.num_neg.2 hq)];ring . simp[hq,abs_of_nonneg (Rat.num_nonneg.2 (not_lt.1 hq))] lemma qJx (s e:Float) (q:ℚ) (hlo:R (s-e)<(q:ℝ)) (hhi:(q:ℝ)< R (s+e)) (h:ziv s e≠Е) (hb : |(q:ℝ)| ≤ 2^(127:ℤ)):roundRational q=ziv s e:=by have hf:=Model.isFinite_roundRatScaled_of_abs_le_posMaxFinite Fmt (decide (q<0)) q.num.natAbs q.den 0 (by decide) q.den_nz (qG1 q ▸ hb.trans qKc);have hM:=Model.toReal_roundRatScaled_eq_roundAt Fmt _ _ _ 0 (by decide) (by simpa using λh0=>qF9 s e q hlo hhi h (by simp[h0])) q.den_nz hf;exact qD8 s e q hlo hhi h _ hf (qG1 q ▸ hM) lemma qJb (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:п ((N:ℝ)/d)*FloatLib.Floats.Formats.Flocq.bpow ь x < 2^(127:ℤ)) : Я (Model.ofModel Fmt (Float.Model.UnpackedFloat.roundWithAccuracy (FloatFormat.toModel Fmt) .positive (sqrtLower N d) x (sqrtAccuracy N d)))=true := Model.isFinite_ofModel_roundWithAccuracy_of_lt_bpow Fmt rfl .positive _ _ _ (п ((N:ℝ)/d)) hr (sqrtAccuracy_correct N d hd) hs (hb.trans_eq (qA4 127).symm) lemma qJ5 (q:ℚ) (hq:0< q) (hb:п (q:ℝ)<2^(127:ℤ)) : Я (sqrtModel q)=true := qJb _ _ _ (ne_of_gt (sqrtRoot_pos q hq)) q.pos (sqrtStep_le_target q) (by rwa [sqrtScale_correct q hq]) lemma qI2 (s e:Float) (q:ℚ) (hq:0< q) (hlo:R (s-e)< п (q:ℝ)) (hhi:п (q:ℝ)< R (s+e)) (h:ziv s e≠Е) (hb:п (q:ℝ)<2^(127:ℤ)):sqrtRational q=ziv s e:=by have hf:=qJ5 q hq hb;exact (if_neg (not_le.2 hq)).trans (qD8 s e _ hlo hhi h _ hf (sqrtModel_correct q hq hf)) lemma qA6 (w:UInt32) (h:sm w=true):good w=true∧|wv w| ≤ 2^99:=by obtain ⟨hg,hl⟩:=ذ.1 h;have h1:=М.1 (of_decide_eq_true hl);rw[qAt] at h1;have h2:=qA3 w hg;rw[qCa w hg];refine ⟨hg,(qA7 _ _ h1 א).trans ?_⟩;unfold A_mag;norm_num end section section open Float.Model Float.Model.UnpackedFloat end end section end @[specialize] def fC {σ:Type} (f:σ->USize->USize->Word) (s:σ) (b j:USize) (o:Array Word):Nat->Array Word | 0=>o | k+1=>fC f s b (j+1) (wrW o (b+j) (f s (b+j) j)) k @[specialize] def fR {σ:Type} (h:Nat->σ) (f:σ->USize->USize->Word) (n r:Nat) (o:Array Word):Nat->Array Word | 0=>o | k+1=>fR h f n (r+1) (fC f (h r) (r*n).toUSize 0 o n) k 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:=А.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:=А.mp h;omega @[inline] def invOK (a b:Float):Bool := decide ((a.toBits >>> 52)-1<1222) && decide ((((a*b-П 0x3FF0000000000000)+П 0x3CD0000000000000).toBits >>> 52)-972<2) @[inline] def lnQ (b:Bool) (n:Nat) (x:Array Word) (r:Nat):ℚ:=if b then 0 else rowMean n x r def lnStat (b:Bool) (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*П ط let ind:=1.0/nd let a:=if b then F1.mk 0 0 else lnSum x base nu 0 0 0 let m:=if b then 0 else a.s*ind let v:=lnVar x base nu 0 m 0 let em:=(nf*a.t)*ind+П ك let tt:=v*ind+dv eps let d:=ф 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 (lnQ b n x r)+Д eps)⟩ @[noinline] def lnSlow (x g b den:Word) (mean:Unit->ℚ):Word := roundRational ((Д x-mean ())*Д g/Д den+Д 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) (П 0x3D10000000000000*(q.abs+bv.abs)+s.em*gd.abs) if 0x7EFFFFFF<(r &&& В) 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 false n eps x r.val fR (λr=>(st[r]!,λ_:Unit=>rowMean n x r)) (λs p j=>lnOut s.1 (rdW x p) (rdW g j) (rdW b j) s.2) n 0 (И (rows*n) 0) rows else layernormSpec rows n eps x g b section lemma qGu (x:UInt64):(x >>> 52).toNat=x.toNat/2^52:=by rw[ъ,т];rfl lemma qEf (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:=я.mp h;rw[UInt64.toNat_sub] at h1;have h2:=x.toNat_lt;have h3:=k.toNat_lt;omega lemma qEx (a b:ℤ) (n:ℕ) (h:a=n+b):(2:ℝ)^a=2^n*2^b:=by rw[h,а Р,к] lemma qC8 {f:Float} {E:Nat} (h:(f.toBits >>> 52).toNat=E) (hE1:1<=E) (hE:E<2047) : f.isFinite=true∧(2:ℝ)^((E:ℤ)-1023)<=R f∧R f<2^((E:ℤ)-1022):=by rw[qGu] at h;obtain ⟨F,hF,hM⟩:∃ F<2^52,f.toBits.toNat=E*2^52+F :=⟨f.toBits.toNat%2^52,by omega,by omega⟩;obtain ⟨h1,h2⟩:=B_R f false E F hE1 hE hF (by simpa using hM);have hb:(0:ℝ)<2^((E:ℤ)-1075):=ы ב _;have hF0:(0:ℝ)<=F:=Ю _;have hF2:(F:ℝ)<2^52:=by exact_mod_cast hF simp only[Bool.false_eq_true,ite_false,one_mul] at h2;push_cast at h2;rw[h2,qEx ((E:ℤ)-1023) (E-1075) 52 א,qEx ((E:ℤ)-1022) (E-1075) 53 א];exact ⟨h1,Б ד hb.le,б ד hb⟩ lemma L_k (c:UInt64) (E n:Nat) (hE1:1<=E) (hn:E+n=1023) (h:(П c).toBits.toNat=E*2^52) : (П c).isFinite=true∧R (П c)=1/2^n:=by obtain ⟨h1,h2⟩:=B_R (П c) false E 0 hE1 א ב (by simpa using h);refine ⟨h1,?_⟩;rw[h2,show (E:ℤ)-1075=-(52+(n:ℤ)) by omega,zpow_neg,а Р];norm_num;field_simp lemma qHt {f:Float} {E:Nat} (h:(f.toBits >>> 52).toNat=E) (hE1:1<=E) (hE:E<2047) : (ф f).isFinite=true∧0< R f ∧ |R (ф f)-п (R f)| ≤ 1/2^53*(п (R f)+A_z):=by obtain ⟨hf,hl,-⟩:=qC8 h hE1 hE have hp:0< R f:=ч (ы ב _) hl rw[qGu] at h have hs:Model.signBit (toModel (ofFloat f))=false:=by rw[qG4];simp only[decide_eq_false_iff_not,not_le];omega have hm:toModel (ofFloat f)=A_M f:=toModel_ofFloat f have hfm:Я (A_M f)=true:=by rw[qAk,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 (ф 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 (ф f))=Model.toModel (Model.sqrt (A_M f)):=by rw[hd,Model.toModel_canonicalizeModel] have hR:R (ф f)=Model.roundAt FloatFormat.binary64 (п (R f)):=by rw[A_R,о qAm,ht,<-о qAm] exact hr refine ⟨?_,hp,?_⟩ . rw[<-qAk,qA2,ht,<-qA2];exact hq . rw[hR];have:=qGx (п (R f));rwa [Ж (Real.sqrt_nonneg _)] at this lemma qAb (x y:ℝ) : |x| ≤ |y| + |x-y|:=by have:=abs_sub_abs_le_abs_sub x y;linarith lemma qAw {k:ℝ} (h:k<=2^256*2^44):k<=A_B :=h.trans_eq ((qEx 300 44 256 rfl).trans ב).symm lemma qBn (a:Array UInt32) (p:UInt32->Bool) (h:a.all p=true) (i:ℕ) (hi:i< a.size) : p a[i]! = true:=by rw[Э a i hi];simpa using Array.all_eq_true.1 h i hi lemma qF4 (w:UInt32) (g:good w=true) (h:w &&& В=0):Д w=0:=by exact_mod_cast (qAq w (qAd _ g)).symm.trans (qBc w g h) lemma qKm (s e:Float) (V:ℝ) (hlo:R (s-e)< V) (hhi:V< R (s+e)) (h0:ziv s e≠Е) (h:¬ (0x7EFFFFFF:UInt32)<(ziv s e &&& В)) : |V| ≤ 2^(127:ℤ):=by obtain ⟨S,ex,fr,W,h1,h2,h3,hz,hV,hW1,-,hW3⟩:=qCd s e V hlo hhi h0 have hb:(0:ℝ)<2^((ex:Int)-1076):=ы ב _ 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 ю.mpr rw[qAt,hz,UInt32.toNat_ofNat_of_lt' hN,(א:ex=1150)] show 2130706431< _ split<;>omega have hF:(fr:ℝ)+1<=2^23:=by exact_mod_cast (א:fr+1<=2^23) rw[hV] have hW:W<=2^54*2^(73:ℤ):=hW1.le.trans (С ד (Ш ב א) hb.le (by positivity)) rw[<-qEx 127 73 54 rfl] at hW split<;>simp only[abs_neg,abs_of_pos hW0,hW] lemma L_I {n I:ℝ} (hn:1<=n) (h3:0< I) (h4 : |I*n-1| ≤ 1/2^48):I<=2:=by have:=Г hn h3.le;linarith [(abs_le.mp h4).2] lemma qGy (n I v t Sb E T:ℝ) (h3:0< I) (h4 : |I*n-1| ≤ 1/2^48) (ht : |t| ≤ Sb) (hv : |v-n*t| ≤ n*E+T) (hE:0<=E) : |v*I-t| ≤ E*(1+1/2^48)+T*I+Sb*(1/2^48):=by have a1 : |(v-n*t)*I| ≤ (n*E+T)*I:=by rw[е,г h3];exact Б hv h3.le have a2:=Г (abs_le.mp h4).2 hE have a3 : |t*(I*n-1)| ≤ Sb*(1/2^48):=by rw[е];exact С ht h4 (Й _) ((Й _).trans ht) have a4:=Ь ((v-n*t)*I) (t*(I*n-1)) rw[show (v-n*t)*I+t*(I*n-1)=v*I-t by ring] at a4 linarith section variable {z:ℝ} (hz0:0<=z) (hz:z<=1/2^200*(1/2^200)) include hz0 hz lemma qEj {P rp rs rc:ℝ} (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 a1:=qAb (rs+1/2^50) rc;rw[и (rs+1/2^50) rc] at a1;have a2 : |rc| = rc:=Ж (ؾ ב lo);obtain ⟨c1,c2⟩:=abs_le.mp h3;have a3 : |rs| ≤ 1/2^49:=by rw[abs_le];constructor<;>linarith [Й (rs+1/2^50)] have b1:=qAb (rp-1) rs;rw[и (rp-1) rs] at b1;have b2 : |rp-1| ≤ 1/2^48:=by linarith [Й (rp-1)] have c3:=qAb (P-1) (rp-1);rw[show P-1-(rp-1)=-(rp-P) by ring,abs_neg] at c3;have c4:=qAb P 1;rw[abs_one] at c4;linarith [Й (P-1)] lemma qIt {a Mr Rm Em g D b I RA Rg Rq RY RE Rsa Rcs Reg Hi Lo:ℝ} (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:=ч (by positivity) hD;generalize hG:g/D=G;generalize hX:a-Rm=X at h1;rw[show (a-Mr)*g/D+b=X*G+(Rm-Mr)*G+b by rw[<-hG,<-hX];field_simp;ring];have hGb : |G| ≤ 2^163:=by rw[<-hG,abs_div,г hDp,div_le_iff₀ hDp];linarith only [hD,hg] have hXb : |X| ≤ 2^111:=hX ▸ (Ե _ _).trans (by linarith only [ha,hm]);have hgI : |g*I-G| ≤ 1/2^48 * |G|:=by rw[show g*I-G=G*(I*D-1) by rw[<-hG];field_simp,е,mul_comm];exact Б h2 (Й _) generalize g*I=Y at h3 hgI;clear hG hX hDp hD ha hg hm h2;have nX:=Й X;have nG:=Й G;have nA:=Й RA;have nR:=Й Rg;have a1:=qAb X RA;rw[и X RA] at a1;have a3 : |X| ≤ (1+2/2^53) * |RA| + 2/2^53*z :=(by linarith only [hz0,h1,nA,a1]);have a4 : |X-RA| ≤ 2/2^53 * |RA| + 2/2^53*z:=by rw[и];linarith only [hz0,h1,nA,a1] have a5 : |RA| ≤ 2^165:=by have:=qAb RA X;linarith have b1:=qAb Y G;have b2:=qAb G Rg;have b3:=abs_sub_le G Y Rg;rw[и G Y,и Y Rg] at b3;have b4 : |G| ≤ (1+1/2^47) * |Rg| + 2/2^53*z :=(by linarith only [hz0,h3,hgI,nR,b1,b2,b3]);have b5 : |G-Rg| ≤ 2/2^48 * |Rg| + 2/2^53*z :=(by linarith only [hz0,h3,hgI,nR,b1,b2,b3]);have c1 : |Rg| ≤ 2^165:=by have:=qAb Rg G;rw[и] at this;linarith have f1:=Ь ((X-RA)*G) (RA*(G-Rg));rw[е,е,show (X-RA)*G+RA*(G-Rg)=X*G-RA*Rg by ring] at f1;have f2:=С a4 b4 nG (by linarith only [hz0,nA]);have f3:=Г b5 nA;have zr:z * |RA| ≤ z*2^165:=Г a5 hz0;have zg:z * |Rg| ≤ z*2^165:=Г c1 hz0;have zz:z*z<=z*2^165:=Г (by linarith only [hz]) hz0;have ze:z*Em<=z*2^165:=Г (by linarith only [hE1]) hz0;have nzr:=Н hz0 nA;have nzg:=Н hz0 nR;have nzz:=Н hz0 hz0;have nP:=Н nA nR;have f4 : |X*G-RA*Rg| ≤ 9/2^50*(|RA| * |Rg|)+1/2^230 :=(by linarith only [hz,f1,f2,f3,zr,zg,zz,nP]);have p1 : |RA*Rg| ≤ (1+2/2^53) * |Rq| + 2/2^53*z:=by have:=qAb (RA*Rg) Rq;rw[и (RA*Rg) Rq] at this;have nq:=Й (RA*Rg);linarith rw[<-е] at f4;have q1 : |X*G-Rq| ≤ 5/2^49 * |Rq| + 1/2^229:=by have:=Ե (X*G-RA*Rg) (Rq-RA*Rg);rw[show X*G-RA*Rg-(Rq-RA*Rg)=X*G-Rq by ring] at this;have nq:=Й Rq;linarith generalize hT:Em * |Rg| = T at h8;have nT:0<=T:=hT ▸ Н hE0 nR;have e1 : |(Rm-Mr)*G| ≤ 5/2^3*T+1/2^230:=by rw[е,и];have h : |Mr-Rm| * |G| ≤ (Em/2)*((1+1/2^47) * |Rg| + 2/2^53*z) :=С (by linarith only [hM]) b4 nG (by linarith only [hE0]);have:=Н hz0 hE0;subst hT;linarith only [hz,ze,h,nT] rw[Ж nT] at h8;have nq:=Й Rq;have nb:=Й b;have nS:0 ≤ |Rq| + |b| :=(by linarith only [nq,nb]);rw[Ж nS] at h6;have s0 : |Rq+b| ≤ |Rq| + |b|:=Ь _ _;have s1 : |Rsa| ≤ 2*(|Rq| + |b|)+z:=by have:=qAb Rsa (|Rq| + |b|);rw[Ж nS] at this;linarith have h7' : |1/2^46*Rsa| = 1/2^46 * |Rsa|:=by rw[е,г (by positivity:(0:ℝ)<1/2^46)] rw[h7'] at h7;have s2 : |Rcs| ≤ 1/2^44*(|Rq| + |b|)+z:=by have:=qAb Rcs (1/2^46*Rsa);rw[h7'] at this;linarith have s3 : |Reg| ≤ 2*T+z:=by have:=qAb Reg T;rw[Ж nT] at this;linarith have s4 : |RY| ≤ 2*(|Rq| + |b|)+z:=by have:=qAb RY (Rq+b);linarith have s5:=Ь Rcs Reg;have s6 : |RE| ≤ 1/2^43*(|Rq| + |b|)+4*T+4*z:=by have:=qAb RE (Rcs+Reg);linarith have s7:=Ь RY RE;have s8:=Ե RY RE;have big:1/2^130 ≤ |Rq| + |b| + T:=by have:=qAb 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 only [hz,nT,nb,s0,s1,s2,s3,s4,s5,s6,s8,big,u1,v1,w2,x1,y1,z1,o1,t2,s7,u2,v2,w1,r1] lemma qIo {n Rs Rt I Rm N Y Em c:ℝ} (r Sb:ℝ) (hn1:1<=n) (hn2:n<=2^20) (hc:c=(n+8)/2^49) (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:=ؾ (Й _) hr;have nS:0<=n*Sb:=Н (by linarith only [hn1]) hS0;have nSb:n*Sb<=2^20*2^99:=С hn2 hS hS0 ב;generalize hW:n*Sb+z=W at h1 h2;have nW:0<=W :=(by linarith only [hz0,nS,hW]);have hI2:=L_I hn1 h3 h4;generalize hE:201/100/2^53*W+Sb/2^48=E have key:∀ v t:ℝ,|t| ≤ Sb->|v-n*t| ≤ 2*n*(1/2^53*W)->|v*I-t| ≤ E := λv t ht hv=>by have:=qGy n I v t Sb (2*(1/2^53*W)) 0 h3 h4 ht (by linarith only [hv]) (by linarith only [hz0,nS,hW]);linarith have hr1:=key Rs r hr h1;have hA1:=key Rt Sb (by rw[Ж hS0]) h2;generalize hA:Rt*I=A at hA1;have hE0:0<=E:=by rw[<-hE];positivity have hEb:E<=2^80:=by rw[<-hE];norm_num at nSb hS ⊢;linarith only [hz,hW,nSb,hS] have hc0:0<=c:=by rw[hc];positivity have hc1:c<=1/2^28:=by rw[hc];norm_num at hn2 ⊢;linarith only [hn2] have b0:=qAb A Sb;rw[Ж hS0] at b0;have b1 : |N*I-c*A| ≤ 1/2^53*(|c*A| + 2*z):=by rw[<-hA,show N*I-c*(Rt*I)=(N-c*Rt)*I by ring,е,г h3,show |c*(Rt*I)| = |c*Rt| * I by rw[е,е,е,г h3];ring];have:=Б h6 h3.le;have:=Г hI2 hz0;linarith have b2 : |c*A| ≤ 1/2^28*(Sb+E):=by rw[е,Ж hc0];exact С hc1 (by linarith only [hA1,b0]) (Й _) ב have b3:c*Sb-1/2^28*E<=c*A:=by have h9 : |c*(A-Sb)| ≤ 1/2^28*E:=by rw[е,Ж hc0];exact С hc1 hA1 (Й _) ב linarith [(abs_le.mp h9).1] have b4:c*Sb=(n*Sb+8*Sb)/2^49:=by rw[hc];ring have c1:=qAb (N*I) (c*A);have c2:=qAb Y (N*I);have c3:=Ь Y (1/2^200);rw[г (by norm_num:(0:ℝ)<1/2^200)] at c3;have d1:=qAb Rm (Rs*I);have d2:=qAb (Rs*I) r;have d3:=abs_sub_le r (Rs*I) Rm;rw[и r (Rs*I),и (Rs*I) Rm] at d3;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 b2 b3 hEb;subst hW;have ha:=Й r;have g1:=le_abs_self (c*A);exact ⟨by linarith only [hz,hr,h5,h7,hS0,nS,b1,b4,c1,c2,c3,d2,d3,e1,e3,e5,hr1,b2,b3],by linarith only [hz,hS,h7,nSb,b1,c1,c2,c3,e2,e4,e6,b2,g1],by linarith only [hz,h7,hS0,nS,b1,b4,c1,c2,c3,e1,e3,e5,b2,b3],by linarith only [hz,hr,hS,h5,nSb,d1,d2,hr1]⟩ lemma qH0 {s c Em dd Rn2 Rmu ee hi lo:ℝ} (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 hcp:0< c:=ч ב hc0;have hcs:0<=c*s:=Н hcp.le hs0;have hcs2:=Б hc0 hs0;have hcc : |c+c| = c+c:=г (by linarith only [hcp]);rw[hcc] at h2;have d1:=qAb dd s;rw[Ж hs0] at d1;have d2 : |dd| ≤ 3*s+z :=(by linarith only [hz0,hs0,h1,d1]);have d3 : |dd| ≤ 2^103:=by norm_num at hs1 hz d2 ⊢;linarith only [hc1,h1,hcp,d1,hs1,hz] have m1:=Ь ((Rn2-(c+c))*dd) ((c+c)*(dd-s));rw[е,е,hcc,show (Rn2-(c+c))*dd+(c+c)*(dd-s)=Rn2*dd-(c+c)*s by ring] at m1;have m2:=С h2 d2 (Й _) (by positivity);have m3:=Г h1 (by linarith only [hcp]:0<=c+c);have zs:=С hz hs1 hs0 ב;have zc:z*c<=z*1:=Г (by linarith only [hc1]) hz0;have zz:z*z<=z*1:=Г (by linarith only [hz]) hz0;have nzs:=Н hz0 hs0;have nzc:=Н hz0 hcp.le;have nzz:=Н hz0 hz0;have m4 : |Rn2*dd-(c+c)*s| ≤ 1/2^49*(c*s)+1/2^230:=by norm_num at zs ⊢;linarith only [hz,hc1,hcp,hcs,m1,m2,m3,zc,zz,zs] generalize Rn2*dd=M at h3 m4;rw[show (c+c)*s=2*(c*s) by ring] at m4;have n1:=qAb M (2*(c*s));rw[Ж (by linarith only [hcs]:0<=2*(c*s))] at n1;have n2:=qAb Rmu M;have n3:=Ь Rmu Em;rw[г (by linarith [(by norm_num:(0:ℝ)<1/2^201)]:0< Em)] at n3;have n4:=qAb ee (Rmu+Em);have n5:=Ь dd ee;have n6:=Ե 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:=Б hc1 hs0;constructor<;>linarith only [hz,hE,h1,h4,hcs,hcs2,d1,h3,m4,n1,n2,n3,n4,n5,a1,b1,c1,d4,e1,hc1,hcp,n6,a2,f2] lemma qKf {x Rd RQ:ℝ} (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 nA:=Й x have zA:=С hz hx nA ב have zz:z*z<=z*1:=Г ד hz0 have nzA:=Н hz0 nA have nzz:=Н hz0 hz0 have hsq : |x| ^ 2=x^2:=sq_abs x generalize he:Rd-x=e at h1 have q1:=ض (Й e) h1 2 have q3 : |2*x*e| ≤ 2 * |x| * (1/2^53*(|x| + z)):=by rw[е,е,abs_two] exact Г h1 (by positivity) have q6 : |Rd*Rd-x^2| ≤ |2*x*e| + |e| ^ 2:=by rw[show Rd*Rd-x^2=2*x*e+e^2 by rw[<-he];ring,<-abs_pow] exact Ь _ _ have q8:=qAb (Rd*Rd) (x^2) rw[Ж (ق x)] at q8 have q9:=qAb (RQ-x^2) (RQ-Rd*Rd) rw[show RQ-x^2-(RQ-Rd*Rd)=Rd*Rd-x^2 by ring] at q9 have nX:=ق x have s1 : |Rd*Rd-x^2| ≤ 201/100/2^53*x^2+1/2^254 :=ד linarith lemma qJz {n Rv I Rp Rt ep c:ℝ} (Ws tau:ℝ) (hn1:1<=n) (hn2:n<=2^20) (hc:c=(n+8)/2^49) (hWs:0<=Ws) (hep:1/2^126<=ep) (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 hep0:0< ep:=ч ב hep have hI2:=L_I hn1 h3 h4 have hX:0<=(2*n+6)/2^53*Ws:=Н (by linarith only [hn1]) hWs have b1:=qGy n I Rv Ws Ws _ tau h3 h4 (by rw[Ж hWs]) (by linarith only [h1]) hX have a3:=Г hI2 ht0 have nnW:=Н (by linarith only [hn1]:0<=n) hWs have nnE:=Н (by linarith only [hn1]:0<=n) hep0.le have nnW2:=Б hn2 hWs have b2:=qAb (Rv*I) Ws rw[Ж hWs] at b2 have b3:=Ь Rp ep rw[г hep0] at b3 have b4:=qAb Rp (Rv*I) have b5:=Ь (Rt-(Rp+ep)) ((Rp-Rv*I)+(Rv*I-Ws)) have b6:=Ь (Rp-Rv*I) (Rv*I-Ws) rw[show Rt-(Rp+ep)+(Rp-Rv*I+(Rv*I-Ws))=Rt-(Ws+ep) by ring] at b5 rw[hc] linarith only [hz,hWs,hep,ht,h5,h6,hep0,hX,b1,a3,nnE,b2,b3,b4,b5,b6] lemma qH9 {n W Rv Sq Si:ℝ} (hn1:1<=n) (hn2:n<=2^20) (hW:0<=W) (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:=Г h3 hn0 have a3:=Б hn2 hW have a4:=С hn2 hn2 hn0 ב have a5:=С hn2 hz hz0 ב have a6:=abs_sub_le Rv Sq W linarith end lemma qIn {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< п T∧п 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];generalize hk:s*(1-3/2*c)=k at h4;have hk0:0<=k-9/10*Em :=ד;have q1:=ض hl h4 2;have q3:=Н 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 have ht:0<=1-3/2*c:=by linarith only[hc1] have hu:1-3/2*c<=1:=by linarith only[hc0] have hh:=mul_le_mul_of_nonneg_right hu ht simpa only[pow_two,one_mul] using hh calc k^2=s^2*(1-3/2*c)^2:=by rw[<-hk];ring _<=_:=Г h5 (ق _) have q5:=ق Em;linear_combination h2 + q4 + q1 + (9/5:ℝ)*q3 + (14/25:ℝ)*q5 + (1/2:ℝ)*hq . have hh:0< hi:=by have h5:0< s*(1+3/2*c):=by positivity linarith rw[Real.sqrt_lt' hh];have q1:=ض (by positivity) h3 2;have r1:0<=s^2*c^2:=by positivity have r2:0<=s*Em*(1+3/2*c):=by positivity have r3:=ق Em;linear_combination h1 + q1 + (9/4:ℝ)*r1 + (9/5:ℝ)*r2 + (81/100:ℝ)*r3 + 2*hq lemma qIv (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 qHf (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[qIv,qIv] field_simp ring lemma qIh (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 (Բ _ hk)) (λk hk=>h k (Բ _ hk)) have h0:=hw j Է have h1:=h j Է simp only[List.map_cons,List.sum_cons,List.length_cons] push_cast have a1:=Ь (f j-w j) ((l.map f).sum-(l.map w).sum) rw[show f j-w j+((l.map f).sum-(l.map w).sum)=f j+(l.map f).sum-(w j+(l.map w).sum) by ring] at a1 have a2:=qAb (f j) (w j) rw[Ж h0] at a2 exact ⟨by linarith,by linarith,by linarith⟩ lemma qIg (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 rw[<-qEt a b hs.symm hf,show dsum a b 0 a.size=0 by simpa using hz,finishWord_zero] lemma qIj (n:Nat) (a b:Nat->UInt32) (hf:∀ t,t< n->expOf (a t)≠255∧expOf (b t)≠255) (hS:∑ j∈р n,Д (a j)*Д (b j)=0) : dotOf n a b=toWord (Model.zero Fmt (decide (n≠0) && dallNZ (Array.ofFn (n:=n) λi=>a i.val) (Array.ofFn (n:=n) λi=>b i.val) 0 n)):=by have gA:=qAa n a have gB:=qAa n b have s:(Array.ofFn (n:=n) λi=>a i.val).size=n:=by simp have e:=qIg (Array.ofFn (n:=n) λi=>a i.val) (Array.ofFn (n:=n) λi=>b i.val) ג (λj hj=>by rw[s] at hj;rw[gA j hj,gB j hj];exact hf j hj) (by rw[s,qFl,<-hS] refine ر rfl λj hj=>?_ have h:=ؽ.mp hj rw[Л,gA j h,gB j h]) rw[s] at e exact e lemma qJ8 (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 qJt (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 qJe (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 х)=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 х)≠255:=λj _=>by by_cases h:j< k . simpa [h] using hf j h . simp only[h,ite_false];exact ⟨by decide,by decide⟩ have hsum:(∑ j∈р (k+1),Д (if j< k then a j else oneW) * Д (if j< k then b j else х)) =∑ j∈р k,Д (a j)*Д (b j):=by rw[Finset.sum_range_succ] simp only[lt_self_iff_false,ite_false,qF4 0x80000000 (by decide) (by decide),mul_zero,add_zero] exact ر rfl λj hj=>by simp[Finset.mem_range.mp hj] by_cases hS:(∑ j∈р k,Д (a j)*Д (b j))=0 . have g1:=qAa (k+1) λt=>if t< k then a t else oneW;have g2:=qAa (k+1) λt=>if t< k then b t else х rw[qIj _ _ _ hf' (hsum.trans hS),qIj k a b hf hS,qJ8,Л,g1 k א,g2 k א, qJt _ _ (Array.ofFn (n:=k) λi=>a i.val) (Array.ofFn (n:=k) λi=>b i.val) k 0 (λj _ h2=>by rw[g1 j א,g2 j א,qAa k a j א,qAa k b j א] simp[show j< k by omega])] simp[show mantOf (0x80000000:UInt32)=0 by decide,show signOf oneW=false by decide,show signOf (0x80000000:UInt32)=true by decide,hk.ne'] . obtain ⟨d,hd,hw⟩:=qCe k a b hf hS;obtain ⟨e,he,hw'⟩:=qCe (k+1) _ _ hf' (by rw[hsum];exact hS);have t:=@FloatLib.Numerics.Dyadic.toRat_eq_zero_iff;have h3:e.toRat=d.toRat:=by rw[he,hd,hsum] rw[hw,hw',roundDyadic_congr Fmt (by decide) e d (λh=>hS (hd.symm.trans (h3.symm.trans ((t _).2 h)))) (λh=>hS (hd.symm.trans ((t _).2 h))) h3] lemma qI8 (A:Array UInt32) (h:A.all finiteWord=true) (t:Nat):expOf A[t]!≠255:=by by_cases ht:t< A.size;. simpa [finiteWord] using qBn A _ h t ht . rw[غ A t ht];decide lemma qKd {σ:Type} {N n c:Nat} {sp:Nat->Word} {f:σ->USize->USize->Word} {s:σ} {b:USize} (hN:N<2^32) (hb:b.toNat=c) (hn:c+n<=N) (hf:∀ p u:USize,p.toNat=c+u.toNat->u.toNat< n->f s p u=sp p.toNat) (k:Nat) : ∀ (j:USize) (o:Array Word),j.toNat+k=n->C_Inv N sp (λq=>q< c+j.toNat) o → C_Inv N sp (λq=>q< c+n) (fC f s b j o k):=by induction k with | zero => intro j o e h rw[fC,<-e];exact h | succ k ih => intro j o e h have a0:(b+j).toNat=c+j.toNat:=by rw[<-hb];exact qAo _ _ א have a1:(j+1).toNat=j.toNat+1:=by rw[qAo _ _ (by rw[ش];omega),ش] rw[fC] refine ih _ _ א ?_ rw[a1] exact qAn hN h a0 א (by rw[hf _ _ a0 א,a0]) lemma qDj {σ:Type} {R n:Nat} (F:Nat->Nat->Nat->Word) {h:Nat->σ} {f:σ->USize->USize->Word} (hN:R*n<2^32) (hn:0< n) (hf:∀ (r:Nat) (p u:USize),r< R->p.toNat=r*n+u.toNat->u.toNat< n → f (h r) p u=F r u.toNat p.toNat) : fR h f n 0 (И (R*n) 0) R =Array.ofFn (n:=R*n) λq=>F (q.val/n) (q.val%n) q.val:=by let sp q:=F (q/n) (q%n) q have K:∀ (d r:Nat) (o:Array Word),r+d=R->C_Inv (R*n) sp (λq=>q< r*n) o → C_Inv (R*n) sp (λq=>q< R*n) (fR h f n r o d):=λd=>by induction d with | zero => intro r o e H subst e exact H | succ d ih => intro r o e H have h1:r*n+n<=R*n:=qA1 (א:r< R) (le_refl _) rw[fR] refine ih _ _ א ?_ rw[ػ] exact qKd hN (qAc _ א) h1 (λp u h2 h3=>by rw[hf r p u א h2 h3] show F _ _ _=F _ _ _ rw[h2,ж r n,ـ hn,ف,ш h3,З h3,у]) n 0 o (Л _) H exact qDp (K R 0 _ א ⟨by simp,λq _ (h:q<0*n)=>by omega⟩) λq hq=>hq lemma qIr (x:Array UInt32) (hx:x.size<2^32) (base nu:USize) (hb:base.toNat+nu.toNat<2^32) (d:ℕ) (i:USize) (s t:Float) (h: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 induction d generalizing i s t with | zero => rw[lnSum,dif_neg (by rw[А];omega)];simp | succ d ih => have hn:i< nu:=by rw[А];omega have e1:=usz i nu hn rw[lnSum,dif_pos hn,ih (i+1) _ _ (by rw[e1];omega),e1,qAj x _ hx,qAo base i א] simp[List.range'_succ] lemma qId (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) (h: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 induction d generalizing i v with | zero => rw[lnVar,dif_neg (by rw[А];omega)];simp | succ d ih => have hn:i< nu:=by rw[А];omega have e1:=usz i nu hn rw[lnVar,dif_pos hn,ih (i+1) _ (by rw[e1];omega),e1,qAj x _ hx,qAo base i א] simp[List.range'_succ] lemma qFr (l:List ℕ) (f:ℕ->ℚ) (u:ℕ->ℝ) (c:ℚ) (h:∀ j∈l,(f j:ℝ)=u j) : ((l.foldl (λt j=>t+f j) c:ℚ):ℝ)=c+(l.map u).sum:=by induction l generalizing c with | nil=>simp | cons j l ih => simp only[List.foldl_cons,List.map_cons,List.sum_cons];rw[ih _ λk hk=>h k (Բ _ hk),<-h j Է];push_cast;ring lemma qJq (w:UInt32) (hg:good w=true) (h1:(0x1F800000:UInt32)<=w) (h2:w<=(0x70FFFFFF:UInt32)):1/2^64<=wv w:=by have a1:528482304<=w.toNat:=М.mp h1;have a2:w.toNat<=1895825407:=М.mp h2;rw[qAz w hg,if_neg א,one_mul];have h3:=qA7 528482304 (w.toNat%2^31) א א;have:A_mag 528482304=1/2^64:=by unfold A_mag;norm_num rwa [this] at h3 lemma qJv (w:UInt32) (hg:good w=true) (h0:0< wv w):1/2^126<=wv w:=by have hn:=qA3 w hg;rw[qAz w hg] at h0 ⊢;rcases hn with hn | ⟨hn,-⟩;. rw[hn] at h0;simp[A_mag] at h0 . have hs:¬ 2^31<=w.toNat:=λhc=>by rw[if_pos hc] at h0;linarith [qAv (w.toNat%2^31)] rw[if_neg hs,one_mul];have h3:=qA7 (2^23) (w.toNat%2^31) hn א;have:A_mag (2^23)=1/2^126:=by unfold A_mag;norm_num rwa [this] at h3 lemma qKi (n:ℕ) (hn:n<2^20) : ((n.toUInt64+8).toFloat*П ط).isFinite=true ∧ R ((n.toUInt64+8).toFloat*П ط)=((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:=qB0 (n.toUInt64+8) (by rw[ht];omega) obtain ⟨h2,h3⟩:=L_k ط 974 49 ב rfl (by rfl) have h4:(n:ℝ)+8<=2^21:=by exact_mod_cast (א:n+8<=2^21) obtain ⟨hf,he⟩:=qC7 _ _ h1.1 h2 (by rw[h1.2,h3,ht] refine ؾ (С (qAw ?_) (qAw (by rw[Ж (by positivity)];norm_num)) (Й _) qKo.le) qCb rw[Nat.cast_add,Ж (by positivity)] push_cast linarith) refine ⟨hf,?_⟩ rw[he,h1.2,h3,ht] have:=qAu ((n:ℤ)+8) (-49) א ב push_cast at this ⊢ rw[show (2:ℝ)^(-49:ℤ)=1/2^49 by norm_num] at this rw[this] ring lemma qEs {r x B:ℝ} (e : |r-x| ≤ 1/2^53*(|x| + A_z)) (h : |x| ≤ B) : |r| ≤ 9/8*B+A_z:=by linarith [qAb r x,Й x,qAs] lemma qAy (x y:Float) (B:ℝ) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ B) (h2 : |R y| ≤ B) (hB:B<=2^256*2^44:=by norm_num) : (x+y).isFinite=true∧|R (x+y)-(R x+R y)| ≤ 1/2^53*(|R x+R y| + A_z) ∧ |R (x+y)| ≤ 9/8*(B+B)+A_z:=by obtain ⟨f,e⟩:=qBa x y hx hy (h1.trans (qAw hB)) (h2.trans (qAw hB)) exact ⟨f,e,qEs e ((Ь _ _).trans (add_le_add h1 h2))⟩ lemma qCh (x y:Float) (B:ℝ) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ B) (h2 : |R y| ≤ B) (hB:B<=2^256*2^44:=by norm_num) : (x-y).isFinite=true∧|R (x-y)-(R x-R y)| ≤ 1/2^53*(|R x-R y| + A_z) ∧ |R (x-y)| ≤ 9/8*(B+B)+A_z:=by obtain ⟨f,e⟩:=qDc x y hx hy (h1.trans (qAw hB)) (h2.trans (qAw hB)) exact ⟨f,e,qEs e ((Ե _ _).trans (add_le_add h1 h2))⟩ lemma qAr (x y:Float) (B C:ℝ) (hx:x.isFinite=true) (hy:y.isFinite=true) (h1 : |R x| ≤ B) (h2 : |R y| ≤ C) (hB:B<=2^256*2^44:=by norm_num) (hC:C<=2^256*2^44:=by norm_num) : (x*y).isFinite=true∧|R (x*y)-R x*R y| ≤ 1/2^53*(|R x*R y| + A_z) ∧ |R (x*y)| ≤ 9/8*(B*C)+A_z:=by obtain ⟨f,e⟩:=qBw x y hx hy (h1.trans (qAw hB)) (h2.trans (qAw hC)) exact ⟨f,e,qEs e (е (R x) (R y) ▸ С h1 h2 (Й _) ((Й _).trans h1))⟩ lemma qGr (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 simp only[invOK,Bool.and_eq_true,decide_eq_true_eq] at h;obtain ⟨r1,r2⟩:1<=_∧_<1+1222:=qEf _ 1 1222 h.1 (by decide);obtain ⟨r3,r4⟩:972<=_∧_<972+2:=qEf _ 972 2 h.2 (by decide);obtain ⟨f1,l1,u1⟩:=qC8 rfl r1 א;have hp:0< R a:=ч (ы ב _) l1;have ha2:R a<=2^200:=u1.le.trans ((Ш ב א).trans_eq (by norm_num:(2:ℝ)^(200:ℤ)=2^200));obtain ⟨k1,k2⟩:=L_k 0x3FF0000000000000 1023 0 ב rfl (by rfl);obtain ⟨k3,k4⟩:=L_k 0x3CD0000000000000 973 50 ב rfl (by rfl);rw[pow_zero,div_one] at k2;have hz1:=qBx;obtain ⟨f2,g1,q1⟩:=qAr a b (2^200) (2^99) f1 hb (by rwa [г hp]) hb2;obtain ⟨f3,g2⟩:=qDc _ _ f2 k1 (qAw ד) (qAw (by rw[k2];norm_num));rw[k2] at g2;have q3:=Ե (R (a*b)) 1;rw[abs_one] at q3;have q2:=qEs g2 q3;obtain ⟨f4,g3⟩:=qBa _ _ f3 k3 (qAw ד) (qAw (by rw[k4];norm_num));rw[k4] at g3;obtain ⟨-,l2,u2⟩:=qC8 rfl (ؾ ב r3) א;refine ⟨f1,hp,ha2,qEj qAs.le qAx g1 g2 g3 ?_ ?_⟩;. exact (by norm_num:(1/2^51:ℝ)=2^(-51:ℤ)).trans_le ((Ш ב א).trans l2) . exact u2.le.trans ((Ш ב א).trans_eq (by norm_num:(2:ℝ)^(-49:ℤ)=1/2^49)) lemma qD4 (n:ℕ) (f:ℕ->ℝ) (B:ℝ) (h:∀ j,j< n->f j<=B) : ((К n).map f).sum<=n*B:=by simpa using List.sum_le_length_nsmul ((List.range n).map f) B (by simpa using λj hj=>h j hj) lemma qF0 (n:ℕ) (hn:n<2^20) (f:ℕ->Float) (a b:ℕ->ℝ) (hf:∀ j,j< n->(f j).isFinite=true∧R (f j)=a j∧|a j| = b j) (hb:((К n).map b).sum<=A_B/4) : (A_fsum ((К n).map f)).isFinite=true ∧ |R (A_fsum ((К n).map f))-((К n).map a).sum| ≤ 2*n*(1/2^53*(((К n).map b).sum+A_z)):=by have s:∀ (u:Float->ℝ) (v:ℕ->ℝ),(∀ j,j< n->u (f j)=v j) → (((К n).map f).map u).sum=((К n).map v).sum:=λu v h=>by simp only[List.map_map] exact congrArg _ (Զ λj hj=>h j (й.1 hj)) have e1:=s (λq=>|R q|) b λj h=>by simp only[(hf j h).2.1,(hf j h).2.2] have e2:=s R a λj h=>(hf j h).2.1 have:=qBf ((К n).map f) (λq hq=>by obtain ⟨j,hj,rfl⟩:=List.mem_map.1 hq exact (hf j (й.1 hj)).1) (by simp;omega) (by rw[A_sa,e1];exact hb) rwa [A_sa,A_sr,e1,e2,List.length_map,List.length_range] at this lemma qIm (n:ℕ) (hn:n<2^20) (hn0:0< n) (g:ℕ->Float) (m v:Float) (W:ℝ) (hv:v=A_fsum ((К n).map λj=>(g j-m)*(g j-m))) (hW:W=((К n).map λj=>(R (g j)-R m)^2).sum) (hg:∀ j,j< n->(g j).isFinite=true∧|R (g j)| ≤ 2^99) (hm:m.isFinite=true) (hm2 : |R m| ≤ 2^110) : v.isFinite=true∧|R v-W| ≤ (2*n+6)/2^53*W+1/2^229∧W<=n*2^222∧0<=W:=by have hz0:=qAs.le;have hzl:=qAx;have hzb:=qBx 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⟩:=qCh (g j) m (2^110) f hm B1 hm2 have b2 : |R (g j-m)| ≤ 2^112 :=ד obtain ⟨f2,e2,-⟩:=qAr _ _ (2^112) (2^112) f1 f1 b2 b2 have hx : |R (g j)-R m| ≤ 2^111:=(Ե _ _).trans ד refine ⟨f2,qKf hz0 hzl hx e1 e2,?_⟩ have:=ض (Й _) hx 2 rw[sq_abs] at this exact this.trans ב obtain ⟨a1,a2,a3⟩:=qIh (К n) (λj=>R ((g j-m)*(g j-m))) (λj=>(R (g j)-R m)^2) (4/2^53) (1/2^250) (λj _=>ق _) (λj hj=>(hq j (й.1 hj)).2.1) ב ב;simp only[List.length_range] at a1 a2;rw[<-hW] at a1 a2 a3;have hW':W<=n*2^222:=hW ▸ qD4 n _ _ λj h=>(hq j h).2.2;have hnR:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have hnR1:(1:ℝ)<=n:=by exact_mod_cast hn0 have h1:(n:ℝ)*2^222<=2^20*2^222:=by gcongr have h2:(n:ℝ)*(1/2^250)<=2^20*(1/2^250):=by gcongr obtain ⟨f2,e2⟩:=qF0 n hn _ _ (λj=>|R ((g j-m)*(g j-m))|) (λj h=>⟨(hq j h).1,rfl,rfl⟩) (by refine ؾ a2 ?_;have:=qAw (k:=2^256*2^44) le_rfl linarith) rw[<-hv] at e2 f2;exact ⟨f2,qH9 hz0 hzl hnR1 hnR a3 e2 a1 a2,hW',a3⟩ lemma qG9 (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 (Ь _ _).trans (add_le_add le_rfl ih) def L_oF (s:LnS) (M:ℝ):Prop := 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 def L_ok (b:Bool) (n:ℕ) (eps:Word) (x:Array Word) (r:ℕ) (s:LnS):Prop := s.den=sqrtRational (rowVariance n x r (lnQ b n x r)+Д eps) ∧ L_oF s (lnQ b n x r:ℚ) lemma qI9 (n r:ℕ) (x:Array Word) (g:ℕ->Float) (h:∀ j,j< n → R (g j)=(Д x[r*n+j]! : ℝ)) (q:ℚ) : ((rowMean n x r:ℚ):ℝ)=((К n).map λj=>R (g j)).sum/n ∧ ((rowVariance n x r q:ℚ):ℝ) =((К n).map λj=>(R (g j)-(q:ℝ))^2).sum/n:=by constructor . rw[rowMean,Rat.cast_div,qFr _ _ (λj=>R (g j)) 0 λj hj=>(h j (й.1 hj)).symm];simp . rw[rowVariance,Rat.cast_div,qFr _ _ (λj=>(R (g j)-(q:ℝ))^2) 0 λj hj=>by rw[h j (й.1 hj)];push_cast;rfl] simp lemma qH7 (n:ℕ) (hnR1:(1:ℝ)<=n) (hnR2:(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+П ك=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 hz0:=qAs.le have hzb:=qBx have hc0:0< c:=by rw[hc];positivity have hc1:c<=1/2^20:=by rw[hc];linarith have bI : |R ind| ≤ 2:=by rw[г pi];exact L_I hnR1 pi ei have hSa0:0<=Sa:=(Й _).trans o3 have hSb:=Б hnR2 (by norm_num:(0:ℝ)<=2^99) have o7:=С hnR2 (by linarith:Sa+A_z<=2^119+1) ד ב have bs : |R Fs| ≤ 2^120:=by linarith [qAb (R Fs) S] have bt : |R Ft| ≤ 2^120:=by have:=qAb (R Ft) Sa rw[Ж hSa0] at this linarith have bnf : |R nf| ≤ 1:=by rw[Rnf,г hc0];linarith obtain ⟨fm,em1,-⟩:=qAr Fs ind (2^120) 2 o1 fi bs bI rw[hm] at fm em1 obtain ⟨fN,emN,bN⟩:=qAr nf Ft 1 (2^120) fnf o2 bnf bt rw[Rnf] at emN obtain ⟨fY,emY,bY⟩:=qAr (nf*Ft) ind (2^122) 2 fN fi ד bI obtain ⟨k1,k2⟩:=L_k ك 823 200 ב rfl (by rfl) obtain ⟨fE,emE,-⟩:=qAy (nf*Ft*ind) _ (2^125) fY k1 ד (by rw[k2];norm_num) rw[k2,hem] at emE rw[hem] at fE have hnpos:(0:ℝ)< n :=ד have hnp:=hnpos.ne' have eS:(n:ℝ)*(S/n)=S:=by field_simp have eA:(n:ℝ)*(Sa/n)=Sa:=by field_simp obtain ⟨m1,m2,m3,m4⟩:=qIo hz0 qAx (S/n) (Sa/n) hnR1 hnR2 hc (by rw[abs_div,г 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 qJ6 (n:ℕ) (hnR1:(1:ℝ)<=n) (hnR2:(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 hnpos:(0:ℝ)< n :=ד;have hnp:=hnpos.ne';have hzb:=qBx;have bI : |R ind| ≤ 2:=by rw[г pi];exact L_I hnR1 pi ei have bW:=Б hnR2 (by norm_num:(0:ℝ)<=2^222);have bv : |R v| ≤ 2^250:=by have a1:=qAb (R v) W;rw[Ж hW0] at a1;have a3:=Б hnR2 hW0;linarith obtain ⟨fp,ep1,bp⟩:=qAr v ind (2^250) 2 p1 fi bv bI;obtain ⟨de1,de2⟩:=qAl eps gE;obtain ⟨ft,et,-⟩:=qAy (v*ind) (dv eps) (2^253) fp de1 ד (by rw[de2];exact bE.trans ב);rw[de2,htt] at et;rw[htt] at ft;exact ⟨ft,qJz qAs.le qAx (W/n) (1/2^229) hnR1 hnR2 hc (div_nonneg hW0 hnpos.le) (qJv eps gE hep0) ב le_rfl (by rw[show (n:ℝ)*(W/n)=W by field_simp];exact p2) pi ei ep1 et⟩ lemma qKk (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 (ф tt-((nf+nf)*ф tt+em))< п T ∧ п T< R (ф tt+((nf+nf)*ф tt+em)) ∧ п T<2^(127:ℤ):=by have hzb:=qBx have hc0:0< c:=ч ב hc2 obtain ⟨-,-,u1⟩:=qC8 hEe hE1 א obtain ⟨fd,ptt,ed⟩:=qHt hEe hE1 א generalize ф tt=d at fd ed ⊢ have ht2:R tt<=2^200:=u1.le.trans ((Ш ב א).trans_eq (by norm_num:(2:ℝ)^(200:ℤ)=2^200)) generalize hs':п (R tt)=s' 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] exact ⟨by norm_num,ht2.trans ב⟩ have bd : |R d| ≤ 2^102:=by have a1:=qAb (R d) s' rw[г hs0] at a1 linarith only[a1,ed,hs1,hzb] have bnf : |R nf| ≤ 1:=by rw[Rnf,г hc0];linarith only[hc1] obtain ⟨f2n,e2n,b2n⟩:=qAy nf nf 1 fnf fnf bnf bnf rw[Rnf] at e2n obtain ⟨fmu,emu,bmu⟩:=qAr (nf+nf) d 4 (2^102) f2n fd ד bd have hEm0:0<=R em:=ؾ ב m3 have bEm : |R em| ≤ 2^120:=by rw[Ж hEm0];exact m2 obtain ⟨fe,ee,be⟩:=qAy ((nf+nf)*d) em (2^120) fmu fE ד bEm obtain ⟨fh,eh,-⟩:=qAy d _ (2^123) fd fe (bd.trans ב) ד obtain ⟨fl,el,-⟩:=qCh d _ (2^123) fd fe (bd.trans ב) ד obtain ⟨hhi,hlo⟩:=qH0 qAs.le qAx 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:=ض (by positivity) m1 2 rw[mul_pow,sq_abs] at a1 linarith only[a1] have nP:0<=c*P:=(mul_pos hc0 hP0).le have a3:=Б (by linarith only[hc1]:c<=1) nP have a4:=Н hc0.le nP have nd2:=ق δ have h1':T<=s'^2*(1+c):=by rw[hsq,hT] have a1:=Б (by linarith only[b1]:P-c/2*P<=R tt) (by linarith only[hc0]:0<=1+c) linarith only[a1,a3,nd2] have h2':s'^2*(1-c)-R em^2/4<=T:=by rw[hsq,hT] have a1:=Б (by linarith only[b2]:R tt<=P+c/2*P) (by linarith only[hc1]:0<=1-c) linarith only[a1,a4,nP,hδ2] obtain ⟨l1,l2⟩:=qIn hT0 hs0 hc0 hc1 hEm0 h1' h2' hhi hlo refine ⟨l1,l2,?_⟩ rw[Real.sqrt_lt' (by positivity),show ((2:ℝ)^(127:ℤ))^2=2^254 by norm_num] have a1:=С (hsq.trans_le ht2) (by linarith only[hc1]:1+c<=2) ד ב linarith only[h1',a1] lemma qFh (b:Bool) (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< Д eps) : L_ok b n eps x r (lnStat b n eps x r):=by have hmul:r*n+n<=rows*n:=by have:=Т n hr;rwa [ػ] at this generalize hgd:(λj:ℕ=>dv x[r*n+j]!)=g;have hg0:∀ j,j< n->(g j).isFinite=true∧|R (g j)| ≤ 2^99 ∧ R (g j)=(Д x[r*n+j]! : ℝ):=λj h=>by obtain ⟨a1,a2⟩:=qA6 _ (qBn x sm hx (r*n+j) א);obtain ⟨a3,a4⟩:=qAl _ a1;rw[<-hgd];beta_reduce;rw[a4];exact ⟨a3,a2,qAq _ (qAd _ a1)⟩ have hnR1:(1:ℝ)<=n:=by exact_mod_cast hn0 have hnR2:(n:ℝ)<=2^20:=by exact_mod_cast hn.le have o4:((К n).map λj=>|R (g j)|).sum<=n*2^99 :=qD4 n _ _ λj h=>(hg0 j h).2.1;have hA2:((К n).map λj=>|R (g j)|).sum<=A_B/4:=by have:=qAw (k:=2^256*2^44) le_rfl;have:=Б hnR2 (by norm_num:(0:ℝ)<=2^99);linarith obtain ⟨o1,o5⟩:=qF0 n hn g (λj=>R (g j)) (λj=>|R (g j)|) (λj h=>⟨(hg0 j h).1,rfl,rfl⟩) hA2 obtain ⟨o2,o6⟩:=qF0 n hn (λj=>(g j).abs) (λj=>|R (g j)|) (λj=>|R (g j)|) (λj h=>by obtain ⟨p,q⟩:=qBk _ (hg0 j h).1 exact ⟨p,q,abs_abs _⟩) hA2 have o3:=qG9 (К n) λj=>R (g j);obtain ⟨hMc,hVc⟩:=qI9 n r x g (λj h=>(hg0 j h).2.2) (lnQ b n x r);generalize hQ:((lnQ b n x r:ℚ):ℝ)=Q at hVc;generalize hS:((К n).map λj=>R (g j)).sum=S at o3 o5 hMc;generalize ((К n).map λj=>|R (g j)|).sum=Sa at o3 o4 o5 o6;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*П ط=nf;generalize hind:(1.0:Float)/nd=ind;generalize ha:(if b=true then F1.mk 0 0 else lnSum x base nu 0 0 0)=a;generalize hm:(if b=true then (0:Float) else a.s*ind)=m;generalize hv:lnVar x base nu 0 m 0=v;generalize hem:nf*a.t*ind+П ك=em;generalize htt:v*ind+dv eps=tt;generalize hd:ф 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 hnp:(n:ℝ)≠0 :=ד;have hzb:=qBx;have hz0:=qAs.le;have hu:nu.toNat=n:=by rw[<-hnu];exact qAc n א have hb:base.toNat=r*n:=by rw[<-hbase];exact qAc _ א have hxs:x.size<2^32 :=א;obtain ⟨fnf,Rnf⟩:=hnf ▸ qKi 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:=qB0 n.toUInt64 א;rwa [e] at this obtain ⟨fi,pi,-,ei⟩:=qGr ind nd fnd (by rw[Rnd,Ж ד];exact hnR2.trans ב) c5 rw[Rnd] at ei;obtain ⟨z1,z2⟩:=qI0 obtain ⟨fm,fE,m2,m3,m1,m4⟩:m.isFinite=true∧em.isFinite=true∧R em<=2^120 ∧ 1/2^201<=R em∧2 * |Q-R m| ≤ R em∧|R m| ≤ 2^110:=by cases b with | true => have e1:a=F1.mk 0 0:=ha.symm;have e2:m=0:=hm.symm;have e3:Q=0:=by rw[<-hQ];simp[lnQ] subst e1;obtain ⟨-,fE,m2,m3,-,-⟩:=qH7 n hnR1 hnR2 0 0 ind nf _ em 0 0 c hc z1 z1 ג (by positivity) (by rw[z2];simp;positivity) (by rw[z2];simp;positivity) fnf Rnf fi pi ei rfl hem;rw[e2,e3,z2];refine ⟨z1,fE,m2,m3,?_,by norm_num⟩;simp only[sub_zero,abs_zero,mul_zero];exact ؾ ב m3 | false => replace ha:lnSum x base nu 0 0 0=a:=ha;replace hm:a.s*ind=m:=hm;have hA:a=⟨A_fsum ((К n).map g),A_fsum ((К n).map λj=>(g j).abs)⟩:=by rw[<-ha,qIr x hxs base nu א n 0 0 0 (by simp[hu])];simp only[USize.toNat_zero,hb,<-hgd,A_fsum,List.range_eq_range'] subst hA;rw[hQ.symm.trans hMc];exact qH7 n hnR1 hnR2 _ _ ind nf m em S Sa c hc o1 o2 o3 o4 o5 o6 fnf Rnf fi pi ei hm hem obtain ⟨p1,p2,p3,hW0⟩:=qIm n hn hn0 g m v _ (by rw[<-hv,qId x hxs base nu m א n 0 0 (by simp[hu])] simp only[USize.toNat_zero,hb,<-hgd,A_fsum,List.range_eq_range']) rfl (λj h=>⟨(hg0 j h).1,(hg0 j h).2.1⟩) fm m4 generalize hW:((К n).map λj=>(R (g j)-R m)^2).sum=W at p2 p3 hW0;generalize hV0:((К n).map λj=>(R (g j)-Q)^2).sum=V0 at hVc;generalize hδ:Q-R m=δ at m1;have hnpos:(0:ℝ)< n :=ד have hWs:W/n=V0/n+δ^2:=by cases b with | true => have e2:m=0:=hm.symm;have e3:Q=0:=by rw[<-hQ];simp[lnQ] rw[<-hδ,<-hW,<-hV0,e2,e3,z2];simp | false => have hs2:=qHf (К n) (λj=>R (g j)) (R m) (by simpa using hnp);simp only[List.length_range] at hs2;rw[hS,hW,show S/n=Q from (hQ.symm.trans hMc).symm,hV0,hδ] at hs2;rw[hs2];field_simp obtain ⟨gE,bE⟩:=qA6 eps he;have epsv:wv eps=(Д eps:ℝ):=qAq _ (qAd _ gE);have hep0:0< wv eps:=by rw[epsv];exact_mod_cast he0 obtain ⟨ft,hq1⟩:=qJ6 n hnR1 hnR2 v ind tt eps W c hc p1 p2 p3 hW0 fi pi ei gE bE hep0 htt;generalize hq:rowVariance n x r (lnQ b n x r)+Д eps=q;have hV1:0<=V0/n:=by rw[<-hV0];refine div_nonneg (List.sum_nonneg λy hy=>?_) hnpos.le;obtain ⟨j,-,rfl⟩:=List.mem_map.1 hy;exact ق _ 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⟩:1<=_∧_<1+1222:=qEf _ 1 1222 c4 (by decide);obtain ⟨l1,l2,hb127⟩:=qKk 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)≠Е:=by rw[hz];intro e0;rw[e0] at c3;exact absurd c3 (by decide) have hden:=((qI2 d _ q hq0 l1 l2 hzne hb127).trans hz).symm;rw[<-hq] at hden;obtain ⟨gZ,bZ⟩:=qA6 z c1;obtain ⟨dz1,dz2⟩:=qAl z gZ;obtain ⟨fi2,-,-,ei2⟩:=qGr ir (dv z) dz1 (by rw[dz2];exact bZ) c6;rw[dz2] at ei2;refine ⟨hden,λ_=>⟨fm,fi2,fE,m2,m3,?_,m4,gZ,qJq z gZ c2 c3,ei2⟩⟩;dsimp only;rw[hQ,hδ];exact m1 . exact ⟨rfl,by simp[L_oF]⟩ lemma qKb (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=П 0x3D10000000000000*(((dv w-m)*(dv gw*ir)).abs+(dv bw).abs) + em*(dv gw*ir).abs) (hne:ziv s e≠Е) : R (s-e)<(wv w-M)*wv gw/D+wv bw∧(wv w-M)*wv gw/D+wv bw< R (s+e):=by have hzb:=qBx obtain ⟨gw1,bw1⟩:=qA6 w hw obtain ⟨gg1,bg1⟩:=qA6 gw hg obtain ⟨gb1,bb1⟩:=qA6 bw hb obtain ⟨fw,Rw⟩:=qAl w gw1 obtain ⟨fg,Rg⟩:=qAl gw gg1 obtain ⟨fb,Rb⟩:=qAl bw gb1 have hD0:0< D:=ч ב hD have bI : |R ir| ≤ 2^65:=by have a1:=qAb (R ir*D) 1 rw[abs_one,е,г hD0] at a1 have a2:=Г hD (Й (R ir)) linarith only[a1,a2,hI] obtain ⟨f1,h1,b1⟩:=qCh (dv w) m (2^111) fw fm (by rw[Rw];exact bw1.trans ב) (e4.trans ב) rw[Rw] at h1 obtain ⟨f2,h3,b2⟩:=qAr (dv gw) ir (2^99) (2^65) fg fi (by rw[Rg];exact bg1) bI rw[Rg] at h3 obtain ⟨f3,h4,b3⟩:=qAr _ _ (2^113) (2^166) f1 f2 ד ד generalize hQ:(dv w-m)*(dv gw*ir)=Q at hs he f3 h4 b3 generalize dv gw*ir=G at he f2 h3 b2 h4 hQ obtain ⟨f4,h5,b4⟩:=qAy Q (dv bw) (2^250*2^31) f3 fb (by norm_num at b3 hzb ⊢;linarith only [b3,hzb]) (by rw[Rb];exact bb1.trans ב) rw[Rb,<-hs] at h5 rw[<-hs] at f4 b4 obtain ⟨fa1,Ra1⟩:=qBk Q f3 obtain ⟨fa2,Ra2⟩:=qBk (dv bw) fb rw[Rb] at Ra2 obtain ⟨fa3,Ra3⟩:=qBk G f2 obtain ⟨f5,h6,b5⟩:=qAy Q.abs (dv bw).abs (2^250*2^31) fa1 fa2 (by rw[Ra1,abs_abs];norm_num at b3 hzb ⊢;linarith only [b3,hzb]) (by rw[Ra2,abs_abs];exact bb1.trans ב) rw[Ra1,Ra2] at h6 obtain ⟨k1,k2⟩:=L_k 0x3D10000000000000 977 46 ב rfl (by rfl) obtain ⟨f6,h7,b6⟩:=qAr _ _ 1 (2^250*2^33) k1 f5 (by rw[k2];norm_num) (by norm_num at b5 hzb ⊢;linarith only [b5,hzb]) rw[k2] at h7 have bE : |R em| ≤ 2^120:=by rw[Ж (ؾ ב e2)];exact e1 obtain ⟨f7,h8,b7⟩:=qAr em G.abs (2^120) (2^166) fe fa3 bE (by rw[Ra3,abs_abs];linarith) rw[Ra3] at h8 obtain ⟨f8,h9,b8⟩:=qAy _ _ (2^250*2^38) f6 f7 (by norm_num at b6 hzb ⊢;linarith only [b6,hzb]) (by norm_num at b7 hzb ⊢;linarith only [b7,hzb]) rw[<-he] at f8 h9 b8 obtain ⟨f9,h10,-⟩:=qAy s e (2^250*2^41) f4 f8 (by norm_num at b4 hzb ⊢;linarith only [b4,hzb]) (by norm_num at b8 hzb ⊢;linarith only [b8,hzb]) obtain ⟨f10,h11,-⟩:=qCh s e (2^250*2^41) f4 f8 (by norm_num at b4 hzb ⊢;linarith only [b4,hzb]) (by norm_num at b8 hzb ⊢;linarith only [b8,hzb]) obtain ⟨-,-,big⟩:=qBh s e hne rw[show (2:ℝ)^(-127:ℤ)=1/2^127 by norm_num] at big exact qIt qAs.le qAx (ؾ ב 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:L_oF s (M:ℝ)) : lnOut s w gw bw mean =roundRational ((Д w-M)*Д gw/Д s.den+Д 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) (П 0x3D10000000000000*(((dv w-s.m)*(dv gw*s.ir)).abs+(dv bw).abs) + s.em*(dv gw*s.ir).abs)≠Е:=λe0=>by rw[e0] at hc exact hc (by decide) obtain ⟨l1,l2⟩:=qKb 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:=qAq w (qAd _ (qA6 w hw).1);have eg:=qAq gw (qAd _ (qA6 gw hg).1);have eb:=qAq bw (qAd _ (qA6 bw hb).1);have ed:=qAq s.den (qAd _ gd);have hV:(((Д w-M)*Д gw/Д s.den+Д 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;exact (qJx _ _ _ l1 l2 hne (qKm _ _ _ l1 l2 hne hc)).symm . unfold lnSlow;rw[hmean] lemma qBy {α:Type} [Inhabited α] (rows k:ℕ) (f:ℕ->α) (hk:k< rows) : (Array.ofFn (n:=rows) λr=>f r.val)[k]! = f k:=by rw[Э _ k (by simpa using hk),Array.getElem_ofFn] lemma qHn: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 rw[qDj (λr c q=>lnOut (Array.ofFn (n:=rows) λr=>lnStat false n eps x r.val)[r]! x[q]! g[c]! b[c]! λ_=>rowMean n x r) h9 h11 λr p u hr hp hu=>by repeat rw[qAj _ _ א]] apply ه ג;intro q h1 h1';simp only[Array.getElem_ofFn,Array.size_ofFn] at h1 h1' ⊢;have hr:q/n< rows:=м (by rwa [ж]);have hj:q%n< n:=э _ h11;have e1:=qBy rows (q/n) (λr=>lnStat false n eps x r) hr;have e2:=qBy rows (q/n) (λr=>rowMean n x r) hr have e3:=qBy rows (q/n) (λr=>sqrtRational (rowVariance n x r ((Array.ofFn (n:=rows) λr=>rowMean n x r.val)[r]!)+Д eps)) hr beta_reduce at e1 e2 e3;rw[e1,e3,e2];obtain ⟨o1,o2⟩:=qFh false rows n eps x (q/n) hr h11 h8 h12 h9 h4 h7 h14;rw[qFq _ (rowMean n x (q/n)) _ rfl _ _ _ (qBn x sm h4 q א) (qBn g sm h5 _ א) (qBn b sm h6 _ א) o2,o1];rfl . rfl end end Public99 namespace Submission open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats section open FloatLib.Numerics end open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats section open FloatLib.Numerics end section open Float.Model Float.Model.UnpackedFloat open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats namespace Bridge end Bridge namespace Bridge end Bridge namespace Bridge end Bridge namespace Bridge end Bridge end section open FloatLib.Numerics FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats end section open Float.Model Float.Model.UnpackedFloat set_option maxRecDepth 8192 end namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open ExactRuntime theorem usize_add_toNat (a b : USize) (h : a.toNat + b.toNat < 2 ^ 32) : (a + b).toNat = a.toNat + b.toNat := by rw [USize.toNat_add] have : 2 ^ 32 ≤ USize.size := USize.le_size have h3 : USize.size = 2 ^ System.Platform.numBits := rfl exact Nat.mod_eq_of_lt (by omega) theorem usize_succ_toNat (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 (by omega) theorem usize_lin (a b t : USize) (h : a.toNat + b.toNat * t.toNat < 2 ^ 32) : (a + b * t).toNat = a.toNat + b.toNat * t.toNat := by have : 2 ^ 32 ≤ USize.size := USize.le_size have h3 : USize.size = 2 ^ System.Platform.numBits := rfl have hm : b.toNat * t.toNat < 2 ^ System.Platform.numBits := by omega rw [USize.toNat_add, USize.toNat_mul, Nat.mod_eq_of_lt hm, Nat.mod_eq_of_lt (by omega)] open ExactRuntime theorem toUSize_toNat (m : Nat) (h : m < 2 ^ 32) : m.toUSize.toNat = m := by have : 2 ^ 32 ≤ USize.size := USize.le_size have h3 : USize.size = 2 ^ System.Platform.numBits := rfl simp only [Nat.toUSize] exact Nat.mod_eq_of_lt (by omega) lemma fa_usize_size (A:FloatArray) (q:USize) (v:Float) (h:q.toNat change (ds.uset q v h).size=ds.size exact Array.size_uset h end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime section open Float.Model Float.Model.UnpackedFloat open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats namespace Bridge end Bridge namespace Bridge end Bridge namespace Bridge end Bridge namespace Bridge end Bridge end end FP64 namespace FP64 open Float.Model Float.Model.UnpackedFloat open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats namespace Bridge end Bridge end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime set_option maxHeartbeats 1000000 end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime set_option maxHeartbeats 2000000 end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime set_option maxHeartbeats 3000000 end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime set_option maxHeartbeats 2000000 set_option maxHeartbeats 2000000 set_option maxHeartbeats 4000000 end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 namespace FP64 open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime end FP64 end Submission namespace Submission namespace FP64 open ExactRuntime theorem g_mul4 (t : USize) (r : Nat) (hr : r < 4) (h : 4 * t.toNat + r < 2 ^ 32) : (t * 4 + r.toUSize).toNat = 4 * t.toNat + r := by have : 2 ^ 32 ≤ USize.size := USize.le_size have h3 : USize.size = 2 ^ System.Platform.numBits := rfl have hr' : r.toUSize.toNat = r := by simp only [Nat.toUSize]; exact Nat.mod_eq_of_lt (by omega) rw [USize.toNat_add, USize.toNat_mul, hr'] simp only [USize.toNat_ofNat] rw [Nat.mod_eq_of_lt (by omega : 4 < 2 ^ System.Platform.numBits)] rw [Nat.mod_eq_of_lt (by omega : t.toNat * 4 < 2 ^ System.Platform.numBits)] rw [Nat.mod_eq_of_lt (by omega)]; ring theorem g_mul8 (t : USize) (r : Nat) (hr : r < 8) (h : 8 * t.toNat + r < 2 ^ 32) : (t * 8 + r.toUSize).toNat = 8 * t.toNat + r := by have : 2 ^ 32 ≤ USize.size := USize.le_size have h3 : USize.size = 2 ^ System.Platform.numBits := rfl have hr' : r.toUSize.toNat = r := by simp only [Nat.toUSize]; exact Nat.mod_eq_of_lt (by omega) rw [USize.toNat_add, USize.toNat_mul, hr'] simp only [USize.toNat_ofNat] rw [Nat.mod_eq_of_lt (by omega : 8 < 2 ^ System.Platform.numBits)] rw [Nat.mod_eq_of_lt (by omega : t.toNat * 8 < 2 ^ System.Platform.numBits)] rw [Nat.mod_eq_of_lt (by omega)]; ring theorem g_mul12 (t : USize) (r : Nat) (hr : r < 12) (h : 12 * t.toNat + r < 2 ^ 32) : (t * 12 + r.toUSize).toNat = 12 * t.toNat + r := by have : 2 ^ 32 ≤ USize.size := USize.le_size have h3 : USize.size = 2 ^ System.Platform.numBits := rfl have hr' : r.toUSize.toNat = r := by simp only [Nat.toUSize]; exact Nat.mod_eq_of_lt (by omega) rw [USize.toNat_add, USize.toNat_mul, hr'] simp only [USize.toNat_ofNat] rw [Nat.mod_eq_of_lt (by omega : 12 < 2 ^ System.Platform.numBits)] rw [Nat.mod_eq_of_lt (by omega : t.toNat * 12 < 2 ^ System.Platform.numBits)] rw [Nat.mod_eq_of_lt (by omega)]; ring def gPackU (X:Array Word) (xo n off st k:USize) (A:FloatArray) (hx:xo.toNat+n.toNat<=X.size) (hxs:X.size<2^32) (ha:∀ j,j rw[gPackU,dif_pos hk,ih] simp only[a,fa_usize_size] | case2 k A ha has hk =>rw[gPackU,dif_neg hk] def gPackRows (width inW i:Nat) (X:Array Word) (hglobal:(i+width)*inW<=X.size) (hxs:X.size<2^32) (hn:inW<2^32) (hw:width<2^32) (r:Nat) (A:FloatArray) (ha:width*inW<=A.size) (has:A.size<2^32):FloatArray:= if hr:rrw[gPackRows,dif_pos hr,ih,hsz] | case2 r A ha has hr =>rw[gPackRows,dif_neg hr] @[inline] def gFinish (inW:Nat) (relu:Bool) (X W b:Array Word) (i j:Nat) (z nf a:Float) (hx bw:Word) (bv E:Float):Word:= let r:=Public99.ziv (z+bv) E if r==0xFFFFFFFF then Public99.fin8 inW relu X W b i j z nf a hx bw inW.toUSize else act relu r def gDot4 (x:FloatArray) (W:Array Word) (wo n t:USize) (hx:4*n.toNat<=x.size) (hw:wo.toNat+n.toNat<=W.size) (hws:W.size<2^32) (hxs:x.size<2^32) (s0 s1 s2 s3:Float):GR4:= if h:t simp [sgnI] def rmin (x : Array Word) (o index : Nat) : Nat → Nat → Nat | 0, m => m | count + 1, m => rmin x o (index + 1) count (min m (idxOf x[o + index]!)) def rsum (x : Array Word) (o m index : Nat) : Nat → Int | 0 => 0 | count + 1 => sgnI (signOf x[o + index]!) (mantOf x[o + index]! <<< (idxOf x[o + index]! - m)) + rsum x o m (index + 1) count def rowMeanF (n : Nat) (x : Array Word) (r : Nat) : ℚ := let m := rmin x (r * n) 0 n 1024 (rsum x (r * n) m 0 n : ℚ) * 2 ^ ((m : ℤ) - 149) / n theorem rmin_le (x : Array Word) (o : Nat) : ∀ count index m0, rmin x o index count m0 ≤ m0 ∧ ∀ k, index ≤ k → k < index + count → rmin x o index count m0 ≤ idxOf x[o + k]! := by intro count induction count with | zero => intro index m0; exact ⟨le_rfl, fun k h1 h2 => by omega⟩ | succ c ih => intro index m0 obtain ⟨h1, h2⟩ := ih (index + 1) (min m0 (idxOf x[o + index]!)) simp only [rmin] refine ⟨le_trans h1 (min_le_left _ _), fun k hk1 hk2 => ?_⟩ by_cases hk : k = index · subst hk; exact le_trans h1 (min_le_right _ _) · exact h2 k (by omega) (by omega) theorem rsum_fold (x : Array Word) (o m : Nat) : ∀ count index (acc : ℚ), (∀ k, index ≤ k → k < index + count → m ≤ idxOf x[o + k]!) → (List.range' index count).foldl (fun t j => t + rationalWord x[o + j]!) acc = acc + (rsum x o m index count : ℚ) * 2 ^ ((m : ℤ) - 149) := by intro count induction count with | zero => intro index acc _; simp [rsum] | succ c ih => intro index acc h have hm := h index le_rfl (by omega) rw [List.range'_succ, List.foldl_cons, ih (index + 1) _ (fun k h1 h2 => h k (by omega) (by omega))] simp only [rsum] unfold rationalWord rw [decodeD_toRat, sgnI_eq, Nat.shiftLeft_eq] have hz : (2 : ℚ) ^ ((idxOf x[o + index]! : ℤ) - 149) = (2 : ℚ) ^ (idxOf x[o + index]! - m) * 2 ^ ((m : ℤ) - 149) := by rw [← zpow_natCast, ← zpow_add₀ two_ne_zero]; congr 1; push_cast [Nat.cast_sub hm]; ring rw [hz] unfold sv cases signOf x[o + index]! <;> simp <;> push_cast <;> ring theorem rowMeanF_eq : rowMeanF = rowMean := by funext n x r unfold rowMeanF rowMean simp only [] obtain ⟨_, hm⟩ := rmin_le x (r * n) n 0 1024 rw [List.range_eq_range', rsum_fold x (r * n) _ n 0 0 (fun k _ h2 => hm k (Nat.zero_le _) h2), zero_add] end SharedMean namespace SharedAdd open FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats ExactRuntime theorem isFinite_toModel32 (z : Model FloatFormat.binary32) : Model.isFinite z = (Model.toModel z).isFinite := by have he := Model.unpackExponent_toNat z have ha := Model.toNat_neg_one_exponentBits FloatFormat.binary32 have hm : Model.isFinite z = (Model.expField z != FloatFormat.expAllOnesNat FloatFormat.binary32) := rfl rw [hm] unfold Model.toModel Float.Model.UnpackedFloat.unpack simp only [] by_cases h : Float.Model.UnpackedFloat.unpackExponent (spec := FloatFormat.toModel FloatFormat.binary32) (Model.toModelBits z) = -BitVec.ofNat _ 1 · rw [if_pos h] have h2 : Model.expField z = FloatFormat.expAllOnesNat FloatFormat.binary32 := by rw [← he, h, ha] rw [h2] split <;> rfl · rw [if_neg h] have h2 : Model.expField z ≠ FloatFormat.expAllOnesNat FloatFormat.binary32 := by intro h3; apply h; apply BitVec.eq_of_toNat_eq; rw [he, h3, ← ha] have h4 : (Model.expField z != FloatFormat.expAllOnesNat FloatFormat.binary32) = true := by simpa using h2 rw [h4] split · split <;> rfl · rfl def m32 (f : Float32) : Model FloatFormat.binary32 := Model.ofFloat32Model f.toModel theorem valid32 (y : Model FloatFormat.binary32) (h : Model.isFinite y = true) : Model.IsModelCanonical y := by refine ⟨fun he _ => ?_⟩ have hf := isFinite_toModel32 y rw [h] at hf unfold Model.toModel Float.Model.UnpackedFloat.unpack at hf simp only [] at hf rw [if_pos he] at hf split at hf <;> simp [Float.Model.UnpackedFloat.isFinite] at hf theorem m32_ofBits (w : Word) (h : expOf w ≠ 255) : m32 (Float32.ofBits w) = ofW w := by have hf : Model.isFinite (ofW w) = true := by simp [ofW, isFinite_ofUInt32, h] rw [← Model.canonicalizeModel_eq_self _ (valid32 _ hf)] unfold m32 Model.canonicalizeModel change Model.ofFloat32Model (Float32.Model.pack _) = _ rw [Model.ofFloat32Model_pack] congr 1 unfold Model.toModel congr 1 apply BitVec.eq_of_toNat_eq simp [ofW, Model.ofUInt32, Model.ofNatBits, Model.toModelBits, Model.ofBits, FloatFormat.ofWordNat] show w.toNat = w.toNat % 2 ^ 32 have := w.toNat_lt omega theorem toBits_m32 (f : Float32) : f.toBits = toWord (m32 f) := by unfold toWord m32 Model.ofFloat32Model Model.ofModelBits Model.toNatBits simp only [Float32.toBits] exact UInt32.ofNat_toNat.symm theorem m32_fin (f : Float32) : Model.isFinite (m32 f) = f.isFinite := by rw [isFinite_toModel32]; rfl theorem m32_add (x y : Float32) (hx : x.isFinite = true) (hy : y.isFinite = true) : m32 (x + y) = Model.add (m32 x) (m32 y) := ExecFloat.Binary.toModel_ofFloat32_add_of_isFinite x y hx hy theorem addN_ok (x y : Word) (hx : expOf x ≠ 255) (hy : expOf y ≠ 255) : (Float32.ofBits x + Float32.ofBits y).toBits = toWord (Model.add (ofW x) (ofW y)) := by have hfx : Model.isFinite (ofW x) = true := by simp [ofW, isFinite_ofUInt32, hx] have hfy : Model.isFinite (ofW y) = true := by simp [ofW, isFinite_ofUInt32, hy] have fx : (Float32.ofBits x).isFinite = true := by rw [← m32_fin, m32_ofBits x hx]; exact hfx have fy : (Float32.ofBits y).isFinite = true := by rw [← m32_fin, m32_ofBits y hy]; exact hfy rw [toBits_m32, m32_add _ _ fx fy, m32_ofBits x hx, m32_ofBits y hy] rfl def gNativeAdd (relu : Bool) (a b : Array Word) : Array Word := a.mapIdx fun i x => let y := b[i]! act relu (if expOf x ≠ 255 ∧ expOf y ≠ 255 then (Float32.ofBits x + Float32.ofBits y).toBits else toWord (Model.add (ofW x) (ofW y))) theorem gNativeAdd_eq : gNativeAdd = addReluSpec := by funext relu a b unfold gNativeAdd addReluSpec apply Array.ext · simp · intro i h1 h2 simp only [Array.getElem_mapIdx, Array.getElem_ofFn] split · rename_i h; rw [addN_ok _ _ h.1 h.2]; rfl · rfl end SharedAdd namespace Submission.FP64 open ExactRuntime lemma gFinish_eq (inW:Nat) (relu:Bool) (X W b:Array Word) (i j:Nat) (z nf a:Float) (hx bw:Word): gFinish inW relu X W b i j z nf a hx bw (Public99.dv bw) (nf*(Public99.dv hx*a+(Public99.dv bw).abs))= Public99.fin8 inW relu X W b i j z nf a hx bw inW.toUSize:=by unfold gFinish dsimp only split · rfl · rename_i h unfold Public99.fin8 dsimp only simp_all only[Bool.false_eq_true,ite_false] lemma gFinish_spec {rows inW outW:Nat} {X W b:Array Word} (G:Public99.C_G rows inW outW X W b) (relu:Bool) {i j:Nat} (hi:ia+Public99.dv X[i*inW+t]!*Public99.dv W[j*inW+t]!) 0): gFinish inW relu X W b i j z (Public99.nfOf inW) ((inW.toUInt64+1).toFloat*Public99.dv hw) hx b[j]! (Public99.dv b[j]!) (Public99.nfOf inW*(Public99.dv hx*((inW.toUInt64+1).toFloat*Public99.dv hw)+(Public99.dv b[j]!).abs))= Public99.C_out inW relu X W b i j:=by rw[gFinish_eq] exact Public99.qHj G relu hi hj Hx.1 (fun t ht=>Hx.2.2.2 _ (by rw[←G.hX];exact Public99.qBe hi ht)) Hx.2.1 Hw (List.range inW) List.nodup_range (fun t ht=>List.mem_range.mp ht) (fun t ht hn=>False.elim (hn (List.mem_range.mpr ht))) hs end Submission.FP64 namespace Submission.FP64 open ExactRuntime lemma gRangeStep (a b:Nat) (h:ax.data[4*t+r]!*Public99.dv W[wo+t]!) lemma gDot4_sem (x:FloatArray) (W:Array Word) (wo n t:USize) (hx:4*n.toNat<=x.size) (hw:wo.toNat+n.toNat<=W.size) (hws:W.size<2^32) (hxs:x.size<2^32) (s0 s1 s2 s3:Float): let r:=gDot4 x W wo n t hx hw hws hxs s0 s1 s2 s3 r.s0=(gTerms4 x W 0 wo.toNat t.toNat n.toNat).foldl (·+·) s0 ∧ r.s1=(gTerms4 x W 1 wo.toNat t.toNat n.toNat).foldl (·+·) s1 ∧ r.s2=(gTerms4 x W 2 wo.toNat t.toNat n.toNat).foldl (·+·) s2 ∧ r.s3=(gTerms4 x W 3 wo.toNat t.toNat n.toNat).foldl (·+·) s3:=by induction t,s0,s1,s2,s3 using gDot4.induct x W wo n hx hw hws hxs with | case1 t s0 s1 s2 s3 h ht d ih=> intro r simp only[r] rw[gDot4];simp only[dif_pos h] have hs:=usize_succ_toNat t n h have hd:d=Public99.dv W[wo.toNat+t.toNat]!:=by simp only[d] rw[Public99.qDm,usize_add_toNat _ _ (by omega)] obtain ⟨i0,i1,i2,i3⟩:=ih have hb:4*t.toNat+3<2^32:=by omega have st:∀ (rr:Nat) (hr:rr<4) (s:Float) (h':(t*4+rr.toUSize).toNat intro r simp only[r] rw[gDot4];simp only[dif_neg h] have hh:n.toNat-t.toNat=0:=by have ht:=USize.lt_iff_toNat_lt.not.mp h;omega simp[gTerms4,hh] def gTerms8 (x:FloatArray) (W:Array Word) (r wo t0 n:Nat):List Float:= (List.range' t0 (n-t0)).map (fun t=>x.data[8*t+r]!*Public99.dv W[wo+t]!) lemma gDot8_sem (x:FloatArray) (W:Array Word) (wo n t:USize) (hx:8*n.toNat<=x.size) (hw:wo.toNat+n.toNat<=W.size) (hws:W.size<2^32) (hxs:x.size<2^32) (s0 s1 s2 s3 s4 s5 s6 s7:Float): let r:=gDot8 x W wo n t hx hw hws hxs s0 s1 s2 s3 s4 s5 s6 s7 r.s0=(gTerms8 x W 0 wo.toNat t.toNat n.toNat).foldl (·+·) s0 ∧ r.s1=(gTerms8 x W 1 wo.toNat t.toNat n.toNat).foldl (·+·) s1 ∧ r.s2=(gTerms8 x W 2 wo.toNat t.toNat n.toNat).foldl (·+·) s2 ∧ r.s3=(gTerms8 x W 3 wo.toNat t.toNat n.toNat).foldl (·+·) s3 ∧ r.s4=(gTerms8 x W 4 wo.toNat t.toNat n.toNat).foldl (·+·) s4 ∧ r.s5=(gTerms8 x W 5 wo.toNat t.toNat n.toNat).foldl (·+·) s5 ∧ r.s6=(gTerms8 x W 6 wo.toNat t.toNat n.toNat).foldl (·+·) s6 ∧ r.s7=(gTerms8 x W 7 wo.toNat t.toNat n.toNat).foldl (·+·) s7:=by induction t,s0,s1,s2,s3,s4,s5,s6,s7 using gDot8.induct x W wo n hx hw hws hxs with | case1 t s0 s1 s2 s3 s4 s5 s6 s7 h ht d ih=> intro r simp only[r] rw[gDot8];simp only[dif_pos h] have hs:=usize_succ_toNat t n h have hd:d=Public99.dv W[wo.toNat+t.toNat]!:=by simp only[d] rw[Public99.qDm,usize_add_toNat _ _ (by omega)] obtain ⟨i0,i1,i2,i3,i4,i5,i6,i7⟩:=ih have hb:8*t.toNat+7<2^32:=by omega have st:∀ (rr:Nat) (hr:rr<8) (s:Float) (h':(t*8+rr.toUSize).toNat intro r simp only[r] rw[gDot8];simp only[dif_neg h] have hh:n.toNat-t.toNat=0:=by have ht:=USize.lt_iff_toNat_lt.not.mp h;omega simp[gTerms8,hh] def gTerms12 (x:FloatArray) (W:Array Word) (r wo t0 n:Nat):List Float:= (List.range' t0 (n-t0)).map (fun t=>x.data[12*t+r]!*Public99.dv W[wo+t]!) lemma gDot12_sem (x:FloatArray) (W:Array Word) (wo n t:USize) (hx:12*n.toNat<=x.size) (hw:wo.toNat+n.toNat<=W.size) (hws:W.size<2^32) (hxs:x.size<2^32) (s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11:Float): let r:=gDot12 x W wo n t hx hw hws hxs s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 r.s0=(gTerms12 x W 0 wo.toNat t.toNat n.toNat).foldl (·+·) s0 ∧ r.s1=(gTerms12 x W 1 wo.toNat t.toNat n.toNat).foldl (·+·) s1 ∧ r.s2=(gTerms12 x W 2 wo.toNat t.toNat n.toNat).foldl (·+·) s2 ∧ r.s3=(gTerms12 x W 3 wo.toNat t.toNat n.toNat).foldl (·+·) s3 ∧ r.s4=(gTerms12 x W 4 wo.toNat t.toNat n.toNat).foldl (·+·) s4 ∧ r.s5=(gTerms12 x W 5 wo.toNat t.toNat n.toNat).foldl (·+·) s5 ∧ r.s6=(gTerms12 x W 6 wo.toNat t.toNat n.toNat).foldl (·+·) s6 ∧ r.s7=(gTerms12 x W 7 wo.toNat t.toNat n.toNat).foldl (·+·) s7 ∧ r.s8=(gTerms12 x W 8 wo.toNat t.toNat n.toNat).foldl (·+·) s8 ∧ r.s9=(gTerms12 x W 9 wo.toNat t.toNat n.toNat).foldl (·+·) s9 ∧ r.s10=(gTerms12 x W 10 wo.toNat t.toNat n.toNat).foldl (·+·) s10 ∧ r.s11=(gTerms12 x W 11 wo.toNat t.toNat n.toNat).foldl (·+·) s11:=by induction t,s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11 using gDot12.induct x W wo n hx hw hws hxs with | case1 t s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 h ht d ih=> intro r simp only[r] rw[gDot12];simp only[dif_pos h] have hs:=usize_succ_toNat t n h have hd:d=Public99.dv W[wo.toNat+t.toNat]!:=by simp only[d] rw[Public99.qDm,usize_add_toNat _ _ (by omega)] obtain ⟨i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11⟩:=ih have hb:12*t.toNat+11<2^32:=by omega have st:∀ (rr:Nat) (hr:rr<12) (s:Float) (h':(t*12+rr.toUSize).toNat intro r simp only[r] rw[gDot12];simp only[dif_neg h] have hh:n.toNat-t.toNat=0:=by have ht:=USize.lt_iff_toNat_lt.not.mp h;omega simp[gTerms12,hh] end Submission.FP64 namespace Submission.FP64 open ExactRuntime lemma gUsetGet (A:FloatArray) (q:USize) (v:Float) (h:q.toNatexact Public99.qGp ds q.toNat p v h lemma gPackU_sem (X:Array Word) (xo n off st k:USize) (A:FloatArray) (hx:xo.toNat+n.toNat<=X.size) (hxs:X.size<2^32) (ha:∀ j,j rw[gPackU,dif_pos hk] obtain ⟨i1,i2⟩:=ih have hsucc:(k+1).toNat=k.toNat+1:=usize_succ_toNat k n hk have hqn:q.toNat=off.toNat+k.toNat*st.toNat:=by dsimp only[q] rw[usize_lin _ _ _ (by have hb:=ha k.toNat hkn;rw[Nat.mul_comm st.toNat k.toNat];omega)] rw[Nat.mul_comm] have hv:v=Public99.dv X[xo.toNat+k.toNat]!:=by dsimp only[v] rw[Public99.qDm,usize_add_toNat _ _ (by omega)] refine ⟨?_,?_⟩ · intro j hj1 hj2 rcases Nat.lt_or_ge k.toNat j with hkj|hkj · exact i1 j (by rw[hsucc];omega) hj2 · have e:j=k.toNat:=by omega subst e rw[i2 _ (fun j' hj1' hj2'=>by rw[hsucc] at hj1' have hkj:k.toNathp j (by rw[hsucc] at hj1;omega) hj2)] change (A.uset q v hq).data[p]! =_ rw[gUsetGet,if_neg (by rw[hqn];exact hp k.toNat (le_refl _) hkn)] | case2 k A ha has hk=> rw[gPackU,dif_neg hk] refine ⟨?_,fun _ _=>rfl⟩ intro j hj1 hj2 have hn:=USize.lt_iff_toNat_lt.not.mp hk omega lemma gPackRows_sem (width inW i:Nat) (X:Array Word) (hglobal:(i+width)*inW<=X.size) (hxs:X.size<2^32) (hn:inW<2^32) (hw:width<2^32) (r:Nat) (A:FloatArray) (ha:width*inW<=A.size) (has:A.size<2^32) (hwpos:0 rw[gPackRows,dif_pos hr] obtain ⟨i1,i2⟩:=ih have hA:∀ j,j < inW.toUSize.toNat → r.toUSize.toNat+j*width.toUSize.toNatby rw[toUSize_toNat _ hn] at ht simpa only[toUSize_toNat _ hr32,toUSize_toNat _ hw,Nat.mul_comm,Nat.add_comm] using hp t ht) refine ⟨?_,?_⟩ · intro rr t h1 h2 h3 rcases Nat.lt_or_ge r rr with hlt|hge · exact i1 rr t (by omega) h2 h3 · have e:rr=r:=by omega subst e rw[i2 _ (fun rr' t' h1' h2' h3'=>by intro eq have hm:=congrArg (fun q=>q%width) eq simp only[Nat.add_mod,Nat.mul_mod_right,Nat.zero_add,Nat.mod_eq_of_lt hr,Nat.mod_eq_of_lt h2'] at hm omega)] exact fs t h3 · intro p hp rw[i2 p (fun rr t h1 h2 h3=>hp rr t (by omega) h2 h3)] exact fp p (fun t ht=>hp r t (le_refl _) hr ht) | case2 r A ha has hr=> rw[gPackRows,dif_neg hr] exact ⟨fun rr t h1 h2=>False.elim (hr (by omega)),fun _ _=>rfl⟩ end Submission.FP64 namespace Submission.FP64 open ExactRuntime def gQS (width outW i j m q:Nat):Prop:= q < i*outW ∨ (∃ k c,k < width ∧ c < j ∧ c < outW ∧ q=(i+k)*outW+c) ∨ (∃ k,k < width ∧ k < m ∧ q=(i+k)*outW+j) lemma gQS_step (width outW i j m q:Nat) (h:gQS width outW i j (m+1) q): gQS width outW i j m q ∨ q=(i+m)*outW+j:=by rcases h with h|h|⟨k,hk,hm,rfl⟩ · exact Or.inl (Or.inl h) · exact Or.inl (Or.inr (Or.inl h)) · by_cases e:k=m · subst e;exact Or.inr rfl · exact Or.inl (Or.inr (Or.inr ⟨k,hk,by omega,rfl⟩)) lemma gQS_skip (width outW i j m q:Nat) (hm:¬m < width) (h:gQS width outW i j (m+1) q): gQS width outW i j m q:=by rcases h with h|h|⟨k,hk,hmk,rfl⟩ · exact Or.inl h · exact Or.inr (Or.inl h) · exact Or.inr (Or.inr ⟨k,hk,by omega,rfl⟩) lemma gQS_next (width outW i j q:Nat) (h:gQS width outW i (j+1) 0 q): gQS width outW i j width q:=by rcases h with h|⟨k,c,hk,hc,hcO,rfl⟩|⟨k,hk,hz,hq⟩ · exact Or.inl h · by_cases e:c < j · exact Or.inr (Or.inl ⟨k,c,hk,e,hcO,rfl⟩) · have he:c=j:=by omega subst he;exact Or.inr (Or.inr ⟨k,hk,hk,rfl⟩) · omega lemma gQS_end (width outW i j q:Nat) (hj:¬j < outW) (hq:q<(i+width)*outW): gQS width outW i j 0 q:=by by_cases h:q < i*outW · exact Or.inl h · right;left have ho:0 < outW:=by by_contra hn have e:outW=0:=by omega rw[e] at hq omega have hbase:i<=q/outW:=(Nat.le_div_iff_mul_le ho).mpr (by omega) refine ⟨q/outW-i,q%outW,?_,by have:=Nat.mod_lt q ho;omega,Nat.mod_lt q ho,?_⟩ · have hd:q/outW < i+width:=(Nat.div_lt_iff_lt_mul ho).mpr hq omega · have hi:i<=q/outW:=(Nat.le_div_iff_mul_le ho).mpr (by omega) rw[Nat.add_sub_cancel' hi];exact (Nat.div_add_mod' q outW).symm lemma gStoreIndex {rows outW i width j k:Nat} (hN:rows*outW<2^32) (hw:i+width<=rows) (hk:k < width) (hj:j < outW): ((i*outW+j).toUSize+outW.toUSize*k.toUSize).toNat=(i+k)*outW+j:=by have hp:(i+k)*outW+j < rows*outW:=Public99.qBe (by omega) hj have hbase:i*outW+j<2^32:=by have hb:=Public99.qBe (by omega:i < rows) hj omega have ho:outW<2^32:=lt_of_le_of_lt (Nat.le_mul_of_pos_left outW (by omega:0 < rows)) hN have hk32:k<2^32:=by have hl:rows<=rows*outW:=Nat.le_mul_of_pos_right rows (by omega:0 < outW) omega have eq:(i*outW+j)+outW*k=(i+k)*outW+j:=by ring rw[usize_lin _ _ _ (by rw[toUSize_toNat _ hbase,toUSize_toNat _ ho,toUSize_toNat _ hk32,eq];omega), toUSize_toNat _ hbase,toUSize_toNat _ ho,toUSize_toNat _ hk32,eq] lemma gStoreStep {rows inW outW width i j k:Nat} {X W b:Array Word} {relu:Bool} (G:Public99.C_G rows inW outW X W b) (hw:i+width<=rows) (hk:k < width) (hj:j < outW) {out:Array Word} (H:Public99.C_Inv (rows*outW) (Public99.C_sp inW outW relu X W b) (gQS width outW i j k) out) {v:Word} (hv:v=Public99.C_out inW relu X W b (i+k) j): Public99.C_Inv (rows*outW) (Public99.C_sp inW outW relu X W b) (gQS width outW i j (k+1)) (Public99.wrW out ((i*outW+j).toUSize+outW.toUSize*k.toUSize) v):=by have hp:(i+k)*outW+j < rows*outW:=Public99.qBe (by omega) hj have hi:=gStoreIndex G.sO hw hk hj have hs:v=Public99.C_sp inW outW relu X W b ((i+k)*outW+j):=by rw[Public99.qHi inW outW relu X W b hj];exact hv exact Public99.qEz (Public99.qFz G.sO H hi hp hs) (fun q hq h=>by rcases gQS_step width outW i j k q h with h|h · exact Or.inr h · exact Or.inl h) end Submission.FP64 namespace Submission.FP64 open ExactRuntime lemma gRangeZero (n:Nat):List.range' 0 (n-0)=List.range n:=by rw[Nat.sub_zero,List.range_eq_range'] lemma gBlock4_sem (R I O:Nat) (relu:Bool) (X W b:Array Word) (i:Nat) (x:FloatArray) (hxw hw:Word) (hW:O*I<=W.size) (hws:W.size<2^32) (hin:I<2^32) (hx:4*I<=x.size) (hxs:x.size<2^32) (G:Public99.C_G R I O X W b) (Hx:Public99.C_Hv X hxw) (Hw:Public99.C_Hv W hw) (hi:i+4<=R) (hcache:∀ k t,k<4 → t < I → x.data[4*t+k]! =Public99.dv X[(i+k)*I+t]!) (j:Nat) (out:Array Word): Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 4 O i j 0) out → Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q<(i+4)*O) (gBlock4 I O relu X W b i x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs j out):=by induction j,out using gBlock4.induct I O relu X W b i x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs with | case1 j out hj hr hwo r bw bv E q step out1 out2 out3 out4 ih=> intro H have hn:I.toUSize.toNat=I:=toUSize_toNat _ hin have hjj:(j*I).toUSize.toNat=j*I:=toUSize_toNat _ hwo obtain ⟨e0,e1,e2,e3⟩:=gDot4_sem x W (j*I).toUSize I.toUSize 0 (by rw[hn];exact hx) (by rw[hjj,hn];exact hr) hws hxs 0 0 0 0 have het:∀ k,k<4 → gTerms4 x W k (j*I).toUSize.toNat (0:USize).toNat I.toUSize.toNat= (List.range I).map (fun t=>Public99.dv X[(i+k)*I+t]!*Public99.dv W[j*I+t]!):=by intro k hk rw[hjj,hn,show (0:USize).toNat=0 from rfl,gTerms4,gRangeZero] exact List.map_congr_left (fun t ht=>by rw[hcache k t hk (List.mem_range.mp ht)]) have hb:bw=b[j]!:=by dsimp only[bw] rw[Public99.qAj _ _ G.sb,toUSize_toNat _ (lt_trans (by rw[←G.hb];exact hj) G.sb)] have v0:gFinish I relu X W b (i+0) j r.s0 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+0) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e0 rw[het 0 (by decide),List.foldl_map] at ee exact ee have v1:gFinish I relu X W b (i+1) j r.s1 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+1) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e1 rw[het 1 (by decide),List.foldl_map] at ee exact ee have v2:gFinish I relu X W b (i+2) j r.s2 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+2) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e2 rw[het 2 (by decide),List.foldl_map] at ee exact ee have v3:gFinish I relu X W b (i+3) j r.s3 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+3) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e3 rw[het 3 (by decide),List.foldl_map] at ee exact ee have H1:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 4 O i j 1) out1:= gStoreStep G hi (by decide) hj H v0 have H2:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 4 O i j 2) out2:= gStoreStep G hi (by decide) hj H1 v1 have H3:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 4 O i j 3) out3:= gStoreStep G hi (by decide) hj H2 v2 have H4:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 4 O i j 4) out4:= gStoreStep G hi (by decide) hj H3 v3 rw[gBlock4,dif_pos hj] apply ih exact Public99.qEz H4 (fun q hq h=>gQS_next 4 O i j q h) | case2 j out hj=> intro H rw[gBlock4,dif_neg hj] exact Public99.qEz H (fun q hq h=>gQS_end 4 O i j q hj h) lemma gBlock8_sem (R I O:Nat) (relu:Bool) (X W b:Array Word) (i:Nat) (x:FloatArray) (hxw hw:Word) (hW:O*I<=W.size) (hws:W.size<2^32) (hin:I<2^32) (hx:8*I<=x.size) (hxs:x.size<2^32) (G:Public99.C_G R I O X W b) (Hx:Public99.C_Hv X hxw) (Hw:Public99.C_Hv W hw) (hi:i+8<=R) (hcache:∀ k t,k<8 → t < I → x.data[8*t+k]! =Public99.dv X[(i+k)*I+t]!) (j:Nat) (out:Array Word): Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 0) out → Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q<(i+8)*O) (gBlock8 I O relu X W b i x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs j out):=by induction j,out using gBlock8.induct I O relu X W b i x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs with | case1 j out hj hr hwo r bw bv E q step out1 out2 out3 out4 out5 out6 out7 out8 ih=> intro H have hn:I.toUSize.toNat=I:=toUSize_toNat _ hin have hjj:(j*I).toUSize.toNat=j*I:=toUSize_toNat _ hwo obtain ⟨e0,e1,e2,e3,e4,e5,e6,e7⟩:=gDot8_sem x W (j*I).toUSize I.toUSize 0 (by rw[hn];exact hx) (by rw[hjj,hn];exact hr) hws hxs 0 0 0 0 0 0 0 0 have het:∀ k,k<8 → gTerms8 x W k (j*I).toUSize.toNat (0:USize).toNat I.toUSize.toNat= (List.range I).map (fun t=>Public99.dv X[(i+k)*I+t]!*Public99.dv W[j*I+t]!):=by intro k hk rw[hjj,hn,show (0:USize).toNat=0 from rfl,gTerms8,gRangeZero] exact List.map_congr_left (fun t ht=>by rw[hcache k t hk (List.mem_range.mp ht)]) have hb:bw=b[j]!:=by dsimp only[bw] rw[Public99.qAj _ _ G.sb,toUSize_toNat _ (lt_trans (by rw[←G.hb];exact hj) G.sb)] have v0:gFinish I relu X W b (i+0) j r.s0 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+0) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e0 rw[het 0 (by decide),List.foldl_map] at ee exact ee have v1:gFinish I relu X W b (i+1) j r.s1 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+1) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e1 rw[het 1 (by decide),List.foldl_map] at ee exact ee have v2:gFinish I relu X W b (i+2) j r.s2 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+2) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e2 rw[het 2 (by decide),List.foldl_map] at ee exact ee have v3:gFinish I relu X W b (i+3) j r.s3 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+3) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e3 rw[het 3 (by decide),List.foldl_map] at ee exact ee have v4:gFinish I relu X W b (i+4) j r.s4 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+4) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e4 rw[het 4 (by decide),List.foldl_map] at ee exact ee have v5:gFinish I relu X W b (i+5) j r.s5 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+5) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e5 rw[het 5 (by decide),List.foldl_map] at ee exact ee have v6:gFinish I relu X W b (i+6) j r.s6 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+6) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e6 rw[het 6 (by decide),List.foldl_map] at ee exact ee have v7:gFinish I relu X W b (i+7) j r.s7 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+7) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e7 rw[het 7 (by decide),List.foldl_map] at ee exact ee have H1:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 1) out1:= gStoreStep G hi (by decide) hj H v0 have H2:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 2) out2:= gStoreStep G hi (by decide) hj H1 v1 have H3:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 3) out3:= gStoreStep G hi (by decide) hj H2 v2 have H4:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 4) out4:= gStoreStep G hi (by decide) hj H3 v3 have H5:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 5) out5:= gStoreStep G hi (by decide) hj H4 v4 have H6:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 6) out6:= gStoreStep G hi (by decide) hj H5 v5 have H7:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 7) out7:= gStoreStep G hi (by decide) hj H6 v6 have H8:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 8 O i j 8) out8:= gStoreStep G hi (by decide) hj H7 v7 rw[gBlock8,dif_pos hj] apply ih exact Public99.qEz H8 (fun q hq h=>gQS_next 8 O i j q h) | case2 j out hj=> intro H rw[gBlock8,dif_neg hj] exact Public99.qEz H (fun q hq h=>gQS_end 8 O i j q hj h) lemma gBlock12_sem (R I O:Nat) (relu:Bool) (X W b:Array Word) (i:Nat) (x:FloatArray) (hxw hw:Word) (hW:O*I<=W.size) (hws:W.size<2^32) (hin:I<2^32) (hx:12*I<=x.size) (hxs:x.size<2^32) (G:Public99.C_G R I O X W b) (Hx:Public99.C_Hv X hxw) (Hw:Public99.C_Hv W hw) (hi:i+12<=R) (hcache:∀ k t,k<12 → t < I → x.data[12*t+k]! =Public99.dv X[(i+k)*I+t]!) (j:Nat) (out:Array Word): Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 0) out → Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q<(i+12)*O) (gBlock12 I O relu X W b i x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs j out):=by induction j,out using gBlock12.induct I O relu X W b i x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs with | case1 j out hj hr hwo r bw bv E q step out1 out2 out3 out4 out5 out6 out7 out8 out9 out10 out11 out12 ih=> intro H have hn:I.toUSize.toNat=I:=toUSize_toNat _ hin have hjj:(j*I).toUSize.toNat=j*I:=toUSize_toNat _ hwo obtain ⟨e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11⟩:=gDot12_sem x W (j*I).toUSize I.toUSize 0 (by rw[hn];exact hx) (by rw[hjj,hn];exact hr) hws hxs 0 0 0 0 0 0 0 0 0 0 0 0 have het:∀ k,k<12 → gTerms12 x W k (j*I).toUSize.toNat (0:USize).toNat I.toUSize.toNat= (List.range I).map (fun t=>Public99.dv X[(i+k)*I+t]!*Public99.dv W[j*I+t]!):=by intro k hk rw[hjj,hn,show (0:USize).toNat=0 from rfl,gTerms12,gRangeZero] exact List.map_congr_left (fun t ht=>by rw[hcache k t hk (List.mem_range.mp ht)]) have hb:bw=b[j]!:=by dsimp only[bw] rw[Public99.qAj _ _ G.sb,toUSize_toNat _ (lt_trans (by rw[←G.hb];exact hj) G.sb)] have v0:gFinish I relu X W b (i+0) j r.s0 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+0) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e0 rw[het 0 (by decide),List.foldl_map] at ee exact ee have v1:gFinish I relu X W b (i+1) j r.s1 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+1) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e1 rw[het 1 (by decide),List.foldl_map] at ee exact ee have v2:gFinish I relu X W b (i+2) j r.s2 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+2) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e2 rw[het 2 (by decide),List.foldl_map] at ee exact ee have v3:gFinish I relu X W b (i+3) j r.s3 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+3) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e3 rw[het 3 (by decide),List.foldl_map] at ee exact ee have v4:gFinish I relu X W b (i+4) j r.s4 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+4) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e4 rw[het 4 (by decide),List.foldl_map] at ee exact ee have v5:gFinish I relu X W b (i+5) j r.s5 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+5) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e5 rw[het 5 (by decide),List.foldl_map] at ee exact ee have v6:gFinish I relu X W b (i+6) j r.s6 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+6) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e6 rw[het 6 (by decide),List.foldl_map] at ee exact ee have v7:gFinish I relu X W b (i+7) j r.s7 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+7) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e7 rw[het 7 (by decide),List.foldl_map] at ee exact ee have v8:gFinish I relu X W b (i+8) j r.s8 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+8) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e8 rw[het 8 (by decide),List.foldl_map] at ee exact ee have v9:gFinish I relu X W b (i+9) j r.s9 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+9) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e9 rw[het 9 (by decide),List.foldl_map] at ee exact ee have v10:gFinish I relu X W b (i+10) j r.s10 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+10) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e10 rw[het 10 (by decide),List.foldl_map] at ee exact ee have v11:gFinish I relu X W b (i+11) j r.s11 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+11) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e11 rw[het 11 (by decide),List.foldl_map] at ee exact ee have H1:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 1) out1:= gStoreStep G hi (by decide) hj H v0 have H2:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 2) out2:= gStoreStep G hi (by decide) hj H1 v1 have H3:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 3) out3:= gStoreStep G hi (by decide) hj H2 v2 have H4:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 4) out4:= gStoreStep G hi (by decide) hj H3 v3 have H5:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 5) out5:= gStoreStep G hi (by decide) hj H4 v4 have H6:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 6) out6:= gStoreStep G hi (by decide) hj H5 v5 have H7:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 7) out7:= gStoreStep G hi (by decide) hj H6 v6 have H8:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 8) out8:= gStoreStep G hi (by decide) hj H7 v7 have H9:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 9) out9:= gStoreStep G hi (by decide) hj H8 v8 have H10:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 10) out10:= gStoreStep G hi (by decide) hj H9 v9 have H11:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 11) out11:= gStoreStep G hi (by decide) hj H10 v10 have H12:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS 12 O i j 12) out12:= gStoreStep G hi (by decide) hj H11 v11 rw[gBlock12,dif_pos hj] apply ih exact Public99.qEz H12 (fun q hq h=>gQS_next 12 O i j q h) | case2 j out hj=> intro H rw[gBlock12,dif_neg hj] exact Public99.qEz H (fun q hq h=>gQS_end 12 O i j q hj h) end Submission.FP64 namespace Submission.FP64 open ExactRuntime def gPackPart (inW i count:Nat) (X:Array Word) (hglobal:(i+count)*inW<=X.size) (hxs:X.size<2^32) (hn:inW<2^32) (hc:count<=4) (r:Nat) (A:FloatArray) (ha:4*inW<=A.size) (has:A.size<2^32):FloatArray:= if hr:r < count then have hrow:(i+r)*inW+inW<=X.size:=by have ht:=Nat.le_trans (Nat.mul_le_mul_right inW (by omega:i+r+1<=i+count)) hglobal simpa only[Nat.add_mul,Nat.one_mul] using ht have hxo:(i+r)*inW<2^32:=by omega have hr32:r<2^32:=by omega let a:=gPackU X ((i+r)*inW).toUSize inW.toUSize r.toUSize (4:Nat).toUSize 0 A (by rw[toUSize_toNat _ hxo,toUSize_toNat _ hn];exact hrow) hxs (by intro j hj rw[toUSize_toNat _ hn] at hj rw[toUSize_toNat _ hr32,toUSize_toNat 4 (by decide)] have hv:=Nat.mul_le_mul_right 4 (by omega:j+1<=inW) simp only[Nat.add_mul,Nat.one_mul,USize.toNat_ofNat] at hv ⊢ rw[Nat.mul_comm inW 4] at hv omega) has have hsz:a.size=A.size:=gPackU_size _ _ _ _ _ _ _ _ _ _ _ gPackPart inW i count X hglobal hxs hn hc (r+1) a (by rw[hsz];exact ha) (by rw[hsz];exact has) else A termination_by count-r lemma gPackPart_size (inW i count:Nat) (X:Array Word) (hglobal:(i+count)*inW<=X.size) (hxs:X.size<2^32) (hn:inW<2^32) (hc:count<=4) (r:Nat) (A:FloatArray) (ha:4*inW<=A.size) (has:A.size<2^32): (gPackPart inW i count X hglobal hxs hn hc r A ha has).size=A.size:=by induction r,A,ha,has using gPackPart.induct inW i count X hglobal hxs hn hc with | case1 r A ha has hr hrow hxo hr32 a hsz ih=>rw[gPackPart,dif_pos hr,ih,hsz] | case2 r A ha has hr=>rw[gPackPart,dif_neg hr] def gBlockPart (inW outW:Nat) (relu:Bool) (X W b:Array Word) (i rem:Nat) (x:FloatArray) (nf a db:Float) (hxw:Word) (hW:outW*inW<=W.size) (hws:W.size<2^32) (hin:inW<2^32) (hx:4*inW<=x.size) (hxs:x.size<2^32) (j:Nat) (out:Array Word):Array Word:= if hj:j < outW then have hr:j*inW+inW<=W.size:=by have ht:=Nat.le_trans (Nat.mul_le_mul_right inW (by omega:j+1<=outW)) hW simpa only[Nat.add_mul,Nat.one_mul] using ht have hwo:j*inW<2^32:=by omega let r:=gDot4 x W (j*inW).toUSize inW.toUSize 0 (by rw[toUSize_toNat _ hin];exact hx) (by rw[toUSize_toNat _ hwo,toUSize_toNat _ hin];exact hr) hws hxs 0 0 0 0 let bw:=Public99.rdW b j.toUSize let bv:=Public99.dv bw let E:=nf*(db+bv.abs) let q:=(i*outW+j).toUSize let step:=outW.toUSize let out:=if 0 < rem then Public99.wrW out (q+step*(0:Nat).toUSize) (gFinish inW relu X W b (i+0) j r.s0 nf a hxw bw bv E) else out let out:=if 1 < rem then Public99.wrW out (q+step*(1:Nat).toUSize) (gFinish inW relu X W b (i+1) j r.s1 nf a hxw bw bv E) else out let out:=if 2 < rem then Public99.wrW out (q+step*(2:Nat).toUSize) (gFinish inW relu X W b (i+2) j r.s2 nf a hxw bw bv E) else out let out:=if 3 < rem then Public99.wrW out (q+step*(3:Nat).toUSize) (gFinish inW relu X W b (i+3) j r.s3 nf a hxw bw bv E) else out gBlockPart inW outW relu X W b i rem x nf a db hxw hW hws hin hx hxs (j+1) out else out termination_by outW-j lemma gPackPart_sem (inW i count:Nat) (X:Array Word) (hglobal:(i+count)*inW<=X.size) (hxs:X.size<2^32) (hn:inW<2^32) (hc:count<=4) (r:Nat) (A:FloatArray) (ha:4*inW<=A.size) (has:A.size<2^32) : (∀ rr t,r<=rr → rr < count → t < inW → (gPackPart inW i count X hglobal hxs hn hc r A ha has).data[4*t+rr]! =Public99.dv X[(i+rr)*inW+t]!) ∧ (∀ p,(∀ rr t,r<=rr → rr < count → t < inW → p≠4*t+rr) → (gPackPart inW i count X hglobal hxs hn hc r A ha has).data[p]! =A.data[p]!):=by induction r,A,ha,has using gPackPart.induct inW i count X hglobal hxs hn hc with | case1 r A ha has hr hrow hxo hr32 a hsz ih=> rw[gPackPart,dif_pos hr] obtain ⟨i1,i2⟩:=ih have hA:∀ j,j < inW.toUSize.toNat → r.toUSize.toNat+j*(4:Nat).toUSize.toNat < A.size:=by intro j hj rw[toUSize_toNat _ hn] at hj rw[toUSize_toNat _ hr32,toUSize_toNat 4 (by decide)] have hv:=Nat.mul_le_mul_right 4 (by omega:j+1<=inW) simp only[Nat.add_mul,Nat.one_mul] at hv rw[Nat.mul_comm inW 4] at hv omega obtain ⟨f1,f2⟩:=gPackU_sem X ((i+r)*inW).toUSize inW.toUSize r.toUSize (4:Nat).toUSize 0 A (by rw[toUSize_toNat _ hxo,toUSize_toNat _ hn];exact hrow) hxs hA has (by rw[toUSize_toNat 4 (by decide)];decide) have fs:∀ t,t < inW → a.data[4*t+r]! =Public99.dv X[(i+r)*inW+t]!:=by intro t ht have e:=f1 t (by change 0<=t;omega) (by rw[toUSize_toNat _ hn];exact ht) change a.data[r.toUSize.toNat+t*(4:Nat).toUSize.toNat]! =Public99.dv X[((i+r)*inW).toUSize.toNat+t]! at e simp only[toUSize_toNat _ hxo,toUSize_toNat _ hr32,toUSize_toNat 4 (by decide)] at e simpa only[Nat.mul_comm,Nat.add_comm] using e have fp:∀ p,(∀ t,t < inW → p≠4*t+r) → a.data[p]! =A.data[p]!:=by intro p hp exact f2 p (fun t _ ht=>by rw[toUSize_toNat _ hn] at ht simpa only[toUSize_toNat _ hr32,toUSize_toNat 4 (by decide),Nat.mul_comm,Nat.add_comm] using hp t ht) refine ⟨?_,?_⟩ · intro rr t h1 h2 h3 rcases Nat.lt_or_ge r rr with hlt|hge · exact i1 rr t (by omega) h2 h3 · have e:rr=r:=by omega subst e rw[i2 _ (fun rr' t' h1' h2' h3'=>by omega)] exact fs t h3 · intro p hp rw[i2 p (fun rr t h1 h2 h3=>hp rr t (by omega) h2 h3)] exact fp p (fun t ht=>hp r t (le_refl _) hr ht) | case2 r A ha has hr=> rw[gPackPart,dif_neg hr] exact ⟨fun rr t h1 h2=>False.elim (hr (by omega)),fun _ _=>rfl⟩ lemma gBlockPart_sem (R I O:Nat) (relu:Bool) (X W b:Array Word) (i rem:Nat) (x:FloatArray) (hxw hw:Word) (hW:O*I<=W.size) (hws:W.size<2^32) (hin:I<2^32) (hx:4*I<=x.size) (hxs:x.size<2^32) (G:Public99.C_G R I O X W b) (Hx:Public99.C_Hv X hxw) (Hw:Public99.C_Hv W hw) (hi:i+rem<=R) (hc:rem<=4) (hcache:∀ k t,k < rem → t < I → x.data[4*t+k]! =Public99.dv X[(i+k)*I+t]!) (j:Nat) (out:Array Word): Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS rem O i j 0) out → Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q<(i+rem)*O) (gBlockPart I O relu X W b i rem x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs j out):=by induction j,out using gBlockPart.induct I O relu X W b i rem x (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hW hws hin hx hxs with | case1 j out hj hr hwo r bw bv E q step out1 out2 out3 out4 ih=> intro H have hn:I.toUSize.toNat=I:=toUSize_toNat _ hin have hjj:(j*I).toUSize.toNat=j*I:=toUSize_toNat _ hwo obtain ⟨e0,e1,e2,e3⟩:=gDot4_sem x W (j*I).toUSize I.toUSize 0 (by rw[hn];exact hx) (by rw[hjj,hn];exact hr) hws hxs 0 0 0 0 have het:∀ k,k < rem → gTerms4 x W k (j*I).toUSize.toNat (0:USize).toNat I.toUSize.toNat= (List.range I).map (fun t=>Public99.dv X[(i+k)*I+t]!*Public99.dv W[j*I+t]!):=by intro k hk rw[hjj,hn,show (0:USize).toNat=0 from rfl,gTerms4,gRangeZero] exact List.map_congr_left (fun t ht=>by rw[hcache k t hk (List.mem_range.mp ht)]) have hb:bw=b[j]!:=by dsimp only[bw] rw[Public99.qAj _ _ G.sb,toUSize_toNat _ (lt_trans (by rw[←G.hb];exact hj) G.sb)] have v0 (hk:0 < rem):gFinish I relu X W b (i+0) j r.s0 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+0) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e0 rw[het 0 hk,List.foldl_map] at ee exact ee have v1 (hk:1 < rem):gFinish I relu X W b (i+1) j r.s1 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+1) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e1 rw[het 1 hk,List.foldl_map] at ee exact ee have v2 (hk:2 < rem):gFinish I relu X W b (i+2) j r.s2 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+2) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e2 rw[het 2 hk,List.foldl_map] at ee exact ee have v3 (hk:3 < rem):gFinish I relu X W b (i+3) j r.s3 (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) hxw bw bv E=Public99.C_out I relu X W b (i+3) j:=by dsimp only[bv,E] rw[hb] apply gFinish_spec G relu (by omega) hj Hx Hw have ee:=e3 rw[het 3 hk,List.foldl_map] at ee exact ee have H1:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS rem O i j 1) out1:=by dsimp only[out1] split · rename_i hk exact gStoreStep G hi hk hj H (v0 hk) · rename_i hk exact Public99.qEz H (fun q hq h=>gQS_skip rem O i j 0 q hk h) have H2:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS rem O i j 2) out2:=by dsimp only[out2] split · rename_i hk exact gStoreStep G hi hk hj H1 (v1 hk) · rename_i hk exact Public99.qEz H1 (fun q hq h=>gQS_skip rem O i j 1 q hk h) have H3:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS rem O i j 3) out3:=by dsimp only[out3] split · rename_i hk exact gStoreStep G hi hk hj H2 (v2 hk) · rename_i hk exact Public99.qEz H2 (fun q hq h=>gQS_skip rem O i j 2 q hk h) have H4:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (gQS rem O i j 4) out4:=by dsimp only[out4] split · rename_i hk exact gStoreStep G hi hk hj H3 (v3 hk) · rename_i hk exact Public99.qEz H3 (fun q hq h=>gQS_skip rem O i j 3 q hk h) rw[gBlockPart,dif_pos hj] apply ih exact Public99.qEz H4 (fun q hq h=>by rcases gQS_next rem O i j q h with h|h|⟨k,hk,hm,hp⟩ · exact Or.inl h · exact Or.inr (Or.inl h) · exact Or.inr (Or.inr ⟨k,hk,by omega,hp⟩)) | case2 j out hj=> intro H rw[gBlockPart,dif_neg hj] exact Public99.qEz H (fun q hq h=>gQS_end rem O i j q hj h) end Submission.FP64 namespace Submission.FP64 open ExactRuntime def gRowsTail (rows inW outW:Nat) (relu:Bool) (X W b:Array Word) (nf a db:Float) (hxw:Word) (hX:rows*inW<=X.size) (hxs:X.size<2^32) (hW:outW*inW<=W.size) (hws:W.size<2^32) (hin:inW<2^20) (i:Nat) (out:Array Word):Array Word:= if hi:i+12<=rows then have hg:(i+12)*inW<=X.size:=Nat.le_trans (Nat.mul_le_mul_right inW hi) hX let buf0:FloatArray:=⟨Array.replicate (12*inW) 0⟩ have hz:buf0.size=12*inW:=by simp only[buf0,FloatArray.size,Array.size_replicate] have hinit:buf0.size<2^32:=by rw[hz];omega let x:=gPackRows 12 inW i X hg hxs (by omega) (by decide) 0 buf0 (by rw[hz]) hinit have hsz:x.size=buf0.size:=gPackRows_size _ _ _ _ _ _ _ _ _ _ _ _ let out:=gBlock12 inW outW relu X W b i x nf a db hxw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) 0 out gRowsTail rows inW outW relu X W b nf a db hxw hX hxs hW hws hin (i+12) out else if hi:i+8<=rows then have hg:(i+8)*inW<=X.size:=Nat.le_trans (Nat.mul_le_mul_right inW hi) hX let buf0:FloatArray:=⟨Array.replicate (8*inW) 0⟩ have hz:buf0.size=8*inW:=by simp only[buf0,FloatArray.size,Array.size_replicate] have hinit:buf0.size<2^32:=by rw[hz];omega let x:=gPackRows 8 inW i X hg hxs (by omega) (by decide) 0 buf0 (by rw[hz]) hinit have hsz:x.size=buf0.size:=gPackRows_size _ _ _ _ _ _ _ _ _ _ _ _ let out:=gBlock8 inW outW relu X W b i x nf a db hxw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) 0 out gRowsTail rows inW outW relu X W b nf a db hxw hX hxs hW hws hin (i+8) out else if hi:i+4<=rows then have hg:(i+4)*inW<=X.size:=Nat.le_trans (Nat.mul_le_mul_right inW hi) hX let buf0:FloatArray:=⟨Array.replicate (4*inW) 0⟩ have hz:buf0.size=4*inW:=by simp only[buf0,FloatArray.size,Array.size_replicate] have hinit:buf0.size<2^32:=by rw[hz];omega let x:=gPackRows 4 inW i X hg hxs (by omega) (by decide) 0 buf0 (by rw[hz]) hinit have hsz:x.size=buf0.size:=gPackRows_size _ _ _ _ _ _ _ _ _ _ _ _ let out:=gBlock4 inW outW relu X W b i x nf a db hxw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) 0 out gRowsTail rows inW outW relu X W b nf a db hxw hX hxs hW hws hin (i+4) out else if hi:iWord} {out:Array Word} (H:Public99.C_Inv N sp (fun q=>q < i*O) out): Public99.C_Inv N sp (gQS width O i 0 0) out:=by apply Public99.qEz H intro q hq h rcases h with h|⟨k,c,hk,hc,hcO,he⟩|⟨k,hk,hz,he⟩ · exact h · omega · omega lemma gRowsTail_sem (R I O:Nat) (relu:Bool) (X W b:Array Word) (hxw hw:Word) (hX:R*I<=X.size) (hxs:X.size<2^32) (hW:O*I<=W.size) (hws:W.size<2^32) (hin:I<2^20) (G:Public99.C_G R I O X W b) (Hx:Public99.C_Hv X hxw) (Hw:Public99.C_Hv W hw) (i:Nat) (out:Array Word): i<=R → Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q < i*O) out → Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q < R*O) (gRowsTail R I O relu X W b (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hX hxs hW hws hin i out):=by induction i,out using gRowsTail.induct R I O relu X W b (Public99.nfOf I) ((I.toUInt64+1).toFloat*Public99.dv hw) (Public99.dv hxw*((I.toUInt64+1).toFloat*Public99.dv hw)) hxw hX hxs hW hws hin with | case1 i out hi hg buf0 hz hinit x hsz out1 ih=> intro hix H obtain ⟨hc,-⟩:=gPackRows_sem 12 I i X hg hxs (by omega) (by decide) 0 buf0 (by rw[hz]) hinit (by decide) have C:∀ k t,k<12 → t < I → x.data[12*t+k]! =Public99.dv X[(i+k)*I+t]!:= fun k t hk ht=>hc k t (Nat.zero_le _) hk ht have B:=gBlock12_sem R I O relu X W b i x hxw hw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) G Hx Hw hi C 0 out (gInitialQS H) rw[gRowsTail,dif_pos hi] exact ih hi B | case2 i out h12 hi hg buf0 hz hinit x hsz out1 ih=> intro hix H obtain ⟨hc,-⟩:=gPackRows_sem 8 I i X hg hxs (by omega) (by decide) 0 buf0 (by rw[hz]) hinit (by decide) have C:∀ k t,k<8 → t < I → x.data[8*t+k]! =Public99.dv X[(i+k)*I+t]!:= fun k t hk ht=>hc k t (Nat.zero_le _) hk ht have B:=gBlock8_sem R I O relu X W b i x hxw hw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) G Hx Hw hi C 0 out (gInitialQS H) rw[gRowsTail,dif_neg h12, dif_pos hi] exact ih hi B | case3 i out h12 h8 hi hg buf0 hz hinit x hsz out1 ih=> intro hix H obtain ⟨hc,-⟩:=gPackRows_sem 4 I i X hg hxs (by omega) (by decide) 0 buf0 (by rw[hz]) hinit (by decide) have C:∀ k t,k<4 → t < I → x.data[4*t+k]! =Public99.dv X[(i+k)*I+t]!:= fun k t hk ht=>hc k t (Nat.zero_le _) hk ht have B:=gBlock4_sem R I O relu X W b i x hxw hw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) G Hx Hw hi C 0 out (gInitialQS H) rw[gRowsTail,dif_neg h12, dif_neg h8, dif_pos hi] exact ih hi B | case4 i out h12 h8 h4 hi rem hg hc buf0 hz hinit x hsz=> intro hix H obtain ⟨hcache,-⟩:=gPackPart_sem I i rem X hg hxs (by omega) hc 0 buf0 (by rw[hz]) hinit have C:∀ k t,k < rem → t < I → x.data[4*t+k]! =Public99.dv X[(i+k)*I+t]!:= fun k t hk ht=>hcache k t (Nat.zero_le _) hk ht have he:i+rem=R:=by dsimp only[rem];omega have B:=gBlockPart_sem R I O relu X W b i rem x hxw hw hW hws (by omega) (by rw[hsz,hz]) (by rw[hsz];exact hinit) G Hx Hw (by omega) hc C 0 out (gInitialQS H) rw[gRowsTail,dif_neg h12,dif_neg h8,dif_neg h4,dif_pos hi] simpa only[he] using B | case5 i out h12 h8 h4 hi=> intro hix H rw[gRowsTail,dif_neg h12,dif_neg h8,dif_neg h4,dif_neg hi] have he:i=R:=by omega simpa only[he] using H end Submission.FP64 namespace Submission.FP64 open ExactRuntime def linearNew (rows inW outW:Nat) (relu:Bool) (X W b:Array Word):Array Word:= let hw:=Public99.scan W W.usize 0 (Public99.qAf W) 0xFFFFFFFF 0 let hxw:=Public99.scan X X.usize 0 (Public99.qAf X) 0xFFFFFFFF 0 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 ∧ hxw≠0xFFFFFFFF ∧ hw≠0xFFFFFFFF ∧ Public99.scan b b.usize 0 (Public99.qAf b) 0xFFFFFFFF 0≠0xFFFFFFFF then if h:rows*inW<=X.size ∧ X.size<2^32 ∧ outW*inW<=W.size ∧ W.size<2^32 ∧ inW<2^20 then let nf:Float:=(inW.toUInt64+8).toFloat*Float.ofBits 0x3CC0000000000000 let a:=(inW.toUInt64+1).toFloat*Public99.dv hw let db:=Public99.dv hxw*a gRowsTail rows inW outW relu X W b nf a db hxw h.1 h.2.1 h.2.2.1 h.2.2.2.1 h.2.2.2.2 0 (Array.replicate (rows*outW) 0) else linearSpec rows inW outW relu X W b else linearSpec rows inW outW relu X W b def gemmNew (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 && decide (k*n<2^32) then let nu:=n.toUSize linearNew m k n false A (Public99.fR (fun r=>r.toUSize) (fun u _ t=>Public99.rdW B (t*nu+u)) k 0 (Array.replicate (n*k) 0) n) (Array.replicate n 0x80000000) else gemmSpec batch m k n A B theorem linearNew_eq:linearNew=linearSpec:=by funext R I O relu X W b unfold linearNew dsimp only split · rename_i h obtain ⟨h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11,h12,h13⟩:=h have Hx:=Public99.qAp X h7 h11 have Hw:=Public99.qAp W h8 h12 have G:Public99.C_G R I O X W b:=⟨h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,Hx.2.2.1,Hw.2.2.1,(Public99.qAp b h9 h13).2.2.1⟩ have ht:R*I<=X.size ∧ X.size<2^32 ∧ O*I<=W.size ∧ W.size<2^32 ∧ I<2^20:= ⟨Nat.le_of_eq h1,h7,Nat.le_of_eq h2,h8,h6⟩ rw[dif_pos ht] have H0:Public99.C_Inv (R*O) (Public99.C_sp I O relu X W b) (fun q=>q<0*O) (Array.replicate (R*O) 0):=⟨by simp,fun q hq h=>by simp at h⟩ have B:=gRowsTail_sem R I O relu X W b (Public99.scan X X.usize 0 (Public99.qAf X) 0xFFFFFFFF 0) (Public99.scan W W.usize 0 (Public99.qAf W) 0xFFFFFFFF 0) ht.1 ht.2.1 ht.2.2.1 ht.2.2.2.1 ht.2.2.2.2 G Hx Hw 0 (Array.replicate (R*O) 0) (Nat.zero_le _) H0 exact Public99.qDp B (fun q hq=>hq) · rfl section open Public99 FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Floats.ExecFloat.Binary local notation"А"=>USize.lt_iff_toNat_lt local notation"Б"=>mul_le_mul_of_nonneg_right local notation"В"=>0x7FFFFFFF local notation"Г"=>mul_le_mul_of_nonneg_left local notation"Д"=>rationalWord local notation"Е"=>0xFFFFFFFF local notation"Ж"=>abs_of_nonneg local notation"З"=>Nat.mod_eq_of_lt local notation"И"=>Array.replicate local notation"Й"=>abs_nonneg local notation"К"=>List.range local notation"Л"=>Nat.zero_add local notation"М"=>UInt32.le_iff_toNat_le local notation"Н"=>mul_nonneg local notation"О"=>Nat.and_two_pow_sub_one_eq_mod local notation"П"=>Float.ofBits local notation"Р"=>two_ne_zero local notation"С"=>mul_le_mul local notation"Т"=>Nat.mul_le_mul_right local notation"У"=>dite_eq_left local notation"Ф"=>FloatArray.emptyWithCapacity local notation"Х"=>ite_eq_right local notation"Ц"=>0x7F800000 local notation"Ч"=>Model.roundDyadic local notation"Ш"=>zpow_le_zpow_right₀ local notation"Щ"=>UInt32.toNat_inj local notation"Ъ"=>dite_eq_right local notation"Ы"=>toDyadic_ofUInt32 local notation"Ь"=>abs_add_le local notation"Э"=>getElem!_pos local notation"Ю"=>Nat.cast_nonneg local notation"Я"=>Model.isFinite local notation"а"=>zpow_add₀ local notation"б"=>mul_lt_mul_of_pos_right local notation"в"=>Model.toReal local notation"г"=>abs_of_pos local notation"д"=>FloatLib.Numerics.Dyadic.cast_toRat local notation"е"=>abs_mul local notation"ж"=>Nat.mul_comm local notation"з"=>ite_eq_left local notation"и"=>abs_sub_comm local notation"й"=>List.mem_range local notation"к"=>zpow_natCast local notation"л"=>UInt64.toNat_add local notation"м"=>Nat.div_lt_of_lt_mul local notation"н"=>UInt32.toNat_toUSize local notation"о"=>Model.toReal_eq_unpackedToReal_toModel local notation"п"=>Real.sqrt local notation"р"=>Finset.range local notation"с"=>Nat.add_assoc local notation"т"=>Nat.shiftRight_eq_div_pow local notation"у"=>Nat.add_zero local notation"ф"=>Float.sqrt local notation"х"=>0x80000000 local notation"ц"=>lt_of_le_of_lt local notation"ч"=>lt_of_lt_of_le local notation"ш"=>Nat.div_eq_of_lt local notation"щ"=>Nat.shiftLeft_eq local notation"ъ"=>UInt64.toNat_shiftRight local notation"ы"=>zpow_pos local notation"ь"=>FloatLib.Numerics.binaryRadix local notation"э"=>Nat.mod_lt local notation"ю"=>UInt32.lt_iff_toNat_lt local notation"я"=>UInt64.lt_iff_toNat_lt local notation"ذ"=>Bool.and_eq_true_iff local notation"ر"=>Finset.sum_congr local notation"ز"=>UInt32.toNat_and local notation"س"=>UInt32.toNat_ofNat' local notation"ش"=>USize.toNat_one local notation"ص"=>Nat.pos_of_ne_zero local notation"ض"=>pow_le_pow_left₀ local notation"ط"=>0x3CE0000000000000 local notation"ظ"=>Model.modelSignBit local notation"ع"=>Nat.le_mul_of_pos_right local notation"غ"=>getElem!_neg local notation"ػ"=>Nat.succ_mul local notation"ؼ"=>Float.Model.UnpackedFloat.unpack local notation"ؽ"=>Finset.mem_range local notation"ؾ"=>le_trans local notation"ؿ"=>List.mem_of_getElem? local notation"ـ"=>Nat.mul_add_div local notation"ف"=>Nat.mul_add_mod local notation"ق"=>sq_nonneg local notation"ك"=>0x3370000000000000 local notation"ل"=>Model.toModel_ofFloatModel local notation"م"=>Nat.add_mul local notation"ن"=>zpow_sub₀ local notation"ه"=>Array.ext local notation"و"=>UInt64.toNat_and local notation"ى"=>FloatLib.Numerics.Dyadic.toRat_eq_zero_iff local notation"ي"=>UInt32.toNat_sub_of_le local notation"Ա"=>List.foldl_cons local notation"Բ"=>List.mem_cons_of_mem local notation"Գ"=>List.range_eq_range' local notation"Դ"=>Nat.one_mul local notation"Ե"=>abs_sub local notation"Զ"=>List.map_congr_left local notation"Է"=>List.mem_cons_self local notation"א"=>by omega local notation"ב"=>by norm_num local notation"ג"=>by simp local notation"ד"=>by linarith theorem gemmNew_eq:gemmNew=gemmSpec:=by funext batch m k n A B;unfold gemmNew;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⟩,h8⟩:=hc;subst h1;have hn:n<2^32:=ц (Nat.le_mul_of_pos_left n h5) h8;dsimp only rw[linearNew_eq,qDj (λr c _=>B[c*n+r]!) (by rwa [ж]) h5 λr p u hr hp hu=>by have a1:=qBe hu hr;have e1:=qAc n hn;have e2:=qAc r א;have e3:(u*n.toUSize).toNat=u.toNat*n:=by rw[qDh _ _ (by rw[e1];omega),e1] rw[qAj _ _ א,qAo _ _ (by rw[e3,e2];omega),e3,e2]] unfold linearSpec linearWith gemmSpec gemmWith;apply ه ג;intro q h8 h9;simp only[Array.getElem_ofFn,Array.size_ofFn] at h8 h9 ⊢;have hq:q< m*n:=by simpa using h9 have e1:q/(m*n)=0:=ш hq;have e2:q/n%m=q/n:=З (м (by rwa [ж]));have hj:q%n< n:=э _ h4;simp only[act,Bool.false_eq_true,ite_false];rw[<-qJe k (λt=>A[(q/(m*n)*m+q/n%m)*k+t]!) (λt=>B[(q/(m*n)*k+t)*n+q%n]!) h5 (λt _=>⟨qI8 A h6 _,qI8 B h7 _⟩)];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:=Т k (א:q%n+1<=n);rw[م,Դ] at this;omega rw[qAa (n*k) (λu=>B[u%k*n+u/k]!) _ hi];have i1:(q%n*k+t)%k=t:=by rw[ж,ف,З ht] have i2:(q%n*k+t)/k=q%n:=by rw[ж,ـ h5,ш ht,у] simp[i1,i2,e1] . simp only[ht,if_false];simp[hj] . rfl end end Submission.FP64 namespace SharedNorm open Public99 open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Floats.ExecFloat.Binary local notation"А"=>USize.lt_iff_toNat_lt local notation"Б"=>mul_le_mul_of_nonneg_right local notation"В"=>0x7FFFFFFF local notation"Г"=>mul_le_mul_of_nonneg_left local notation"Д"=>rationalWord local notation"Е"=>0xFFFFFFFF local notation"Ж"=>abs_of_nonneg local notation"З"=>Nat.mod_eq_of_lt local notation"И"=>Array.replicate local notation"Й"=>abs_nonneg local notation"К"=>List.range local notation"Л"=>Nat.zero_add local notation"М"=>UInt32.le_iff_toNat_le local notation"Н"=>mul_nonneg local notation"О"=>Nat.and_two_pow_sub_one_eq_mod local notation"П"=>Float.ofBits local notation"Р"=>two_ne_zero local notation"С"=>mul_le_mul local notation"Т"=>Nat.mul_le_mul_right local notation"У"=>dite_eq_left local notation"Ф"=>FloatArray.emptyWithCapacity local notation"Х"=>ite_eq_right local notation"Ц"=>0x7F800000 local notation"Ч"=>Model.roundDyadic local notation"Ш"=>zpow_le_zpow_right₀ local notation"Щ"=>UInt32.toNat_inj local notation"Ъ"=>dite_eq_right local notation"Ы"=>toDyadic_ofUInt32 local notation"Ь"=>abs_add_le local notation"Э"=>getElem!_pos local notation"Ю"=>Nat.cast_nonneg local notation"Я"=>Model.isFinite local notation"а"=>zpow_add₀ local notation"б"=>mul_lt_mul_of_pos_right local notation"в"=>Model.toReal local notation"г"=>abs_of_pos local notation"д"=>FloatLib.Numerics.Dyadic.cast_toRat local notation"е"=>abs_mul local notation"ж"=>Nat.mul_comm local notation"з"=>ite_eq_left local notation"и"=>abs_sub_comm local notation"й"=>List.mem_range local notation"к"=>zpow_natCast local notation"л"=>UInt64.toNat_add local notation"м"=>Nat.div_lt_of_lt_mul local notation"н"=>UInt32.toNat_toUSize local notation"о"=>Model.toReal_eq_unpackedToReal_toModel local notation"п"=>Real.sqrt local notation"р"=>Finset.range local notation"с"=>Nat.add_assoc local notation"т"=>Nat.shiftRight_eq_div_pow local notation"у"=>Nat.add_zero local notation"ф"=>Float.sqrt local notation"х"=>0x80000000 local notation"ц"=>lt_of_le_of_lt local notation"ч"=>lt_of_lt_of_le local notation"ш"=>Nat.div_eq_of_lt local notation"щ"=>Nat.shiftLeft_eq local notation"ъ"=>UInt64.toNat_shiftRight local notation"ы"=>zpow_pos local notation"ь"=>FloatLib.Numerics.binaryRadix local notation"э"=>Nat.mod_lt local notation"ю"=>UInt32.lt_iff_toNat_lt local notation"я"=>UInt64.lt_iff_toNat_lt local notation"ذ"=>Bool.and_eq_true_iff local notation"ر"=>Finset.sum_congr local notation"ز"=>UInt32.toNat_and local notation"س"=>UInt32.toNat_ofNat' local notation"ش"=>USize.toNat_one local notation"ص"=>Nat.pos_of_ne_zero local notation"ض"=>pow_le_pow_left₀ local notation"ط"=>0x3CE0000000000000 local notation"ظ"=>Model.modelSignBit local notation"ع"=>Nat.le_mul_of_pos_right local notation"غ"=>getElem!_neg local notation"ػ"=>Nat.succ_mul local notation"ؼ"=>Float.Model.UnpackedFloat.unpack local notation"ؽ"=>Finset.mem_range local notation"ؾ"=>le_trans local notation"ؿ"=>List.mem_of_getElem? local notation"ـ"=>Nat.mul_add_div local notation"ف"=>Nat.mul_add_mod local notation"ق"=>sq_nonneg local notation"ك"=>0x3370000000000000 local notation"ل"=>Model.toModel_ofFloatModel local notation"م"=>Nat.add_mul local notation"ن"=>zpow_sub₀ local notation"ه"=>Array.ext local notation"و"=>UInt64.toNat_and local notation"ى"=>FloatLib.Numerics.Dyadic.toRat_eq_zero_iff local notation"ي"=>UInt32.toNat_sub_of_le local notation"Ա"=>List.foldl_cons local notation"Բ"=>List.mem_cons_of_mem local notation"Գ"=>List.range_eq_range' local notation"Դ"=>Nat.one_mul local notation"Ե"=>abs_sub local notation"Զ"=>List.map_congr_left local notation"Է"=>List.mem_cons_self @[inline] def lnQFast (b:Bool) (n:Nat) (x:Array Word) (r:Nat):ℚ:=if b then 0 else SharedMean.rowMeanF n x r def lnStatFast (b:Bool) (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*П ط let ind:=1.0/nd let a:=if b then F1.mk 0 0 else lnSum x base nu 0 0 0 let m:=if b then 0 else a.s*ind let v:=lnVar x base nu 0 m 0 let em:=(nf*a.t)*ind+П ك let tt:=v*ind+dv eps let d:=ф 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 (lnQFast b n x r)+Д eps)⟩ def lnFFast (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=>lnStatFast false n eps x r.val fR (λr=>(st[r]!,λ_:Unit=>SharedMean.rowMeanF n x r)) (λs p j=>lnOut s.1 (rdW x p) (rdW g j) (rdW b j) s.2) n 0 (И (rows*n) 0) rows else layernormSpec rows n eps x g b theorem lnQFast_eq:lnQFast=Public99.lnQ:=by funext b n x r simp only[lnQFast,Public99.lnQ,SharedMean.rowMeanF_eq] theorem lnStatFast_eq:lnStatFast=Public99.lnStat:=by funext b n eps x r unfold lnStatFast Public99.lnStat rw[lnQFast_eq] theorem lnFFast_eq:lnFFast=Public99.lnF:=by funext rows n eps x g b unfold lnFFast Public99.lnF rw[lnStatFast_eq,SharedMean.rowMeanF_eq] theorem lnFFast_spec:lnFFast=layernormSpec:=lnFFast_eq.trans Public99.qHn end SharedNorm namespace Submission open ExactRuntime def kernels:Kernels where core:=specCore dense:=⟨FP64.linearNew,FP64.gemmNew⟩ conv:=specConv elem:=⟨avgpoolSpec,maxpoolSpec,SharedAdd.gNativeAdd,scaleShiftSpec⟩ norm:=⟨rmsnormSpec,SharedNorm.lnFFast⟩ theorem correct:Obligation kernels:=by simp only[Obligation,kernels,specKernels,specDense,specElem,specNorm, FP64.linearNew_eq,FP64.gemmNew_eq,SharedAdd.gNativeAdd_eq,SharedNorm.lnFFast_spec] end Submission