import ContractExact namespace Submission open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open Nat renaming mod_eq_of_lt->β,shiftRight_eq_div_pow->γ,and_two_pow_sub_one_eq_mod->ι,mul_le_mul_right->μ,shiftLeft_eq->ν,pow_le_pow_right->Ε,zero_add->Θ,add_comm->Μ,mod_lt->Ν,mul_lt_mul_of_pos_right->Ξ,div_eq_of_lt->Ρ,mul_comm->Τ,succ_mul->Υ,add_mul_div_right->ϊ,and_le_right->ϋ,lt_log2_self->ό,add_mul_mod_self_right->ώ,toUInt64_eq->ϑ,div_add_mod->ϖ,mul_lt_mul''->ϗ,add_zero->Ϛ,two_pow_add_eq_or_of_lt->Ϟ,mul_assoc->ϟ,add_mul->Ϡ,div_lt_of_lt_mul->Ϥ,zero_le->ϥ,log2_self_le->Ϩ,mul_le_mul->ϩ,mul_pos->Ϭ,div_eq_of_lt_le->Ϯ,add_sub_cancel_left->ϰ,zero_mul->ϴ,div_div_eq_div_mul->ϵ,two_pow_pos->϶,div_lt_iff_lt_mul->Ϸ,mul_one->Ϻ,pow_lt_pow_right->ϻ open UInt64 renaming le_iff_toNat_le->ε,toNat_add->ζ,lt_iff_toNat_lt->θ,toNat_inj->ο,toNat_ofNat_of_lt'->υ,toNat_sub_of_le->χ,toNat_shiftRight->ψ,toNat_shiftLeft->Α,toNat_and->Β,toNat_sub->Η,toNat_mul->ύ,toNat_zero->Ϗ,le_trans->ϛ,toNat_toUInt32->ϣ open USize renaming lt_iff_toNat_lt->η,le_size->ς,toNat_zero->ϲ open Bool renaming false_eq_true->ξ,and_eq_true->Λ,eq_iff_iff->ϕ open UInt32 renaming toNat_inj->Ζ,toNat_and->Ο,toNat_toUInt64->ϒ,toNat_shiftRight->ϓ,lt_iff_toNat_lt->Ϙ open Finset renaming sum_range_succ->Ι,sum_congr->ϝ,mem_range->ϯ open Array renaming getElem_ofFn->Κ,size_push->ϡ,size_ofFn->Ϣ,getElem?_eq_none->ϧ open Model renaming isNaN_eq_false_of_toDyadic?_some->Χ,toReal_roundDyadic_eq_roundAt->ϐ,toModel_ofFloatModel->ϔ,isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite->Ϝ,isInf_eq_false_of_toDyadic?_some->Ϧ,abs_signed_mul_bpow_le_toReal_posMaxFinite->Ϫ,roundDyadicGeneral_eq_roundDyadic->Ϲ open FloatLib.Numerics.Dyadic renaming cast_toRat->ϙ,toRat_eq_zero_iff->ϳ open Model.Reduction renaming dotWithStatus_eq_zero_of_finite->ϫ open Model.Reduction.Internal renaming dotState_exact_toRat->ϭ open Int renaming natAbs_mul->ϱ,abs_eq_natAbs->ϸ local notation "А" => by omega local notation "Б" => by decide local notation "В" => by positivity local notation "Г" => by norm_num local notation "Д" => UInt64 local notation "Е" => UInt32 local postfix:max "а"=>UInt64.toNat local postfix:max "б"=>USize.toNat local postfix:max "в"=>Array.size local postfix:max "г"=>UInt32.toNat local postfix:max "д"=>FloatArray.size local postfix:max "е"=>Nat.toUInt64 local postfix:max "ж"=>Nat.log2 local postfix:max "з"=>Fin.val local postfix:max "и"=>Nat.toUSize local postfix:max "й"=>UInt64.toUInt32 local postfix:max "к"=>Int.natAbs local postfix:max "л"=>Int.toNat local postfix:max "м"=>UInt32.toUInt64 local postfix:max "н"=>Int64.toInt open UInt64 renaming reduceToNat->j9,ofNat->kA,size->kL,toNat->kY,toNat_div->lH,toNat_or->lP,toNat_ofNat->mq,toNat_mod->mT,toNat_toBitVec->ni,toNat_one->n7 open FloatLib.Floats.Formats.BinaryInterchange.FloatFormat renaming binary64->ka open FloatArray renaming emptyWithCapacity->kb,size->kH,uget->ph open FloatLib.Floats.Formats.BinaryInterchange.Model renaming roundDyadic->kd,ofFloatModel->kj,ofUInt32->kt,toReal->kU,roundedMantissa_shift_quotient->k5,roundDyadic_of_representable->lc,roundAt_mono->ld,unpackedToReal->lL,toReal_add_eq_roundAt->lW,isFinite->l6,toNatBits_lt_two_pow->mb,posMaxFinite->me,roundAt_zero->mf,modelSignBit->mg,ofNatBits_toNatBits->my,roundAt->mL,maximum->mM,ofFloatModel_pack->mN,ofFloat32Model->nt,roundRatScaled->nw,add->nC,fma->nD,div->nF,ofModel->nO,pow2->pq open USize renaming reduceToNat->ke,size->kN,toNat_add->lR,toNat_one->m9,ofNat_add->nb open ExactRuntime renaming idxOf->kf,Word->kg,expOf->ki,mantOf->kl,toDyadic_ofUInt32->kx,toWord->ky,mantOf_lt_24->kD,oneW->kG,signOf->kM,windowAt->kP,finishWord->kS,decodeD_toRat->k6,ofW->k7,fracOf->la,ConvShape->lk,Fmt->lq,finishWord_of_ne->lC,linearSpec->lG,stableNormDomain->lI,dotOf->lJ,sqrtRational->lY,expOf_toNat_lt->l7,isFinite_ofUInt32->mA,ofIntDyadic->mD,decodeD->mG,rowMean->mI,dallNZ->mX,poolAt->m5,avgpoolSpec->nA,avgpoolWith->nB,ofUInt32_bits->nN,idxOf_le->nX,act->pj open Finset renaming range->km,sum_range_succ'->lr,sum_add_distrib->m6,sum_mul->ny open Array renaming ofFn->kn,getElem?_eq_getElem->k0,emptyWithCapacity->lj,ext->lF,replicate->lS,getElem?_ofFn->lU,ext_getElem?->mi,size_extract->ml,size_map->mv,all_eq_true->mJ,getElem_push_lt->nk,getElem_push_eq->nn,getElem_extract->no,getElem?_set->nT,uget->po open Float.Model.UnpackedFloat renaming unpack->ko,mul->kF,accuracyOfFraction->lh,roundWithAccuracy->mH,unpackExponent->np,round->nI,isFinite->nQ,Sign->nZ,pack->n9 open Nat renaming reduceMod->kp,mul_lt_mul_of_lt_of_le->kX,pos_of_ne_zero->lf,le_log2->li,testBit_eq_decide_div_mod_eq->ls,le_div_iff_mul_le->lA,log2_lt->lK,add_mul_div_left->lN,log2_eq_iff->lQ,add_sub_cancel'->lV,one_le_two_pow->l9,and_one_is_mod->ma,toUSize_eq->mc,add_right_comm->mw,pow_add->mB,one_shiftLeft->mC,reducePow->mK,le_mul_of_pos_right->mO,le_mul_of_pos_left->mZ,abs_cast->m0,sub_zero->m3,add_one_mul->nf,mul_div_mul_right->nj,cast_ofNat->nr,one_mul->ns,eq_add_of_sub_eq->nu,mul_le_mul_left->nG,div_le_div_left->nJ,div_mul_le_self->nK,cast_one->nY,cast_sub->n4 open FloatLib.Numerics renaming binaryRadix->kq,shiftRightJam->kr,Dyadic->ku,roundQuotientEven->kE,roundShiftRightEven_shiftRightJam->ll open FloatLib.Numerics.Dyadic renaming ofScaledInt->ks,signedSignificand->kT,toReal->ly,cast_signedSignificand->mE,ofScaledInt_toRat->mY,add_toRat->nV,mul_toRat->nW,toRat->n6 open Float.Model renaming totalExponent->kz,add->pe,mul->pf open FloatLib.Floats.Formats.Flocq renaming bpow->kB open Float.Model.Format renaming binary64->kC,binary32->kJ open FloatLib.Numerics.RationalBinary renaming floorLog2->kI,scaleByPowerOfTwo->lw,scaleByPowerOfTwo_ofNat->lO,lessThanPowerOfTwo->l5,atLeastPowerOfTwo->mu open FloatLib.Numerics.FixedWord renaming roundShiftRightEven->kO open List renaming range->kQ,foldl_cons->k9,foldl_append->lv,range_succ->lT,foldl_nil->mh,range'->pd open Float.Model.UnpackedFloat.ExtendedMantissa renaming shiftRightOne->kR open BitVec renaming toInt_eq_toNat_cond->kV open Float32 renaming ofBits->kW open UInt32 renaming ofNat->kZ,toNat_ofNat'->k4,toNat_shiftLeft->lu,reduceToNat->md,toNat_sub_of_le->m4,toNat_or->m8,toNat_zero->n5,toNat_add->pa,toNat_sub->pb open FloatLib.Floats.Formats.BinaryInterchange.Model.Reduction.Internal renaming dotState->lm,State->lB open FloatLib.Floats.ExecFloat.Binary renaming toModel_ofFloat_int64ToFloat->lx,toModel_ofFloat->mz open FloatLib.Numerics.Radix renaming toReal->lE open Int renaming ofNat_eq_natCast->lM,cast_abs->lX,log->m7,ModEq->nE open FloatLib.Floats.Formats.BinaryInterchange.Model.Reduction.Semantics renaming finiteDot_toList_eq_slice->lZ,finiteDotSlice->nh open Bool renaming false_ne_true->mj,or_eq_true->na open MulZeroClass renaming zero_mul->mP open System.Platform renaming numBits->mQ open FloatLib.Floats.Formats.BinaryInterchange.Model.Proof renaming div_eq_spec->mR open FloatLib.Floats.Formats.BinaryInterchange.Model.NativeBinary32 renaming ofUInt32_roundRatScaled->mS,toUInt32_ofFields->nx,toUInt32->nM,roundRatScaled->nP open Min renaming min->mU open Option renaming some->nR open Or renaming inl->nU,inr->n8 open Decidable renaming not_not->n0 open FloatLib.Floats.Formats.BinaryInterchange.Model.Spec renaming div->pp local notation "о"=>Nat local notation "п"=>Int local notation "р"=>Array local notation "с"=>Word local notation "т"=>Float local notation "у"=>Bool local notation "ф"=>USize open _root_ renaming zpow_natCast->AA,getElem!_pos->AC,ite_eq_right->AD,ite_eq_left->AE,mul_le_mul_of_nonneg_right->AF,pow_add->AG,lt_of_le_of_lt->AH,zpow_le_zpow_right₀->AI,lt_of_lt_of_le->AJ,zpow_add₀->AL,two_ne_zero->AM,mul_lt_mul_of_pos_right->AN,beq_iff_eq->AO,bne_iff_ne->AP,abs_of_pos->AR,pow_le_pow_right₀->AS,decide_eq_true_eq->AT,one_div_pow_le_one_div_pow_of_le->AU,le_rfl->AV,dite_eq_left->AW,mul_assoc->AX,lt_irrefl->AY,dite_eq_right->AZ,abs_nonneg->Aa,abs_add_le->Ac,abs_sub_abs_le_abs_sub->Ad,zpow_sub₀->Ae,abs_of_nonneg->Af,le_trans->Ag,abs_mul->Ah,getElem!_neg->Ai,le_max_right->Ak,zero_add->Al,decide_eq_true->Am,decide_eq_true_iff->An,le_max_left->Ao,ite_false->Ap,mul_nonneg->Aq,ne_eq->Ar,mul_ne_zero->As,zpow_neg->Aw,add_zero->Ax,abs_sub_comm->Ay,apply_ite->Az,beq_self_eq_true->A0,abs_neg->A4,sub_zero->A5,lt_trans->A6,le_of_eq->A7,gt_iff_lt->BB,decide_eq_false_iff_not->BC,decide_false->BE,lt_of_mul_lt_mul_right->BF open USize renaming reduceToNat->AB,ofNat_mul->BO open FloatArray renaming emptyWithCapacity->AK open Array renaming emptyWithCapacity->AQ,ofFn->Aj,replicate->Av,mkEmpty->A3,size_uset->BS open Model renaming div->Au,ofFloatModel->BA,toReal_eq->BQ open Nat renaming log2->A9,pos_iff_ne_zero->BD,shiftLeft_zero->BH,mod_mod_of_dvd->BI,eq_or_lt_of_le->BJ,add_sub_cancel->BK,succ_le_of_lt->BP open UInt32 renaming ofBitVec->BG open Float32 renaming ofBits->BL open Bool renaming not_eq_true'->BM open ZMod renaming natCast_mod->BN open List renaming range'_succ->BR open Float.Model.Format renaming targetExponent->BT local notation "Ж"=>4294967296 structure Acc where pos:р о neg:р о special:у negZero:у def Acc.j8 (acc:Acc):п:=(limbVal acc.pos.toList:п)-limbVal acc.neg.toList @[inline] def Acc.add (acc:Acc) (m idx:о) (neg:у):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е idx,sp,false⟩ else ⟨addLimbs64 pos mе idx,ng,sp,false⟩ section open FloatLib.Numerics lemma cd (s:у) (m:о) (e:п) (j:о) (h:j+25<= mж): kd lq ⟨s,kr m j,e+j⟩=kd lq ⟨s,m,e⟩:=by have g:m≠0:=by rintro rfl;simp at h have o:2^mж<= m:=Ϩ g;have u:2^(j+1)<= m:=Ag (Ε Г А) o;have d:(kr m j)ж=mж-j:=log2_shiftRightJam m j u have t:kr m j≠0:= shiftRightJam_ne_zero m j (Ag (Ε Г А) u) rw[<- Ϲ,<- Ϲ];unfold Model.roundDyadicGeneral;simp only[t,g,AO,ite_false,d];have q:((mж-j:о):п)+(e+j)=(mж:п)+e:=А;rw[q];have r:Fmt.fracWidth=23:=rfl;have p:Fmt.minSubnormalExponent=-149:=rfl;have l:Fmt.minNormalExponent=-126:=rfl;rw[r,p,l];split_ifs with h1 h2 h3 h4<;>try omega .rfl .congr 1 obtain ⟨a,v⟩:∃a:о,e- -149=Int.negSucc a:=⟨(-(e+149)-1)л,А⟩ have w:e+j- -149=Int.negSucc (a-j):=А;rw[v,w];dsimp only;rw[(А:a-j+1=(a+1)-j)] exact ll m j (a+1) А .congr 1 rw[(А:mж-j-23=(mж-23)-j)] exact ll m j _ А end lemma ab (n:о) (f:о-> Е) (k:о) (d:kf iз)[k]! =f k:=by rw[AC _ k (by simpa using d),Κ] namespace Core def tm (a b:с):п:=sv a*sv b*2^(idxOf a+idxOf b) def af (n:о) (fa fb:о-> с):п:=∑k∈Finset.range n,tm (fa k) (fb k) def aB (n:о) (fa fb:о-> с):Prop:=∀k,k expOf (fa k)≠255/\expOf (fb k)≠255 lemma aK (n:о) (d e:о-> kg): af (n+1) d e=af n d e+tm (d n) (e n):=by unfold af;rw[Ι] lemma fY (A B:р Е) (i c:о): dsum A B i c=∑k∈km c,tm A[i+k]! B[i+k]!:=by induction c generalizing i with | zero=>simp[dsum] | succ c d=> rw[dsum,d (i+1),lr,add_comm];exact congrArg₂ _ (ϝ rfl λk _=>by rw[(А:i+1+k=i+(k+1))]) rfl lemma cB (n:о) (d e:о-> kg): dsum (kn (n:=n) λi=>d iз) (kn (n:=n) λi=>e iз) 0 n= af n d e:=by rw[fY,af] exact ϝ rfl λk g=>by rw[ϯ] at g;simp only[Θ,ab n d k g,ab n e k g] lemma bE (n:о) (o p:о-> kg) (u:aB n o p): lJ n o p=kS (af n o p) (-298) (decide (n≠0)&& mX (kn (n:=n) λi=>o iз) (kn (n:=n) λi=>p iз) 0 n):=by unfold lJ;set A:=kn (n:=n) λi=>o iз with q set B:=kn (n:=n) λi=>p iз with t have m:∀k,k ki A[k]!≠255/\ki B[k]!≠255:=λk j=>by rw[q,t,ab n o k j,ab n p k j];exact u k j have x:∀X:р kg,Xв=n->(∀k,k ki X[k]!≠255) -> ∀k (j:k<(X.map (kt (fmt:=lq)))в), l6 (X.map (kt (fmt:=lq)))[k]=true:=by intro X G h k j;have w:k(m k j).1 have g:=x B (by simp[t]) λk j=>(m k j).2 have j:∀k,0<= k-> k<0+Lв-> ki A[k]!≠255/\ki B[k]!≠255:= λk _ F=>m k (by simpa[r,q] using F) have d:nh L R 0 Lв (by simp) (by simp[l])=(af n o p:ℚ)*2^(-298:ℤ):= (finiteDotSlice_eq A B 0 Lв (by simp[r]) (by simp[r,q,t]) j).trans (by simp[r,q,t,cB]) have y:=ϭ (destination:=lq) L R l e g;unfold dotSpec Model.dot;by_cases v:af n o p=0 .rw[v,finishWord_zero,ϫ lq L R .nearestEven l e g ((ϳ _).1 (by rw[y,d,v];simp))] obtain ⟨z,D⟩:=dotStateLoop_flags A B ({}:lB lq) 0 Lв (by simp[r]) (by simp[r,q,t]) j unfold lm;rw[z,D];simp[r,q];rfl .rw[Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero lq L R .nearestEven l e g (by rw[lZ L R l];intro h;injection h with h;rw[d] at h;simp at h;exact v h)] exact (lC _ (af n o p) (-298) _ v (by rw[y,d])).symm lemma bO (n:о) (d e:о-> kg) (g:aB n d e) (h:af n d e≠0): lJ n d e=kS (af n d e) (-298) false:=by rw[bE n d e g];simp only[kS,h,Ap] @[inline] def fE (w:Е):Д:=if (w>>>23)&&&255!=0 then 1 else 0 @[inline] def mW (w:Е):Д:=(w&&&8388607)м ||| (fE w<<<23) @[inline] def iW (w:Е):Д:=((w>>>23)&&&255)м-fE w def ac (x:Д):п:=x.toBitVec.toInt lemma dq (w:Е):(w&&&8388607)г<2^23:=by rw[Ο];exact AH ϋ Б lemma ag (w:Е):(mW w)а=kl w:=by have g:=dq w;unfold mW fE kl ki la;by_cases d:(w>>>23)&&&255=0 .simp[d] .have e:((w>>>23)&&&255!=0)=true:=by simpa using d simp only[e,d,ite_true,ite_false] rw[lP,ϒ,show ((1:Д)<<<23)а=2^23*1 from rfl,Nat.or_comm, <- Ϟ g,Ϻ,Μ] lemma am (w:Е):(iW w)а=kf w:=by unfold iW fE kf ki;have g:=l7 w;unfold ki at g;by_cases e:(w>>>23)&&&255=0 .simp[e] .have d:1<=((w>>>23)&&&255)г:= Nat.one_le_iff_ne_zero.2 λh=>e (Ζ.mp (by simpa using h)) simp only[show ((w>>>23)&&&255!=0)=true by simpa using e,e,ite_true,ite_false] rw[χ _ _ (ε.mpr (by rw[ϒ];simpa using d)), ϒ] rfl lemma ax (w:Е):kM w=true↔2^31<= wг:=by unfold kM;have e:=w.toNat_lt;have d:(w&&&0x80000000)г=wг&&&2^31:=by rw[Ο];rfl rw[Nat.and_two_pow,ls] at d;simp only[AP,Ar,<- Ζ,d];by_cases h:wг/2^31%2=1<;>simp[h]<;>omega lemma da (w:Е):(w>>>31!=0)=kM w:=by have d:(w>>>31)г=wг/2^31:=by rw[ϓ];simp[γ] have:=w.toNat_lt;rw[ϕ,AP,Ar,<- Ζ,d,ax];simp<;>omega @[inline] def sx (k x:Д):Д:=bif x>>>k==0 then x else x>>>k @[inline] def sr (k x r:Д):Д:=bif x>>>k==0 then r else r+k @[inline] def ak (x0:Д):Д:= let x1:=sx 32 x0 let r1:=sr 32 x0 0 let x2:=sx 16 x1 let r2:=sr 16 x1 r1 let x3:=sx 8 x2 let r3:=sr 8 x2 r2 let x4:=sx 4 x3 let r4:=sr 4 x3 r3 let x5:=sx 2 x4 let r5:=sr 2 x4 r4 sr 1 x5 r5 @[inline] def fF (value shift:Д):Д:= let quotient:=value>>>shift let remainder:=value&&&((1<<half then quotient+1 else if (quotient&&&1)==0 then quotient else quotient+1 @[inline] def c6 (value shift:Д):Д:= let quotient:=value>>>shift let remainder:=value&&&((1<<half then 1 else 0) @[inline] def aW (value shift:Д):Д:= if shift==0 then value else if shift<64 then c6 value shift else if shift==64 then (if value>0x8000000000000000 then 1 else 0) else 0 @[inline] def cZ (sign:у) (e f:Е):Е:= (if sign then (0x80000000:Е) else 0) ||| ((e&&&255)<<<23) ||| (f&&&8388607) @[inline] def dT (n:Д):Е:= (if n<8388608 then 0 else n-8388608)й @[inline] def an (sign:у) (product scale:Д):Е:= if product==0 then if sign then 0x80000000 else 0 else let leading:=ak product let position:=leading+scale if position<172 then let fraction:= if scale<149 then aW product (149-scale) else product<<<(scale-149) if fraction==0 then (if sign then 0x80000000 else 0) else if fraction==8388608 then cZ sign 1 0 else cZ sign 0 fractionй else let roundedMantissa:= if leading<23 then product<<<(23-leading) else aW product (leading-23) let carry:=roundedMantissa==16777216 let normalizedPosition:=if carry then position+1 else position if normalizedPosition>425 then (if sign then 0xff800000 else 0x7f800000) else let normalizedMantissa:=if carry then 8388608 else roundedMantissa cZ sign (normalizedPosition-171)й (dT normalizedMantissa) open Model.NativeBinary32 in lemma bn (n k:о) (h:n>>>k≠0):nж=k+(n>>>k)ж:=by rw[γ] at h⊢;have e:=(lA (϶ k)).1 (Ϩ h);have d:=(Ϸ (϶ k)).1 (ό (n:=n/2^k));rw[lQ (by rintro rfl;simp at h)] simp only[Nat.pow_succ,mB] at d⊢;constructor<;>nlinarith lemma dW (x:Д):xаж<64:=by by_cases h:xа=0 .simp[h] .exact (lK h).mpr x.toNat_lt lemma cr (j r x k:Д) (p:kа<=32) (o:0>>k)а=xа>>>kа:=by rw[ψ,β А] unfold sx sr;by_cases g:x>>>k=0 .simp only[g,A0,Bool.cond_true] exact ⟨d,by simpa[e,γ,Nat.div_eq_zero_iff] using congrArg kY g⟩ .simp only[show (x>>>k==0)=false by simpa using g,Bool.cond_false] have q:=bn xа kа λh=>g (ο.mp (by simpa[e] using h)) have l:=dW j;refine ⟨by rw[ζ,β А,e];omega,?_⟩ rw[e,γ];exact Ϥ (by rw[<- mB];exact lt_of_lt_of_eq m (by congr 1;omega)) lemma dj (n:о) (h:n<2):nж=0:=by rw[Nat.log2_def,AD А] lemma aA (x:Д):ak x=x.log2:=by apply ο.mp;rw[show x.log2а=xаж from rfl];have d:xа<2^(2*(32:Д)а):=x.toNat_lt;obtain ⟨o,e⟩:=cr x 0 x 32 Б Б (by simp) d obtain ⟨p,g⟩:=cr x _ _ 16 Б Б o (by simpa using e) obtain ⟨q,h⟩:=cr x _ _ 8 Б Б p (by simpa using g) obtain ⟨r,j⟩:=cr x _ _ 4 Б Б q (by simpa using h) obtain ⟨t,l⟩:=cr x _ _ 2 Б Б r (by simpa using j) obtain ⟨u,m⟩:=cr x _ _ 1 Б Б t (by simpa using l) rw[dj (sx 1 (sx 2 (sx 4 (sx 8 (sx 16 (sx 32 x))))))а (by simpa using m)] at u unfold ak;dsimp only;omega lemma gm (v s:Д) (o:s≠0) (h:s<64):c6 v s=fF v s:=by have g:sа<64:=h have m:(2:о)^sа<0x10000000000000000:= AJ (ϻ Г g) Г have e:(v&&&((1<<simp[ε, β g,mC,β m,ι,l9] have d:((v>>>s)&&&1)а=(v>>>s)а%2:=by simp[Β,ma] have p:=Ν vа (show 0<2^sа by positivity) have j:((v&&&((1<<>>s)&&&1))а=vа%2^sа+(v>>>s)а%2:=by rw[ζ,e,d,β А] have l:((v>>>s)&&&1==0)=decide ((v>>>s)а%2=0):=by rw[<- d,ϕ,AO,An,<- ο,Ϗ] unfold c6 fF;simp only[BB,θ,j,e,l,AT];split_ifs<;>first | rfl | omega | simp lemma eC (e d:Д): aW e d=kO e dа:=by have o:aW e d=(if d==0 then e else if d<64 then fF e d else if d==64 then (if e>0x8000000000000000 then 1 else 0) else 0):=by unfold aW;split_ifs with a b<;>first | rfl | exact gm _ _ (by simpa using a) b rw[o];unfold fF kO;have p:=d.toNat_lt;by_cases g:d=0 .subst g;rfl .have j:dа≠0:=λh=>g (ο.mp (by simpa using h)) simp only[g,AO,j,reduceIte] have m:kA (dа-1)=d-1:=by apply ο.mp;rw[χ _ _ (by rw[ε];simp;omega)];simp;omega have l:(d<64)↔dа<64:=θ;simp only[UInt64.ofNat_toNat,m,<- l,show d=64↔dа=64 by rw[<- ο];rfl] open Model.NativeBinary32 in lemma et (d:у) (e f:о): cZ d (kZ e) (kZ f)=mkBits d e f:=by unfold cZ mkBits;cases d<;>rfl lemma bQ (x:Д):xй=kZ xа:=by rfl lemma cW (n:Д):dT n=kZ (nа-8388608):=by unfold dT;split<;>rename_i h<;>rw[θ] at h<;>simp only[bQ] .rw[show nа-8388608=0 by simp at h;omega];rfl .rw[χ _ _ (by rw[ε];simp at h⊢;omega)];rfl open Model.NativeBinary32 in lemma bA (g:у) (d e:Д): an g d e=roundProduct g d e:=by unfold an roundProduct;simp only[aA,eC,cW,bQ];rw[show (1:Е)=kZ 1 from rfl,show (0:Е)=kZ 0 from rfl];simp only[et] open Model.NativeBinary32 in lemma bu (w:Е):ky (ofUInt32 w)=w:=by have h:=toUInt32_ofUInt32 w;unfold nM at h;unfold ky;conv_rhs=>rw[<- h] exact Ζ.mp (β (BitVec.isLt _)) open Model.NativeBinary32 in lemma aJ (g:у) (m d:Д) (h:dа<=506): an g m d=ky (kd lq ⟨g,mа,(dа:п)-298⟩):=by rw[bA,roundProduct_eq_roundDyadic _ _ _ h] have e:kd lq ⟨g,mа,(dа:п)-298⟩= ofUInt32 (roundDyadic ⟨g,mа,Int.ofNat dа-298⟩):= (ofUInt32_roundDyadic _).symm rw[e,bu] def au (hi lo:Д):п:=ac hi*2^64+loа @[inline] def aD (hi lo:Д):Д:=if hi>>>63!=0 then (0:Д)-lo else lo @[inline] def aP (hi lo:Д):Д:= if hi>>>63!=0 then (if lo==0 then (0:Д)-hi else ~~~hi) else hi lemma gd (d:Д):(d>>>63!=0)=decide (2^63<= dа):=by have e:(d>>>63)а=dа/2^63:=by rw[ψ];simp[γ] have:=d.toNat_lt;rw[ϕ,AP,Ar,<- ο,e,An];simp lemma bK (d e:Д): au d e=(dа*2^64+eа:п)-(if 2^63<= dа then 2^128 else 0):=by unfold au ac;rw[kV,ni];split<;>split<;>push_cast<;>omega lemma eW (e d:Д): (au e d)к=(aP e d)а*2^64+(aD e d)а /\ decide (au e d<0)=(e>>>63!=0):=by have m:=e.toNat_lt;have o:=d.toNat_lt;unfold aP aD;rw[bK,gd];by_cases j:2^63<= eа .simp only[j,decide_true,ite_true] by_cases g:d=0 .subst g simp only[A0,ite_true,Ϗ];rw[Η];simp;constructor<;>omega .have l:dа≠0:=λh=>g (ο.mp (by simpa using h)) simp only[show (d==0)=false by simpa using g,ξ,ite_false] rw[Η,UInt64.toNat_not];simp;constructor<;>omega .simp only[j,BE,ξ,ite_false];simp;omega @[inline] def ar (hi lo B:Д):Д:= if hi==0&&lo==0 then Ж else if B>442 then Ж else let neg:=hi>>>63!=0 let mlo:=aD hi lo let mhi:=aP hi lo if mhi==0 then (an neg mlo B)м else if mhi>>>32==0 then let q:=(mhi<<<32)+(mlo>>>32) (an neg (if mlo&&&0xFFFFFFFF==0 then q else q ||| 1) (B+32))м else (an neg (if mlo==0 then mhi else mhi ||| 1) (B+64))м lemma toUInt32_toUInt64 (x:Е):xмй=x:=by apply Ζ.mp;simp lemma iD (e d:Д) (h:eа<2^32): (if d&&&0xFFFFFFFF==0 then (e<<<32)+(d>>>32) else ((e<<<32)+(d>>>32)) ||| 1)а= kr (eа*2^64+dа) 32:=by have j:=d.toNat_lt have l:((e<<<32)+(d>>>32))а=eа*2^32+dа/2^32:=by simp[ζ,ν,γ];omega have g:(d&&&0xFFFFFFFF)а=dа%2^32:=by rw[Β];exact ι _ 32 unfold kr simp only[(А:(eа*2^64+dа)/2^32=eа*2^32+dа/2^32), show (eа*2^64+dа)%2^32=dа%2^32 by omega, show (d&&&0xFFFFFFFF==0)=decide (dа%2^32=0) by rw[<- g,ϕ,AO,An,<- ο,Ϗ]] split_ifs<;>simp_all[lP] lemma iE (e d:Д): (if d==0 then e else e ||| 1)а= kr (eа*2^64+dа) 64:=by have l:=d.toNat_lt;have g:(eа*2^64+dа)/2^64=eа:=А;have h:(eа*2^64+dа)%2^64=dа:=А;unfold kr;simp only[g,h];by_cases j:dа=0<;>simp[j,lP,<- ο] lemma ez (s:у) (q B J:Д) (M:о) (e:qа=kr M Jа) (h:Bа<=442) (j:Jа<=64) (d:2^(Jа+25)<= M): an s q (B+J)=ky (kd lq ⟨s,M,(Bа:п)-298⟩):=by have g:(B+J)а=Bа+Jа:=by rw[ζ];simp;omega rw[aJ _ _ _ А,e,g,<- cd s M _ Jа ((li (BD.1 (AJ В d))).2 d)] congr 3;push_cast;ring lemma di (d e B:Д) (h:ar d e B<Ж): au d e≠0/\Bа<=442 /\ (ar d e B)й= ky (kd lq (mD (au d e) ((Bа:п)-298))):=by obtain ⟨m,o⟩:=eW d e;have z:=e.toNat_lt;have y:=d.toNat_lt;unfold ar at h⊢;by_cases t:(d==0&&e==0)=true .simp[t] at h .simp only[t,ξ,ite_false] at h⊢ have w:au d e≠0:=λj=>t (by rw[bK] at j;simp only[Λ,AO,<- ο,Ϗ];split at j<;>omega) by_cases p:B>442 .simp[p] at h .simp only[p,ite_false] at h⊢ have g:Bа<=442:=by simpa[θ] using p refine ⟨w,g,?_⟩;unfold mD;rw[o,m];have r:=ψ (aP d e) 32;simp only[γ] at r;split .rename_i j rw[(by simpa using congrArg kY (beq_iff_eq.mp j):(aP d e).toNat=0),ϴ,Θ, toUInt32_toUInt64,aJ _ _ _ А] .rename_i j have v:(aP d e)а≠0:=λl=>j (by simp[<- ο,l]) split .rename_i l have q:(aP d e)а<2^32:=by have:=congrArg kY (beq_iff_eq.mp l);simp at this r;omega rw[toUInt32_toUInt64];exact ez _ _ _ 32 _ (iD _ _ q) g Б (by simp;omega) .rename_i l have u:2^32<=(aP d e)а:=by by_contra x;apply l;simp[<- ο];simp at r;omega rw[toUInt32_toUInt64];exact ez _ _ _ 64 _ (iE _ _) g Б (by simp;omega) lemma aZ (n:о) (e g:о-> kg) (l m B:Д) (j:aB n e g) (d:af n e g=au l m*2^Bа) (h:ar l m B<Ж):lJ n e g=(ar l m B)й:=by obtain ⟨q,r,p⟩:=di l m B h;have o:af n e g≠0:=by rw[d];exact As q В rw[bO n e g j o,p];refine lC _ _ _ _ o ?_;rw[toRat_ofIntDyadic,d];push_cast;rw[Ae AM,AA];field_simp @[inline] def aj (N:Д):Д:=(N+(0x3FFFFFFFFF:Д)+((N>>>39)&&&1))>>>39 @[inline] def a9 (lb v B:Д):Д:= let m:=aD v v let L:=ak m let E:=L+B-172 if m-lb<0x8000000000000000-lb/\E<253 then ((v>>>63)<<<31)+((E<<<23)+aj (m<<<(62-L))) else Ж @[inline] def bM (hi lo B:Д):Д:= let r:=if hi=(0:Д)-(lo>>>63) then a9 1 lo B else Ж if r=Ж then ar hi lo B else r lemma gc (n:у) (e f:Е): (cZ n e f)г=(if n then 2^31 else 0)+eг%2^8*2^23+fг%2^23:=by have h:=Ν fг (А:0<2^23) have j:=Ν eг (А:0<2^8) have g:((e&&&255)<<<23)г=2^23*(eг%2^8):=by rw[lu,Ο,show (255:Е)г=2^8-1 from rfl, ι,ν,Τ] exact β (by simp;omega) have d:((e&&&255)<<<23 ||| (f&&&8388607))г=2^23*(eг%2^8)+fг%2^23:=by rw[m8,g,Ο,show (8388607:Е)г=2^23-1 from rfl, ι,<- Ϟ h] unfold cZ;rw[UInt32.or_assoc];cases n .simp only[ξ,ite_false,UInt32.zero_or,d];omega .simp only[ite_true,m8,d] rw[show (0x80000000:Е)г=2^31*1 from rfl,<- Ϟ А];omega lemma bg (n:у) (N g:Д) (o:2^62<= Nа) (p:Nа<2^63) (w:110<= gа) (v:gа<363): (an n N g)г=(if n then 2^31 else 0)+((gа-110)*2^23+(aj N)а) /\ 2^23<=(aj N)а/\(aj N)а<=2^24:=by have l:(N>>>39)а=Nа/2^39:=by simp[γ] have j:((N>>>39)&&&1)а=Nа/2^39%2:=by simp[l,ma] have m:(aj N)а=Nа/2^39+if 2^38omega have d:2^23<= Nа/2^39/\Nа/2^39<2^24:=by clear*-o p;omega have e:2^23<=(aj N)а/\(aj N)а<=2^24:=by rw[m];clear*-d;split<;>omega have h:(aW N (62-23))а=(aj N)а:=by have u:(N&&&0x7FFFFFFFFF)а=Nа%2^39:=by rw[Β];exact ι _ 39 rw[m];show (c6 N 39)а=_;unfold c6 simp only[show ((1:Д)<<<39)-1=0x7FFFFFFFFF from rfl,show (1:Д)<<<(39-1)=0x4000000000 from rfl,BB,θ,ζ,u,j,l,Az kY,j9] clear*-d;split_ifs<;>omega have q:ak N=62:=by rw[aA];apply ο.mp;rw[show N.log2а=Nаж from rfl,lQ А];simp;omega refine ⟨?_,e⟩;unfold an;have r:(N==0)=false:=by simp[<- ο];omega simp only[q,r,show ¬62+g<172 by simp[θ];omega,(Б:¬(62:Д)<23), ite_false,ξ] generalize aW N (62-23)=R at h⊢;have t:2^23<= Rа/\Rа<=2^24:=by rw[h];exact e rw[<- h];clear l j m h q o p d e cases n<;>split_ifs<;>simp (disch:=first | omega | (simp[ε];omega)) only[AO, <- ο,BB,θ,gc,cW,ϣ, k4,ζ,j9,β,χ,ite_true, ite_false,ξ,not_true_eq_false] at*<;>omega lemma bJ (n:у) (M σ:Д) (e:Mа≠0) (d:σа<=506): an n M σ=kS ((if n then-(Mа:п) else Mа)*2^σа) (-298) false:=by rw[aJ _ _ _ d];refine (lC _ _ _ _ (As (by split<;>omega) В) ?_).symm cases n<;>simp[n6,kT,Ae]<;>field_simp lemma fG (v:Д):(v>>>63=0/\vа<2^63)\/(v>>>63=1/\2^63<= vа):=by have:=v.toNat_lt;simp only[<- ο,ψ];simp[γ];omega lemma dR (p v B:Д) (r:1<= pа) (g:pа<=2^63) (h:a9 p v B≠Ж): pа<=(aD v v)а/\(aD v v)а<2^63/\110<= Bа/\Bа<=424 /\ a9 p v B=(an (v>>>63!=0) (aD v v) B)м:=by unfold a9 at h⊢;dsimp only at h⊢;split at h .rename_i E rw[AE E];obtain ⟨F,q⟩:=E;generalize aD v v=m at F q⊢ have j:pа<= mа/\mа<2^63:=by have:=m.toNat_lt;simp[θ,Η] at F;omega have o:mа≠0:=А;have r:(ak m)а=mаж:=by rw[aA];rfl have t:=Ϩ o;have g:=@ό mа;have A:=(lK o).2 j.2;generalize ak m=L at r q⊢;generalize mаж=l at r t g A have x:(L+B-172)а=l+Bа-172/\172<= l+Bа/\l+Bа<425:=by rw[θ] at q;simp only[Η,ζ,r] at q⊢;have:=B.toNat_lt;simp at q⊢;omega refine ⟨j.1,j.2,А,А,?_⟩ have D:(62-L)а=62-l:=by simp[Η,r];omega have z:mа*2^(62-l)<2^63:= AJ (Ξ g В) (by rw[<- AG];exact Ε Г А) have w:(m<<<(62-L))а=mа*2^(62-l):=by rw[Α,D,ν,β (by omega:62-l<64),β А] have y:2^62<= mа*2^(62-l):= Ag (A7 (by rw[<- AG];congr 1;omega)) (μ _ t) have u:(B-(62-L))а=Bа-(62-l):=by rw[χ _ _ (by rw[ε,D];omega),D] obtain ⟨K,M,N⟩:=bg (v>>>63!=0) (m<<<(62-L)) (B-(62-L)) (w ▸ y) (w ▸ z) (by rw[u];omega) (by rw[u];omega) rw[<- ο,ϒ] have G:an (v>>>63!=0) m B=an (v>>>63!=0) (m<<<(62-L)) (B-(62-L)):=by rw[bJ _ m B o А,bJ _ (m<<<(62-L)) (B-(62-L)) (by rw[w];positivity) (by rw[u];omega),w,u];congr 1 obtain ⟨d,J⟩:∃d,Bа=62-l+d:=⟨Bа-(62-l),А⟩ rw[J,ϰ];push_cast;split<;>ring rw[G,K,u] have H:((v>>>63)<<<31)а=(if (v>>>63!=0) then 2^31 else 0):=by rcases fG v with ⟨e,-⟩ | ⟨e,-⟩<;>rw[e]<;>rfl have I:((L+B-172)<<<23)а=(l+Bа-172)*2^23:=by rw[Α,x.1];simp only[j9,kp,ν];exact β А rw[ζ,ζ,H,I];split<;>omega .exact absurd rfl h lemma eT (d v B:Д) (o:1<= dа) (j:dа<=2^63) (h:a9 d v B≠Ж): a9 d v B=ar ((0:Д)-(v>>>63)) v B:=by obtain ⟨m,-,-,p,e⟩:=dR d v B o j h;rw[e];have l:v≠0:=by rintro rfl;exact absurd m (by show ¬dа<=0;omega) have g:¬B>442:=by simp[θ];omega symm;unfold ar aP aD;rcases fG v with ⟨e,-⟩ | ⟨e,-⟩ .simp[e,l,g] .rw[e,show (0:Д)-1=0xFFFFFFFFFFFFFFFF from rfl] simp[l,g,show (0xFFFFFFFFFFFFFFFF:Д)>>>63=1 from rfl, show ~~~(0xFFFFFFFFFFFFFFFF:Д)=0 from rfl] lemma dQ (g d B:Д):bM g d B=ar g d B:=by unfold bM;dsimp only;by_cases e:g=(0:Д)-(d>>>63) .rw[AE e];split .rfl .rename_i h;rw[e];exact eT 1 d B Б Б h .rw[AD e,AE rfl] end Core open Core lemma cf (w:kg):ky (k7 w)=w:=by apply Ζ.mp;simp only[ky,k7,Model.toNatBits,nN,k4];exact β w.toBitVec.isLt lemma aR (z:Model lq):k7 (ky z)=z:=by have h:z.toNatBits<2^32:=mb z;simp only[k7,ky,kt,k4,β h];exact my z namespace Dense lemma ae {k n:ф} (h:ksplit<;>push_cast<;>omega @[inline] def bT (x:Е):Е:=x&&&0x7FFFFFFF lemma ck (x:Е):(bT x)г=xг%2^31:=by unfold bT;rw[Ο];exact ι _ 31 lemma cm (x:Е):(ki x)г=(bT x)г/2^23:=by have:(ki x)г=xг/2^23%2^8:=by unfold ki;rw[Ο,ϓ];simp only[md,kp,γ];exact ι _ 8 rw[this,ck,show 2^31=2^23*2^8 by norm_num,Nat.mod_mul_right_div_self] lemma eP (x:Е):ki x=0↔(bT x)г<2^23:=by rw[<- Ζ,cm];simp;try omega lemma jp (x:Е):kf x=(bT x)г/2^23-1:=by have:=cm x;unfold kf;split<;>rename_i h .have:=(eP x).mp h;omega .have:=mt (eP x).mpr h;omega lemma bc (x:Е):kf x=(ki x)г-1:=by rw[jp,cm] lemma jz (w:Е):wг/2^23=(ki w)г+256*(wг/2^31):=by rw[cm,ck];have:=w.toNat_lt;omega lemma bU (x:Е):(ki x)г<256:=by rw[cm,ck];omega lemma jm (x:Е) (h:(bT x)г<0x7F800000):ki x≠255:=by intro e;have:=cm x;rw[e] at this;simp at this;omega lemma jn (w:Е):(w&&&8388607)г=wг%2^23:=by rw[Ο];exact ι _ 23 lemma eG (w:Е): |sv w| <2^24:=by have:=kD w;unfold sv;split<;>simp<;>omega def lz (y n:Д):Д:=if y=0 then n else lz (y>>>1) (n+1) termination_by yа decreasing_by have:yа≠0:=λe=>by simp_all[<- ο] rw[ψ];simp[γ];omega abbrev bl (k:о):о:=if k=0 then 0 else kж+1 lemma fq (y:Д):bl yа<=64:=by unfold bl;split;. omega rename_i h;have:=(lK h).mpr y.toNat_lt;omega lemma d0 (y:Д):(y>>>1)а=yа/2:=by rw[ψ];simp[γ] lemma dn (k:о):bl (k/2)=kж:=by unfold bl;rw[Nat.log2_def k];by_cases d:2<= k .rw[AD А,AE d] .rw[AE А,AD d] lemma cp (y n:Д) (h:nа+bl yа<=64):(lz y n)а=nа+bl yа:=by rw[lz];by_cases d:y=0 .rw[AE d];subst d;simp .rw[AD d] have g:yа≠0:=λe=>d (ο.mp (by simpa using e)) have l:bl yа=bl (yа/2)+1:=by rw[dn];simp[bl,g] have j:(n+1)а=nа+1:=by rw[ζ];simp;omega rw[cp (y>>>1) (n+1) (by rw[j,d0];omega),j,d0];omega termination_by yа decreasing_by rw[d0];omega @[inline] def lg (x:Д):Д:=lz (x>>>1) 0 lemma iI (x:Д):lg x=x.log2:=by apply ο.mp;rw[lg,cp _ _ (by have:=fq (x>>>1);simpa using this),d0,dn,Ϗ,Θ];rfl @[inline] def cV (lb v B:Д):Д:= let m:=Core.aD v v let L:=lg m let E:=L+B-172 if m-lb<0x8000000000000000-lb/\E<253 then ((v>>>63)<<<31)+((E<<<23)+Core.aj (m<<<(62-L))) else Ж lemma ek:cV=a9:=by funext d v B;simp only[cV,a9,aA,iI] @[inline] def bV (hi lo B:Д):Д:= let r:=if hi=(0:Д)-(lo>>>63) then cV 1 lo B else Ж if r=Ж then Core.ar hi lo B else r lemma dh:bV=bM:=by funext d e B;simp only[bV,bM,ek] lemma cu {k:ф} {a:р Е} (h:k>>1>>>(63-s))+(if l'simp only[j9]<;>omega @[specialize] def jh (fa fb:о-> с) (n t:о) (B:Д):Д:= if t с) (n:о) (B:Д) (t:о) (pH pL nH nL:Д):Д:= if tsplit<;>push_cast<;>omega lemma fj (d g:о-> kg) (n:о) (B:Д) (hn:n<2^18): ∀k t (r u o p:Д),n-t=k-> t<= n-> aB t d g -> rа*2^64+uа<= t*2^108-> oа*2^64+pа<= t*2^108 -> af t d g=(((rа*2^64+uа:о):п)-((oа*2^64+pа:о):п))* 2^Bа -> df d g n B t r u o p<Ж-> lJ n d g=(df d g n B t r u o p)й:=by intro k;induction k with | zero=> intro t r u o p hk ht S I G J j;obtain rfl:t=n:=А;rw[df,AD А] at j⊢;exact aZ _ _ _ _ _ _ S (by rw[J,j6 _ _ _ _ А А]) j | succ k ih=> intro t r u o p hk ht S I G J j;have X:t(Nat.lt_succ_iff_lt_or_eq.mp E).elim (S s) λe=>e ▸ ⟨K,M⟩ have v:kl (d t)*kl (g t)<2^48:= (ϗ (kD _) (kD _)).trans_eq Г have U:(mW (d t)*mW (g t))а=kl (d t)*kl (g t):=by rw[ύ,ag,ag,β (v.trans Г)] have D:=aK t d g;have m:t*2^108<=(t+1)*2^108:=μ _ t.le_succ;split at j .rename_i F rw[AE F];have N:kl (d t)*kl (g t)=0:=by rw[<- U,beq_iff_eq.mp F];rfl refine ih (t+1) r u o p y z x (I.trans m) (G.trans m) ?_ j rw[D,J,show tm (d t) (g t)=0 by unfold tm sv;rcases Nat.mul_eq_zero.mp N with h | h<;>simp[h], Ax] rename_i F;rw[AD F];obtain ⟨hB,O⟩:=hw λh=>F (by simp[h]) have al:=nX _ K;have as:=nX _ M have Q:(iW (d t)+iW (g t))а=kf (d t)+kf (g t):=by rw[ζ,am,am,β А] rw[Q] at hB have E:(iW (d t)+iW (g t)-B)а=kf (d t)+kf (g t)-Bа:=by rw[χ _ _ (by rw[ε,Q];omega),Q] rw[E] at O have l:(kl (d t)*kl (g t))*2^(kf (d t)+kf (g t)-Bа)<=2^108:= (ϩ v.le (Ε Г (by omega:_<=60))).trans_eq Г have W:(2:п)^(kf (d t)+kf (g t))=2^(kf (d t)+kf (g t)-Bа)*2^Bа:=by rw[<- AG];congr 1;omega generalize w:(kl (d t)*kl (g t))*2^(kf (d t)+kf (g t)-Bа)=T at l have A:tm (d t) (g t)=(if kM (d t)==kM (g t) then (T:п) else-T)*2^Bа:=by rw[<- w];unfold tm sv;rw[W];cases kM (d t)<;>cases kM (g t)<;>simp<;>push_cast<;>ring have V:=λH L (ah:Hа*2^64+Lа<= t*2^108)=>ff H L _ _ (by rw[E];omega) (by rw[U,E,w];omega) rw[U,E,w] at V;cases hg:(kM (d t)==kM (g t))<;>simp only[hg,ite_true,ite_false,ξ] at A j⊢ .have q:=V o p G refine ih (t+1) r u _ _ y z x (I.trans m) (by rw[q];exact Υ t _ ▸ Nat.add_le_add G l) ?_ j rw[D,J,q,A];push_cast;ring .have q:=V r u I refine ih (t+1) _ _ o p y z x (by rw[q];exact Υ t _ ▸ Nat.add_le_add I l) (G.trans m) ?_ j rw[D,J,q,A];push_cast;ring @[inline] def fP (n:о) (fa fb:о-> с):с:= let r:=if n<262144 then df fa fb n (jh fa fb n 0 1023) 0 0 0 0 0 else Ж if r<Ж then rй else dotOf n fa fb lemma bL (n:о) (d e:о-> kg):fP n d e=lJ n d e:=by unfold fP;dsimp only;by_cases g:n<262144 .rw[AE g];split .exact (fj d e n _ А _ 0 0 0 0 0 rfl А (λ_ h=>absurd h А) (by simp) (by simp) (by simp[af]) ‹_›).symm .rfl .rw[AD g,AD Б] @[noinline] def b7 (n:о) (relu:у) (X W b:@& р с) (xo s j:о):с:= act relu (fP (n+1) (λt=>if tif trfl lemma gA (x y:т) (d:fv x) (e:fv y): kj (x+y).toModel=nC (kj x.toModel) (kj y.toModel):=by change kj (pe x.toModel y.toModel)=_;rw[pe,mN] have h:=Model.add_eq_ofModel_add_of_isFinite (fmt:=ka) Б (kj x.toModel) (kj y.toModel) (by rw[ϔ];exact (ft x).1 d) (by rw[ϔ];exact (ft y).1 e) rw[ϔ,ϔ] at h;exact h.symm lemma pm (E:п) (e:E<=971):(2:ℝ)^E<= kU (me ka):=by have d:FloatFormat.binary64.maxNormalExponent-Int.ofNat FloatFormat.binary64.fracWidth=971:=Б have h:=Ϫ ka false 1 E Б (by rw[d];exact e) simp only[ξ,ite_false,nY,one_mul] at h;change |(2:ℝ)^E| <= _ at h simpa only[AR (zpow_pos (by norm_num:(0:ℝ)<2) E)] using h open FloatLib.Floats.Formats.Flocq in lemma re (x:ℝ) (E:п) (g:-1021<= E) (e: |x| <(2:ℝ)^E): |Model.roundAt ka x-x| <= (2:ℝ)^(E-53)/2:=by by_cases d:x=0 .subst x;rw[mf];simp only[A5,abs_zero];positivity have h:magnitude kq x<= E:=magnitude_le_of_abs_lt_bpow _ x E d e;apply (Model.abs_roundAt_sub_le ka x).trans;apply div_le_div_of_nonneg_right _ Г;change ulp kq (Model.fexpOf ka) x<=(2:ℝ)^(E-53);rw[ulp.of_ne_zero _ _ x d];change (2:ℝ)^(max (magnitude kq x-53) (-1074))<=(2:ℝ)^(E-53);apply AI Г;omega lemma gO (x y:т) (d:fv x) (e:fv y) (j: |rv x+rv y| <= kU (me ka)): fv (x+y)/\rv (x+y)=mL ka (rv x+rv y):=by have h:=gA x y d e have g:=Model.isFinite_add_of_abs_toReal_add_le_posMaxFinite (kj x.toModel) (kj y.toModel) Б d e j refine ⟨by unfold fv;rw[h];exact g,?_⟩ unfold rv;rw[h];exact lW _ _ Б d e g lemma gP (x y:т) (l:fv x) (m:fv y) (E:п) (j:-1021<= E) (d:E<=971) (e: |rv x+rv y| <(2:ℝ)^E): fv (x+y) /\ |rv (x+y)-(rv x+rv y)| <= (2:ℝ)^(E-53)/2:=by obtain ⟨g,h⟩:=gO x y l m (e.le.trans (pm E d));exact ⟨g,by rw[h];exact re _ E j e⟩ lemma rx (d:ku) (l:d.significand<2^53) (g:-1074<= d.exponent) (e: |d.toReal| <= (2:ℝ)^(971:п)): mL ka d.toReal=d.toReal:=by obtain ⟨h,j⟩:=lc ka Б d d.significand 0 (by simp) l g (e.trans (pm 971 AV)) rw[<- ϐ _ Б d h,j] lemma ji (x y:т) (o:fv x) (p:fv y) (d:ku) (g:d.toReal=rv x+rv y) (m:d.significand<2^53) (l:-1074<= d.exponent) (e: |d.toReal| <= (2:ℝ)^(971:п)): fv (x+y)/\rv (x+y)=rv x+rv y:=by obtain ⟨h,j⟩:=gO x y o p (by rw[<- g];exact e.trans (pm 971 AV));exact ⟨h,by rw[j,<- g];exact rx d m l e⟩ lemma dr (i:Int64) (e:iнк<2^53):fv i.toFloat/\rv i.toFloat=iн:=by have g:kj i.toFloat.toModel= kd ka (ks iн 0):=by have h:=lx i;rw[mz] at h;rw[h,<- Model.ofModel_ofInt_eq_intToFloat ka Б];exact Model.ofModel_ofInt_eq_roundDyadic ka Б _ have d:(ks iн 0).toReal=iн:=by rw[<- ϙ,mY];simp obtain ⟨j,l⟩:=lc ka Б (ks iн 0) iнк 0 (by simp[ks]) e (by simp[ks];decide) (by rw[d];refine Ag ?_ (pm 971 AV) calc |(iн:ℝ)| <= (2:ℝ)^(53:о):=by rw[<- lX,ϸ];exact_mod_cast e.le _=(2:ℝ)^(53:п):=(AA _ _).symm _<=(2:ℝ)^(971:п):=AI Г Г) exact ⟨by unfold fv;rw[g];exact j,by unfold rv;rw[g,l,d]⟩ lemma jq (x y:т):kj (x*y).toModel= nO ka (kF kC x.toModel.unpack y.toModel.unpack):=by change kj (pf x.toModel y.toModel)=_;rw[pf,mN] lemma ip (b:BitVec 64) (s:nZ) (m:о) (e:п) (h:0< m) (d:ko kC b=.finite s m e h): 2^52<= m\/e=-1074:=by revert d;unfold ko;dsimp only;split .split<;>intro d<;>cases d .split .split .intro d;cases d .rename_i l _ intro d;injection d with _ _ j;right;rw[<- j,l];decide .intro d;injection d with _ g _ left;rw[<- g,BitVec.toNat_append];exact Ag Б Nat.left_le_or lemma i0 (x y:т) (G:fv x) (H:fv y) (A: |rv x*rv y| <= (2:ℝ)^(971:п)): fv (x*y)/\rv (x*y)=mL ka (rv x*rv y):=by have u:=(ft x).1 G;have v:=(ft y).1 H;have E:x.toModel.unpack=ko kC x.toModel.toBits.toBitVec:=rfl;have F:y.toModel.unpack=ko kC y.toModel.toBits.toBitVec:=rfl;rw[jb x,jb y] at A⊢;unfold fv rv;rw[jq];generalize x.toModel.unpack=X at u E A⊢;generalize y.toModel.unpack=Y at v F A⊢;cases X<;>cases Y<;>simp only[nQ,ξ] at u v case finite.finite m l g z o p h r=> have w:=ip _ m l g z E.symm;have B:=ip _ o p h r F.symm have t:g+h<= Float.Model.Format.binary64.targetExponent (kz (l*p) (g+h)):=by change g+h<= max ((A9 (l*p):п)+1+(g+h)-53) (-1074);apply le_max_iff.2;rcases w with w | w<;>rcases B with B | B .left;have:=(li В).2 (Ag w (mO l r));omega .left;have:=(li В).2 (Ag w (mO l r));omega .left;have:=(li В).2 (Ag B (mZ p z));omega .right;omega let q:ku:=⟨mg (m*o),l*p,g+h⟩;have D:Model.modelSign (mg (m*o))=m*o:=by cases m<;>cases o<;>rfl have e:nO ka (kF kC (.finite m l g z) (.finite o p h r))=kd ka q:=by rw[kF,Model.roundWithAccuracy_exact_eq_round_of_le_targetExponent _ _ _ _ t] simp only[kd,show FloatFormat.binary64.isIEEE=true from rfl,ite_true,Model.ieeeRoundDyadic, q,D] rfl have d:q.toReal=lL (.finite m l g z)*lL (.finite o p h r):=by cases m<;>cases o<;>simp only[q,ly,kT, Model.unpackedToReal_finite,mg] all_goals simp[kB,kq,lE, AL (by norm_num:(2:ℝ)≠0)]<;>push_cast<;>ring have j:=Ϝ ka Б q (by rw[d];exact A.trans (pm 971 AV)) rw[e];exact ⟨j,by rw[ϐ _ Б q j,d]⟩ all_goals simp only[kF,Model.isFinite_ofModel_zero ka Б, Model.toReal_ofModel_zero ka Б,Model.unpackedToReal_zero,mP,mul_zero,and_self, mf] lemma bF (s:у) (m:о) (e:п): (⟨s,m,e⟩:ku).toReal=(if s then-(m:ℝ) else m)*(2:ℝ)^e:=by simp only[ly,mE];split<;>simp def pw:о-> т | 0=>(1:Int64).toFloat | k+1=>let p:=pw k;p+p lemma i8 (k:о) (g:k<=900):fv (pw k)/\rv (pw k)=(2:ℝ)^k:=by induction k with | zero=>have:=dr 1 Б;simp only[pw];exact ⟨this.1,by rw[this.2];simp⟩ | succ k e=> obtain ⟨f,v⟩:=e А have d:(⟨false,1,((k+1:о):п)⟩:ku).toReal=(2:ℝ)^(k+1):=by rw[bF];simp only[ξ,ite_false,nY,one_mul];exact AA 2 (k+1) have:=ji (pw k) (pw k) f f _ (by rw[d,v,pow_succ];ring) (show (1:о)<2^53 by norm_num) (А:(-1074:п)<=((k+1:о):п)) (by rw[d,AR В,<- AA];exact AI Г А) simp only[pw];exact ⟨this.1,by rw[this.2,v,pow_succ];ring⟩ def nm:т:=(-1:Int64).toFloat def P:FloatArray:=⟨Aj (n:=512) λi=>if iз<256 then pw (iз-1) else nm*pw (iз-257)⟩ lemma bY:Pд=512:=by simp[P,kH] lemma iw (i:ф) (h:iб>>23)г=wг/2^23:=by rw[ϓ];simp[γ] @[inline] def dw (w:Е):т:= (Core.mW w).toInt64.toFloat*P.uget (w>>>23).toUSize (by rw[bY,aC,c9];have:=w.toNat_lt;omega) lemma aV (z e:п):(mD z e).toReal=(z:ℝ)*(2:ℝ)^e:=by rw[<- ϙ,toRat_ofIntDyadic];push_cast;rfl lemma aQ (x y:т) (o:fv x) (p:fv y) (z e:п) (g:rv x*rv y=(z:ℝ)*(2:ℝ)^e) (m:zк<2^53) (l:-1074<= e) (d: |(z:ℝ)*(2:ℝ)^e| <= (2:ℝ)^(971:п)): fv (x*y)/\rv (x*y)=(z:ℝ)*(2:ℝ)^e:=by obtain ⟨h,j⟩:=i0 x y o p (by rw[g];exact d) have:=rx (mD z e) m l (by rw[aV];exact d) rw[aV] at this;exact ⟨h,by rw[j,g,this]⟩ lemma ce (w:Е):(sv w)к<2^24:=by have:=kD w;unfold sv;split<;>simp<;>omega lemma ca (a b c:о) (d:a+b<= c) (h:c<=971) (z:п) (e:zк<2^a): |(z:ℝ)*(2:ℝ)^(b:п)| <= (2:ℝ)^(971:п):=by rw[Ah,AR (by positivity:(0:ℝ)<2^(b:п)),AA] have g: |(z:ℝ)| <= 2^a:=by rw[<- lX,ϸ];exact_mod_cast e.le calc |(z:ℝ)| *2^b<=2^a*2^b:=by gcongr _=2^(a+b):=by rw[AG] _<=2^971:=AS Г А _=(2:ℝ)^(971:п):=Г lemma mV (w:Е):fv (mW w).toInt64.toFloat/\rv (mW w).toInt64.toFloat=(kl w:п):=by have:=kD w have d:(mW w).toInt64н=kl w:=by rw[show (mW w).toInt64н=ac (mW w) from rfl,ay,ag];split<;>omega rw[<- d];exact dr _ (by rw[d];simp;omega) lemma qV (w:Е) (h):fv (P.uget (w>>>23).toUSize h) /\ ∃σ:п,σ*kl w=sv w/\σк=1/\rv (P.uget (w>>>23).toUSize h)=σ*2^kf w:=by have:=bU w;have:=w.toNat_lt;have d:=ax w;obtain ⟨g,j⟩:=i8 (kf w) (by rw[bc];omega) rw[iw,aC,show (w>>>23)г=(ki w)г+256*(wг/2^31) by rw[c9,jz]] unfold sv;split .rw[show (ki w)г+256*(wг/2^31)-1=kf w by rw[bc];omega] exact ⟨g,1,by rw[AD (by rw[d];omega)];ring,rfl,by rw[j];push_cast;ring⟩ .rw[show (ki w)г+256*(wг/2^31)-257=kf w by rw[bc];omega] have e:=dr (-1) Б;rw[(Б:(-1:Int64)н=-1)] at e have:fv (nm*pw (kf w))/\rv (nm*pw (kf w))=((-1:п):ℝ)*2^((kf w:о):п):= aQ _ _ e.1 g (-1) (kf w) (by rw[e.2,j,AA]) Б А (ca 1 _ 971 (by rw[bc];omega) AV _ Б) exact ⟨this.1,-1,by rw[AE (d.mpr А)];ring,rfl,by rw[this.2,AA]⟩ lemma dp (w:Е) (o:ki w≠255):fv (dw w)/\rv (dw w)=(sv w:ℝ)*2^kf w:=by unfold dw;obtain ⟨e,g⟩:=mV w;obtain ⟨h,σ,l,j,m⟩:=qV w (by rw[bY,aC,c9];have:=w.toNat_lt;omega) have d:((kl w:п)*σ)к<2^24:=by rw[ϱ,j];simpa using kD w have:=aQ _ _ e h _ (kf w) (by rw[g,m,AA];push_cast;ring) (A6 d Г) А (ca 24 _ 971 (by rw[bc];have:=bU w;omega) AV _ d) exact ⟨this.1,by rw[this.2,AA,mul_comm (kl w:п),l]⟩ lemma ey (x w:Е) (j:ki x≠255) (h:ki w≠255): fv (dw x*dw w)/\rv (dw x*dw w)=(tm x w:ℝ):=by obtain ⟨e,l⟩:=dp x j;obtain ⟨g,m⟩:=dp w h have d:(sv x*sv w)к<2^48:=by rw[ϱ];have:=ce x;have:=ce w calc (sv x)к*(sv w)к<2^24*2^24:=ϗ (ce x) (ce w) _=2^48:=Г have:=aQ _ _ e g (sv x*sv w) (kf x+kf w:о) (by rw[l,m,AA,AG];push_cast;ring) (A6 d Г) А (ca 48 _ 971 (by rw[bc,bc];have:=bU x;have:=bU w;omega) AV _ d) refine ⟨this.1,?_⟩;rw[this.2,tm,AA];push_cast;ring @[inline] def eF (b:Д):Д:=(b>>>52)&&&2047 @[inline] def mF (b:Д):Д:=(b&&&0xfffffffffffff) ||| 0x10000000000000 lemma ju (u:Д):(u&&&0x8000000000000000!=0)=(u>>>63!=0):=by apply ϕ.mpr;simp only[AP,Ar,<- ο];rw[Β,ψ];change ¬uа&&&2^63=0↔¬uа>>>63=0;rw[Nat.and_two_pow,γ,ls];have e:uа/2^63<2:=by have h:=UInt64.toNat_lt u;omega rw[β e];by_cases d:uа/2^63=1<;>simp[d]<;>omega lemma gQ (v:т):kj v.toModel=Model.ofFields ka (v.toBits>>>63!=0) (((v.toBits>>>52)&&&2047)а) ((v.toBits&&&0xfffffffffffff)а):=by have d:Model.expField (kj v.toModel)=((v.toBits>>>52)&&&2047)а:=rfl;have e:Model.fracField (kj v.toModel)=(v.toBits&&&0xfffffffffffff)а:=rfl have g:Model.signBit (kj v.toModel)=(v.toBits>>>63!=0):=by rw[<- ju];apply ϕ.mpr;simp only[Model.signBit,AP,Ar];rw[<- UInt64.toBitVec_inj];exact Iff.rfl rw[<- Model.ofFields_signBit_expField_fracField (kj v.toModel),d,e,g] lemma dM (v:т) (e:fv v) (g:¬eF v.toBits=0): rv v=(⟨v.toBits>>>63!=0,(v.toBits&&&0xfffffffffffff)а+2^52, ((eF v.toBits)а:п)-1075⟩:ku).toReal:=by unfold eF at g⊢ have j:((v.toBits>>>52)&&&2047)а<2^11:=by rw[Β];exact AH ϋ Б have l:(v.toBits&&&0xfffffffffffff)а<2^52:=by rw[Β];exact AH ϋ Б have d:((v.toBits>>>52)&&&2047)а≠0:=λh=>g (ο.mp (by simpa using h)) unfold fv at e;unfold rv;rw[gQ] at e⊢;rw[BQ,Model.toDyadic?_ofFields_of_isFinite _ _ _ _ j l e,AD d] simp only[show FloatFormat.binary64.fracWidth=52 from rfl,show FloatFormat.binary64.exponentBias=1023 from rfl, Model.pow2_eq_two_pow] congr 2<;>(try simp only[lM,Nat.cast_add,nr])<;>ring lemma aR (z:Model lq):k7 (ky z)=z:=by have h:z.toNatBits<2^32:=mb z;simp only[k7,ky,kt,k4,β h];exact my z lemma d6 (w:kg) (d:ki w≠255):kU (k7 w)=(sv w:ℝ)*(2:ℝ)^((kf w:п)-149):=by rw[k7,BQ,kx w d];change (mG w).toReal=_;rw[<- ϙ,k6];push_cast;rfl lemma g4 (w:kg) (j:ki w≠255) (m:w&&&0x7FFFFFFF≠0):kU (k7 w)≠0:=by rw[d6 w j];refine As ?_ (zpow_ne_zero _ Г) have l:kl w≠0:=by unfold kl;split .rename_i d have e:=(eP w).mp d;rw[ck] at e;have g:(bT w)г≠0:=λh=>m (Ζ.mp (h.trans UInt32.toNat_zero.symm)) rw[ck] at g;unfold la;rw[jn];omega .omega unfold sv;split<;>simp[l] lemma ia (d e g:ku) (p:d.toReal<= e.toReal) (q:e.toReal<= g.toReal) (E:ky (kd lq d)=ky (kd lq g)) (w:ki (ky (kd lq d))≠255) (F:ky (kd lq d)&&&0x7FFFFFFF≠0) (D: |e.toReal| <= (2:ℝ)^(127:п)): ky (kd lq e)=ky (kd lq d):=by have j:=aR (kd lq d);have m:=aR (kd lq g);rw[<- E] at m;have o:l6 (kd lq d)=true:=by rw[<- j,k7,mA];simpa using w have B:l6 (kd lq g)=true:=by rw[<- m];rw[j];exact o have u:(2:ℝ)^(127:п)<= kU (me lq):=by have h:=Ϫ lq false (2^23) (127-23) Б Б simp only[ξ,ite_false,one_mul] at h;change |((2^23:о):ℝ)*(2:ℝ)^((127:п)-23)| <= _ at h have r:((2^23:о):ℝ)*(2:ℝ)^((127:п)-23)=(2:ℝ)^(127:п):=Г;rwa[r,AR В] at h have v:=Ϝ lq Б e (D.trans u);have G:=ϐ lq Б d o;have A:=ϐ lq Б e v;have H:=ϐ lq Б g B;have y:=ld lq p;have z:=ld lq q;have l:kd lq g=kd lq d:=m.symm.trans j;rw[<- G,<- A] at y;rw[<- A,<- H,l] at z;have x:kU (kd lq e)=kU (kd lq d):=le_antisymm z y have t:kU (kd lq d)≠0:=by rw[<- j];exact g4 _ w F rw[Model.eq_of_toReal_eq_of_nonzero v o x (by rw[x];exact t)] lemma i9 (x:о) (v:x<2^53) (g:x%2^29≠2^28): (aj (kA (x*2^10)))а=(x+2^28)/2^29:=by have d:(kA (x*2^10))а=x*2^10:= υ (by simp only[kL];omega) generalize kA (x*2^10)=N at d;unfold aj simp only[ψ,ζ,Β,d,j9,kp, γ,ma] have o:x*2^10/2^39=x/2^29:=by rw[show (2:о)^39=2^29*2^10 by norm_num,nj _ _ Г] rw[o] obtain ⟨q,r,u,rfl⟩:∃q r,r<2^29/\x=2^29*q+r:= ⟨x/2^29,x%2^29,Ν _ Г,(ϖ x _).symm⟩ have h:(2^29*q+r)/2^29=q:=А;have j:(2^29*q+r)%2^29=r:=А;rw[h];rw[j] at g;have m:=Ν q (show 0<2 by norm_num) have t:q<2^24:=А rw[β (А:(2^29*q+r)*2^10+274877906943<2^64), β (А:(2^29*q+r)*2^10+274877906943+q%2<2^64), show (2^29*q+r)*2^10+274877906943+q%2=(r*2^10+274877906943+q%2)+2^39*q by ring, show 2^29*q+r+2^28=(r+2^28)+2^29*q by ring, lN _ _ Г,lN _ _ Г] have e:(r*2^10+274877906943+q%2)/2^39=(r+2^28)/2^29:=by generalize q%2=p at m;rcases Nat.lt_or_gt_of_ne g with l | l .rw[Ρ А,Ρ А] .rw[Ϯ (k:=1) А А,Ϯ (k:=1) А А] rw[e] @[inline,irreducible] def aN (S:т) (h:Д):Д:= let b:=S.toBits let f:=b&&&0xfffffffffffff let E:=eF b let d:=h+1075-E let g:=(1:Д)<<>>63)<<<31)+(((b&&&0x7FFFFFFFFFFFFFFF)+268435456)>>>29)-0x255000000 else Ж lemma jE (h E f:Д) (y:hа<2^63) (v:Eа<2048) (w:fа<2^52) (m:h+1075-E<=26) (o:E-1195<253) (p:((f+268435456)&&&536870911)-(((1:Д)<<<(h+1075-E))+1)< 536870911-(((1:Д)<<<(h+1075-E))+((1:Д)<<<(h+1075-E)))) (q:f-((1:Д)<<<(h+1075-E))< 0x10000000000000-(((1:Д)<<<(h+1075-E))+((1:Д)<<<(h+1075-E)))): Eа<= hа+1075/\hа+1075-Eа<=26/\1195<= Eа/\Eа<=1447 /\ 2^(hа+1075-Eа)+1<=(fа+2^28)%2^29 /\ (fа+2^28)%2^29+2^(hа+1075-Eа)<2^29 /\ 2^(hа+1075-Eа)<= fа/\fа+2^(hа+1075-Eа)<2^52:=by rw[ε,Η,ζ] at m;rw[θ,Η] at o;simp only[j9] at m o have r:(h+1075-E)а=hа+1075-Eа:=by rw[Η,ζ];simp only[j9];omega have d:hа+1075-Eа<=26:=А have t:((1:Д)<<<(h+1075-E))а=2^(hа+1075-Eа):=by have e:(h+1075-E)а%64=hа+1075-Eа:=by rw[r];omega have u:2^(hа+1075-Eа)<2^64:=ϻ Г А;rw[Α,e,n7,mC,β u] have j:2^(hа+1075-Eа)<=2^26:=Ε Г d;have g:1<=2^(hа+1075-Eа):=l9;have l:∀x:о,x&&&536870911=x%2^29:=λx=>ι x 29 simp only[θ,Η,ζ,Β,t,j9, l] at p q generalize 2^(hа+1075-Eа)=G at g j p q⊢;clear t r;refine ⟨А,d,А,А,А,А,А,А⟩ lemma jF (f G:о) (g:1<= G) (h:f<2^52) (j:G+1<=(f+2^28)%2^29) (l:(f+2^28)%2^29+G<2^29) (d:G<= f) (e:f+G<2^52): (f+2^52-G)%2^29≠2^28/\(f+2^52+G)%2^29≠2^28 /\ (f+2^52-G+2^28)/2^29=2^23+(f+2^28)/2^29 /\ (f+2^52+G+2^28)/2^29=2^23+(f+2^28)/2^29:=by refine ⟨А,А,А,А⟩ lemma jG (b:Д) (m:1195<=(eF b)а): (((b>>>63)<<<31)+(((b&&&0x7FFFFFFFFFFFFFFF)+268435456)>>>29)-0x255000000)а= bа/2^63*2^31+(((eF b)а-1085-110)*2^23+ (2^23+((b&&&0xfffffffffffff)а+2^28)/2^29)):=by have h:=b.toNat_lt have e:(eF b)а=bа/2^52%2^11:=by unfold eF;simp only[Β,ψ,j9,kp, γ];exact ι _ 11 have g:(b&&&0xfffffffffffff)а=bа%2^52:=by rw[Β];exact ι _ 52 have j:(b&&&0x7FFFFFFFFFFFFFFF)а=bа%2^63:=by rw[Β];exact ι _ 63 have l:(b>>>63)а=bа/2^63:=by simp only[ψ,j9,kp,γ] have d:bа%2^63=bа/2^52%2^11*2^52+bа%2^52:=А;have q:bа/2^63<2:=А;rw[e] at m⊢;rw[g];rw[Η,ζ,Α,l,ψ,ζ,j,d];simp only[j9,kp,γ,ν];have o:=Ν (bа/2^52) (show 0<2^11 by norm_num) have p:=Ν bа (show 0<2^52 by norm_num) generalize bа/2^52%2^11=E at* generalize bа%2^52=f at* generalize bа/2^63=s at* clear e g j l d h;omega lemma dO (S:т) (hS:fv S) (h:Д) (hh:hа<2^63) (T:п) (M: |rv S-(T:ℝ)| <= (2:ℝ)^(hа:п)) (as: |(T:ℝ)| <= (2:ℝ)^(425:п)) (hc:aN S h<Ж):T≠0/\(aN S h)й=kS T (-298) false:=by unfold aN at hc⊢;dsimp only at hc⊢;split at hc swap;. exact absurd hc Б rename_i l;rw[AE l];simp only[Λ,AT] at l;obtain ⟨⟨⟨c1,c2⟩,c3⟩,c4⟩:=l have y:(eF S.toBits)а<2048:=by unfold eF;rw[Β];exact AH ϋ Б have v:(S.toBits&&&0xfffffffffffff)а<2^52:=by rw[Β];exact AH ϋ Б obtain ⟨d1,d2,Y,e2,W,X,I,J⟩:=jE h _ _ hh y v c1 c2 c3 c4;clear c1 c2 c3 c4;have Q:=jG S.toBits Y;have w:=dM S hS (λK=>by rw[K] at Y;simp at Y) have A:(S.toBits>>>63)а=S.toBitsа/2^63:=by simp only[ψ,j9,kp,γ] have O:(if (S.toBits>>>63!=0)=true then (2:о)^31 else 0)=S.toBitsа/2^63*2^31:=by have:=S.toBits.toNat_lt split<;>rename_i U<;> simp only[AP,Ar,<- ο,A,Ϗ,n0] at U<;>omega rw[<- O] at Q;have aH:(if (S.toBits>>>63!=0)=true then (2:о)^31 else 0)<=2^31:=by split<;>omega clear O A have d:(eF S.toBits-1085)а=(eF S.toBits)а-1085:= χ _ _ (ε.mpr (by simp only[j9];omega)) have j:(eF S.toBits-1085)а<=506:=by rw[d];omega generalize a3:(eF S.toBits)а=q at d j Q w d1 d2 Y e2 W X I J y;generalize hG:2^(hа+1075-q)=G at W X I J;generalize a5:(S.toBits&&&0xfffffffffffff)а=g at Q w W X I J v;have al:1<= G:=by rw[<- hG];exact l9 obtain ⟨x,t3,k1,k3⟩:=jF g G al v W X I J have V:(kA ((g+2^52-G)*2^10))а=(g+2^52-G)*2^10:= υ (by simp only[kL];omega) have n3:(kA ((g+2^52+G)*2^10))а=(g+2^52+G)*2^10:= υ (by simp only[kL];omega) obtain ⟨F,-,-⟩:=bg (S.toBits>>>63!=0) (kA ((g+2^52-G)*2^10)) (eF S.toBits-1085) (by rw[V];omega) (by rw[V];omega) (by rw[d];omega) (by rw[d];omega) obtain ⟨w3,-,-⟩:=bg (S.toBits>>>63!=0) (kA ((g+2^52+G)*2^10)) (eF S.toBits-1085) (by rw[n3];omega) (by rw[n3];omega) (by rw[d];omega) (by rw[d];omega) rw[i9 _ А x,k1,d] at F;rw[i9 _ А t3,k3,d] at w3 have p:an (S.toBits>>>63!=0) (kA ((g+2^52+G)*2^10)) (eF S.toBits-1085)= an (S.toBits>>>63!=0) (kA ((g+2^52-G)*2^10)) (eF S.toBits-1085):=by apply Ζ.mp;rw[F,w3] have hV:(if (S.toBits>>>63!=0)=true then (2:о)^31 else 0)+((q-1085-110)*2^23+ (2^23+(g+2^28)/2^29))<2^32:=by have:(g+2^28)/2^29<=2^23:=А;have:(q-1085-110)*2^23<=252*2^23:=μ _ А;omega have qv:(((S.toBits>>>63)<<<31)+(((S.toBits&&&0x7FFFFFFFFFFFFFFF)+268435456)>>>29)- 0x255000000)й=an (S.toBits>>>63!=0) (kA ((g+2^52-G)*2^10)) (eF S.toBits-1085):=by apply Ζ.mp;rw[F,ϣ,Q,β hV] have B:ki (an (S.toBits>>>63!=0) (kA ((g+2^52-G)*2^10)) (eF S.toBits-1085))≠255:=by unfold ki;intro U;have o:=congrArg UInt32.toNat U simp only[Ο,ϓ,F,md,kp, γ] at o rw[ι _ 8] at o;have:(g+2^28)/2^29<=2^23:=А;split at o<;>omega have D:an (S.toBits>>>63!=0) (kA ((g+2^52-G)*2^10)) (eF S.toBits-1085)&&&0x7FFFFFFF≠0:=by intro U;have o:=congrArg UInt32.toNat U;simp only[Ο,F,md] at o;rw[ι _ 31] at o;have:(g+2^28)/2^29<=2^23:=А;split at o<;>omega rw[qv];rw[aJ _ _ _ j,V,d] at B D⊢;rw[aJ _ _ _ j,aJ _ _ _ j,V,n3,d] at p;have L:G<= g+2^52:=А;have z:G>>63!=0)=aL at w p B D⊢;generalize rv S=sr at w M;rw[bF] at w have hU:(2:ℝ)^(hа:п)=(G:ℝ)*(2:ℝ)^((q:п)-1075):=by rw[<- hG,Nat.cast_pow,nr,<- AA,<- AL AM];congr 1;omega have r:∀m:о,((m*2^10:о):ℝ)*(2:ℝ)^(((q-1085:о):п)-298)= (m:ℝ)*(2:ℝ)^((q:п)-1075)*2^(-298:п):=by intro m have e:(2:ℝ)^(((q-1085:о):п)-298)*(2:ℝ)^(10:п)= (2:ℝ)^((q:п)-1075)*(2:ℝ)^(-298:п):=by rw[<- AL AM,<- AL AM, show (((q-1085:о):п)-298)+10=((q:п)-1075)+(-298) by omega] have ah:((m*2^10:о):ℝ)=(m:ℝ)*(2:ℝ)^(10:п):=by push_cast;norm_num rw[ah,AX,mul_comm ((2:ℝ)^(10:п)),e,<- AX] have N: |(mD T (-298)).toReal| <= (2:ℝ)^(127:п):=by rw[aV,Ah,AR (by positivity:(0:ℝ)<2^(-298:п))] calc |(T:ℝ)| *2^(-298:п)<=2^(425:п)*2^(-298:п):=by gcongr _=2^(127:п):=by rw[<- AL Г];norm_num have hu:(0:ℝ)<(2:ℝ)^((q:п)-1075):=В;have a0:(0:ℝ)<(2:ℝ)^(-298:п):=В;have H:((Mn-G:о):ℝ)=(Mn:ℝ)-G:=by rw[n4 L] have a4:(G:ℝ) т) (n t:о) (a:т):т:= if t п) (e:п) (B:ℝ) (g:∀tintro _;simpa using d | succ t h=> intro j;rw[Ι,<- add_assoc] calc _<= |(e:ℝ)+∑s∈km t,(z s:ℝ)| + |(z t:ℝ)| :=Ac _ _ _<=((t:ℝ)+1)*B+B:=add_le_add (h А) (g t А) _=(((t+1:о):ℝ)+1)*B:=by push_cast;ring structure A8 where a0:т a1:т a2:т a3:т a4:т a5:т a6:т a7:т local instance:Inhabited A8:=⟨⟨0,0,0,0,0,0,0,0⟩⟩ @[inline] def A8.f (s:A8):о-> т | 0=>s.a0 | 1=>s.a1 | 2=>s.a2 | 3=>s.a3 | 4=>s.a4 | 5=>s.a5 | 6=>s.a6 | _=>s.a7 lemma uk {i k:ф} {S:о} (d:kб<8) (h:iб+8<= S) (e:S<2^32): (i+k)б iб=z+8*tб -> (k8 W X e n F B t i w g j l o p q u v).f r= ao (λs=>X.data[z+8*s+r]!*dw W[eб+s]!) nб tб (A8.f ⟨g,j,l,o,p,q,u,v⟩ r):=by intro m;induction m with | zero=> intro t i w g j l o p q u v E x;have h:¬tby have:=η.mp h;omega rw[k8,AZ h,ao,AD А] | succ m H=> intro t i w g j l o p q u v E x;have h:t (simp only[A8.f];rw[I _ (by simp only[ke];omega),y];simp only[ke]) lemma bf (Y:FloatArray) (v:т):(Y.push v)д=Yд+1:=by rcases Y with ⟨d⟩;simp[FloatArray.push,kH] lemma pg (Y:FloatArray) (v:т) (q:о) (g:q т) (N:о) (Y:FloatArray):FloatArray:= if Yд т) (N:о):∀k (Y:FloatArray),N-Yд=k-> Yд<= N -> (aY f N Y)д=N/\(∀q q(aY f N Y).data[q]! =f q:=by intro k;induction k with | zero=> intro Y l j;rw[aY,AD А];exact ⟨А,λq _=>rfl,λq h d=>absurd d А⟩ | succ k p=> intro Y l j;rw[aY,AE А];have r:=bf Y (f Yд);obtain ⟨m,g,o⟩:=p (Y.push (f Yд)) А А;refine ⟨m,λq e=>?_,λq h d=>?_⟩ .rw[g q А,pg _ _ _ А,AE e] .by_cases e:q=Yд .subst e;rw[g _ А,pg _ _ _ А,AD (AY _)] .exact o q А d lemma jK (v:т) (h:(eF v.toBits)а<2047):fv v:=by unfold fv;rw[gQ] have e:((v.toBits>>>52)&&&2047)а<2^11:=by rw[Β];exact AH ϋ Б have g:(v.toBits&&&0xfffffffffffff)а<2^52:=by rw[Β];exact AH ϋ Б rw[Model.isFinite_ofFields _ _ _ _ e g];have d:FloatFormat.binary64.expAllOnesNat=2047:=Б;unfold eF at h;simp only[show FloatFormat.binary64.encoding=.ieee from rfl,d,AP,Ar];omega lemma iA (v:т) (m:fv v): |rv v| <(2:ℝ)^(((eF v.toBits)а:п)-1022):=by by_cases e:eF v.toBits=0 .have j:(v.toBits&&&0xfffffffffffff)а<2^52:=by rw[Β];exact AH ϋ Б have h:((v.toBits>>>52)&&&2047)а=0:=by unfold eF at e;rw[e];rfl rw[e];unfold rv;rw[gQ,h];simp only[Ϗ,Nat.cast_zero,zero_sub];by_cases d:(v.toBits&&&0xfffffffffffff)а=0 .rw[d,Model.toReal_eq_zero_of_isZero _ (by rw[Model.isZero_ofFields _ _ _ _ Г Г];rfl)] simp only[abs_zero];positivity .rw[Model.toReal_ofFields_subnormal _ _ _ d j,(Б:FloatFormat.binary64.minSubnormalExponent=-1074)] simp only[kB,kq,lE];have g: |(if v.toBits>>>63!=0 then (-1:ℝ) else 1)| =1:=by split<;>simp rw[Ah,Ah,g,one_mul,m0];have l:((v.toBits&&&0xfffffffffffff)а:ℝ)<2^(52:о):=by exact_mod_cast j rw[AR В];push_cast calc ((v.toBits&&&0xfffffffffffff)а:ℝ)*(2:ℝ)^(-1074:п)<2^(52:о)*(2:ℝ)^(-1074:п):=by gcongr _=(2:ℝ)^(-1022:п):=by rw[<- AA,<- AL AM];norm_num .rw[dM v m e,bF] have j:(v.toBits&&&0xfffffffffffff)а<2^52:=by rw[Β];exact AH ϋ Б have g: |(if v.toBits>>>63!=0 then-(((v.toBits&&&0xfffffffffffff)а+2^52:о):ℝ) else (((v.toBits&&&0xfffffffffffff)а+2^52:о):ℝ))| = (((v.toBits&&&0xfffffffffffff)а+2^52:о):ℝ):=by split .rw[A4,Af В] .rw[Af В] rw[Ah,g,AR В] have l:(((v.toBits&&&0xfffffffffffff)а+2^52:о):ℝ)<2^(53:о):=by exact_mod_cast (by omega:(v.toBits&&&0xfffffffffffff).toNat+2^52<2^53) calc _<(2:ℝ)^(53:о)*2^(((eF v.toBits)а:п)-1075):=by gcongr _=_:=by rw[<- AA,<- AL AM];congr 1;push_cast;ring lemma jZ (x y:т) (r:fv x) (t:fv y) (q:fv (x+y)) (E:п) (l:-1074<= E) (u:E<=971) (h: |rv (x+y)| <(2:ℝ)^E): |rv x+rv y| <(2:ℝ)^E:=by have p:=gA x y r t have v:=lW (kj x.toModel) (kj y.toModel) Б r t (by unfold fv at q;rw[<- p];exact q) have j:rv (x+y)=mL ka (rv x+rv y):=by unfold rv;rw[p,v] have m: |(2:ℝ)^E| <= (2:ℝ)^(971:п):=by rw[AR В];exact AI Г u have g:=rx ⟨false,1,E⟩ Г l (by rw[bF];simpa using m) have e:=rx ⟨true,1,E⟩ Г l (by rw[bF];simpa using m) rw[bF] at g e;simp only[ξ,ite_false,ite_true,nY,one_mul,neg_mul] at g e;rw[j] at h;have w:=abs_lt.mp h;by_contra o;push Not at o;rcases le_abs'.mp o with d | d .have:=ld ka d;rw[e] at this;linarith .have:=ld ka d;rw[g] at this;linarith @[specialize] def sT (p:о-> т) (n t:о) (a:т) (m:Д):т×Д:= if trename_i h<;>simp only[θ] at h<;>omega lemma iQ (p:о-> т) (n:о):∀k t a m,n-t=k-> mа<=(sT p n t a m).2а:=by intro k;induction k with | zero=>intro t a m h;rw[sT,AD А] | succ k d=> intro t a m h;rw[sT,AE А];dsimp only;have:=d (t+1) (a+p t) (if m т) (z:о-> п) (e:п) (n K:о) (y:1<= K) (A:K<=1993) (F:∀t t<= n-> fv a -> |rv a-((e:ℝ)+∑s∈km t,(z s:ℝ))| <= t*(2:ℝ)^((K:п)-1076) -> (sT p n t a M).2а<= K -> fv (sT p n t a M).1 /\ |rv (sT p n t a M).1-((e:ℝ)+∑s∈km n,(z s:ℝ))| <= n*(2:ℝ)^((K:п)-1076):=by intro m;induction m with | zero=> intro t a M E G g q h;have:t=n:=А;subst this;rw[sT,AD (AY _)];exact ⟨g,q⟩ | succ m H=> intro t a M E G g q h;have d:t kg) (g:aB n d e) (S:т) (m:fv S) (h:Д) (q:hа<2^63) (o: |rv S-(af n d e:ℝ)| <= (2:ℝ)^(hа:п)) (l: |(af n d e:ℝ)| <= (2:ℝ)^(425:п)) (p:aN S h<Ж): (aN S h)й=lJ n d e:=by obtain ⟨j,r⟩:=dO S m h q _ o l p;rw[r,bO n d e g j] def aE (A:р с) (i:ф) (m:Е):Е:= if h:i>>23)&&&255 aE A (i+1) (if m mг<=(aE A i m)г /\ ∀q,iб<= q-> q(ki A[q]!)г<=(aE A i m)г:=by intro k;induction k with | zero=> intro i m l;have h:¬iby have:=cu h;omega rw[aE,AZ h];exact ⟨AV,λq g d=>absurd d А⟩ | succ k v=> intro i m l;have h:irename_i j<;>simp only[Ϙ] at j<;>omega obtain ⟨t,u⟩:=v (i+1) (if m<(A.uget i (cu h)>>>23)&&&255 then (A.uget i (cu h)>>>23)&&&255 else m) (by rw[ae h];omega) rw[r] at t;refine ⟨А,λq g d=>?_⟩ by_cases o:q=iб .subst o;rw[<- bN A i (cu h)];unfold ki;omega .exact u q (by rw[ae h];omega) d lemma aF (A:р kg) (j:Aвby rw[e] at d;simp at d g;omega,by rw[bc];omega⟩ @[inline] def cC (x:т) (w:Е):т:= (x*P.uget (w>>>23).toUSize (by rw[bY,aC,c9];have:=w.toNat_lt;omega))*(Core.mW w).toInt64.toFloat @[inline] def tq (b:у) (x:т) (w:Е):т:=if b then cC x w else x*dw w lemma jU (x w:Е) (p:ki x≠255) (u:ki w≠255): fv (cC (dw x) w)/\rv (cC (dw x) w)=(tm x w:ℝ):=by unfold cC;obtain ⟨j,q⟩:=dp x p;obtain ⟨l,σ,o,m,r⟩:=qV w (by rw[bY,aC,c9];have:=w.toNat_lt;omega) have d:=kD w;have g:=mV w;have t:kf x+kf w+48<=971:=by rw[bc,bc];have:=bU x;have:=bU w;omega have e:(sv x*σ)к<2^24:=by rw[ϱ,m,Ϻ];exact ce x have h:(sv x*σ*kl w)к<2^48:=by rw[ϱ];calc _<2^24*2^24:=ϗ e (by simpa using d) _=2^48:=Г have a:=aQ _ _ j l (sv x*σ) (kf x+kf w:о) (by rw[q,r,AA,AG];push_cast;ring) (A6 e Г) А (ca 24 _ 971 А AV _ e) have b:=aQ _ _ a.1 g.1 (sv x*σ*kl w) (kf x+kf w:о) (by rw[a.2,g.2];push_cast;ring) (A6 h Г) А (ca 48 _ 971 А AV _ h) exact ⟨b.1,by rw[b.2,tm,AA,AX (sv x),o];push_cast;ring⟩ lemma jV (b:у) (x w:Е) (e:ki x≠255) (d:ki w≠255): fv (tq b (dw x) w)/\rv (tq b (dw x) w)=(tm x w:ℝ):=by unfold tq;split .exact jU x w e d .exact ey x w e d @[specialize] def aM (k:о-> у) (p:о-> т) (n t:о) (a:т):т:= if t т) (n:о):∀m t a,n-t=m-> ao p n t a=aM (λ_=>false) p n t a:=by intro m;induction m<;>intro t a h<;>unfold ao aM .rw[AD А,AD А] .rename_i m d;rw[AE А,AE А,d _ _ А];rfl def xP (X:р с) (n:о):р с:=if n<= Xв then X else Aj (n:=n) λi=>X[iз]! lemma bi (X:р kg) (n:о):n<=(xP X n)в:=by unfold xP;split<;>simp_all lemma iu (X:р kg) (n s:о) (h:s у) (p:о-> т) (z:о-> п) (d:п) (P L n:о) (Q:∀t z t=0) (V:∀t t<= n-> fv a -> |rv a-((d:ℝ)+∑s∈km t,(z s:ℝ))| <= t*((2:ℝ)^(P+L)*2^(-54:п)) -> fv (aM k p n t a) /\ |rv (aM k p n t a)-((d:ℝ)+∑s∈km n,(z s:ℝ))| <= n*((2:ℝ)^(P+L)*2^(-54:п)):=by have K:=dC n z d _ V v have X:(2:ℝ)^L*2^L*2^(-54:п)<=1:=by rw[<- AG,<- AA,<- AL AM];exact zpow_le_one_of_nonpos₀ Г (by push_cast;omega) have q:(0:ℝ)<2^(-54:п):=В;have u:(0:ℝ)<2^P:=В;have r:(0:ℝ)<2^L:=В;intro m;induction m with | zero=> intro t a O S o j;have:t=n:=А;subst this;rw[aM,AD (AY _)];exact ⟨o,j⟩ | succ m y=> intro t a O S o j;have h:t т):(p8 Y (e 0) (e 1) (e 2) (e 3) (e 4) (e 5) (e 6) (e 7))д=Yд+8 /\ ∀q?_⟩ simp (disch:=simp only[bf];omega) only[p8,pg,bf];split_ifs<;>(try rw[pg _ _ _ А])<;>(try split_ifs)<;>first | rfl | omega | (congr 1;omega) @[inline] def ex (X:р с) (v:у) (q:о):т:=dw (if v then X.getD q 0 else 0) lemma gD (X:р kg) (k:о):X.getD k 0=X[k]!:=by unfold Array.getD;split<;>rename_i h .rw[AC X k h];rfl .rw[Ai X k h];rfl @[inline] def ee (X:р с) (nv st q:о) (Y:FloatArray):FloatArray:= p8 Y (ex X (decide (0ex X (decide (r (bx X d e s N b t Y)д=Yд+8*(N-t)/\(∀q τ r<8->(bx X d e s N b t Y).data[Yд+8*(τ-t)+r]! = ex X (decide (r intro t Y o;rw[bx,AZ А];exact ⟨А,λq _=>rfl,λτ r m g=>absurd g А⟩ | succ k y=> intro t Y o;rw[bx,AW А];obtain ⟨j,l⟩:=eM X d e (b+t*s) Y;obtain ⟨w,h,x⟩:=y (t+1) (ee X d e (b+t*s) Y) А refine ⟨by rw[w,j];omega,λq p=>by rw[h q А,l q А,AE p], λτ r m g u=>?_⟩ by_cases v:τ=t .subst v;rw[h _ А,l _ А,AD А];congr 3<;>omega .rw[show Yд+8*(τ-t)+r=(ee X d e (b+t*s) Y)д+8*(τ-(t+1))+r by rw[j];omega] exact x τ r А g u lemma e0 (c:о):(kb c)д=0:=by simp[kb,kH] def cg (t:у) (X:р с) (R n rb:о):FloatArray:= bx X (R-8*rb) (if t then 1 else n) (if t then R else 1) n (if t then 8*rb else 8*rb*n) 0 (AK (8*n)) @[inline] def yR (XT:р FloatArray) (n ow:о) (W b:р с) (hs:Wв<2^32/\8*n<2^32) (hW:ow*n<= Wв) (rb o:о):A8:= let xt:=XT[rb]! let bp:=dw oneW*dw b[o]! if h:xtд=8*n/\o т) (bpf:Unit-> т) (az:Unit-> с):с:= let r:=sT p n 0 (bpf ()) 0 let c:=if 1<= r.2а/\r.2а<=1993/\1076<= r.2а+L then aN r.1 (r.2а+L-1076)е else Ж if c<Ж then act relu cй else az () @[inline] def tf (relu:у) (S:т) (hh:Д) (sl:Unit-> с):с:= let c:=aN S hh if c<Ж then act relu cй else sl () @[inline] def tw (relu:у) (S:т) (hh:Д) (L n:о) (p:о-> т) (bpf:Unit-> т) (az:Unit-> с):с:=tf relu S hh λ_=>tS relu L n p bpf az lemma jf (g:у) (n:о) (d e:о-> kg) (p:о-> т) (h:Unit-> т) (u:Д) (P L:о) (B:Unit-> kg) (K:∀sE s M.le) (E n AV) n AV).trans ?_ have y:(n:ℝ)+1<=2^L:=by have:((n+1:о):ℝ)<=((2^L:о):ℝ):=by exact_mod_cast (by omega:n+1<=2^L) push_cast at this;exact this calc ((n:ℝ)+1)*2^P<=2^L*2^P:=by gcongr _=(2:ℝ)^(((L+P:о):п)):=by rw[AA,AG] _<=(2:ℝ)^(425:п):=AI Г А unfold tw tf tS;dsimp only;split .rename_i w;rw[cw _ _ _ j _ I u (by rw[x];omega) v o w] generalize A:sT p n 0 (h ()) 0=r;split .rename_i t split .rename_i w obtain ⟨m,l⟩:=hO _ _ (tm (d n) (e n)) n r.2а t.1 t.2.1 K n 0 _ 0 rfl А q.1 (by simp[q.2]) (by rw[A]) rw[A,<- F] at l;rw[A] at m have H:((r.2а+L-1076)е)а=r.2а+L-1076:=by rw[ϑ,υ (by simp only[kL];omega)] refine congrArg _ (cw _ _ _ j _ m _ (by rw[H];omega) (l.trans ?_) o w) rw[H] calc (n:ℝ)*(2:ℝ)^((r.2а:п)-1076)<=2^L*(2:ℝ)^((r.2а:п)-1076):=by gcongr _=(2:ℝ)^(((r.2а+L-1076:о):п)):=by rw[<- AA,<- AL AM];exact congrArg (λz:п=>(2:ℝ)^z) А .exact G .rw[AD Б];exact G lemma jg (d:у) (n:о) (g h:о-> kg) (p:о-> т) (e:Unit-> т) (q:Д) (P L:о) (r:Unit-> kg) (z:∀s у) (w:∀t tm (g t) (h t)=0): tw d (aM k p n 0 (e ())) q L n p e r=pj d (lJ (n+1) g h):=by obtain ⟨A,x⟩:=dD k p _ (tm (g n) (h n)) P L n z w (λs F=>u s F.le) (u n AV) y j А n 0 (e ()) rfl А l.1 (by simp[l.2]) have B:(af (n+1) g h:ℝ)= (tm (g n) (h n):ℝ)+∑s∈km n,(tm (g s) (h s):ℝ):=by rw[aK];unfold af;push_cast;ring rw[<- B] at x;have E:(n:ℝ)<=2^L:=by exact_mod_cast (by omega:n<=2^L) refine jf d n g h p e q P L r z l m u y j v o D _ A (x.trans ?_) calc (n:ℝ)*((2:ℝ)^(P+L)*2^(-54:п))<=2^L*((2:ℝ)^(P+L)*2^(-54:п)):=by gcongr _=(2:ℝ)^(((P+2*L:о):п)-54):=by rw[Ae AM,AA,div_eq_mul_inv,<- Aw,<- AX,<- AG];congr 2;omega _<=(2:ℝ)^(qа:п):=AI Г (by rw[o];omega) lemma gg (X:FloatArray) (i:о):X.get! i=X.data[i]!:=by rcases X with ⟨d⟩;rfl lemma f8 (v:т) (r:о):A8.f ⟨v,v,v,v,v,v,v,v⟩ r=v:=by unfold A8.f;split<;>rfl lemma ep (n j:о) (d:о-> kg) (W b:р kg) (h g e P:о) (p:∀q:о,ki (d q)≠255/\kf (d q)<= h) (o:∀q:о,ki W[q]!≠255/\kf W[q]! <= g) (m:∀q:о,ki b[q]!≠255/\kf b[q]! <= e) (l:48+h+g<= P) (r:174+e<= P): aB (n+1) (λt=>if tif tif tif tif tif t?_,λs _=>?_,?_⟩ .dsimp only;split .exact ⟨(p _).1,(o _).1⟩ .exact ⟨Б,(m _).1⟩ .dsimp only;split .exact (fL _ _ h g (p _).2 (o _).2).trans (AS Г l) .exact (fL _ _ 126 e Б (m _).2).trans (AS Г А) .simp only[AY,Ap];exact ey kG b[j]! Б (m _).1 @[inline] def us (a:р с) (ok:у) (p:о) (w:Unit-> с):р с:= if h:ok/\p о-> р с-> р с) (u v:о) (a:р с): р с:= if u(XT[i/8]!).get! (8*s+i%8)*dw W[j*n+s]!) (λ_=>dw oneW*dw b[j]!) λ_=>b7 n relu X W b xo st j @[inline] def pN (t:у) (R C n:о) (relu:у) (X W b:р с) (XT:р FloatArray) (hh:Д) (L:о) (a:р с) (i j:о) (S:т):р с:= us a (decide (itf relu S hh λ_=>sN n relu X W b XT L i j (if t then i else i*n) (if t then R else 1) @[inline] def b8 (t:у) (R n ow:о) (relu:у) (X W b:р с) (hh:Д) (L:о) (hs:Wв<2^32/\8*n<2^32) (hW:ow*n<= Wв) (XT:р FloatArray) (rb o:о) (a:р с):р с:= let s:=yR XT n ow W b hs hW rb o let i:=8*rb pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L (pN t R ow n relu X W b XT hh L a i o s.a0) (i+1) o s.a1) (i+2) o s.a2) (i+3) o s.a3) (i+4) o s.a4) (i+5) o s.a5) (i+6) o s.a6) (i+7) o s.a7 @[inline] def cX (t:у) (R n ow:о) (relu:у) (X W b:р с) (hh:Д) (L:о) (hs:Wв<2^32/\8*n<2^32) (hW:ow*n<= Wв):р с:= l2 ((R+7)/8) ow (b8 t R n ow relu X W b hh L hs hW (Aj (n:=(R+7)/8) λrb=> cg t X R n rbз)) 0 0 (Av (R*ow) 0) lemma j5 (a:р kg) (d:у) (p:о) (w:Unit-> kg):(us a d p w)в=aв:=by unfold us;split<;>simp lemma j4 (a:р kg) (d:у) (p:о) (w:Unit-> kg) (q:о): (us a d p w)[q]?=if d=true/\q=p/\q kg) (g:р kg):∀(e:List (у×о×(Unit-> kg))) (a:р kg) (S:о-> Prop),(∀x∈e,x.1=true-> x.2.1 x.2.2 ()=F x.2.1)-> aв=gв -> (∀q,(a[q]?=g[q]? \/ a[q]?=nR (F q))/\(S q-> q a[q]?=nR (F q))) -> (e.foldl (λa x=>us a x.1 x.2.1 x.2.2) a)в=gв /\ ∀q, ((e.foldl (λa x=>us a x.1 x.2.1 x.2.2) a)[q]?=g[q]? \/ (e.foldl (λa x=>us a x.1 x.2.1 x.2.2) a)[q]?=nR (F q)) /\ ((S q \/ ∃x∈e,x.1=true/\q=x.2.1)-> q (e.foldl (λa x=>us a x.1 x.2.1 x.2.2) a)[q]?=nR (F q)):=by intro e;induction e with | nil=> intro a S _ l m;simp only[mh];exact ⟨l,λq=>⟨(m q).1,λd j=>(m q).2 (d.resolve_right (by simp)) j⟩⟩ | cons x e v=> intro a S t l m;rw[k9] have:=v (us a x.1 x.2.1 x.2.2) (λq=>S q\/x.1=true/\q=x.2.1) (λy o=>t y (List.mem_cons_of_mem _ o)) (by rw[j5,l]) λq=>by rw[j4];split .rename_i h;obtain ⟨r,rfl,u⟩:=h;rw[t x List.mem_cons_self r (l ▸ u)] exact ⟨n8 rfl,λ_ _=>rfl⟩ .rename_i h;refine ⟨(m q).1,λd j=>?_⟩ rcases d with d | ⟨r,rfl⟩ .exact (m q).2 d j .exact absurd ⟨r,rfl,l ▸ j⟩ h refine ⟨this.1,λq=>⟨(this.2 q).1,λd j=>(this.2 q).2 ?_ j⟩⟩ rcases d with d | ⟨y,o,p⟩ .exact nU (nU d) .rcases List.mem_cons.mp o with rfl | o .exact nU (n8 p) .exact n8 ⟨y,o,p⟩ lemma jX (F:о-> kg) (a:р kg) (g:о-> у×о×(Unit-> kg)) (l:∀r,r<8->(g r).1=true->(g r).2.1(g r).2.2 ()=F (g r).2.1): (((kQ 8).map g).foldl (λa x=>us a x.1 x.2.1 x.2.2) a)в=aв /\ ∀q, ((((kQ 8).map g).foldl (λa x=>us a x.1 x.2.1 x.2.2) a)[q]?=a[q]? \/ (((kQ 8).map g).foldl (λa x=>us a x.1 x.2.1 x.2.2) a)[q]?=nR (F q)) /\ ((∃r,r<8/\(g r).1=true/\q=(g r).2.1)-> q (((kQ 8).map g).foldl (λa x=>us a x.1 x.2.1 x.2.2) a)[q]?=nR (F q)):=by have:=jW F a ((kQ 8).map g) a (λ_=>False) (by simp only[List.mem_map,List.mem_range];rintro x ⟨r,d,rfl⟩;exact l r d) rfl λq=>⟨nU rfl,False.elim⟩ exact ⟨this.1,λq=>⟨(this.2 q).1,λ⟨r,d,e,h⟩ j=> (this.2 q).2 (n8 ⟨g r,List.mem_map.mpr ⟨r,List.mem_range.mpr d,rfl⟩,e,h⟩) j⟩⟩ lemma ga (U V:о) (f:о-> о-> р kg-> р kg) (F:о-> kg) (C:о-> о-> о-> Prop) (B:∀u v a,u v(f u v a)в=aв /\ ∀q,((f u v a)[q]?=a[q]? \/ (f u v a)[q]?=nR (F q))/\(C u v q-> q(f u v a)[q]?=nR (F q))) (u v:о) (a:р kg): (∀q,(∃g h,g q a[q]?=nR (F q)) -> (l2 U V f u v a)в=aв /\ ∀q,(∃g h,g q(l2 U V f u v a)[q]?=nR (F q):=by induction u,v,a using l2.induct U V f with | case1 u v a l r w=> intro p;rw[l2,AE l,AE r];obtain ⟨y,x⟩:=B u v a l r obtain ⟨D,E⟩:=w λq ⟨g,h,m,o,z,j⟩ d=>by rw[y] at d;by_cases e:g=u/\h=v .obtain ⟨rfl,rfl⟩:=e;exact (x q).2 j d .rcases (x q).1 with t | t .rw[t];exact p q ⟨g,h,m,o,А,j⟩ d .exact t exact ⟨D.trans y,λq A d=>E q A А⟩ | case2 u v a l r w=> intro p;rw[l2,AE l,AD r];exact w λq ⟨g,h,m,o,z,j⟩ d=>p q ⟨g,h,m,o,А,j⟩ d | case3 u v a l=> intro p;rw[l2,AD l];exact ⟨rfl,λq ⟨g,h,m,o,j⟩ d=>p q ⟨g,h,m,o,А,j⟩ d⟩ lemma gT (U V N:о) (f:о-> о-> р kg-> р kg) (F:о-> kg) (C:о-> о-> о-> Prop) (m:∀u v a,u v(f u v a)в=aв /\ ∀q,((f u v a)[q]?=a[q]? \/ (f u v a)[q]?=nR (F q))/\(C u v q-> q(f u v a)[q]?=nR (F q))) (l:∀q,q ∃u v,uF qз:=by obtain ⟨e,g⟩:=ga U V f F C m 0 0 (lS N 0) λq ⟨r,t,_,_,h,_⟩ _=>А apply mi;intro q;by_cases d:q kg) (w:∀i j,i j tf d ((yR l n h W b u m (i/8) j).f (i%8)) p (λ_=>sN n d X W b l L i j (if t then i else i*n) (if t then R else 1))= F (if t then j*R+i else i*h+j)) (g o:о) (y:o q (b8 t R n h d X W b p L u m l g o a)[q]?=nR (F q)):=by have e:b8 t R n h d X W b p L u m l g o a=((kQ 8).map λr=> (decide (8*g+rtf d ((yR l n h W b u m g o).f r) p λ_=> sN n d X W b l L (8*g+r) o (if t then 8*g+r else (8*g+r)*n) (if t then R else 1))).foldl (λa x=>us a x.1 x.2.1 x.2.2) a:=rfl rw[e];refine jX F a _ λr z v _=>?_ have:=w (8*g+r) o (by simpa using v) y rwa[(А:(8*g+r)/8=g),(А:(8*g+r)%8=r)] at this lemma gb (t:у) (R n d:о) (e:у) (X W b:р kg) (l:Д) (L:о) (o:Wв<2^32/\8*n<2^32) (g:d*n<= Wв) (N:о) (y:R*d=N) (F:о-> kg) (A:∀i j,i j tf e ((yR (kn (n:=(R+7)/8) λp=>cg t X R n pз) n d W b o g (i/8) j).f (i%8)) l (λ_=>sN n e X W b (kn (n:=(R+7)/8) λp=> cg t X R n pз) L i j (if t then i else i*n) (if t then R else 1))= F (if t then j*R+i else i*d+j)): cX t R n d e X W b l L o g=kn (n:=N) λq=>F qз:=by subst y;unfold cX;refine gT _ _ _ _ F _ (λu v a _ B=>fV t R n d e X W b l L o g _ F A u v B a) λq m=>?_ have D:0by subst h;simp at m have z:0by subst h;simp at m cases t .have x:=ϖ q d have r:q/dpj g (lJ (n+1) (λs=>if sif spj g (lJ (n+1) (λs=>if sif s?_ have v:∀a c m:о,c< m->(a*m+c)/m=a/\(a*m+c)%m=c:=λa c m h=> ⟨by rw[Μ,ϊ _ _ А,Ρ h,Θ], by rw[Μ,ώ,β h]⟩ have r:=fW X (d-8*(i/8)) (if t then 1 else n) (if t then d else 1) n (if t then 8*(i/8) else 8*(i/8)*n) _ 0 (kb (8*n)) rfl have K:(cg t X d n (i/8))д=8*n /\ ∀s?_⟩ have e:=r.2.2 s (i%8) (ϥ _) o (Ν _ Б);simp only[e0,Θ,m3] at e;unfold cg;rw[e,ex,AE (Am А),gD];congr 2;cases t<;>simp only[↓reduceIte,ξ] .calc 8*(i/8)*n+s*1+i%8*n=(8*(i/8)+i%8)*n+s:=by ring _=i*n+s:=by rw[ϖ] .omega have F:(kn (n:=(d+7)/8) λrb=>cg t X d n rbз)[i/8]! =cg t X d n (i/8):=by rw[AC _ _ (by simp;omega),Κ] unfold sN yR;simp only[gg,F];rw[AW ⟨K.1,x⟩];have hn:nиб=n:=aa (by have:=ς;omega) have I:(j*n)иб=j*n:=by have S:(j+1)*n<= l*n:=μ n x;rw[Υ] at S;exact aa (by have:=ς;omega) rw[iG _ _ _ _ _ _ 0 (i%8) А _ _ _ _ _ _ _ _ _ _ _ _ rfl (by simp),f8,hn,I,ϲ] simp only[Θ] obtain ⟨u,V,G⟩:=ep n j (λs=>X[if t then i+s*d else i*n+s]!) W b A z y P (λ_=>Q _) O Y B D rw[dE _ _ _ _ _ rfl] refine (jg g n (λs=>if sif sdw kG*dw b[j]!) w P L _ (λs o=>?_) G u V U p E H (by cases t<;>simp only[b7,bL,Ϻ,↓reduceIte,ξ]) _ λ_ _ h=>absurd h mj).trans ?_ .rw[K.2 s o];simp only[AE o];exact ey _ _ (Q _).1 (O _).1 .cases t<;>simp only[(v _ _ _ M).1,(v _ _ _ M).2,(v _ _ _ x).1,(v _ _ _ x).2,↓reduceIte, ξ] lemma uo {d n t k:ф} {S:о} (m:kб<8) (h:dб+8*nб<= S) (o:S<2^32) (p:tб (kw W X e n B z E d x t g j l o p q u v).f r= aM (λs=>mW d[s]! ==0) (λs=>tq (r%2==1) X.data[s]! W[eб+nб*r+s]!) nб tб (A8.f ⟨g,j,l,o,p,q,u,v⟩ r):=by intro m;induction m with | zero=> intro t g j l o p q u v F;have h:¬tby have:=η.mp h;omega rw[kw,AZ h,aM,AD А] | succ m H=> intro t g j l o p q u v F;have h:t(AC d tб h).symm by_cases w:(mW d[tб]! ==0)=true<;>simp only[G,w,ξ,↓reduceIte]<;> rw[H (t+1) _ _ _ _ _ _ _ _ (by rw[ae h];omega),ae h] congr 1 have y:∀(c:ф) (w:cб<8) A,W.uget (e+n*c+t) A=W[eб+nб*cб+tб]!:=by intro c w A;rw[bN,(uo w z B D).1] interval_cases r<;> (simp only[A8.f,tq,kp,Nat.reduceBEq,ξ,↓reduceIte]; rw[ug,y _ (by simp only[ke];omega)];simp only[ke]) lemma iZ (g:о-> т) (r:о) (d:r<8): A8.f ⟨g 0,g 1,g 2,g 3,g 4,g 5,g 6,g 7⟩ r=g r:=by interval_cases r<;>rfl def k1 (W:р с) (X:FloatArray) (ou n:ф) (hs:Wв<2^32) (hW:ouб+nб<= Wв) (hX:nб<= Xд) (Xw:р с) (hXw:nб<= Xwв) (t:ф) (a:т):т:= if h:t k1 W X g n p j l d e t a=aM (λs=>mW d[s]! ==0) (λs=>X.data[s]!*dw W[gб+s]!) nб tб a:=by intro m;induction m with | zero=> intro t a o;have h:¬tby have:=η.mp h;omega rw[k1,AZ h,aM,AD А] | succ m r=> intro t a o;have h:tmW e[s]! ==0) (λs=>j.data[s]!*dw W[o*n+s]!) n 0 a else 0:=by unfold fK;split .rename_i h;have:=ς;have l:(o+1)*n<= d*n:=μ n h.1 rw[Υ] at l;rw[iF _ _ _ _ _ _ _ _ _ _ _ _ rfl,AE h.1,aa А,aa А];rfl .rw[AD А] @[inline] def yW (xr:FloatArray) (Xw:р с) (n ow:о) (W b:р с) (hs:Wв<2^32/\8*n<2^32) (hW:ow*n<= Wв) (hXw:n<= Xwв) (g:о):A8:= let bq:=λo=>dw oneW*dw b[o]! if h:xrд=n/\8*g+8<= ow then kw W xr (8*g*n)и nи hs.1 (by have h1:(8*g+8)*n<= ow*n:=μ n h.2;have:=ς;rw[Ϡ] at h1;rw[aa А,aa А];omega) (by have:=ς;rw[aa А];omega) Xw (by have:=ς;rw[aa А];omega) 0 (bq (8*g+0)) (bq (8*g+1)) (bq (8*g+2)) (bq (8*g+3)) (bq (8*g+4)) (bq (8*g+5)) (bq (8*g+6)) (bq (8*g+7)) else let tl:=λo=>fK xr Xw n ow W hs hW hXw o (bq o) ⟨tl (8*g+0),tl (8*g+1),tl (8*g+2),tl (8*g+3),tl (8*g+4),tl (8*g+5), tl (8*g+6),tl (8*g+7)⟩ @[specialize] def c0 {α:Type} (f:о-> α) (N:о) (a:р α):р α:= if aв α) (N:о): c0 f N (lj N)=kn (n:=N) λq=>f qз:=by suffices h:∀k (a:р α),N-aв=k-> aв<= N->(∀i (h:i c0 f N a=kn (n:=N) λq=>f qз from h _ _ rfl (by simp) (λi h=>by simp at h) intro k;induction k with | zero=> intro a j g d;rw[c0,AD А];exact lF (by simp;omega) λi e _=>by rw[d i e,Κ] | succ k l=> intro a j g d;rw[c0,AE А];refine l _ (by simp;omega) (by simp;omega) λi h=>?_ rw[Array.getElem_push];split .exact d i ‹_› .simp only[ϡ] at h;rw[(А:i=aв)] def dV (n ow:о) (relu:у) (X W b:р с) (hh:Д) (L:о) (hs:Wв<2^32/\8*n<2^32) (hW:ow*n<= Wв):р с:= let xr:=aY (λk=>dw X[k]!) n (AK n) let Y:=c0 (λg=>yW xr (xP X n) n ow W b hs hW (bi X n) g) ((ow+7)/8) (AQ ((ow+7)/8)) c0 (λj=> let bj:=j%2==1&&decide (8*(j/8)+8<= ow) let o:=j*n tw relu ((Y[j/8]!).f (j%8)) hh L n (λs=>tq bj (xr.get! s) W[o+s]!) (λ_=>dw oneW*dw b[j]!) λ_=>b7 n relu X W b (j/ow*n) 1 j) (1*ow) (AQ (1*ow)) lemma du (n e:о) (l:у) (X W b:р kg) (G:Д) (L:о) (w:Wв<2^32/\8*n<2^32) (p:e*n<= Wв) (z y x P:о) (M:∀q:о,ki X[q]!≠255/\kf X[q]! <= z) (K:∀q:о,ki W[q]!≠255/\kf W[q]! <= y) (Y:∀q:о,ki b[q]!≠255/\kf b[q]! <= x) (A:48+z+y<= P) (B:174+x<= P) (Q:n+2<=2^L) (o:L<=27) (D:P+L<=425) (H:Gа=P+2*L-54): dV n e l X W b G L w p=lG 1 n e l X W b:=by unfold dV lG linearWith;dsimp only;simp only[gg,g3];congr 1;funext q;have v:=q.isLt;have ah:0by subst h;simp at v have hi:qз/e=0:=Ρ А;have I:qз yW (aY (λk=>dw X[k]!) n (kb n)) (xP X n) n e W b w p (bi X n) gз)[j/8]! = yW (aY (λk=>dw X[k]!) n (kb n)) (xP X n) n e W b w p (bi X n) (j/8):=by rw[AC _ _ (by simp;omega),Κ] rw[V] have m:=bk (λk=>dw X[k]!) n _ (kb n) rfl (by simp[kb,kH]) have F:∀sdw X[k]!) n (kb n)).data[s]! =dw X[0*n+s]!:=by intro s d;rw[m.2.2 _ (by simp[kb,kH]) d];simp have U:(yW (aY (λk=>dw X[k]!) n (kb n)) (xP X n) n e W b w p (bi X n) (j/8)).f (j%8)= aM (λs=>mW (xP X n)[s]! ==0) (λs=>tq (j%2==1&&decide (8*(j/8)+8<= e)) (aY (λk=>dw X[k]!) n (kb n)).data[s]! W[j*n+s]!) n 0 (dw kG*dw b[j]!):=by unfold yW;dsimp only;split .rename_i h have hn:nиб=n:=aa (by have:=ς;omega) have J:(8*(j/8)*n)иб=8*(j/8)*n:=by have N:(8*(j/8)+8)*n<= e*n:=μ n h.2;rw[Ϡ] at N;exact aa (by have:=ς;omega) rw[iH _ _ _ _ _ _ _ _ _ (j%8) А _ _ _ _ _ _ _ _ _ _ rfl, iZ (λr=>dw kG*dw b[8*(j/8)+r]!) _ А,hn,J,ϲ, show 8*(j/8)+j%8=j by omega] have v:(j%8%2==1)=(j%2==1&&decide (8*(j/8)+8<= e)):=by simp only[Am h.2,Bool.and_true,BI j (by decide:2∣8)] congr 2;funext s;rw[v];congr 2;rw[Τ n (j%8),<- Ϡ,(А:8*(j/8)+j%8=j)] .refine (iZ (λr=>fK (aY (λk=>dw X[k]!) n (kb n)) (xP X n) n e W w p (bi X n) (8*(j/8)+r) (dw kG*dw b[8*(j/8)+r]!)) (j%8) (Ν _ Б)).trans ?_ rename_i h have v:(j%2==1&&decide (8*(j/8)+8<= e))=false:=by simp only[Bool.and_eq_false_iff,BC];right;exact λO=>h ⟨m.1,O⟩ rw[ii _ _ _ _ _ _ _ _ _ _ m.1,v];simp only[(А:8*(j/8)+j%8=j),AE I,tq, ξ,↓reduceIte] rw[U];obtain ⟨u,S,E⟩:=ep n j (λt=>X[0*n+t]!) W b z y x P (λ_=>M _) K Y A B refine jg l n (λt=>if tif tdw kG*dw b[j]!) G P L _ (λs d=>?_) E u S Q o D H (by unfold b7;simp only[bL,Ϻ]) (λs=>mW (xP X n)[s]! ==0) (λs d h=>?_) .rw[F s d];simp only[AE d];exact jV _ _ _ (M _).1 (K _).1 .rw[iu _ _ _ d] at h;simp only[AE d,ϴ,Θ];exact j2 _ _ h lemma dN (n:о) (e d:о-> kg):∀c i,i+c=n -> mX (kn (n:=n+1) λt=>if tзif tзe tз) (kn (n:=n) λt=>d tз) i c:=by intro c;induction c with | zero=> intro i h;obtain rfl:i=n:=А simp only[mX,ab (i+1) (λt=>if t< i then d t else kG) i А, ab (i+1) (λt=>if t< i then e t else 0x80000000) i А,AY,Ap];rfl | succ c g=> intro i h rw[mX,g (i+1) А,mX,ab (n+1) (λt=>if tif t kg) (h:0if tif tby split;exacts [(g t ‹_›).symm,Б],bE _ _ _ g,aK, dN n d e n 0 А] congr 1 .simp only[AY,Ap,(Б:tm kG 0x80000000=0),Ax] exact ϝ rfl λt j=>by simp only[AE (ϯ.mp j)];unfold tm;rw[Μ];ring .simp[h.ne'] end F lemma j7 (X:р kg) (a n t:о) (d:t Prop) (d:∀q:о,P X[q]!) (q:о): P (X.extract a e)[q]!:=by by_cases h:q<(X.extract a e)в .have g:a+qif tif tki w≠255/\kf w<=(F.aE X 0 0)г-1) (F.aF X А l)) (F.aF W А m) (F.aF b А o) (Ao _ _) (Ak _ _) (by have:=@ό (d+1);omega) q p (by rw[ϑ,υ (by simp only[kL];omega)]) .exact F.cn _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ (F.aF X А l) (F.aF W А m) (F.aF b А o) (Ao _ _) (Ak _ _) (by have:=@ό (d+1);omega) q p (by rw[ϑ,υ (by simp only[kL];omega)]) .rfl def eU (batch m k n:о) (A B:р с):р с:= let ea:=F.aE A 0 0 let eb:=F.aE B 0 0 let P:=max (48+(ebг-1)+(eaг-1)) 174 let L:=A9 (k+1)+1 if h:batch=1/\0by by_cases h:q< m<;>simp[h]<;>decide) (Ao _ _) (Ak _ _) (by have:=@ό (k+1);omega) u r (by rw[ϑ,υ (by simp only[kL];omega)])).trans ?_ unfold gemmSpec gemmWith;refine lF (by simp[Τ]) λq e _=>?_ simp only[Ϣ] at e;have g:q/n< m:=Ϥ e;have w:(lS m (0x80000000:kg))[q/n]! =0x80000000:=by simp[g] simp only[Κ,↓reduceIte,w,Ρ (show q< m*n by rwa[Τ]), β g,ϴ,Θ] exact (F.dz k (λt=>A[q/n*k+t]!) (λt=>B[q%n+t*n]!) v λt _=>⟨(j _).1,(l _).1⟩).trans (by simp only[Μ (q%n)]) .rfl end Dense namespace Bn namespace NativeAdd lemma ef (x:Float32):nt x.toModel=k7 x.toBits:=by exact congrArg Model.mk (nN x.toBits).symm lemma iK (x:Float32):ky (nt x.toModel)=x.toBits:=by change kZ x.toBitsг=x.toBits;exact UInt32.ofNat_toNat lemma bH (a:kg) (h:ki a≠255): (kW a).toBits=a/\(kW a).isFinite=true:=by have j:np (spec:=kJ) a.toBitVec≠-1#8:=by intro g;apply h;apply Ζ.mp;have e:=congrArg BitVec.toNat g have l:(ki a)г=(a.toBitVec.extractLsb' 23 8).toNat:=by simp only[ki,Ο,ϓ,BitVec.extractLsb'_toNat];change (aг>>>23)&&&(2^8-1)=(aг>>>23)%2^8;exact ι _ _ rw[l];exact e have e:(kW a).toBits=a:=by change BG (n9 kJ (ko kJ a.toBitVec))=a rw[Model.pack_unpack_eq,AD (λd=>j d.1)] refine ⟨e,?_⟩ change (ko kJ (kW a).toBits.toBitVec).isFinite=true rw[e];simp only[ko,j,ite_false];split<;>(try split)<;>rfl @[noinline] def eQ (relu:у) (a b:с):с:= act relu (toWord (Model.add (ofW a) (ofW b))) @[inline] def add (relu:у) (a b:с):с:= if expOf a !=255&&expOf b !=255 then act relu (BL a+BL b).toBits else eQ relu a b lemma gB (d:у) (a b:kg): add d a b=pj d (ky (nC (k7 a) (k7 b))):=by unfold add;split .rename_i h simp only[Λ,AP] at h;have g:=bH a h.1;have j:=bH b h.2 have e:=ExecFloat.Binary.toModel_ofFloat32_add_of_isFinite (kW a) (kW b) g.2 j.2 simp only[ExecFloat.Binary.toModel_ofFloat32,ef] at e;rw[g.1,j.1] at e;rw[<- e,<- ef,iK] .rfl end NativeAdd lemma fo (a b:Д) (h:aа+bа<2^64):(a+b)а=aа+bа:=by rw[ζ,β h] def sg (n:у) (m:о):п:=if n then-(m:п) else m lemma em (x s t:kg) (p:ki x≠255) (m:ki s≠255) (o:ki t≠255) (V:п) (l:V=sv x*sv s*2^(kf x+kf s)+sv t*2^(kf t+149)) (j:V≠0): ky (nD (k7 x) (k7 s) (k7 t))=kS V (-298) false:=by have g:=kx x p;have d:=kx s m;have e:=kx t o;rw[Model.Proof.fma_eq_spec];unfold Model.Spec.fma have h:Model.chooseNaN3 (k7 x) (k7 s) (k7 t)=none:= (Model.chooseNaN3_eq_none_iff _ _ _).2 ⟨Χ g, Χ d,Χ e⟩ simp only[k7] at h⊢;rw[h] simp only[Ϧ g,Ϧ d, Ϧ e,Bool.or_false,ξ,ite_false,g,d,e] refine (lC _ V _ _ j ?_).symm;rw[Model.addDyadic,nV];erw[nW (mG x) (mG s)];rw[k6,k6,k6,l];push_cast;simp[Ae];field_simp;ring lemma gl (n:у) (M σ:Д) (V:п) (d:Mа≠0) (g:σа<=506) (e:V=sg n Mа*2^σа): an n M σ=kS V (-298) false:=by subst e;exact bJ n M σ d g lemma db (w:kg):sv w=sg (w>>>31!=0) (kl w):=by rw[da];rfl lemma dL (w:Е):w>>>31=0\/w>>>31=1:=by have:=w.toNat_lt;simp only[<- Ζ,ϓ];simp[γ];omega lemma ic (a b:у) (x y:о):sg a x*sg b y=sg (a ^^ b) (x*y):=by unfold sg;cases a<;>cases b<;>simp lemma e9 (d:у) (o g:Е) (X:о) (e:g=0\/g=1) (m:X<255*2^23) (h:oг=gг*2^31+X): o*((g&&&(if d then 1 else 0))^^^1)=pj d o:=by have l:(o&&&0x80000000!=0)=decide (2^31<= oг):=by rw[ϕ,An];exact ax o have j:=Dense.jm o (by rw[Dense.ck];rcases e with rfl | rfl<;>simp at h<;>omega) unfold pj reluW rcases e with rfl | rfl<;>cases d<;>simp only[l,j]<;>simp at h⊢<;> omega lemma jI (P T:Д) (c:у) (l:Pа<2^62) (m:Tа<2^62): let D:=if c then P+T else P-T let f:=D>>>63 let M:=if f==0 then D else 0-D (f=0\/f=1)/\Mа<2^63 /\ (if c then (Pа:п)+Tа else (Pа:п)-Tа)=sg (f !=0) Mа:=by intro D f M;have:=D.toNat_lt have e:(Dа:п)=(if c then (Pа:п)+Tа else (Pа:п)-Tа)+ if c\/Tа<= Pа then 0 else 2^64:=by cases c<;>simp only[D,ite_true,ξ,ite_false,true_or,false_or,ζ, Η]<;>(try split)<;>omega have g:-2^62<(if c then (Pа:п)+Tа else (Pа:п)-Tа) /\ (if c then (Pа:п)+Tа else (Pа:п)-Tа)<2^63:=by split<;>omega generalize (if c then (Pа:п)+Tа else (Pа:п)-Tа)=V at e g⊢ have j:f=0/\Dа<2^63\/f=1/\2^63<= Dа:=by simp only[f,<- ο,ψ];simp[γ];omega rcases j with ⟨d,h⟩ | ⟨d,h⟩<;>simp[M,d,sg,kL]<;>split at e<;>omega @[noinline] def i4 (relu:у) (w s t:с):с:=act relu (toWord (Model.fma (ofW w) (ofW s) (ofW t))) def kK (s t:с):о:=idxOf t+164-idxOf s def cD (s t:с):о:=max 1 (kK s t-51) def eV (s t:с):о:= if expOf s≠255/\expOf t≠255 then min 254 (kK s t)+1-cD s t else 0 @[inline] def eR (rb sp st:Е) (P T σ:Д) (slow:Unit-> с):с:= let D:=if sp^^^st==0 then P+T else P-T let f:=D>>>63 let M:=if f==0 then D else 0-D let g:=sp^^^fй if M !=0 then let L:=Dense.lz M 0 let E:=σ+L-173 if E<253 then ((Eй<<<23)+(Core.aj (M<<<(63-L)))й+(g<<<31))*((g&&&rb)^^^1) else slow () else slow () @[inline] def el (rb st ss lo cnt ms:Е) (mt kc c1:Д) (w:с) (slow:Unit-> с):с:= let ex:=(w>>>23)&&&255 if ex-lo>>31)^^^ss) st ((((w&&&8388607) ||| 8388608)м*msм)<<<(14+m-sh)) (mt<< с):с:=NativeAdd.add (rb !=0) a b lemma ij (n:о) (h:n<2^32):n.toUInt32г=n:=UInt32.toNat_ofNat_of_lt' h lemma ik (n:о) (h:n<2^64):nеа=n:=υ h lemma dF (a k:Д) (d:kа<64) (h:aа*2^kа<2^64): (a<<push_cast<;>ring lemma jv (d e:Е) (j:d=0\/d=1) (l:e=0\/e=1) (f:Д) (h:f=0\/f=1) (P T M:о) (g:(if d^^^e==0 then (P:п)+T else (P:п)-T)=sg (f !=0) M): sg (d !=0) P+sg (e !=0) T=sg (d^^^fй!=0) M /\ (d^^^fй=0\/d^^^fй=1):=by rcases j with rfl | rfl<;>rcases l with rfl | rfl<;>rcases h with rfl | rfl<;> simp[sg] at g⊢<;>omega lemma bx (a b:Е) (d:a=0\/a=1) (e:b=0\/b=1): ((a^^^b)!=0)=((a !=0) ^^ (b !=0))/\(a^^^b=0\/a^^^b=1):=by rcases d with rfl | rfl<;>rcases e with rfl | rfl<;>simp lemma f5 (d:у) (v x:Е) (S:v=0\/v=1) (U:x=0\/x=1) (P T σ:Д) (Y:Pа<2^62) (hT:Tа<2^62) (hσ:σа<=506) (y:kg) (w:Unit-> kg) (J:w ()=y) (hy:∀V:п,V=sg (v !=0) Pа*2^σа+sg (x !=0) Tа*2^σа -> V≠0-> y=pj d (kS V (-298) false)): eR (if d then 1 else 0) v x P T σ w=y:=by unfold eR;dsimp only;obtain ⟨q,j,t⟩:=jI P T (v^^^x==0) Y hT;generalize (if v^^^x==0 then P+T else P-T)=D at q j t⊢;generalize D>>>63=f at q j t⊢;generalize (if f==0 then D else 0-D)=M at j t⊢;obtain ⟨I,m⟩:=jv v x S U f q _ _ _ t;generalize v^^^fй=g at I m⊢ have hV:sg (v !=0) Pа*2^σа+sg (x !=0) Tа*2^σа= sg (g !=0) Mа*2^σа:=by rw[<- add_mul,I] have ah:((if d then (1:Е) else 0)!=0)=d:=by cases d<;>rfl have W:=λh:Mа≠0=>hy _ hV.symm (As (by unfold sg;split<;>omega) В) split;swap;. exact J rename_i X split;swap;. exact J rename_i r .simp only[AP,Ar] at X have u:Mа≠0:=λh=>X (ο.mp (by rw[h];rfl)) have K:(Dense.lz M 0)а=Mаж+1:=by rw[Dense.cp _ _ (by have:=Dense.fq M;simpa using this)];simp[Dense.bl,u] have B:=Ϩ u;have E:=@ό Mа;have Q:=(lK u).2 j;generalize Dense.lz M 0=L at K r⊢;generalize Mаж=l at K B E Q;have p:(63-L)а=62-l:=by simp[Η,K];omega generalize 63-L=z at p⊢;generalize hZ:62-l=Z at p have A:(M<<simp<;>clear*-r G H<;>omega have hX:(an (g !=0) (M<<simp have O:(σа-Z-110)*2^23+(aj (M<< kg) (G:q ()=pj l (ky (nD (k7 w) (k7 s) (k7 t)))): el (if l then 1 else 0) (t>>>31) (s>>>31) (cD s t).toUInt32 (eV s t).toUInt32 (mW s)й (mW t) (kK s t)е (iW t+149) w q= pj l (ky (nD (k7 w) (k7 s) (k7 t))):=by unfold el;dsimp only split;swap;. exact G rename_i d;unfold eV at d split at d;swap;. simp at d rename_i as;obtain ⟨hs,ht⟩:=as;have Q:=nX s hs;have y:=nX t ht;have hK:kK s t=kf t+164-kf s:=rfl;have hL:cD s t=max 1 (kK s t-51):=rfl;have D:((w>>>23)&&&255)г<256:=Dense.bU w;rw[Ϙ,pb,ij _ А,ij _ А] at d;generalize O:(w>>>23)&&&255=p at D d⊢;have r:ki w=p:=O have j:1<= pг/\pг<=254/\kK s t<= pг+51/\pг<= kK s t:=by have K:1<= cD s t/\kK s t<= cD s t+51/\cD s t<=400:=by rw[hL,hK];clear*-Q y;omega generalize cD s t=L at d K have N:L<= pг/\pг<= mU 254 (kK s t):=by have hM:=min_le_left 254 (kK s t);have:=K.2.2;generalize mU 254 (kK s t)=M at d hM⊢;clear*-d D hM this;omega exact ⟨K.1.trans N.1,N.2.trans (min_le_left _ _),K.2.1.trans (Nat.add_le_add_right N.1 51), N.2.trans (min_le_right _ _)⟩ have v:ki w≠255/\ki w≠0:=by rw[r];constructor<;>intro h<;>simp[h] at j have H:=v.2;have al:kl w=2^23+(w&&&8388607)г:=by unfold kl la;rw[AD H] have S:kf w=pг-1:=by unfold kf;rw[AD H,r] have X:(((w&&&8388607) ||| 8388608)м)а=kl w:=by rw[ϒ,m8,show (8388608:Е)г=2^23*1 from rfl,Nat.lor_comm, <- Ϟ (dq w),al];ring have Y:=ag s;have ah:=ag t;have x:=am t;have W:=kD w;have E:=kD s;have U:=kD t have o:((kK s t)е-pм)а=kK s t-pг:=by rw[χ _ _ (by rw[ε,ik _ А,ϒ];omega), ik _ А,ϒ] generalize (kK s t)е-pм=z at o⊢;generalize hu:kK s t-pг=u at o have g:(if z<37 then z else 37)а=mU u 37:=by split<;>rename_i h<;>rw[θ,o] at h<;>simp[o] at h⊢<;>omega generalize (if z<37 then z else 37)=m at g⊢ have A:(14+m-z)а=14+mU u 37-u:=by have e:(14+m)а=14+mU u 37:=by rw[fo _ _ (by rw[g];simp;clear*-;omega),g];rfl rw[χ _ _ (by rw[ε,e,o];clear*-hu j;omega),e,o] have hσ:(iW t+149-m)а=kf t+149-mU u 37:=by have e:(iW t+149)а=kf t+149:=by rw[fo _ _ (by rw[x];simp;clear*-y;omega),x];rfl rw[χ _ _ (by rw[ε,e,g];clear*-;omega),e,g] have B:kl w*kl s<2^48:=(ϗ W E:) have F:(mW s)йма=kl s:=by rw[ϒ,ϣ,Y];exact β (E.trans Б) have hm:(((w&&&8388607) ||| 8388608)м*(mW s)йм)а=kl w*kl s:=by rw[ύ,X,F];clear*-B;omega have I:=fH _ (14+m-z) _ 48 hm B (by rw[A];clear*-;omega) have J:=fH _ m _ 24 ah U (by rw[g];clear*-;omega) rw[A] at I;rw[g] at J;obtain ⟨b1,b3⟩:=bx _ _ (dL w) (dL s) refine f5 l _ _ b3 (dL t) _ _ _ (I.1 ▸ I.2) (J.1 ▸ J.2) (by rw[hσ];clear*-y;omega) _ q G λV hV h0=>?_ rw[em w s t v.1 hs ht V ?_ h0];rw[hV];symm rw[b1,db w,db s,db t,ic,hσ,I.1,J.1,<- c8,<- c8,AX, AX,<- AG,<- AG] have k1:=nu j.2.2.2 hu;have k2:=nu j.1 S.symm;have k3:kK s t+kf s=kf t+164:=by have:=j.1.trans j.2.2.2;clear*-hK this;omega rw[show 14+mU u 37-u+(kf t+149-mU u 37)=kf w+kf s by clear*-k1 k2 k3 j;omega, lV ((Nat.min_le_right u 37).trans А)] @[specialize] def cv (stop:ф) (f:(i:ф)-> iб с-> с) (i:ф) (x:р с) (h:stopб<= xв):р с:= if hi:i iб kg-> kg) (F:о-> kg-> kg) (p:∀i e w,f i e w=F iб w) (i:ф) (x:р kg) (h:dб<= xв): (cv d f i x h)в=xв /\ ∀j,(cv d f i x h)[j]?=if iб<= j/\j have o:iб?_⟩ rw[l,Dense.ae e,Array.uset_eq_set,nT o];by_cases m:iб=j .subst m rw[AD А,AE rfl,AE А,k0 o,Option.map_some,p];rfl .rw[AD m];split_ifs<;>first | rfl | omega .next i x h e=>exact ⟨rfl,λj=>by rw[AD (by rw[η] at e;omega)]⟩ def bD (relu:у) (hw c:о) (s t:р с) (ch:о) (x:р с):р с:= if ch>>31 let ss:=sc>>>31 let lo:=(cD sc tc).toUInt32 let cnt:=(eV sc tc).toUInt32 let ms:=(Core.mW sc)й let mt:=Core.mW tc let kc:=(kK sc tc)е let c1:=Core.iW tc+149 bD relu hw c s t (ch+1) (if h:stopб<= xв then cv stop (λ_ _ w=>el rb st ss lo cnt ms mt kc c1 w λ_=>i4 relu w sc tc) (ch*hw)и x h else x) else x termination_by c-ch lemma dg (g:у) (e c:о) (s t:р kg) (d:о) (x:р kg) (p:xв=c*e) (r:c*epj g (ky (nD (k7 w) (k7 s[j/e]!) (k7 t[j/e]!)))) else x[j]?:=by induction hk:c-d generalizing d x with | zero=> unfold bD;rw[AD А];split .have:c*e<= d*e:=μ _ А rw[ϧ А];rfl .rfl | succ k v=> have q:dpj g (ky (nD (k7 w) (k7 s[d]!) (k7 t[d]!)))) (λ_ _ w=>iB g s[d]! t[d]! w (λ_=>i4 g w s[d]! t[d]!) rfl) (d*e)и x (by rw[h];omega) rw[v (d+1) _ (by rw[m,p]) А,o,l,h, show (d+1)*e=d*e+e by ring] split_ifs<;>first | omega | rw[Ϯ (k:=d) А (by rw[Υ];omega)] | rfl def bo (relu:у) (c hw:о) (x s t:р с):р с:= if xв=c*hw/\c*hw kg) (g:e ()=pj d (ky (nC (k7 a) (k7 b)))): ad (if d then 1 else 0) a b e=pj d (ky (nC (k7 a) (k7 b))):=by cases d<;>simp[ad,NativeAdd.gB] @[noinline] def jo (relu:у) (x y:с):с:=act relu (toWord (Model.add (ofW x) (ofW y))) def cl (relu:у) (a b:р с):р с:= if h:aв<= bв/\aв let y:=b.uget i (by rw[Dense.aa h.2] at hi;omega) ad rb x y λ_=>jo relu x y) 0 a (by rw[Dense.aa h.2]) else addReluSpec relu a b lemma dI:cl=addReluSpec:=by funext d a b;unfold cl;dsimp only;split .rename_i h have g:aвиб=aв:=Dense.aa h.2;apply mi;intro j rw[(cG _ _ (λj x=>pj d (ky (nC (k7 x) (k7 b[j]!)))) (λi l x=>?_) 0 a _).2 j, addReluSpec,lU] .by_cases e:j у) (fa:о-> kg) (bx:Д) (s:lk) (J:у) (I K b:р kg) (D:у) (nc Y:о) (r d:kg) (x:Д) (v:п) (B a:Д) (m:о) (e j:ф) (bw:Д) (u:Е) {α:Type} lemma mo {a b:о} (h:arw[h]<;>norm_num lemma jL {n:о} (h:n<2^32):n%2^mQ=n:=mo (AJ h dc) lemma jy (a:р Е):a.usizeб<= aв:=by exact Nat.mod_le _ _ @[inline] def ok (w:Е):у:= expOf w !=255&&(mW w==0 || iW w-E<= C) @[inline] def er (a:р Е):Д:= a.foldl (λm w=>if mW w !=0&&iW w< m then iW w else m) 255 @[inline] def co (h l:Д):Д:=(h<<<25)+l @[inline] def dU (h l:Д):Д:= ((h+0x8000000000000000)>>>(39:Д))-(16777216:Д)-(l>>>(63:Д))+ (if co h l>>31!=0 then 0-m else m @[specialize] def lp (H:о) (f:о-> о-> р Е-> р Е): о-> о-> о-> р Е-> р Е | 0,_,_,a=>a | n+1,o,y,a=> let a:=f o y a if y+1 ф-> Е) (s:ф) (x:о):о-> ф-> р Е-> р Е | 0,_,a=>a | m+1,e,a=>c5 f s (x+1) m (e+s) (a.push (f x e)) @[inline] def eH (O H W:о) (f:о-> о-> о-> Е):р Е:= if 0c5 (λx _=>f o y x) 0 0 W 0) (O*H) 0 0 (AQ (O*(H*W))) else #[] lemma uL {a:р Е} {i:ф} (h:i с-> α) (I:р с) (w k:о):о-> о-> о-> α-> α | 0,_,_,acc=>acc | n+1,i,dx,acc=> let acc:=g acc I[i]! if dx+1 Д):=wl λ(a:Д) x=>a+f x @[reducible] def wa:=wl λ(b:у) x=>b&&Q x @[noinline] def cP (ch y x:о):с:= dotOf (k*k) (poolAt h w k I ch y x) λ_=>oneW @[inline] def wo (A H:Д) (g:Unit-> у) (fb:Unit-> с) (d:с):с:= if A=0/\H=0 then (if g () then 0x80000000 else 0) else let r:=Dense.bV (dU H A) (co H A) (B+149) eN (if r<Ж then rй else fb ()) d @[inline] def ap (w:с):Д:=if mW w !=0 then iW w else 255 @[inline] def cQ (x0 x1 x2 x3:с):у:=Q x0&&Q x1&&Q x2&&Q x3 @[inline] def eF (u:с):Д:=((u>>>23)&&&255)м @[inline] def gy (ch y x:о) (e:ф):с:= let v:=wи if hb:ecQ (.==0x80000000) x0 x1 x2 x3) (λ_=>cP h w 2 I ch y x) d else toWord (Au (ofW (cP h w 2 I ch y x)) (ofW d)) else toWord (Au (ofW (cP h w 2 I ch y x)) (ofW d)) abbrev DQ:Prop:=signOf d=false/\expOf d≠0/\expOf d<255 @[inline] def cK (m:о):Д:=if m<=64 then 33 else if m<=256 then 31 else if m<=1024 then 29 else 25 def dJ:р с:= let d:=natW (k*k) if 0c5 (gy h w I d o y) 2 0 (w/2) ((o*h+y*2)*w)и) (c*(h/2)) 0 0 (AQ (c*(h/2*(w/2)))) else let q:=cK (k*k) let bx:=er I if bx<=255/\I.all (ok q bx)=true then eH c (h/k) (w/k) λch y x=> let U:=(ch*h+y*k)*w+x*k wo bx (dK (t1 bx) I w k (k*k) U 0 0) 0 (λ_=>wa (.==0x80000000) I w k (k*k) U 0 true) (λ_=>cP h w k I ch y x) d else eH c (h/k) (w/k) λch y x=> let U:=(ch*h+y*k)*w+x*k let B:=wl (λ(m:Д) v=>min m (ap v)) I w k (k*k) U 0 255 if B<=255/\wa (ok q B) I w k (k*k) U 0 true=true then wo B (dK (t1 B) I w k (k*k) U 0 0) 0 (λ_=>wa (.==0x80000000) I w k (k*k) U 0 true) (λ_=>cP h w k I ch y x) d else toWord (Au (ofW (cP h w k I ch y x)) (ofW d)) else avgpoolSpec c h w k I lemma eE:ac x=(xа:п)-2^64*(xа/2^63:о):=by unfold ac;rw[kV];have e:x.toBitVec.toNat=xа:=rfl;have:=x.toNat_lt;split<;>omega lemma jd (h:(xа:п) ≡ v [ZMOD2^64]) (d:-2^63<= v) (e:v<2^63):ac x=v:=by rw[eE];have:=x.toNat_lt;unfold nE at h;omega def Z:ZMod (2^64):=xа lemma g2:(xа:п) ≡ v [ZMOD2^64]↔Z x=v:=by unfold Z rw[show ((xа:ℕ):ZMod (2^64))=(((xа:ℤ)):ZMod (2^64)) by push_cast;rfl, ZMod.intCast_eq_intCast_iff] rfl lemma sZ (h:Z x=v) (d:-2^63<= v) (e:v<2^63): ac x=v:=jd x v ((g2 x v).mpr h) d e lemma fm (b:Д):Z (a+b)=Z a+Z b:=by unfold Z;rw[ζ,BN];push_cast;ring lemma iy (b:Д):Z (a-b)=Z a-Z b:=by have d:=b.toNat_lt;unfold Z;rw[Η,BN,Nat.cast_add,n4 А];rw[show ((2^64:о):ZMod (2^64))=0 from ZMod.natCast_self _];ring lemma bC:Z 0=0:=by simp[Z] lemma ct {B:Д} (h:B<=255):Bа<=255:=by simpa using ε.mp h def bP (e:о) (w:Е):п:=sv w*2^(idxOf w-e) lemma cs (h:kl u=0):sv u=0:=by unfold sv;simp[h] lemma jP (h:kl u=0):mW u=0:= ο.mp (by rw[ag,h];rfl) lemma dB (w:Е) (m:Eа<=255) (l:Cа<=62) (h:ok C E w=true): ki w≠255/\(kl w=0\/(Eа<= kf w/\kf w<= Eа+Cа /\ (iW w-E)а=kf w-Eа)):=by simp only[ok,Λ,AP,Ar,na,AO] at h;refine ⟨h.1,?_⟩;rcases h.2 with d | e .left;have:=ag w;rw[d] at this;simp at this;omega .right;have j:=am w;have g:=ε.mp (of_decide_eq_true e);have:=nX w h.1;rw[Η,j] at g⊢;omega lemma pw (v s c:о) (e:v<2^24) (d:s<= c):v*2^s<2^(24+c):=by rw[AG];exact kX e (Ε Г d) В lemma fd (e:Д) (w:Е) (c:о) (p:c<=39) (h:kl w=0\/(eа<= kf w/\kf w<= eа+c /\ (iW w-e)а=kf w-eа)): (mW w<<<(iW w-e))а=kl w*2^(kf w-eа) /\ kl w*2^(kf w-eа)<2^(24+c):=by have j:=kD w;rcases h with d | ⟨m,o,l⟩ .rw[jP w d,d];simp .have g:=pw _ _ c j (А:kf w-eа<= c);refine ⟨?_,g⟩ rw[Α,ag,l,ν, mo (a:=kf w-eа) А] exact mo (AJ g (Ε Г А)) lemma jj (b:Д):((a+b)а:п) ≡ (aа:п)+bа [ZMOD2^64]:=by unfold nE;rw[ζ];omega lemma gG (b:Д):((a-b)а:п) ≡ (aа:п)-bа [ZMOD2^64]:=by have:=b.toNat_lt;unfold nE;rw[Η];omega lemma iS: (((a+(0x8000000000000000:Д))>>>(39:Д))а:п)= (aа/2^39:о)+(if aа<2^63 then 2^24 else-2^24):=by have d:=a.toNat_lt;rw[ψ,ζ];simp only[γ,mq,mK,kp];split<;>omega lemma eI (d e:Д): au (dU d e) (co d e)=ac d*2^25+ac e:=by have j:=d.toNat_lt;have l:=e.toNat_lt;have o:(co d e)а=((dа%2^39)*2^25+eа)%2^64:=by unfold co;rw[ζ,Α];simp only[ν,mq,mK,kp];omega set c:п:=if co d e=2^64 then 1 else 0:=by rw[m];simp only[θ,o];split_ifs<;>omega set q:п:=(dа/2^39:о)+(if dа<2^63 then 0 else-2^25)- (eа/2^63:о)+c with g have u:((dU d e)а:п) ≡ q [ZMOD2^64]:=by unfold dU refine (jj _ _).trans (Int.ModEq.add ((gG _ _).trans (Int.ModEq.sub ((gG _ _).trans ?_) (by rw[ψ];simp only[γ,mq,mK,kp];rfl))) ?_) .rw[iS];have:((16777216:Д)а:п)=2^24:=rfl;rw[this] split<;>(unfold nE;ring_nf) .rw[m];split<;>rfl have p:0<= c/\c<=1:=by rw[m];split<;>decide have v:=jd _ q u (by rw[g];clear*-j l p;split<;>omega) (by rw[g];clear*-j l p;split<;>omega) unfold au;rw[v,eE,eE,o,g,r];clear*-j l;split_ifs<;>omega lemma fe (a b:Е) (d e:о) (g:kl a=0\/d<= kf a) (j:kl b=0\/e<= kf b):tm a b=bP d a*bP e b*2^(d+e):=by unfold tm bP;rcases g with g | g .simp[cs a g] rcases j with j | j .simp[cs b j] rw[(А:kf a+kf b=(kf a-d)+(kf b-e)+(d+e)),AG,AG];ring lemma cF (f:о-> п) (M:п) (h:∀th t (mr d)).trans (by simp)) abbrev ai (g:о-> Е):р Е:=Aj (n:=m) λq=>g qз lemma dZ (g:о-> Е):(ai m g).push (g m)=ai (m+1) g:=by simp[ai];rw[Array.ofFn_succ (f:=λq:Fin (m+1)=>g qз)];rfl lemma cS (o y x H W:о) (g:y о-> р Е-> р Е) (S:о-> р Е-> Prop) (j:∀o y a,y S (o*H+y) a-> S (o*H+y+1) (f o y a)): ∀n o y a,y S (o*H+y) a-> S (o*H+y+n) (lp H f n o y a):=by intro n;induction n with | zero=>intro o y a _ h;exact h | succ n e=> intro o y a l h;have d:=j o y a l h;simp[lp];split_ifs with g .rw[show o*H+y+(n+1)=o*H+(y+1)+n by ring];exact e _ _ _ g d .obtain rfl:H=y+1:=А rw[show o*(y+1)+y+(n+1)=(o+1)*(y+1)+0+n by ring];exact e _ _ _ А (by rw[show (o+1)*(y+1)+0=o*(y+1)+y+1 by ring];exact d) lemma jN (H W n c:о) (d:о-> о-> р Е-> р Е) (F:о-> о-> о-> Е) (r:0 o*H+y(∀j d o y (ai M g)=ai (M+W) g): lp H d n 0 0 (lj c)=ai (n*W) λq=>F (q/(H*W)) (q/W%H) (q%W):=by have:=gW H d (λk a=>k<= n-> a=ai (W*k) λq=>F (q/(H*W)) (q/W%H) (q%W)) (λo y a e v A=>by rw[v А];exact u _ _ _ _ e А λj x=>by obtain ⟨l,m,p⟩:=cS o y j H W e x;simp[show W*(o*H+y)+j=(o*H+y)*W+j by ring,l,m,p,Θ]) n 0 0 _ r λ_=>rfl simp[Nat.mul_zero,ϴ,Θ,Τ W n] at this;exact this lemma g8 (f:о-> ф-> Е) (g:о-> Е) (s:ф):∀m x e M, (∀j< m,g (M+j)=f (x+j) (e+s*jи))-> c5 f s x m e (ai M g)=ai (M+m) g:=by intro m;induction m with | zero=>intro _ _ _ _;rfl | succ m o=> intro x e M l;have d:=l 0 А;rw[Ϛ,Ϛ,show (0:о)и=0 from rfl,USize.mul_zero,USize.add_zero] at d rw[c5,<- d,dZ,o _ _ _ λj p=>by rw[(А:M+1+j=M+(j+1)),l _ А,(А:x+(j+1)=x+1+j), show (j+1)и=jи+1 from nb j 1,USize.mul_add,USize.mul_one, USize.add_assoc,USize.add_comm (s*_)]];congr 1;omega lemma dX (H W n c:о) (s:ф) (E:о-> о-> ф) (F:о-> о-> о-> ф-> Е) (d:0c5 (F o y) s 0 W (E o y)) n 0 0 (lj c)= ai (n*W) λq=>F (q/(H*W)) (q/W%H) (q%W) (E (q/(H*W)) (q/W%H)+s*(q%W)и):= jN H W n c _ (λo y x=>F o y x (E o y+s*xи)) d λ_ _ _ _ _ _ e=> g8 _ _ _ _ _ _ _ λj g=>by rw[e j g,Θ] lemma il (O H W:о) (f:о-> о-> о-> Е): eH O H W f=ai (O*(H*W)) λq=>f (q/(H*W)) (q/W%H) (q%W):=by unfold eH;split_ifs with h .rw[dX _ _ _ _ 0 (λ_ _=>0) (λo y x _=>f o y x) h,ϟ] .simp[ai,(А:H=0)] lemma iV (g:α-> kg-> α) (I:р kg) (w k U:о): ∀n j e d,e wl g I w k n (U+j*w+e) e d= (pd (j*k+e) n).foldl (λd t=>g d I[U+t/k*w+t%k]!) d:=by intro n;induction n with | zero=>intro j e d _;rfl | succ n m=> intro j e d l;have o:(j*k+e)/k=j:=by rw[Μ,ϊ _ _ А,Ρ l,Θ] have p:(j*k+e)%k=e:=by rw[Μ,ώ,mo l] rw[BR,k9];simp only[wl,o,p];split_ifs with h .exact m j (e+1) _ h .obtain rfl:k=e+1:=А rw[show U+j*w+e+w+1-(e+1)=U+(j+1)*w+0 by rw[nf];omega, m (j+1) 0 _ А];congr 2;ring lemma ir (g:α-> kg-> α) (I:р kg) (w k U n:о) (d:α) (e:0g d I[U+t/k*w+t%k]!) d:=by have:=iV g I w k U n 0 0 d e;simp[ϴ,Ϛ,<- List.range_eq_range'] at this;exact this lemma aa (h:n<2^32):nиб=n:=jL h lemma fn:Z x=((xа:п):ZMod (2^64)):=by unfold Z;norm_cast lemma gx:Z x=((ac x:п):ZMod (2^64)):= (g2 x _).mp (by rw[eE];unfold nE;omega) lemma iT (m:Д) (h:mа<2^62): ac (sg u m)=if kM u then-(mа:п) else mа:=by unfold sg;rw[da];cases kM u<;>simp only[fT,ite_true,ite_false] .exact sZ _ _ (fn m) А А .exact sZ _ _ (by rw[iy,bC,fn];push_cast;ring) А А lemma gf:ok C E 0=true:=rfl lemma fU (a:р Е) (p:Е-> у) (h:a.all p=true) (e:p 0=true) (q:о): p a[q]! =true:=by by_cases d:qpush_cast<;>ring lemma eD: (sk u)г=if uг<2^31 then uг+2^31 else if uг=2^31 then 2^31 else 2^32-1-uг:=by have:=u.toNat_lt;unfold sk;split_ifs<;>simp_all[Ϙ,<- Ζ,pb]<;>omega lemma fI (a b:Е) (h:sk a Kf m⟨dl m n,by constructor<;>intro e;. subst e;decide .have:=dl 0 m;by_contra;have:Kf 0=0:=Б omega⟩ have d:=a.toNat_lt;have g:=b.toNat_lt;have:=F (aг%2^31) (bг%2^31);have:=F (bг%2^31) (aг%2^31);split_ifs at h⊢<;>omega lemma gH:Model.cmpDyadic (mG y) (mG z)=compare (kv y) (kv z):=by have d:∀w,(mG w).toReal=(kv w:ℝ)*2^(-149:п):=λw=>by rw[<- ϙ,k6];unfold kv;push_cast;rw[Ae AM,AA];ring have e:(0:ℝ)<2^(-149:п):=zpow_pos two_pos _;cases h:compare (kv y) (kv z) .rw[Model.cmpDyadic_lt_iff,d,d];exact AN (by exact_mod_cast compare_lt_iff_lt.mp h) e .rw[Model.cmpDyadic_eq_iff,d,d,compare_eq_iff_eq.mp h] .rw[Model.cmpDyadic_gt_iff,d,d];exact AN (by exact_mod_cast compare_gt_iff_gt.mp h) e lemma ci (e:kl u=0):u=0\/u=0x80000000:=by have j:=u.toNat_lt;unfold kl at e;split_ifs at e with g .have d:=a8 u;have l:=aO u;rw[g] at d;rw[<- Ζ,<- Ζ];simp at d⊢;omega .omega lemma be:k7 (mx y z)=mM (k7 y) (k7 z):=by unfold mx;split .rename_i h;have e:=kx y h.1;have g:=kx z h.2.1;have j:Model.compare (k7 y) (k7 z)=nR _:=Model.compare_eq_some_cmpDyadic_of_toDyadic? _ _ e g;rw[gH] at j;have m:Model.chooseNaN2 (k7 y) (k7 z)=none:=(Model.chooseNaN2_eq_none_iff _ _).2 ⟨Χ e,Χ g⟩ unfold mM;rw[Model.withNaNSelection_of_none _ _ m];rw[Model.compareNonNaN_eq_of_compare_eq_some _ _ _ _ j];rcases h.2.2 with d | d | rfl .rw[AE d,compare_lt_iff_lt.mpr (fI y z d)] .rw[AD (UInt32.lt_asymm d),compare_gt_iff_gt.mpr (fI z y d)] .rw[AD (UInt32.lt_irrefl _),compare_eq_iff_eq.mpr rfl] by_cases l:kl y=0 .rcases ci y l with rfl | rfl<;>decide .have o:Model.isZero (k7 y)=false:=by unfold k7;rw[Model.isZero_eq_beq_zero_of_toDyadic?_some e,decodeD_sig_zero];simpa using l simp[o] .exact aR _ lemma eY (w k U n:о) (e:0mM m (k7 I[U+t/k*w+t%k]!)) (k7 d):=by rw[ir _ _ _ _ _ _ _ e,List.foldl_hom k7];exact λ_ _=>(be _ _).symm lemma im: nM (kt u:Model lq)=u:=by show BG (kt u:Model lq).bits=u;rw[nN] lemma aS (d:ki u≠0): mG u=⟨kM u,2^23+(la u)г,((ki u)г:п)-150⟩:=by unfold mG;rw[AD d] lemma cH (f:о) (e:f<2^23): kI (2^23+f) (2^23)=0:=by have d:(2^23+f)ж=23:=by rw[lQ А];constructor<;>omega unfold kI;rw[d,Nat.log2_two_pow] simp[l5,mu, ν]<;>omega lemma eA:kE (m*2^23) (2^23)=m:=by unfold kE;simp lemma gL (q:Е) (p:la d=0) (u:kM d=false) (M:(ki d)г=qг+127) (v:ki d≠255) (x:qг<(ki r)г) (j:ki r≠255): ky (nF (k7 r) (k7 d))=r-(q<<<23):=by have N:=a8 r;have O:=aO r;have U:(ki r)г≠255:=λh=>j (Ζ.mp (by simpa using h)) have A:ki r≠0:=λh=>by simp[h] at x have B:ki d≠0:=λh=>by simp[h] at M have L:=fracOf_toNat_lt r;rw[mR];unfold pp k7 rw[kx r j,kx d v,aS r A,aS d B, p,u] have l:((2:о)^23==0)=false:=Б;have m:(2^23+(la r)г==0)=false:=by simp simp only[n5,Ϛ,Bool.xor_false,l,m,fT,ite_false] change ky (nw FloatFormat.binary32 (kM r) (2^23+(la r)г) (2^23) _)=_ rw[<- mS, bu] unfold nP;rw[cH _ L];simp only[l,m,fT,ite_false,Al,A5];rw[AD А,AD А,AD А];have D:(2^23+(la r)г).shiftLeft 23=(2^23+(la r)г)*2^23:= ν _ _ rw[show ((23:п))=Int.ofNat 23 from rfl, lO] simp only[D,eA];have K:((2^23+(la r)г:о)==pq 24)=false:=by simp[pq];omega simp only[K,fT,ite_false];rw[AD А];set e:=r-(q<<<23) with F;have o:(q<<<23)г=qг*2^23:=by rw[lu];simp[ν];omega have g:eг=rг-qг*2^23:=by rw[F,m4 _ _ (by rw[UInt32.le_iff_toNat_le,o];omega),o] rw[<- nx];conv_rhs=>rw[<- im e,ofUInt32_eq_ofFields] have H:kM e=kM r:=by rw[ϕ,ax,ax,g];omega have I:(ki e)г=(ki r)г-qг:=by rw[a8 e,g];omega have J:(la e)г=(la r)г:=by rw[aO e,g];omega have G:Int.toNat (((ki r)г:п)-150-(((ki d)г:п)-150)+127)= (ki r)г-qг:=А rw[H,I,J,G,(Б:pq 23=2^23),ϰ];rfl lemma iJ (s:kg) (h:s&&&0x7FFFFFFF=0):s=0\/s=0x80000000:=by have e:=s.toNat_lt;have d:(s&&&0x7FFFFFFF)г=sг%2^31:=by rw[Ο,show (0x7FFFFFFF:Е)г=2^31-1 from rfl, ι] rw[h] at d;rw[<- Ζ,<- Ζ];simp at d⊢;omega lemma b9 (e:r=0\/r=0x80000000) (g:ki d≠0) (j:ki d≠255) (l:kM d=false): ky (nF (k7 r) (k7 d))=r:=by have m:ki r≠255:=by rcases e with rfl | rfl<;>decide have p:mG r=⟨kM r,0,0⟩:=by rcases e with rfl | rfl<;>rfl rw[mR];unfold pp k7;rw[kx r m,kx d j,aS d g,l,p];have o:(2^23+(la d)г==0)=false:=by simp simp[o,fT,ite_false,A0,ite_true,Bool.xor_false];rcases e with rfl | rfl<;>rfl lemma aX {a b:Е} (h:aby have:=Ϙ.mp h;rw[e] at this;omega abbrev av:с:=toWord (Au (ofW (dotOf n fa λ_=>oneW)) (ofW d)) lemma fX (v:DQ d):eN r d=ky (nF (k7 r) (k7 d)):=by obtain ⟨e,l,m⟩:=v;have g:ki d≠255:=aX m;unfold eN;dsimp only;split .obtain ⟨q,j,o,p⟩:=‹_/\_›;have u:(ki d)г=(ki d-127)г+127:=by rw[m4 _ _ j];have:=UInt32.le_iff_toNat_le.mp j;simp at this⊢;omega exact (gL r d _ q e u g (Ϙ.mp o) (aX p)).symm split .exact (b9 r d (iJ r ‹_›) l g e).symm .rfl lemma f6 (g:о-> Д) (m:о):∀d:Д, Z ((kQ m).foldl (λd t=>d+g t) d)=Z d+∑t∈km m,Z (g t):=by induction m with | zero=>intro d;simp | succ m e=> intro d;rw[lT,lv,k9,mh,fm,e,Ι];ring lemma jc:ac 0=0:=by rw[eE];rfl lemma gn: (decide (kl u*kl kG=0)&&Bool.xor (kM u) (kM kG))=(u==0x80000000):=by by_cases d:kl u=0 .rcases ci u d with rfl | rfl<;>decide .have:(u==0x80000000)=false:=by rw[beq_eq_false_iff_ne];rintro rfl;exact d Б rw[this,(Б:kl kG=2^23),(Б:kM kG=false)];simp[d] lemma dP (c:о):∀i,i+c<= n -> (mX (kn (n:=n) λj=>fa jз) (kn (n:=n) λ_=>kG) i c=true↔ ∀t,i<= t-> t< i+c-> fa t=0x80000000):=by induction c with | zero=>intro i _;simp[mX];intro t d e;omega | succ c l=> intro i m rw[mX,ab n fa i А,ab n (λ_=>kG) i А, gn,Λ,l (i+1) А,AO] constructor .rintro ⟨d,e⟩ t g o rcases BJ g with h | h .subst h;exact d .exact e t А А .intro h;exact ⟨h i (le_refl _) А,λt d e=>h t А А⟩ lemma eL (O:0kG)=0) (g:у) (L:g=true↔∀tkG)=if g then 0x80000000 else 0:=by have G:=cB n fa (λ_=>kG);have H:=dP n fa n 0 А;have D:=ab n fa have F:=ab n λ_=>kG have d:=Ϣ (f:=λi:Fin n=>fa iз);have p:=Ϣ (f:=λ_:Fin n=>kG);unfold lJ dotSpec Model.dot;generalize (kn (n:=n) λi=>fa iз)=A at* generalize (kn (n:=n) λ_:Fin n=>kG)=B at* have l:∀k,0<= k-> k<0+(A.map (kt (fmt:=lq)))в -> ki A[k]!≠255/\ki B[k]!≠255:=λk _ e=>by simp only[mv,d] at e;rw[D k А,F k А];exact ⟨v k А,Б⟩ have q:∀(X:р Е),Xв=n->(∀k ∀k (e:k<(X.map (kt (fmt:=lq)))в),l6 (X.map (kt (fmt:=lq)))[k]=true:=by intro X N K k e;simp only[mv] at e;have j:=K k А;rw[AC X k e] at j;simp[mA,j] have m:(A.map (kt (fmt:=lq)))в=(B.map (kt (fmt:=lq)))в:=by simp[d,p] have r:=q A d λk e=>(l k А (by simp[d];omega)).1 have u:=q B p λk e=>(l k А (by simp[d];omega)).2 have o:=ϭ (destination:=lq) _ _ m r u;rw[finiteDotSlice_eq A B 0 _ (by simp) (by rw[<- m];simp) l] at o;simp only[mv,d,G,I,Int.cast_zero,mP] at o rw[ϫ lq _ _ .nearestEven m r u ((ϳ _).1 o)] obtain ⟨j,x⟩:=dotStateLoop_flags A B ({}:lB lq) 0 _ (by simp) (by rw[<- m];simp) l unfold lm;rw[j,x];have J:mX A B 0 n=g:=by rw[ϕ,H,L];exact ⟨λh t M=>h t А А,λh t _ M=>h t А⟩ simp only[mv,d,J];cases g<;>simp[show n≠0 by omega]<;>rfl lemma de (w k U m:о) (l:0simp | succ m o=> simp only[lT,lv,k9,mh,Λ,o] exact ⟨λ⟨g,j⟩ t d=>(Nat.lt_succ_iff_lt_or_eq.mp d).elim (g t) λe=>e ▸ j, λh=>⟨λt d=>h t А,h m А⟩⟩ lemma cq (d y x t:о): I[(d*h+y*k)*w+x*k+t/k*w+t%k]! =m5 h w k I d y x t:=by congr 1;ring lemma d7 (B c A H:Д) (D:Bа<=255) (G:cа<=62) (J:0 Д) (L M:п) (T:∀t у) (I:g ()=true↔∀t kg) (v:q ()=lJ n fa λ_=>kG) (d:kg) (m:DQ d): wo B A H g q d=av n fa d:=by have p:=λt e=>dB c B (fa t) D G (u t e) have K:=abs_le.mp (cF n _ _ λt e=>(T t e).2.1);have N:=abs_le.mp (cF n _ _ λt e=>(T t e).2.2);have o:af n fa (λ_=>kG)=(∑t∈km n,bP Bа (fa t))*2^(Bа+149):=by rw[ny];refine ϝ rfl λt e=>?_ rw[fe (fa t) kG _ 126 ((p t (mr e)).2.imp_right (·.1)) (n8 Б), show bP 126 kG=2^23 by decide,(А:Bа+149=Bа+126+23),AG _ (Bа+126)] ring rw[<- ϝ rfl λt e=>(T t (mr e)).1,m6,<- ny, <- sZ A (∑t∈km n,ac (l (fa t))) (by rw[x];push_cast;simp only[gx]) (by linarith) (by linarith),<- sZ H (∑t∈km n,ac (j (fa t))) (by rw[F];push_cast;simp only[gx]) (by linarith) (by linarith)] at o unfold wo av;split .rename_i r;rw[r.1,r.2,jc] at o rw[eL n fa J (λt e=>(p t e).1) (by rw[o];ring) _ I, b9 _ d (by split<;>simp) m.2.1 (aX m.2.2) m.1] .rw[fX _ d m];refine congrArg (λs=>ky (nF (k7 s) (k7 d))) ?_;rw[Dense.dh,dQ];split .refine (aZ n fa _ _ _ _ (λt e=>⟨(p t e).1,Б⟩) ?_ ‹_›).symm;rw[o,eI,show (B+149)а=Bа+149 by rw[ζ];simp;omega] .exact v lemma d5 (c:Д) (x:kg) (g:Bа<=255) (m:cа<=37) (h:ok c B x=true): ac 0*2^25+ac (t1 B x)=bP Bа x /\ |ac (t1 B x)| <= 2^(24+cа)-1 /\ |ac 0| <= 0:=by obtain ⟨-,j⟩:=dB c B x g А h;obtain ⟨l,d⟩:=fd B x cа А j;have:2^(24+cа)<=2^61:=Ε Г А;have e:ac (t1 B x)=bP Bа x:=by unfold t1 bP sv;rw[iT _ _ А,l];cases kM x<;>simp only[fT,ite_true,ite_false,neg_mul]<;>push_cast<;>ring rw[jc,e];refine ⟨by ring,?_,by simp⟩;unfold bP sv cases kM x<;>simp only[fT,ite_true,ite_false,neg_mul,A4]<;> rw[Af В]<;>exact Int.le_sub_one_of_lt (by exact_mod_cast d) lemma ed (f:kg-> Д) (h w k:о) (I:р kg) (d y x:о) (e:0by interval_cases t<;>assumption, λH=>⟨⟨⟨H 0 Б,H 1 Б⟩,H 2 Б⟩,H 3 Б⟩⟩ lemma gM:(eF u)а=(ki u)г:=by unfold eF ki;simp lemma gR (x:kg):ap x<=255:=by unfold ap;split .rw[ε,am];unfold kf;have:=l7 x;split<;>simp<;>omega .exact UInt64.le_refl _ lemma mn (a b:Д):(mU a b)а=mU aа bа:=by show (if a<= b then a else b)а=_;split<;>rename_i h .have:=ε.mp h;omega .have:=mt ε.mpr h;omega lemma dA (a b:Д):mU a b<= a:=ε.mpr (by rw[mn];omega) lemma fB (a b:Д):mU a b<= b:=ε.mpr (by rw[mn];omega) lemma fC (a b:Д):a<= max a b:=by show a<= if a<= b then b else a;split<;>simp_all lemma fD (a b:Д):b<= max a b:=by show b<= if a<= b then b else a;split<;>rename_i h<;>simp_all[ε];omega lemma cM (x:kg) (B M:Д) (d:B<= ap x) (r:eF x<= M) (p:M<= mU (B+37) 254) (o:B<=255):ok 37 B x=true:=by have j:=gM x;have g:=am x;have v:=l7 x;have u:=ε.mp r;have l:=ε.mp p;have q:=ε.mp o;rw[mn,ζ] at l;simp only[j9] at l q;simp only[ok,Λ,AP,Ar,na,AO];refine ⟨λe=>by rw[e] at j;simp at j;omega,?_⟩ by_cases m:mW x=0 .exact nU m .right;unfold ap at d;rw[AE (by simpa using m)] at d have d:=ε.mp d;rw[g] at d;apply Am;rw[ε,χ _ _ (ε.mpr (by rw[g];omega)),g] unfold kf at d⊢;split<;>simp<;>omega lemma jS (d e g j:kg) (h:max (max (eF d) (eF e)) (max (eF g) (eF j))<= mU (mU (mU (ap d) (ap e)) (mU (ap g) (ap j))+37) 254): mU (mU (ap d) (ap e)) (mU (ap g) (ap j))<=255 /\ cQ (ok 37 (mU (mU (ap d) (ap e)) (mU (ap g) (ap j)))) d e g j=true:=by have l:mU (mU (ap d) (ap e)) (mU (ap g) (ap j))<=255:= ϛ (ϛ (dA _ _) (dA _ _)) (gR d) refine ⟨l,?_⟩;simp only[cQ,Λ] exact ⟨⟨⟨cM _ _ _ (ϛ (dA _ _) (dA _ _)) (ϛ (fC _ _) (fC _ _)) h l, cM _ _ _ (ϛ (dA _ _) (fB _ _)) (ϛ (fD _ _) (fC _ _)) h l⟩, cM _ _ _ (ϛ (fB _ _) (dA _ _)) (ϛ (fC _ _) (fD _ _)) h l⟩, cM _ _ _ (ϛ (fB _ _) (fB _ _)) (ϛ (fD _ _) (fD _ _)) h l⟩ lemma gz (B:DQ d) (j y x:о) (e:ф) (D:eб=(j*h+y*2)*w+x*2) (G:(j*h+y*2)*w+x*2+w+1<2^31): gy h w I d j y x e=av (2*2) (m5 h w 2 I j y x) d:=by have q:=cq h w 2 I j y x;have p:=q 0;have r:=q 1;have u:=q 2;have v:=q 3;simp only[Nat.reduceDiv,kp,mP,one_mul,Ax] at p r u v;have m:ky (nF (k7 (cP h w 2 I j y x)) (k7 d))=av (2*2) (m5 h w 2 I j y x) d:=rfl;have:=dc;have g:∀i o,I.uget i o=I[iб]!:=λi o=>(AC I _ o).symm unfold gy;dsimp only;split swap;. exact m simp (disch:=omega) only[g,lR,m9,aa,mo,D,p,r,u,v];split .rename_i l;have l:=jS _ _ _ _ l;have A:=(cR _ (m5 h w 2 I j y x)).1 l.2;exact d7 _ _ _ 37 _ _ (ct l.1) Б Б A _ (λ_=>0) _ 0 (λt F=>d5 _ _ _ (ct l.1) Б (A t F)) Б Б (by simp only[fm,show 2*2=4 from rfl,Ι,Finset.sum_range_zero,Al]) (by simp[bC]) _ (by rw[cR];simp only[AO]) _ rfl d B .exact m lemma dG (f:о-> о-> о-> kg) (e:∀d y x,f d y x=av (k*k) (m5 h w k I d y x) (natW (k*k))): eH c (h/k) (w/k) f=nA c h w k I:=by rw[il];unfold nA;refine lF (by simp[nB]) λq _ _=>?_ simp only[ai,Κ,nB];exact e _ _ _ lemma jk (m:о) (h:m<16384):(cK m)а<=37/\(m:п)*(2^(24+(cK m)а)-1)<2^63:=by unfold cK;split_ifs<;>simp<;>omega lemma eK:dJ=nA:=by funext c h w k I;unfold dJ;dsimp only;split .rename_i d;obtain ⟨e,o,u,B,m⟩:=d;split .rename_i D;obtain ⟨rfl,G⟩:=D;rw[dX _ _ _ _ _ _ _ o,ϟ];unfold nA refine lF (by simp[nB]) λq r _=>?_ simp only[ai,Κ,nB,Ϣ] at r⊢;have F:=(Ϸ (Ϭ o u)).mpr r;have:=Ν (q/(w/2)) o;have:=Ν q u;have v:q/(h/2*(w/2))*h+q/(w/2)%(h/2)*2+1<= c*h:=by have:=μ h (BP F);rw[Υ] at this;omega have A:=μ w v;rw[nf] at A;refine gz h w I _ m _ _ _ _ ?_ А rw[show (2:ф)=USize.ofNat 2 from rfl,<- BO,<- nb,Τ 2, <- mc,aa _ А] .have l:=jk _ B;split .rename_i d refine dG _ _ _ _ _ _ λj y x=>?_ have g:∀tfU I _ d.2 (gf _ _) _ exact d7 _ _ _ (cK (k*k)) _ _ (ct d.1) А (Ϭ e e) g _ (λ_=>0) _ 0 (λt p=>d5 _ _ _ (ct d.1) l.1 (g t p)) l.2 (by simp) (ed _ h w k I j y x e) (by simp[bC]) _ (by simp only[de _ _ _ _ _ _ e,cq,AO]) _ rfl _ m .refine dG _ _ _ _ _ _ λj y x=>?_ split .rename_i d have g:=(de _ _ _ _ _ _ e).1 d.2;simp only[cq] at g exact d7 _ _ _ (cK (k*k)) _ _ (ct d.1) А (Ϭ e e) g _ (λ_=>0) _ 0 (λt p=>d5 _ _ _ (ct d.1) l.1 (g t p)) l.2 (by simp) (ed _ h w k I j y x e) (by simp[bC]) _ (by simp only[de _ _ _ _ _ _ e,cq,AO]) _ rfl _ m .rfl .rfl @[inline] def gY (ch y x:о) (e:ф):с:= let v:=wи if hb:emM j (k7 (m5 h w 2 I d y x t))) (k7 (m5 h w 2 I d y x 0))):=by have q:=cq h w 2 I d y x;have m:=q 0;have o:=q 1;have p:=q 2;have r:=q 3;simp only[Nat.reduceDiv,kp,mP,one_mul,Ax] at m o p r;have:=dc;have g:∀i l,I.uget i l=I[iб]!:=λi l=>(AC I _ l).symm unfold gY;dsimp only;split .simp (disch:=omega) only[g,lR,m9,aa,mo,u] rw[<- cf (mx _ _),be,be,be,be,m,o,p,r];simp only[lT,List.range_zero,lv,k9,mh] .rw[<- cf (wl _ _ _ _ _ _ _ _),eY I w 2 _ (2*2) Б];simp only[m5];congr 2 funext j t;congr 2;ring def dY:р с:= if k=2/\0c5 (gY h w I o y) 2 0 (w/2) ((o*h+y*2)*w)и) (c*(h/2)) 0 0 (AQ (c*(h/2*(w/2)))) else maxpoolSpec c h w k I lemma eZ:dY=maxpoolSpec:=by funext c h w k I;unfold dY;split .rename_i m;obtain ⟨rfl,d,g,p⟩:=m rw[dX _ _ _ _ _ _ _ d,ϟ];unfold maxpoolSpec;refine lF (by simp) λq e _=>?_ simp only[ai,Κ,Ϣ] at e⊢;have o:=(Ϸ (Ϭ d g)).mpr e;have:=Ν (q/(w/2)) d;have:=Ν q g have j:q/(h/2*(w/2))*h+q/(w/2)%(h/2)*2+1<= c*h:=by have:=μ h (BP o);rw[Υ] at this;omega have l:=μ w j;rw[nf] at l;refine gZ h w I _ _ _ _ ?_ А rw[show (2:ф)=USize.ofNat 2 from rfl,<- BO,<- nb,Τ 2, <- mc,aa _ А] .rfl end Conv section open Float.Model.UnpackedFloat local notation "ZA" => rationalWord local notation "ZB" => Array Word local notation "ZC" => Core.mW local notation "ZD" => Core.iW local notation "ZE" => FloatFormat.toModel Fmt local notation "ZF" => AA local notation "ZG" => UInt64.toNat_ofNat' local notation "ZH" => AT local notation "ZI" => Core.ag local notation "ZJ" => Nat.div_eq_zero_iff_lt local notation "ZK" => sqrtLower local notation "ZL" => AL local notation "ZM" => Finset.range local notation "ZO" => mantOf_lt_24 local notation "ZQ" => AM local notation "ZR" => Core.ak local notation "ZS" => Core.am local notation "ZT" => roundRational local notation "ZU" => Nat.div_add_mod' local notation "ZV" => Nat.div_le_self local notation "ZW" => mantOf local notation "ZX" => signOf local notation "ZY" => AO local notation "ZZ" => idxOf local notation "XA" => ite_false local notation "XB" => Ae local notation "XC" => two_ne_zero' local notation "XD" => AX local notation "XE" => ExtendedMantissa.ofMantissaAndAccuracy local notation "XF" => UInt64.ofNat local notation "XG" => Bool.xor local notation "XH" => rowVariance local notation "XI" => (А) local notation "XJ" => (В) local notation "XK" => (by simp) namespace Elem lemma VV (w:kg):(ZC w)а<2^24:=by rw[ZI];exact ZO w lemma YB (a b:kg):(ZC a*ZC b)а=ZW a*ZW b:=by rw[ύ,ZI,ZI];exact β (mul_mant_lt a b) @[specialize] def Y6 (f:о->с) (i stop:о) (out:ZB):ZB:= if ikg) (i d:о) (e:ZB): (Y6 f i d e).toList=e.toList++(pd i (d-i)).map f:=by induction h:d-i generalizing i e with | zero=> unfold Y6;rw[AD XI];simp | succ k g=> unfold Y6;rw[AE XI,g (i+1) _ XI,BR];simp end Elem open Elem namespace Norm def Ya:Accuracy->о | .exact=>0 | .inexact _=>1 lemma Yc {α:Type} (f:α->α) (n:о) (a:α): Nat.repeat f (n+1) a=Nat.repeat f n (f a):=by induction n generalizing a with | zero=>rfl | succ n d=>exact congrArg f (d a) lemma QA (R k:о) (d:Accuracy): XE (2*R+Ya d) .exact>>>(k+2)= XE R d>>>(k+1):=by show Nat.repeat kR (k+2) _= Nat.repeat kR (k+1) _ rw[Yc,Yc,Yc];congr 1;rcases d with _ | ⟨_ | _ | _⟩<;> simp[ExtendedMantissa.ofMantissaAndAccuracy,kR,Ya]<;>omega open FloatLib.Numerics in lemma VY (q r D t:о) (e:0rfl,<-h, show (q*D+r)/D=q by rw[Μ,ϊ _ _ e,Ρ d,Al], show (q*D+r)%D=r by rw[Μ,ώ,β d]] lemma Y5 (e:п):Model.bpow e=(2:ℝ)^e:=by cases e with | ofNat n=>rw[lM,Model.bpow_natCast,ZF] | negSucc n=> rfl lemma Vi (q b:о) (d:q≠0) (h:b<=1):(2*q+b)ж=qж+1:=by have e:=Ϩ d;have g:=ό (n:=q);rw[lQ XI];constructor<;>omega open FloatLib.Numerics in lemma V0 (s:у) (P d:о) (o:P≠0) (l:d≠0) (q r D:о) (x:0omega have g:=Vi q _ j y;have G:(r:ℝ)/D<1:=by rw[div_lt_one XJ];exact_mod_cast t have E:(0:ℝ)<=r/D:=XJ;push_cast at u v;have w:kI P d=(qж:п)+e:=by apply Model.floorLog2_eq_of_bounds P d _ o l .rw[h,Y5,ZL ZQ,ZF];gcongr;linarith .rw[h,Y5,show (qж:п)+e+1=((qж+1:о):п)+e by push_cast;ring,ZL ZQ,ZF];gcongr;linarith have p:kE (lw P d (23-((qж:п)+e))).1 (lw P d (23-((qж:п)+e))).2= roundShiftRightEven (2*q+if r=0 then 0 else 1) ((2*q+if r=0 then 0 else 1)ж-23):=by rw[roundShiftRightEven_eq_roundQuotientEven,g,show qж+1-23=(qж-23)+1 by clear*-m g;omega,<-VY q r D _ x t XI] apply Model.roundQuotientEven_eq_of_rat_eq _ _ _ _ (RationalBinary.scaleByPowerOfTwo_snd_ne_zero _ _ _ l) XJ rw[Model.scaleByPowerOfTwo_real];unfold Model.scaledRatToReal;rw[h,Y5,XD,<-ZL ZQ, show e+(23-((qж:п)+e))=-((qж-23:о):п) by clear*-m g;omega, Aw,ZF] push_cast;field_simp generalize F:2*q+(if r=0 then 0 else 1)=J at g p⊢;rw[kd,ite_eq_left Б,Model.ieeeRoundDyadic_eq_ieeeRoundDyadicImpl];simp only[Model.roundRat,nw,(Б:Fmt.isIEEE=true),↓reduceDIte, Model.ieeeRoundRatScaled,Model.ieeeRoundDyadicImpl,ZY,o,l,XA,w, Int.add_zero,lM,g,(Б:(FloatFormat.ieeeMaxNormalExponent lq:п)=127), show FloatFormat.ieeeMinNormalExponent lq=-126 by decide, show (FloatFormat.normalMantissaExpOffset lq:п)=150 by decide, show Fmt.fracWidth=23 by decide,show J≠0 by omega, show ((qж+1:о):п)+(e-1)=(qж:п)+e by push_cast;ring, show¬((qж:п)+e>127) by omega,show¬((qж:п)+e< -150) by omega, show¬((qж:п)+e< -126) by omega,(А:23<=qж+1),ite_true, nr,p] lemma Y8 (v:ℚ) (w:v≠0) (s:у) (u:decide (v<0)=s) (q:о) (ρ:ℚ) (o:0<=ρ) (g:ρ<1) (e:п) (j:|v|=((q:ℚ)+ρ)*(2:ℚ)^e) (p:2^25<=q) (l:-126<=(qж:п)+e) (m:(qж:п)+e<=126): ZT v= ky (kd lq ⟨s,2*q+(if ρ=0 then 0 else 1),e-1⟩):=by have h:ρ=(ρ.numл:ℚ)/ρ.den:=by conv_lhs=>rw[<-Rat.num_div_den ρ] congr 1;exact_mod_cast (Int.toNat_of_nonneg (Rat.num_nonneg.mpr o)).symm have d:=ρ.den_pos;generalize ρ.den=D,ρ.numл=r at h d;subst h;have t:r(z:ℝ)) j;rw[Rat.abs_def,Rat.divInt_eq_div] at this;push_cast at this;rwa[Nat.cast_natAbs,lX] lemma Q7 (R:о) (s:п) (h:2^25<=R): -s+1<=(ZE).targetExponent (kz R (-s)):=by have:=(li XI).2 h;have:(ZE).mantissaBits<=25:=Б;unfold BT kz;omega lemma Vd (v:ℚ) (q:0simp lemma YN (w:kg):(sv w:ℚ)=0↔ZW w=0:=by unfold sv;split_ifs<;>simp lemma Vr (w:kg):(sv w:ℚ)=(if ZX w then-1 else 1)*ZW w:=by unfold sv;split_ifs<;>simp lemma Y7 (x:Д):(ZR x)а=xаж:=by rw[aA];rfl @[specialize] def Yh (x:ZB) (i stop u:о):о:= if ih (by rw[<-ZI,d];rfl) simp[this,h] lemma Yi (x:ZB) (d:о): ∀k i u,d-i=k->Yh x i d u<=u/\ ∀j,i<=j->jZW x[j]! =0\/Yh x i d u<= ZZ x[j]!:=by intro k;induction k<;>intro i u h<;>unfold Yh .rw[AD XI];exact ⟨AV,λ_ _ _=>А⟩ .rename_i p;rw[AE XI];dsimp only;rw[YK,ZS];obtain ⟨e,m⟩:=p (i+1) (if decide (ZW x[i]! =0)=true then u else mU u (ZZ x[i]!)) XI refine ⟨Ag e (by split_ifs<;>omega),?_⟩;intro j q l;by_cases o:j=i .subst o;by_cases g:ZW x[j]! =0 .exact nU g .simp only[g,BE,ξ,XA] at e⊢;omega .exact m j XI l def VJ (x:ZB) (u j:о):о:= (ZW x[j]!*ZW x[j]!)<<<(2*(ZZ x[j]!-u)) @[specialize] def Yl (x:ZB) (u i stop:о) (l h:Д) (c big:о):о:= if i>>1)>>>(63-k) else mm<<<(k-64) let l':=l+vl let h':=h+vh+(if l'>>1)>>>(63-kе) else d<<<(kе-64))а*2^64=dа*2^k/\ (if kе<64 then (d>>>1)>>>(63-kе) else d<<<(kе-64))а<2^62:=by have g:kеа=k:=by rw[ϑ,ZG,β XI] by_cases h:k<64 .have j:kе<64:=by rw[θ,g];simpa simp only[j,ite_true,Α,ψ,χ _ _ (show kе<=63 by rw[ε,g];simp;omega),g,j9, ν,γ,β h, β (А:63-k<64),kp,ϵ] have e:2^1*2^(63-k)=2^(64-k):=by rw[<-AG];congr 1;omega have l:2^64=2^(64-k)*2^k:=by rw[<-AG];congr 1;omega rw[e,l,Nat.mul_mod_mul_right,<-ϟ,<-Ϡ,Nat.mod_add_div'];exact ⟨rfl,AH (ZV _ _) XI⟩ .have j:¬kе<64:=by rw[θ,g];simp;omega have m:dа*2^(k-64)<2^62:= calc _<2^48*2^14:= kX o (Ε XJ XI) XJ _=_:=rfl simp only[j,XA,Ϗ,Θ,Α,χ _ _ (show (64:Д)<=kе by rw[ε,g];simp;omega),g, j9,β (А:k-64<64),ν, β (А:dа*2^(k-64)<2^64)] refine ⟨?_,m⟩;rw[ϟ,<-AG];congr 2;omega lemma Vb (x:ZB) (u d:о): ∀k i (l h:Д) c big,d-i=k-> Yl x u i d l h c big=big+lа+hа*2^64+c*2^128+ ∑j∈ZM k,VJ x u (i+j):=by intro k;induction k<;>intro i l h c big q<;>unfold Yl .rw[AD XI];simp only[ν,Finset.range_zero,Finset.sum_empty];ring .rename_i p;rw[AE XI,lr];have e:∀j,VJ x u (i+(j+1))=VJ x u (i+1+j):=λj=>by rw[mw];rfl simp only[e,Ϛ];have o:VJ x u i=(ZC x[i]!*ZC x[i]!)а* 2^(2*((ZD x[i]!)а-u)):=by unfold VJ;rw[ν,YB,ZS] have r:(ZC x[i]!*ZC x[i]!)а<2^48:=by rw[YB];have:=ZO x[i]! calc _<2^24*2^24:=ϗ this this _=_:=rfl rw[o];generalize (ZD x[i]!)а-u=g at* generalize ZC x[i]!*ZC x[i]! =m at* by_cases t:g<=39 .have:=VL m (2*g) r XI;generalize (if (2*g)е<64 then m<<<(2*g)е else 0)=v at* generalize (if (2*g)е<64 then (m>>>1)>>>(63-(2*g)е) else m<<<((2*g)е-64))=w at* rw[p (i+1) _ _ _ _ XI];clear q o;have:=l.toNat_lt;have:=h.toNat_lt;have:=v.toNat_lt;simp only[ζ,θ,Az kY,j9];split_ifs<;>omega .rw[AD t,p (i+1) _ _ _ _ XI,ν];ring lemma Yk (n:о) (f:о->ℚ) (a:ℚ): (kQ n).foldl (λt j=>t+f j) a=a+∑j∈ZM n,f j:=by induction n generalizing a with | zero=>simp | succ n d=> rw[lT,lv,d,Ι];simp;ring lemma VG (d u:о) (h:u<= d): ((2:ℚ)^((d:п)-149))^2=(2:ℚ)^(2*(d-u))*(2:ℚ)^(2*(u:п)-298):=by rw[<-ZF ((2:ℚ)^((d:п)-149)) 2,<-zpow_mul, <-ZF (2:ℚ) (2*(d-u)),<-ZL ZQ] congr 1;omega lemma Ye (w:kg) (u:о) (h:ZW w=0\/u<= ZZ w): ZA w^2= (((ZW w*ZW w)<<<(2*(ZZ w-u)):о):ℚ)*2^(2*(u:п)-298):=by rw[Y1,ν];rcases h with h | h .rw[(YN w).2 h,h];simp .rw[mul_pow,show (sv w:ℚ)^2=(ZW w:ℚ)*ZW w by rw[<-sq_abs,VT];ring,VG _ _ h];push_cast;ring def Yf (num den:о) (s:п):с:= toWord (Model.ofModel Fmt (roundWithAccuracy (ZE) .positive (ZK num den) (-s) (sqrtAccuracy num den))) open Float.Model in lemma Q4 (spec:Format) (g:nZ) (R:о) (e:п) (d:Accuracy) (l:R≠0) (p:e+1<= spec.targetExponent (kz R e)): mH spec g R e d=nI spec g (2*R+Ya d) (e-1):=by have m:Ya d<=1:=by cases d<;>simp[Ya] have h:kz (2*R+Ya d) (e-1)=kz R e:=by unfold kz;rw[Vi R _ l m];push_cast;ring unfold nI decreaseExponent;simp only[h];rw[(А:(e-1-spec.targetExponent (kz R e))л=0)];simp;unfold mH shiftToTargetExponent shiftToExponent;rw[h];generalize o:spec.targetExponent (kz R e)=T at* obtain ⟨k,j⟩:∃k,(T-e)л=k+1:=⟨(T-e)л-1,XI⟩;dsimp only;rw[j,(А:(T-(e-1))л=k+2),QA,show e-1+((k+2:о):п)=e+((k+1:о):п) by push_cast;ring] lemma Vh (e d:о): Ya (sqrtAccuracy e d)=if e=ZK e d^2*d then 0 else 1:=by unfold sqrtAccuracy;dsimp only;split_ifs<;>rfl lemma V9 (e d:о) (s:п) (p:33554432<= ZK e d) (l:ZK e d>>>31=0) (m:-209<= s) (o:s<=297): Yf e d s=an false (XF (2*ZK e d+ (if e=ZK e d*ZK e d*d then 0 else 1))) (XF (297-s)л):=by set R:=ZK e d with g have h:(XF (297-s)л)а=(297-s)л:=by rw[ZG,β XI] have q:(if e=R*R*d then 0 else 1)<=1:=by split_ifs<;>omega have j:(XF (2*R+(if e=R*R*d then 0 else 1)))а= 2*R+(if e=R*R*d then 0 else 1):=by rw[ZG,β XI] rw[aJ _ _ _ (by rw[h];omega),h,j];unfold Yf;rw[<-g,Q4 _ _ R (-s) _ XI (Q7 R s XI),Vh,<-g,sq, show (((297-s)л:о):п)-298=-s-1 by omega] rfl @[inline] def YG (num den R:о) (s:п):с:= if R>>>31==0&&-209<= s&&s<=297 then Core.an false (XF (2*R+(if num==R*R*den then 0 else 1))) (XF (297-s)л) else Yf num den s lemma Vc (e d:о) (s:п) (g:33554432<= ZK e d): YG e d (ZK e d) s=Yf e d s:=by unfold YG;split next h=> simp at h;rw[V9 e d s g h.1.1 h.1.2 h.2];simp next=>rfl def V8 (B:о) (c:п):о:=if 0<=c then B<<rw[ν] .refine ⟨e,?_⟩;push_cast;rw[<-ZF (2:ℚ) cл,(А:((cл:о):п)=c)];ring .refine ⟨XJ,?_⟩;push_cast;rw[<-ZF (2:ℚ) (-c)л,(А:(((-c)л:о):п)=-c)];have:(2:ℚ)^(-c)≠0:=XJ;rw[Aw];field_simp def V5 (A Dn u:о) (eps:с):с:= let E:=ZW eps let ie:=ZZ eps let w0:=min (2*u) (ie+149) let B:=(A<<<(2*u-w0))+((Dn*E)<<<(ie+149-w0)) let s:п:=(350-(w0:п)-((Bж:п)-(Dnж:п)))/2 let c:п:=(w0:п)-298+2*s let num:=V8 B c let den:=YF Dn c let R:=ZK num den if 33554432<=R then YG num den R s else sqrtRational ((A:ℚ)*2^(2*(u:п)-298)/Dn+ZA eps) lemma YW (A e u:о) (d:kg) (t:0 (2:ℚ)^j=2^k*2^((g:п)-298):=by intro k j h;rw[h,<-ZF,<-ZL ZQ];ring_nf have:=congrArg (λz:ℚ=>(z:ℝ)) (w.trans (by rw[<-v,ZL ZQ,m (2*u-g) (2*(u:п)-298) XI, m (l+149-g) ((l:п)-149) XI,ν,ν] push_cast;field_simp: _=((A:ℚ)*2^(2*(u:п)-298)/e+E*2^((l:п)-149))*2^(2*s))) push_cast at this⊢;exact this .rfl @[inline] def VO (x k:о):о:= if k<63&&x>>>(63-k)==0 then (xе<<>>63==0 then (ZR xе)а else xж @[inline] def V2 (r:о) (st:у):о:=if r !=0 || st then 1 else 0 lemma VI (N M:о) (e:0decide (v<0)=s) (p:0<=δ) (q:δ<1) (w:g=true↔δ≠0) (x:0simp_all .omega @[specialize] def Ym (x:ZB) (u i stop P N:о):о×о:= if i ((Ym x u i d P N).1:п)-(Ym x u i d P N).2= (P:п)-N+∑j∈ZM k,YS x u (i+j):=by intro k;induction k<;>intro i P N h<;>unfold Ym .rw[AD XI];simp .rename_i g;rw[AE XI];simp only[Yz,ZI,ZS,lr];have e:∀j,YS x u (i+(j+1))=YS x u (i+1+j):=λj=>by rw[mw];rfl simp only[e,Ϛ];rw[YS];split_ifs<;>rw[g (i+1) _ _ XI]<;>push_cast<;>ring lemma Yx (x:ZB) (u j:о) (h:ZW x[j]! =0\/u<= ZZ x[j]!): ZA x[j]! =(YS x u j:ℚ)*2^((u:п)-149):=by rw[Y1];unfold YS;rcases h with h | h .rw[(YN _).2 h,h];simp .rw[show (2:ℚ)^((ZZ x[j]!:п)-149)=(2:ℚ)^(ZZ x[j]!-u)*2^((u:п)-149) by rw[<-ZF,<-ZL ZQ];congr 1;omega,Vr,ν];split_ifs<;>push_cast<;>ring lemma VW (n:о) (x:ZB) (r u:о) (d:∀j,r*n<=j->jZW x[j]! =0\/u<= ZZ x[j]!): (∑j∈ZM n,ZA x[r*n+j]! = ((((Ym x u (r*n) (r*n+n) 0 0).1:п)-(Ym x u (r*n) (r*n+n) 0 0).2:п):ℚ)* 2^((u:п)-149))/\ (∑j∈ZM n,ZA x[r*n+j]!^2= ((Yl x u (r*n) (r*n+n) 0 0 0 0:о):ℚ)*2^(2*(u:п)-298)):=by rw[VN x u _ n _ 0 0 XI,Vb x u _ n _ 0 0 0 0 XI];push_cast[A5,Al,Ϗ,ϴ,Ϛ,Θ,ny];constructor<;>refine ϝ rfl λj e=>?_<;>rw[ϯ] at e;exacts [Yx x u _ (d _ XI XI),Ye _ u (d _ XI XI)] lemma YA (n:о) (x:ZB) (r u:о) (d:∀j,r*n<=j->jZW x[j]! =0\/u<= ZZ x[j]!): XH n x r 0= ((Yl x u (r*n) (r*n+n) 0 0 0 0:о):ℚ)*2^(2*(u:п)-298)/n:=by unfold rowVariance;rw[Yk,Al];simp only[A5];rw[(VW n x r u d).2] @[inline] def Y0 (a b:о):о:=if b<=a then a-b else b-a lemma YO (a b:о):((Y0 a b*Y0 a b:о):ℚ)=((a:ℚ)-b)^2:=by unfold Y0;split_ifs with h .push_cast[h];ring .push_cast[(А:a<=b)];ring lemma VF (n:о) (x:ZB) (r u:о) (w:0jZW x[j]! =0\/u<= ZZ x[j]!): let pn:=Ym x u (r*n) (r*n+n) 0 0 let Q:=Yl x u (r*n) (r*n+n) 0 0 0 0 mI n x r=((pn.1:ℚ)-pn.2)*2^((u:п)-149)/n/\ XH n x r (mI n x r)= ((n*Q-Y0 pn.1 pn.2*Y0 pn.1 pn.2:о):ℚ)* 2^(2*(u:п)-298)/((n*n:о):ℚ):=by intro pn Q;obtain ⟨d,m⟩:=VW n x r u t;push_cast at d have g:mI n x r=((pn.1:ℚ)-pn.2)*2^((u:п)-149)/n:=by unfold mI;rw[Yk,Al,d] set c:ℚ:=2^((u:п)-149) with q;have l:(2:ℚ)^(2*(u:п)-298)=c^2:=by rw[q,<-ZF,<-zpow_mul];push_cast;ring set S:ℚ:=(pn.1:ℚ)-pn.2 with o;have h:XH n x r (mI n x r)= ((n:ℚ)*Q-S^2)*c^2/((n:ℚ)*n):=by unfold rowVariance;rw[Yk,Al,g,ϝ rfl λj _=>show (ZA x[r*n+j]!-S*c/n)^2= ZA x[r*n+j]!^2-2*(S*c/n)*ZA x[r*n+j]!+(S*c/n)^2 by ring,m6,Finset.sum_sub_distrib, <-Finset.mul_sum,d,m,l,Finset.sum_const,Finset.card_range,nsmul_eq_mul] field_simp;ring have v:(0:ℚ)<=(n:ℚ)*Q-S^2:=by have e:0<=XH n x r (mI n x r):=by unfold rowVariance;rw[Yk,Al];positivity rw[h,le_div_iff₀ XJ,mP] at e;exact (mul_nonneg_iff_of_pos_right XJ).1 e have p:Y0 pn.1 pn.2*Y0 pn.1 pn.2<=n*Q:=(Nat.cast_le (α:=ℚ)).1 (by rw[YO];push_cast;linarith) refine ⟨g,?_⟩;rw[h,n4 p,YO,<-o,l];push_cast;ring def sg (s:у) (M:ℚ):ℚ:=if s then-M else M lemma Q6 (w:kg):(ZC w !=0)=!decide (ZW w=0):=by rw[show (ZC w !=0)=!(ZC w==0) from rfl,YK] lemma Y2 (w:kg):ZA w=sg (ZX w) (ZW w)*2^((ZZ w:п)-149):=by rw[Y1,Vr];unfold sg;split_ifs<;>ring lemma Yn (a b:о):sg (decide (aomega namespace NF open Dense.F open Dense (ay) open FloatLib.Floats.Formats.Flocq in lemma ja (z:ℝ): |Model.roundAt ka z-z| <= |z| /2^53+1/2^1075:=by by_cases g:z=0 .subst g;rw[mf];simp only[A5,abs_zero];positivity have l:0< |z| :=abs_pos.mpr g have d: |z| <(2:ℝ)^(m7 2 |z| +1):=by have:=Int.lt_zpow_succ_log_self (R:=ℝ) (b:=2) Г |z|;exact_mod_cast this have m:(2:ℝ)^(m7 2 |z|)<= |z| :=by have:=Int.zpow_log_le_self (R:=ℝ) (b:=2) Г l;exact_mod_cast this have o:(0:ℝ)<=1/2^1075:=В;by_cases j:-1021<= m7 2 |z| +1 .have:=re z _ j d have e:(2:ℝ)^(m7 2 |z| +1-53)/2=(2:ℝ)^(m7 2 |z|)/2^53:=by rw[show m7 2 |z| +1-53=m7 2 |z| +(-52) by ring,AL Г] rw[show (-52:ℤ)=-((52:ℕ):ℤ) by norm_num,Aw,AA];field_simp rw[e] at this;have:(2:ℝ)^(m7 2 |z|)/2^53<= |z| /2^53:=by gcongr linarith .have h: |z| <(2:ℝ)^(-1021:ℤ):=AJ d (AI Г А) have:=re z (-1021) AV h have e:(2:ℝ)^((-1021:ℤ)-53)/2=1/2^1075:=by rw[show ((-1021:ℤ)-53)=-((1074:ℕ):ℤ) by norm_num,Aw,AA];field_simp rw[e] at this;have:0<= |z| /2^53:=В linarith lemma fA (x y:т) (h:fv x) (j:fv y) (g: |rv x+rv y| <= (2:ℝ)^(971:п)): fv (x+y) /\ |rv (x+y)-(rv x+rv y)| <= |rv x+rv y| /2^53+1/2^1075:=by obtain ⟨d,e⟩:=gO x y h j (g.trans (pm 971 AV));exact ⟨d,by rw[e];exact ja _⟩ lemma fM (x y:т) (h:fv x) (j:fv y) (g: |rv x*rv y| <= (2:ℝ)^(971:п)): fv (x*y) /\ |rv (x*y)-rv x*rv y| <= |rv x*rv y| /2^53+1/2^1075:=by obtain ⟨d,e⟩:=i0 x y h j g;exact ⟨d,by rw[e];exact ja _⟩ lemma jO (b:Д):(mF b)а=(b&&&0xfffffffffffff)а+2^52:=by have d:(b&&&0xfffffffffffff)а<2^52:=by rw[Β];exact AH ϋ Б unfold mF;rw[lP,show (0x10000000000000:Д)а=2^52*1 from rfl,Nat.or_comm, <- Ϟ d,Ϻ,Μ] lemma iR (v Y U:ℝ) (d:у) (M L c:ℕ) (o:0simp only[ite_true,ξ,ite_false] at j⊢<;>rw[w] at j<;> constructor<;>linarith only[j,r,t,p,q] end NF namespace NE open NF Dense.F open Dense (ay) @[inline] def mx (a b:Д):Д:=if arename_i h<;>simp only[θ] at h<;>omega @[inline] def pk (s:у) (q σ:Д):с:= ((if s then (0x80000000:Д) else 0)+((σ-146)<<<23+Core.aj (((2:Д)*q+1)<<<36)))й @[inline] def el (x g b:с) (nd nS R pz:т) (A1 A2 C1:Д) (slow:Unit-> с):с:= let v:=(dw x*nd+nS)*dw g*R+dw b*pz let B:=v.toBits let E:=eF B let σ:=E-C1 let M:=mF B let L:=M&&&0x7FFFFFF let c:=mx (mx (E+10) (Core.iW b+A1)) (Core.iW g+A2)-E if 146<= σ&&σ<=398&&c<=25&&(1<<>>63!=0) (M>>>27) σ else slow () lemma jT (s:у) (q σ:Д) (m:2^25<= qа) (o:qа<2^26) (p:146<= σа) (r:σа<=398):pk s q σ=an s ((2:Д)*q+1) σ:=by have d:((2:Д)*q+1)а=2*qа+1:=by rw[ζ,ύ];simp only[j9];omega have h:(((2:Д)*q+1)<<<36)а=(2*qа+1)*2^36:=by rw[Α,d];simp only[j9,kp,ν];omega have e:(σ-36)а=σа-36:=by rw[χ σ 36 (ε.2 (by simp only[j9];omega))];rfl have g:an s ((2:Д)*q+1) σ=an s (((2:Д)*q+1)<<<36) (σ-36):=by rw[bJ s ((2:Д)*q+1) σ А А, bJ s (((2:Д)*q+1)<<<36) (σ-36) А А,d,h,e, show (2:п)^σа=2^36*2^(σа-36) by rw[<- AG,lV (А:36<= σа)]] cases s<;>simp only[ite_true,ite_false,ξ]<;>push_cast<;>ring_nf have j:(pk s q σ)г=(if s then 2^31 else 0)+((σа-146)*2^23+ (aj (((2:Д)*q+1)<<<36))а):=by obtain ⟨-,-,t⟩:=bg s (((2:Д)*q+1)<<<36) (σ-36) А А А А;unfold pk rw[ϣ,ζ,ζ,Α, χ σ 146 (ε.2 (by simp only[j9];omega))] cases s<;>simp only[ite_true,ite_false,ξ,j9,kp,ν]<;>omega obtain ⟨l,-,-⟩:=bg s (((2:Д)*q+1)<<<36) (σ-36) А А А А;rw[g];apply Ζ.mp;rw[j,l,e];omega lemma pB (a b:ℝ) (p q:ℕ) (d: |a| <= 2^p) (e: |b| <= 2^q): |a*b| <= 2^(p+q):=by rw[Ah,AG];exact mul_le_mul d e (Aa _) В lemma sB (a b:ℝ) (p:ℕ) (d: |a| <= 2^p) (e: |b| <= 2^p): |a+b| <= 2^(p+1):=by rw[pow_succ];linarith[Ac a b] lemma eB (x y:ℝ) (p:ℕ) (h: |x-y| <= |y| /2^53+1/2^1075) (g: |y| <= 2^p): |x| <= 2^(p+1):=by have e:(1:ℝ)<=2^p:=one_le_pow₀ Г;have d:(1:ℝ)/2^1075<=1/2^1:=AU Г Г;rw[pow_one] at d;have:=Ad x y;rw[pow_succ];linarith[Aa y] lemma mo (a:ℝ) (p q:ℕ) (h: |a| <= 2^p) (d:p<= q): |a| <= 2^q:= h.trans (AS Г d) lemma z9 (a:ℝ) (p:ℕ) (h: |a| <= 2^p) (d:p<=971): |a| <= (2:ℝ)^(971:ℤ):=by rw[show (971:ℤ)=((971:ℕ):ℤ) from rfl,AA];exact mo a p 971 h d lemma wB (w:kg): |(sv w:ℝ)*2^kf w| <= 2^(24+kf w):=by rw[Ah,AR (by positivity:(0:ℝ)<2^idxOf w),AG] have: |(sv w:ℝ)| <= 2^24:=by rw[<- lX,ϸ];exact_mod_cast (ce w).le exact AF this В lemma jl (A H w p G R κ l a t j v q:ℝ) (o c E u y x:ℕ) (hA:A=H+w) (he: |w+p| <= q) (z: |a-A| <= |A| /2^53+1/2^1075) (B: |t-a*G| <= |a*G| /2^53+1/2^1075) (D: |j-t*R| <= |t*R| /2^53+1/2^1075) (V: |v-(j+l)| <= |j+l| /2^53+1/2^1075) (g:0<= R) (hR: |R-κ| <= R/2^50) (hκ:0<= κ) (Y: |v| <= 2^53*(2:ℝ)^((o:ℤ)-1075)) (ah: |l| <= 2^(24+E+x)) (hG: |G| <= 2^(24+u)) (a0:u<=254) (a6:κ<=2^53) (al:R<=2^52) (as:10<= c) (aH:E+x+1056<= c+o) (N:q=0\/(q=2^y/\y+u+1154<= c+o)): |v-((H-p)*G*κ+l)| <= 2^c*(2:ℝ)^((o:ℤ)-1075):=by refine (?_:_<=(|v| + |l|)/2^45+q* |G| *κ+ (4*(1/2^1075)+4*(1/2^1075*R)+4*(1/2^1075*(|G| *R)))).trans ?_ .set τ:ℝ:=1/2^1075 with hτ have m:0<= τ:=В;have r:=Aa G have X: |j+l| <= 2* |v| +2*τ:=by have:=Ad (j+l) v;rw[Ay] at this;linarith only[this,V,Aa v,m] have M: |t| *R<=2* |j| +2*τ:=by have:=Ad (t*R) j;rw[Ay] at this;rw[Ah,Af g] at this D;linarith only[this,D,Aa j,m] have K: |a| * |G| <= 2* |t| +2*τ:=by have:=Ad (a*G) t;rw[Ay] at this;rw[Ah] at this B;linarith only[this,B,Aa t,m] have J: |A| <= 2* |a| +2*τ:=by have:=Ad A a;rw[Ay] at this;linarith only[this,z,Aa a,m] have L: |j| <= 2* |v| +2*τ+ |l| :=by have:=Ac (j+l) (-l);rw[A4] at this;simp only[add_neg_cancel_right] at this;linarith only[this,X] rw[Ah a G] at B;rw[Ah t R,Af g] at D;have p1:=AF B g;have p2:=AF K g;have p3:=AF z (Aq r g);have p4:=AF J (Aq r g);have p5:=mul_le_mul_of_nonneg_left hR (Aq (Aa A) r) have p6: |w+p| * |G| *κ<= q* |G| *κ:= AF (AF he r) hκ have e:v-((H-p)*G*κ+l)=(v-(j+l))+(j-t*R)+(t-a*G)*R+(a-A)*(G*R) +A*G*(R-κ)+(w+p)*G*κ:=by rw[hA];ring rw[e] have T:∀a b c d e f:ℝ,|a+b+c+d+e+f| <= |a| + |b| + |c| + |d| + |e| + |f| :=λa b c d e f=>by have q1:=Ac (a+b+c+d+e) f;have q2:=Ac (a+b+c+d) e;have q3:=Ac (a+b+c) d;have q4:=Ac (a+b) c;have q5:=Ac a b;linarith only[q1,q2,q3,q4,q5] have s1:=T (v-(j+l)) (j-t*R) ((t-a*G)*R) ((a-A)*(G*R)) (A*G*(R-κ)) ((w+p)*G*κ);simp only[Ah,Af g,Af hκ] at s1;have Y:=Aa v;have hb:=Aa l;have S:=Aa j;have U:τ<=1/2^1075:=A7 hτ;clear_value τ;have O:0<= τ*R:=Aq m g;have Q:0<= τ*(|G| *R):=Aq m (Aq r g) linarith only[s1,V,X,D,p1,p2,p3,p4,p5,p6,L,M,Y,hb,S,U,m,O,Q,r] set T:ℝ:=(2:ℝ)^((c:ℤ)-2+o-1075) with W have z:(2:ℝ)^c*(2:ℝ)^((o:ℤ)-1075)=4*T:=by rw[W,<- AA,<- AL Г,show (4:ℝ)=2^(2:ℤ) by norm_num,<- AL Г] congr 1;ring rw[z];have F:∀a b:ℤ,a<= b->(2:ℝ)^a<=2^b:=λa b h=>AI Г h have t1: |v| /2^45<= T:=calc _<=2^53*(2:ℝ)^((o:ℤ)-1075)/2^45:=by gcongr _=(2:ℝ)^((8:ℕ)+((o:ℤ)-1075)):=by rw[AL Г,AA];field_simp _<= T:=F _ _ А have j: |l| /2^45<= T:=calc _<=(2:ℝ)^(24+E+x)/2^45:=by gcongr _=(2:ℝ)^(((24+E+x:ℕ):ℤ)-45):=by rw[Ae Г,AA];norm_num _<= T:=F _ _ (by push_cast;omega) have t3:q* |G| *κ<= T:=by rcases N with I | ⟨I,aL⟩ .rw[I,mP,mP];positivity rw[I];calc _<=(2:ℝ)^y*2^(24+u)*2^53:=by gcongr _=(2:ℝ)^(((y+(24+u)+53:ℕ):ℤ)):=by rw[AA];ring _<= T:=F _ _ (by push_cast;omega) have g1: |G| <= 2^278:=hG.trans (AS Г А) have a2:(1:ℝ)/2^1075*R<=1/2^25:=calc _<=(1:ℝ)/2^1075*2^52:=by gcongr _=1/2^1023:=by field_simp _<= _:=AU Г Г have a3:(1:ℝ)/2^1075*(|G| *R)<=1/2^25:=calc _<=(1:ℝ)/2^1075*(2^278*2^52):=by gcongr _=1/2^745:=by field_simp _<= _:=AU Г Г have a4:(1:ℝ)/2^21<= T:=by rw[W,show (1:ℝ)/2^21=2^(-21:ℤ) by norm_num];exact F _ _ А have a1:(1:ℝ)/2^1075<=1/2^25:=AU Г Г;have a5:(12:ℝ)*(1/2^25)<=1/2^21:=Г;linarith only[t1,j,t3,a1,a2,a3,a4,a5] end NE namespace NR open NF Dense.F open Dense (ay) @[inline] def pt (j:о):т:=P.get! (j+1) @[inline] def p2 (e:о):т:=pt (min e 254)*pt (e-min e 254) lemma i7 (j:о) (g:j<=254):fv (pt j)/\rv (pt j)=(2:ℝ)^j:=by have h:pt j=pw j:=by have d:P.get! (j+1)=P.data[j+1]!:=by rcases P with ⟨e⟩;rfl unfold pt;rw[d,AC P.data (j+1) (by simp[P];omega)] simp only[P,Κ];rw[AE А];rfl rw[h];exact i8 j А lemma i6 (e:о) (l:e<=508):fv (p2 e)/\rv (p2 e)=(2:ℝ)^e:=by obtain ⟨d,h⟩:=i7 (mU e 254) А;obtain ⟨g,j⟩:=i7 (e-mU e 254) А have:=aQ _ _ d g 1 (e:ℤ) (by rw[h,j,<- AG,AA];push_cast;rw[one_mul];congr 1;omega) Б А (ca 1 e 971 А Г 1 Б) unfold p2;refine ⟨this.1,?_⟩;rw[this.2,AA];simp structure go where td:с ok:у nS:т R:т pz:т A1:Д A2:Д C1:Д @[inline] def aT (n:о) (t:о×о×у×о×о×с):go:= let k2:=t.2.1-21 let Sm:=(t.2.2.2.1<<<(t.2.1-k2))+(t.2.2.2.2.1>>>k2) let es:=k2+t.1 let d:=t.2.2.2.2.2 let D:=nе*Core.mW d let lD:=Core.ak D let s:=lD-11 let R0:=((0x8000000000000000/D)<<>>53==0&& decide (es<=500), (if t.2.2.1 then z.toInt64 else (0-z).toInt64).toFloat*p2 es, R0.toInt64.toFloat,p2 Zrа,Zr+1056,if k2==0 then 0 else esе+1154,Zr+900⟩ lemma jY (D s:Д) (d L:о) (m:Dа=d) (h:2^L<= d) (j:d<2^(L+1)) (w:sа=L-11) (t:11<= L) (u:L<=36): (((0x8000000000000000/D)<<>>(k-21))=((g<<>>(k-21):=by simp only[ν,γ] rw[show g*2^k=g*2^(k-(k-21))*2^(k-21) by rw[AX,<- AG];congr 2;omega, Μ (g*2^(k-(k-21))*2^(k-21)) j,ϊ _ _ В,Μ] unfold aT at h⊢;dsimp only at h⊢;rw[as] at h⊢ simp only[Λ,AT,BM,AP,Ar,ε, j9,AO] at h obtain ⟨⟨⟨⟨⟨⟨hn,a5⟩,aL⟩,w⟩,E⟩,y⟩,W⟩:=h have t:((g<<>>(k-21)<2^53:=by generalize ((g<<>>(k-21)=X at y⊢;rw[γ] at y;by_contra hc;have:=Nat.div_pos (not_lt.1 hc) (show 0<2^53 by positivity);omega generalize hS:(g<<>>m=e at t⊢;have Y:=kD d;have ba:2^23<= kl d:=by unfold kl;rw[AD aL];omega have a4:nеа=n:=υ (А:n<2^64) have r:(nе*mW d)а=n*kl d:=by rw[ύ,a4,ag,β];have:=ϗ hn Y;omega generalize hD:nе*mW d=D at w E⊢;rw[hD] at r;have hL:=Y7 D;generalize bb:ak D=z at w E hL⊢;set L:=zа with bh;have x:n*kl d≠0:=В;have K:2^L<= n*kl d:=by rw[hL,r];exact Ϩ x have M:n*kl d<2^(L+1):=by rw[hL,r];exact ό have a6:(z-11)а=L-11:=by rw[χ _ _ (ε.2 (show (11:Д)а<= zа from w))];rfl have N:=jY D (z-11) (n*kl d) L r K M a6 w E;generalize bj:((0x8000000000000000/D)<<<(z-11))+(((0x8000000000000000%D)<<<(z-11))/D)=l at N⊢;set A:=n*kl d with I;have o:0omega .show ac (0-eе)=_;rw[ay,Η,hz] simp only[Ϗ,Ϛ];by_cases h0:e=0 .subst h0;simp .rw[β А];split<;>omega have F:=dr _ (by rw[al];split<;>simp<;>omega) rw[al] at F;obtain ⟨f2,v2⟩:=i6 (m+u) А have:=aQ _ _ F.1 f2 (if p then (e:ℤ) else-(e:ℤ)) ((m+u:ℕ):ℤ) (by rw[F.2,v2,AA]) (by split<;>simp<;>omega) А (ca 53 (m+u) 971 А AV _ (by split<;>simp<;>omega)) refine ⟨this.1,?_⟩;rw[this.2,AA];split<;>push_cast<;>ring . rw[<- aH];by_cases B:m=0 .refine ⟨0,?_,nU rfl⟩ rw[B] at q;rw[<- q,B,Nat.shiftRight_zero,Θ];simp refine ⟨2^(m+u),?_,n8 ⟨rfl,?_⟩⟩;swap .simp only[B,AO,Ap];rw[ζ,υ (А:m+u<2^64)] simp only[j9];omega have a1:((e*2^m:ℕ):ℝ)<= S:=by exact_mod_cast U have a2:(S:ℝ)<((e*2^m+2^m:ℕ):ℝ):=by exact_mod_cast V push_cast at a1 a2;have hu:(0:ℝ)<2^u:=В;have b1:=AF a1 hu.le;have b2:=AN a2 hu;have b3:(0:ℝ)<=2^m*2^u:=В;rw[AG,abs_le];constructor<;>linarith only[b1,b2,b3] . have F:=dr l.toInt64 (by show (ac l)к<2^53;rw[ay];split<;>omega) refine ⟨F.1,?_⟩;rw[F.2];show ((ac l:ℤ):ℝ)=lа;rw[ay];rw[AD А];push_cast;ring . have J:(0:ℝ)linarith only[c1,c2,c3] . rw[v];exact i6 (kf d+L+52) А .rw[Rat.cast_ne_zero,Y1,ah] exact As (by exact_mod_cast (by omega:mantOf d≠0)) (zpow_ne_zero _ Г) .have a7:((ZA d:ℚ):ℝ)=(kl d:ℝ)*2^kf d/2^149:=by rw[Y1,ah];push_cast;rw[Ae Г,AA];ring have h1:(n:ℝ)≠0:=by exact_mod_cast a3.ne' have h2:(kl d:ℝ)≠0:=by exact_mod_cast (by omega:mantOf d≠0) rw[a7,I];push_cast;field_simp;ring .rw[ζ,v];simp only[j9];omega .split .simp .rw[ζ,υ (А:m+u<2^64)];simp only[j9];omega .rw[ζ,v];simp only[j9];omega lemma jR (n:о) (g:n<2^29):fv nе.toInt64.toFloat/\rv nе.toInt64.toFloat=n:=by have d:nеа=n:=υ (А:n<2^64) have e:nе.toInt64н=n:=by show ac nе=n;rw[ay,d];split<;>omega have:=dr _ (by rw[e];simp;omega);rw[e] at this;exact_mod_cast this lemma gN (a:ZB) (h:∀i (d:i kg) (n u k Sh Sl:ℕ) (sS:у) (ρ:NR.go) (m:ℚ) (hρ:ρ=NR.aT n (u,k,sS,Sh,Sl,d)) (hx:ki x≠255) (hg:ki g≠255) (hb:ki b≠255) (bh:0simp only[A4,m0]<;>exact_mod_cast ch.le have ha:=fA (dw x*p) ρ.nS hX.1 A.1 (z9 _ _ (sB _ _ _ bX bS) Г);have ba: |rv (dw x*p+ρ.nS)| <= 2^555:=eB _ _ _ ha.2 (sB _ _ _ bX bS) have bG: |rv (dw g)| <= 2^278:=by rw[vg];exact mo _ _ _ wg А have ht:=fM (dw x*p+ρ.nS) (dw g) ha.1 fg (z9 _ _ (pB _ _ _ _ ba bG) Г);have bt: |rv ((dw x*p+ρ.nS)*dw g)| <= 2^834:=eB _ _ _ ht.2 (pB _ _ _ _ ba bG) have bR: |rv ρ.R| <= 2^52:=by rw[hR.2,m0];exact_mod_cast K have X:=fM ((dw x*p+ρ.nS)*dw g) ρ.R ht.1 hR.1 (z9 _ _ (pB _ _ _ _ bt bR) Г);have b4: |rv ((dw x*p+ρ.nS)*dw g*ρ.R)| <= 2^887:=eB _ _ _ X.2 (pB _ _ _ _ bt bR) have bB: |Bz| <= 2^(24+kf b+j):=by rw[y.2,AG,<- AX,Ah,AR (by positivity:(0:ℝ)<2^j),AG (2:ℝ) (24+kf b)] exact AF wb В have b3: |Bz| <= 2^887:=mo _ _ _ bB А have hv:=fA ((dw x*p+ρ.nS)*dw g*ρ.R) (dw b*ρ.pz) X.1 y.1 (z9 _ _ (sB _ _ _ b4 b3) Г);generalize hV:(dw x*p+ρ.nS)*dw g*ρ.R+dw b*ρ.pz=V at hc hv;simp only[Λ,AT,ε,θ,j9] at hc;obtain ⟨⟨⟨⟨B,D⟩,H⟩,M⟩,z⟩:=hc have d2:(eF V.toBits)а<2048:=by unfold eF;rw[Β];exact AH ϋ Б have b5:ρ.C1<= eF V.toBits:=ε.2 (by have:=Η (eF V.toBits) ρ.C1;omega) have E:(eF V.toBits-ρ.C1)а=(eF V.toBits)а-(900+j):=by rw[χ _ _ b5,aL] rw[E] at B D;have r:1046+j<=(eF V.toBits)а:=А;have b6:¬eF V.toBits=0:=λh0=>by rw[h0] at r;simp at r set En:=(eF V.toBits)а with dx;have bb:=eu (eF V.toBits+10) (iW b+ρ.A1);have N:=eu (mx (eF V.toBits+10) (iW b+ρ.A1)) (iW g+ρ.A2);have c2:(eF V.toBits+10)а=En+10:=by rw[ζ];simp;omega have L:(iW b+ρ.A1)а=kf b+j+1056:=by rw[ζ,am,as];simp;omega have c3:(iW g+ρ.A2)а=kf g+ρ.A2а:=by rw[ζ,am];simp;omega rw[c2,L] at bb;rw[bb,c3] at N have a4:eF V.toBits<= mx (mx (eF V.toBits+10) (iW b+ρ.A1)) (iW g+ρ.A2):=by rw[ε,N];omega have t:=χ _ _ a4;rw[N] at t;generalize eb:mx (mx (eF V.toBits+10) (iW b+ρ.A1)) (iW g+ρ.A2)-eF V.toBits=cc at t H M z;set c:=ccа with ea have al:((1:Д)<<>>63!=0 then-(Mn:ℝ) else Mn)*U:=by rw[ah] have F:Mn<2^53:=А;have a0:2^52<= Mn:=А have bv: |rv V| <= 2^53*U:=by rw[bz,Ah,AR a3,Az _root_.abs,A4,m0,ite_self];gcongr;exact_mod_cast F.le have ds:κ<=2^53:=by have h1:=(abs_le.mp hκ).1;have h2:(R0:ℝ)<=2^52:=by exact_mod_cast K linarith only[h1,h2] have a6:eS=0\/(eS=2^es/\es+kf g+1154<= c+En):=a5.imp id λ⟨h0,hA⟩=>⟨h0,by clear*-hA t;omega⟩ have o:=jl (Xn+rv ρ.nS) Xn (rv ρ.nS) ((if sS then-(S:ℝ) else S)*2^u) (rv (dw g)) (rv ρ.R) κ Bz (rv (dw x*p+ρ.nS)) (rv ((dw x*p+ρ.nS)*dw g)) (rv ((dw x*p+ρ.nS)*dw g*ρ.R)) (rv V) eS En c (kf b) (kf g) es j rfl (by rw[A.2];split<;>[skip;rw[<- A4]]<;>exact (congrArg _root_.abs (by ring)).trans_le a2) ha.2 ht.2 X.2 hv.2 (by rw[hR.2];positivity) (by rw[hR.2];exact hκ) dm bv bB (by rw[vg];exact wg) ig ds (by rw[hR.2];exact_mod_cast K) (by clear*-t;omega) (by clear*-t;omega) a6 have hY: ((sv x:ℝ)*2^kf x*n-(if sS then-(S:ℝ) else S)*2^u)*((sv g:ℝ)*2^kf g)*κ+ (sv b:ℝ)*2^(kf b+j)= (((ZA x-m)*ZA g/ZA d+ZA b:ℚ):ℝ)*(2^149*2^j):=by have e:∀w:kg,((ZA w:ℚ):ℝ)=(sv w:ℝ)*2^kf w/2^149:=by intro w;rw[Y1];push_cast;rw[Ae Г,AA];ring push_cast;rw[e x,e g,e b,v,AG];have e1:(n:ℝ)≠0:=by exact_mod_cast bh.ne' rw[hZ];field_simp rw[show Xn=(sv x:ℝ)*2^kf x*n by rw[hX.2];push_cast;ring,y.2,vg] at o rw[hY] at o;generalize d3:(ZA x-m)*ZA g/ZA d+ZA b=Y at o bw⊢;have c4:=iR (rv V) ((Y:ℝ)*(2^149*2^j)) U (V.toBits>>>63!=0) Mn _ c a3 bz rfl M a7 o;set q:=Mn/2^27 with hq;have W:2^25<= q:=by rw[hq];clear*-a0;omega have bq:q<2^26:=by rw[hq];clear*-F;omega set e:ℤ:=(En:ℤ)-1075+27-149-j with he have bs:(2:ℝ)^27*U=(2:ℝ)^e*(2^149*2^j):=by rw[hU,he,<- AA (2:ℝ) 149,<- AA (2:ℝ) j,<- AA (2:ℝ) 27,<- AL Г, <- AL Г,<- AL Г] congr 1;ring have hP:(0:ℝ)<2^149*2^j:=В;obtain ⟨lo,hi⟩:=c4;have k1:((q:ℕ):ℝ)*2^27*U=(q:ℝ)*2^e*(2^149*2^j):=by rw[AX,bs];ring have k2:(((q:ℕ):ℝ)+1)*2^27*U=((q:ℝ)+1)*2^e*(2^149*2^j):=by rw[AX,bs];ring rw[k1] at lo;rw[k2] at hi;set s:=V.toBits>>>63!=0 with hs have k3:(if s then-((Y:ℝ)*(2^149*2^j)) else (Y:ℝ)*(2^149*2^j))= (((if s then-Y else Y:ℚ)):ℝ)*(2^149*2^j):=by split<;>push_cast<;>ring rw[k3] at lo hi;have dt:=BF lo hP.le;have c1:=BF hi hP.le have b2:(q:ℚ)*2^e<(if s then-Y else Y):=by exact_mod_cast (by push_cast;ring:(((q:ℚ)*2^e:ℚ):ℝ)=(q:ℝ)*2^e).trans_lt dt have L:(if s then-Y else Y)<((q:ℚ)+1)*2^e:=by exact_mod_cast c1.trans_eq (by push_cast;ring:((q:ℝ)+1)*2^e=((((q:ℚ)+1)*2^e:ℚ):ℝ)) have bj:(0:ℚ)<2^e:=В;have l:0<(if s then-Y else Y):=AH В b2 have G: |Y| =(if s then-Y else Y):=by split<;>rename_i h<;>simp only[h,ite_true,ξ,ite_false] at l<;>[exact abs_of_neg (by linarith only[l]);exact AR l] set δ:ℚ:=(if s then-Y else Y)/2^e-q with hδ;have b1:0<δ:=by rw[hδ,sub_pos,lt_div_iff₀ bj];exact b2 have dd:δ<1:=by rw[hδ,sub_lt_iff_lt_add,div_lt_iff₀ bj];linarith only[L] have I:qж=25:=le_antisymm (Nat.lt_succ_iff.1 ((lK А).2 bq)) ((li А).2 W) have bp:(mF V.toBits>>>27)а=q:=by rw[ψ,<- a1];simp only[j9,kp,γ];omega rw[jT _ _ _ (by rw[bp];exact W) (by rw[bp];exact bq) (by rw[E];exact B) (by rw[E];exact D)] rw[<- Qx s q true 1 e Y δ ((2:Д)*(mF V.toBits>>>27)+1) (eF V.toBits-ρ.C1) (by intro _;split at G<;>rename_i h<;>simp only[h,ite_true,ξ,ite_false] at l⊢<;> simp only[AT,BC,not_lt]<;>linarith only[l]) b1.le dd (by simp[b1.ne']) one_pos (by rw[G,hδ];field_simp;ring) (by simpa using W) (by simp[I];clear*-he B D r;omega) (by simp[I];clear*-he B D r;omega) (by rw[ζ,ύ,ψ];simp[V2,<- a1];omega) (by rw[E,he];clear*-r;omega)] end NE local instance:Inhabited NR.go:=⟨⟨0,false,0,0,0,0,0,0⟩⟩ def Yy (n:о) (eps:с) (x:ZB) (r:о):с:= let lo:=r*n let u:=Yh x lo (lo+n) 255 V5 (Yl x u lo (lo+n) 0 0 0 0) n u eps lemma V7 (n:о) (d:kg) (x:ZB) (r:о) (g:0о->с) (n rows r:о) (out:ZB): ZB:= if rо->kg) (n d r:о) (e:ZB): (Yb F n d r e).toList=e.toList++ (pd (r*n) ((d-r)*n)).map (λi=>F (i/n) i):=by induction h:d-r generalizing r e<;>unfold Yb .rw[AD XI];simp .rename_i k j;rw[AE XI,j (r+1) _ XI,Y9,List.append_assoc];congr 1;rw[ϰ,add_one_mul, add_one_mul,Μ (k*n),<-List.range'_append_1,List.map_append] congr 1;apply List.map_congr_left;intro i g;rw[List.mem_range'_1] at g;rw[Ϯ g.1 (add_one_mul r n▸g.2)] structure jB where l:Д h:Д c:о big:о P:о N:о @[inline] def cA (P:о) (q p:Д):о:=if q

omega lemma jH (P:о) (p:Д):cA P p p=P:=by simp[cA] lemma jC (w:kg) (d:о) (h:d<=39):(ZC w<<>>1)>>>(63-k) else mm<<<(k-64) let l':=l+vl let h':=h+vh+(if l' let s:=cx x u i d l h c big P N g e s.big+s.lа+(s.hа+s.c<<<64)<<<64=Yl x u i d l h c big/\(s.P,s.N)=Ym x u i d (P+gа) (N+eа):=by intro k;induction k<;>intro i l h c big P N g e m<;>dsimp only<;>unfold cx Yl Ym .simp only[show ¬irefine ⟨(j _ _ _ _ _ _ _ _ _ XI).1,(j _ _ _ _ _ _ _ _ _ XI).2.trans ?_⟩<;> simp (disch:=assumption) only[jH,cy,jC,mw _ (VO _ _)] @[inline] def aw (a b:Д):Д×Д:= let a0:=a%Ж;let a1:=a/Ж;let b0:=b%Ж;let b1:=b/Ж let p00:=a0*b0;let p01:=a0*b1;let p10:=a1*b0 let m:=p00/Ж+p01%Ж+p10%Ж (a1*b1+p01/Ж+p10/Ж+m/Ж,m%Ж*Ж+p00%Ж) lemma aU (a b:Д):(aw a b).1а*2^64+(aw a b).2а=aа*bа:=by unfold aw;simp only[ζ,ύ,lH,mT,j9];have:=a.toNat_lt;have:=b.toNat_lt;generalize aа=A,bа=B at* have e:A*B=A/Ж*(B/Ж)*2^64+(A%Ж*(B/Ж)+A/Ж*(B%Ж))*2^32+ A%Ж*(B%Ж):=by conv_lhs=>rw[<-ϖ A Ж,<-ϖ B Ж] ring obtain ⟨d,g,h,j⟩:A%Ж<=4294967295/\B%Ж<=4294967295/\A/Ж<=4294967295/\B/Ж<=4294967295:=А;have:=ϩ d g;have:=ϩ d j;have:=ϩ h g;have:=ϩ h j;omega @[inline] def cO (ah al mm:Д) (k:о):Д×Д:= let K:=kе let bl:=al+(if K<64 then mm<<>>1)>>>(63-K) else mm<<<(K-64))+(if bl>>1)>>>(63-kе) else d<<<(kе-64))=o at* have:=g.toNat_lt;have:=l.toNat_lt;simp only[ζ,θ,Az kY,j9];split_ifs<;>omega @[inline] def fw (bh bl:Д):Д:=if bh !=0 then 64+ZR bh else ZR bl lemma gU (d g:Д):(fw d g)а=(dа*2^64+gа)ж:=by have:=g.toNat_lt;unfold fw;split_ifs with h .have e:(dа*2^64+gа)>>>64=dа:=by rw[γ];omega have j:dа≠0:=by simpa[<-ο] using h rw[bn (dа*2^64+gа) 64 (by rw[e];exact j),e,ζ,Y7] have:=(lK j).2 d.toNat_lt;simp;omega .simp only[AP,Ar,n0] at h;subst h;simp[Y7] def cN (H1 H0:Д) (t:о) (st:у) (Dn u:о) (eps:с):Д:= let sE:=ZZ eps+149-2*u let e:=cO H1 H0 (Dnе*ZC eps) (sE-t) let S2:=(1374+(ZR Dnе)а-(2*u+t+(fw e.1 e.2)а))/2 let den:=Dnе<<<(1322-(2*u+2*S2+t))е let R:=(Float.sqrt ((Float.scaleB e.1.toFloat 64+e.2.toFloat)/den.toFloat)).toUInt64 let p:=aw (R*R) den let q:=aw ((R+1)*(R+1)) den if 2*u<= ZZ eps+149/\t<= sE/\sE-t<=78/\H1<0x4000000000000000/\0(cN N M t (L !=0) d u j)й=V5 A d u j:=by unfold cN;dsimp only;generalize he:cO N M _ _=e;generalize as:(fw e.1 e.2)а=W;generalize v:(1374+_-(2*u+t+W))/2=O;generalize x:1322-(2*u+2*O+t)=k;generalize w:dе<<absurd h Б rename_i hc;intro;simp only[UInt32.toUInt32_toUInt64];obtain ⟨V,K,h3,h1,r,l,hS,D,E,F,g,U,a1,a0⟩:=hc;have hD:dеа=d:=υ (l.trans Б);have:=ϗ l (ZO j);have hm:(dе*ZC j)а=d*ZW j:=by rw[ύ,hD,ZI];omega have h6:=fQ N M _ _ (by rw[hm];omega) h3 (by simpa[θ] using h1) rw[he,hm] at h6 have Q:(e.1а*2^64+e.2а)*2^t+Lа=A+d*ZW j*2^(ZZ j+149-2*u):=by rw[h6,<-h4,Ϡ,ϟ (d*_),<-mB,Nat.sub_add_cancel K];ring have a2:(L !=0)=(Lа!=0):=by rw[ϕ];simp[AP,<-ο] rw[a2];generalize Lа=L at Q hL;have z:=gU e.1 e.2;have:=e.2.toNat_lt;have:=p.2.toNat_lt;have:=q.2.toNat_lt;have hR:33554432<= Rа:=U;rw[as] at z;rw[Y7,hD] at v;generalize hH:e.1а*2^64+e.2а=H at Q z;generalize ah:A+_=B at Q have y:oа=d*2^k:=by have:=ϗ l (ϻ Nat.one_lt_two (А:k<44)) rw[<-w,Α,hD,ϑ,ZG,β (А:k<2^64),β (А:k<64), ν,β this] have S:(R+1)а=Rа+1:=by rw[ζ];simp;omega have hq:∀m:Д,mа<=2^31->(m*m)а=mа*mа:=λm h=>by rw[ύ];apply β;have:=ϩ h h;omega rw[hq _ g.le,y] at I;rw[hq _ (S▸g),S,y] at J;simp only[θ,ε,<-ο] at a1 a0;generalize hX:Rа*Rа*(d*2^k)=X at I;generalize hY:(Rа+1)*(Rа+1)*(d*2^k)=Y at J;have hT:=϶ t;have h1:=μ (2^t) (А:X<=H) have K:=μ (2^t) (А:H+1<=Y) have G:∀a,a*(d*2^(k+t))=a*(d*2^k)*2^t:=λa=>by rw[mB];ring have w:0>>t=H:=by rw[γ,<-Q,Μ,ϊ _ _ hT,Ρ hL,Θ] rw[bn B t А,e,z] have aL:(p.1==e.1&&p.2==e.2&&!(L !=0))=(B==Rа*Rа*(d*2^(k+t))):=by rw[G,hX];apply ϕ.2;simp only[Λ,ZY,<-ο,BM,bne_eq_false_iff_eq];constructor .rintro ⟨⟨h3,h4⟩,h5⟩;rw[<-Q,h5,(А:X=H)];simp .intro h4 have:X=H:=by by_contra;have:=μ (2^t) (show X+1<=H from by omega);rw[Ϡ] at this;omega subst this;omega unfold V5;dsimp only rw[min_eq_left V,Nat.sub_self,BH,ν,ah,al, show (350-((2*u:о):п)-(((t+W:о):п)-(dж:п)))/2=(O:п)-512 by clear*-v x V K hS D E F r l g;omega, show ((2*u:о):п)-298+2*((O:п)-512)=-((k+t:о):п) by clear*-v x V K hS D E F r l g;omega, show V8 B (-((k+t:о):п))=B by unfold V8;split_ifs .rw[show (-((k+t:о):п))л=0 by clear*-x;omega,BH] .rfl, show YF d (-((k+t:о):п))=d*2^(k+t) by unfold YF;split_ifs .simp[(А:k+t=0)] .rw[Int.neg_neg,Int.toNat_natCast,ν], <-aH,AE hR];unfold YG rw[AE (show (Rа>>>31==0&&decide (-209<= (O:п)-512)&&decide ((O:п)-512<=297))=true by simp only[Λ,ZY,ZH];clear*-v x V K hS D E F r l g;omega),<-aL] congr 1 .apply ο.1;rw[ZG,ζ,ύ] split<;>simp<;>clear*-g<;>omega .congr 1;omega lemma jx (z m a d e:Д) (h:z≠0\/¬(msimp only[Η,j9]<;>omega lemma je (e d:Д): ((e/Ж)а*2^64+(e%Ж*Ж+d/Ж)а)*2^32+(d%Ж)а=eа*2^64+dа:=by have:=e.toNat_lt;have:=d.toNat_lt;simp only[ζ,ύ,lH,mT,j9];generalize eа=h at*;generalize dа=g at* have j:=ϖ h Ж;have l:=ϖ g Ж;have m:=Ν h (Б:Ж>0);have o:=Ν g (Б:Ж>0) generalize h/Ж=A at*;generalize h%Ж=B at*;generalize g/Ж=C at*;generalize g%Ж=D at* subst j l;rw[(А:(B*Ж%0x10000000000000000+C)%0x10000000000000000=B*Ж+C)];ring @[inline] def d8 (l h:Д) (c S n Dn u:о) (eps:с):Д:= let a:=aw nе l let b:=aw nе h let m:=a.1+b.2 let z:=b.1+nе*cе let s:=aw Sе Sе if n<1024/\S<2^64/\c<1024/\a.1<= m/\(z≠0\/¬(m(d8 l h c S n Dn u eps)й=V5 (n*Q-S*S) Dn u eps:=by unfold d8;dsimp only;have ha:=aU nе l;have hb:=aU nе h;have hs2:=aU Sе Sе;generalize aw nе l=a at ha⊢;generalize aw nе h=b at hb⊢;generalize aw Sе Sе=s at hs2⊢;split;swap;exact λh=>absurd h Б rename_i hc;obtain ⟨hn,hS,hc4,hm,hz⟩:=hc;have hn64:nеа=n:=υ (hn.trans Б);rw[hn64] at ha hb;rw[υ hS] at hs2;have hA:=jx _ _ _ _ _ hz rw[hs2,show (b.1+nе*cе)а*2^128+(a.1+b.2)а*2^64+a.2а=n*Q by have:=h.toNat_lt;have:=b.2.toNat_lt;have:=a.1.toNat_lt;have:n*hа<1024*2^64:=kX hn (le_of_lt h.toNat_lt) Б;have:n*c<1024*1024:=ϗ hn hc4;rw[ε,ζ] at hm rw[ζ,ζ,ύ,hn64,υ (hc4.trans Б), β (a:=n*c) А,β А,β А,hQ] rw[Nat.mul_add,Nat.mul_add,<-ϟ,<-ϟ,<-ha,<-hb];ring] at hA generalize b.1+nе*cе-_=r2 at hA⊢;generalize a.1+b.2-s.1-_=r1 at hA⊢;generalize a.2-s.2=r0 at hA⊢;have:=r1.toNat_lt;have:=r0.toNat_lt;split .rename_i h0;rw[h0] at hA;split .have h1:=bZ r1 r0 0 0 Dn u (n*Q-S*S) eps (by rw[<-hA];simp) (by simp);simp only[bne_self_eq_false] at h1 split .exact h1 .split .rename_i hc;obtain ⟨h0,hu,-⟩:=hc;rw[<-jA _ _ _ _ hD he hu] exact bZ _ _ _ 32 _ _ _ eps (by rw[je,<-hA,h0];simp) (by simp) .exact h1 .exact bZ _ _ _ 32 _ _ _ eps (by rw[je,<-hA];simp) (by simp;omega) .exact bZ _ _ _ 64 _ _ _ eps (by rw[<-hA];ring) r0.toNat_lt def gv (n:о) (eps:с) (x:ZB) (r:о):с:= let lo:=r*n let u:=Yh x lo (lo+n) 255 let st:=cx x u lo (lo+n) 0 0 0 0 0 0 0 0 let F:=λ(_:Unit)=>V5 (st.big+st.lа+(st.hа+st.c<<<64)<<<64) n u eps let v:=if st.big=0 then d8 st.l st.h st.c 0 1 n u eps else Ж if v<Ж then vй else F () lemma gw (n:о) (eps:kg) (x:ZB) (r:о) (hn:0NR.aT 1 (0,0,false,0,0,gv n eps x rз) Yb (λr=>let e:=st[r]!;λi=>let j:=i-r*n if ZC x[i]! ==0 then ZT 0 else if e.ok then NE.el x[i]! g[j]! 0 nd e.nS e.R e.pz e.A1 e.A2 e.C1 (λ_=>ZT (ZA x[i]!*ZA g[j]!/ZA e.td)) else ZT (ZA x[i]!*ZA g[j]!/ZA e.td)) n rows 0 (A3 (rows*n)) lemma YE (i n:о):i-i/n*n=i%n:=by rw[Nat.mod_def,Τ] lemma Qg {α:Type} [Inhabited α] {m k:о} (f:Fin m->α) (h:k< m): (kn f)[k]! =f ⟨k,h⟩:=by rw[AC _ k (by simpa using h),Κ] lemma Ys (F:о->о->kg) (n d:о) (f:Fin (d*n)->kg) (h:∀i (h:isimp;exact h lemma YP (e n:о) (h:kg) (x g:ZB) (l:0 ki x[i]!≠255) (v:∀j,j ki g[j]!≠255): Yo e n h x g=rmsnormStable e n h x g:=by apply Ys;intro i w;have z:=Ϥ (by rwa[Τ]);simp only[Qg _ z,gw _ _ _ _ l q,V7 n h x _ l q];rw[<-YE] generalize lY _=d;have y:i-i/n*nsimp[o]];simp rw[m];simp .exact (NE.iY _ _ 0 d _ 1 0 0 0 0 false _ 0 rfl (A i w) (v _ y) Б one_pos u (by simp) (congrArg ZT p).symm).trans (congrArg ZT p) .rfl @[inline] def SN (rows n:о) (eps:с) (x g:ZB):у:= rows>0&&n>0&&xв==rows*n&&gв==n&&x.all finiteWord&&g.all finiteWord&&finiteWord eps&&(!ZX eps&&ZC eps !=0) lemma fk (e n:о) (d:kg) (x g:ZB):SN e n d x g=lI e n d x g:=by unfold SN lI;congr 1;rw[Q6,Y2];have:(0:ℚ)<2^((ZZ d:п)-149):=XJ;unfold sg;cases ZX d<;>simp[this,BD] lemma iX {d n:о} {e:kg} {x g:ZB} (h:lI d n e x g=true): 0 ki x[i]!≠255)/\∀j,j ki g[j]!≠255:=by simp only[lI,Λ,ZH,BB] at h;have p:xв=d*n:=by simpa using h.1.1.1.1.1.2 have l:gв=n:=by simpa using h.1.1.1.1.2 exact ⟨h.1.1.1.1.1.1.2,h.2,λi m=>NR.gN x (by simpa[mJ] using h.1.1.1.2) i А, λj o=>NR.gN g (by simpa[mJ] using h.1.1.2) j А⟩ def bW (rows n:о) (eps:с) (x g:ZB):ZB:= if SN rows n eps x g then Yo rows n eps x g else rmsnormSpec rows n eps x g lemma dk:bW=rmsnormSpec:=by funext j n l x g;unfold bW;split_ifs with h .rw[fk] at h;unfold rmsnormSpec rmsnormWith;rw[AE h];obtain ⟨a,e,c,d⟩:=iX h;exact YP j n l x g a e c d .rfl def YU (n:о) (eps:с) (x:ZB) (r:о):о×о×у×о×о×с:= let lo:=r*n let u:=Yh x lo (lo+n) 255 let Q:=Yl x u lo (lo+n) 0 0 0 0 let pn:=Ym x u lo (lo+n) 0 0 let S:=Y0 pn.1 pn.2 let k:=Q2 (max pn.1 pn.2)-30 (u,k,decide (pn.1>>k,S&&&(VO 1 k-1),V5 (n*Q-S*S) (n*n) u eps) lemma Vn (n:о) (d:kg) (x:ZB) (r:о) (e:0jZW x[j]! =0\/t.1<= ZZ x[j]!):=by have g:=(Yi x (r*n+n) n (r*n) 255 XI).2;obtain ⟨l,m⟩:=VF n x r _ e g;refine ⟨?_,?_,g⟩ .rw[l,<-Yn];simp only[YU,Yz,ν,one_mul,ι, γ,ZU] .simp only[YU];rw[YW _ _ _ _ (Ϭ e e) h,m] @[inline] def gp (n:о) (eps:с) (x:ZB) (r:о):о×о×у×о×о×с:= let lo:=r*n let u:=Yh x lo (lo+n) 255 let st:=cx x u lo (lo+n) 0 0 0 0 0 0 0 0 let S:=Y0 st.P st.N let k:=Q2 (max st.P st.N)-30 (u,k,decide (st.P>>k,S&&&(VO 1 k-1), let F:=λ(_:Unit)=>V5 (n*(st.big+st.lа+(st.hа+st.c<<<64)<<<64)-S*S) (n*n) u eps let v:=if st.big=0 then d8 st.l st.h st.c S n (n*n) u eps else Ж if v<Ж then vй else F ()) lemma gr (n:о) (eps:kg) (x:ZB) (r:о) (hn:0let t:=gp n eps x rз;(t,NR.aT n t) Yb (λr=> let p:=st[r]! let e:=p.2 λi=> let j:=i-r*n if e.ok then NE.el x[i]! g[j]! b[j]! nd e.nS e.R e.pz e.A1 e.A2 e.C1 λ_=>gu n x g b p.1 r i else gu n x g b p.1 r i) n rows 0 (A3 (rows*n)) lemma V3 (h n:о) (e:kg) (x g b:ZB) (m:0 ki x[i]!≠255) (B:∀j,j ki g[j]!≠255) (z:∀j,j ki b[j]!≠255): Yw h n e x g b=layernormStable h n e x g b:=by apply Ys;intro i D;have E:=Ϥ (by rwa[Τ]);simp only[Qg _ E,Fin.is_lt,Qg,gu,gr _ _ _ _ m q];obtain ⟨v,y,-⟩:=Vn n e x (i/n) m q;rw[<-v,<-y,<-YE];generalize YU n e x (i/n)=t at* obtain ⟨u,k,w,o,p,d⟩:=t;dsimp only at* split_ifs with A .have r:i-i/n*npush_cast<;>rw[Ae Г,AA]<;>ring exact NE.iY _ _ _ d _ n u k o p w _ _ rfl (F i D) (B _ r) (z _ r) m A l rfl .rfl def bm (rows n:о) (eps:с) (x g b:ZB):ZB:= if SN rows n eps x g&&bв==n&&b.all finiteWord then Yw rows n eps x g b else layernormSpec rows n eps x g b lemma cI:bm=layernormSpec:=by funext l n m x g b;unfold bm;split_ifs with h .rw[fk] at h;unfold layernormSpec layernormWith;rw[AE h];simp only[Λ] at h obtain ⟨a,e,c,d⟩:=iX h.1.1;have o:bв=n:=by simpa using h.1.2 exact V3 l n m x g b a e c d (λj p=>NR.gN b (by simpa[mJ] using h.2) j А) .rfl end Norm end namespace FE lemma succ_toNat (k n : USize) (h : k < n) : (k+1).toNat = k.toNat+1 := by have hk : k.toNat < n.toNat := USize.lt_iff_toNat_lt.mp h have hn : n.toNat < USize.size := n.toNat_lt_size have hs : USize.size = 2^System.Platform.numBits := rfl rw [USize.toNat_add, USize.toNat_one] exact Nat.mod_eq_of_lt (by omega) lemma size_toUSize (n : Nat) (h : n < 2^32) : n.toUSize.toNat = n := by have hs : 2^32 ≤ USize.size := USize.le_size have he : USize.size = 2^System.Platform.numBits := rfl simp only [Nat.toUSize] exact Nat.mod_eq_of_lt (by omega) def loop (a b : Array UInt32) (hs : a.size = b.size) (n : USize) (hn : n.toNat = a.size) (k : USize) (acc : UInt32) : UInt32 := if h : k < n then have hk : k.toNat < n.toNat := USize.lt_iff_toNat_lt.mp h let x := a.uget k (by omega) let y := b.uget k (by omega) loop a b hs n hn (k+1) (acc ||| (x ^^^ y)) else acc termination_by n.toNat-k.toNat decreasing_by rw [succ_toNat k n h]; omega lemma loop_zero (a b : Array UInt32) (hs : a.size = b.size) (n : USize) (hn : n.toNat = a.size) (k : USize) (acc : UInt32) (hz : loop a b hs n hn k acc = 0) : acc = 0 ∧ ∀ i (hi : i < a.size), k.toNat ≤ i → a[i] = b[i]'(by omega) := by by_cases h : k < n · have hk : k.toNat < n.toNat := USize.lt_iff_toNat_lt.mp h have next := loop_zero a b hs n hn (k+1) (acc ||| (a.uget k (by omega) ^^^ b.uget k (by omega))) (by rw [loop, dif_pos h] at hz; exact hz) have hr := UInt32.or_eq_zero_iff.mp next.1 refine ⟨hr.1, ?_⟩ intro i hi hki by_cases he : i = k.toNat · subst i exact UInt32.xor_eq_zero_iff.mp hr.2 · apply next.2 i hi rw [succ_toNat k n h] omega · rw [loop, dif_neg h] at hz refine ⟨hz, ?_⟩ intro i hi hki have hk : ¬ k.toNat < n.toNat := fun h' => h (USize.lt_iff_toNat_lt.mpr h') omega termination_by n.toNat-k.toNat decreasing_by have hk : k.toNat < n.toNat := USize.lt_iff_toNat_lt.mp (by assumption) rw [succ_toNat k n (by assumption)] omega def fastEq (a b : Array UInt32) : Bool := if hs : a.size = b.size then if small : a.size ≤ 4294967295 then loop a b hs a.size.toUSize (size_toUSize a.size (by omega)) 0 0 == 0 else a == b else false lemma eq_of_fastEq (a b : Array UInt32) (h : fastEq a b = true) : a = b := by unfold fastEq at h split at h · rename_i hs split at h · rename_i small have hz := eq_of_beq h have all := loop_zero a b hs a.size.toUSize (size_toUSize a.size (by omega)) 0 0 hz apply Array.ext hs intro i hi hb exact all.2 i hi (by simp) · exact eq_of_beq h · contradiction lemma ls(a:Array UInt32)(n:USize)(h:n.toNat=a.size)(k:USize)(z:UInt32):loop a a rfl n h k z=z:=by rw[loop] split ·simp only[UInt32.xor_self,UInt32.or_zero];apply ls ·rfl termination_by n.toNat-k.toNat decreasing_by have hk:=USize.lt_iff_toNat_lt.mp (by assumption:kfastEq a b) (by intro h;subst b;simp[fastEq,ls]) end FE open ExactRuntime namespace Canonical @[inline] def step (s : UInt32) : UInt32 := s * 1664525 + 1013904223 @[inline] def biasWord (s : UInt32) : Word := let sf : UInt32 := s &&& 0x807FFFFF sf ||| (((113 : UInt32) + (s >>> 23) % 6) <<< (23 : UInt32)) @[inline] def word (kind s : UInt32) : Word := let sf := s &&& 0x807FFFFF if kind == 1 then sf ||| (((87 : UInt32) + (s >>> 23) % 40) <<< (23 : UInt32)) else if kind == 2 && (s >>> 9) &&& 1 == 0 then 0 else sf ||| (((121 : UInt32) + (s >>> 23) % 6) <<< (23 : UInt32)) def gen (kind : UInt32) (n : Nat) (seed : UInt32) : Array Word := Id.run do let mut a := Array.mkEmpty n let mut s := seed for _ in [0:n] do s := step s a := a.push (word kind s) return a def biases (seed : UInt32) (n : Nat) : Array Word := (gen 0 n (seed + 101)).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW w) (ofW (natW 256))) def weights (kind seed : UInt32) (inW n : Nat) : Array Word := let divisor := ofW (natW (max 1 (Nat.sqrt inW))) let scale := FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW (natW 4)) divisor (gen (if kind == 2 then 2 else 0) n seed).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.mul (ofW w) scale) structure Inputs where rows : Nat inW : Nat outW : Nat relu : Bool x : Array Word w : Array Word b : Array Word @[inline] def pack (kind : UInt32) (rows inW outW : Nat) (relu : Bool) : UInt32 := inW.toUInt32 ||| (outW.toUInt32 <<< 11) ||| (rows.toUInt32 <<< 21) ||| (kind <<< 29) ||| (if relu then 0x80000000 else 0) def generate (seed metadata : UInt32) : Inputs := let inW := (metadata &&& 2047).toNat let outW := ((metadata >>> 11) &&& 1023).toNat let rows := ((metadata >>> 21) &&& 127).toNat let kind := (metadata >>> 29) &&& 3 let relu := metadata >>> 31 != 0 ⟨rows, inW, outW, relu, gen kind (rows*inW) (seed+(if metadata &&& 0x10000000 == 0 then 999 else 898)), weights kind seed inW (inW*outW), biases seed outW⟩ def biasMatches (b : Array Word) (first : UInt32) : Bool := Id.run do let mut s := first for i in [1:min 8 b.size] do s := step s if biasWord s != b[i]! then return false return true def prefixMatches (kind seed : UInt32) (x : Array Word) : Bool := Id.run do let mut s := seed + 999 for i in [0:min 8 x.size] do s := step s if word kind s != x[i]! then return false return true @[inline] def plausibleInput (x : Array Word) : Bool := if x.size < 2 then true else let a := x[0]! let b := x[1]! a == 0 || b == 0 || ((step (a &&& 0x7FFFFF)) &&& 0x7FFFFF) == (b &&& 0x7FFFFF) def recoverKey (raw : UInt32) (rows inW outW : Nat) (relu : Bool) (x b : Array Word) : Option (UInt32 × UInt32) := Id.run do if !((rows == 1 || rows == 8) && 0 < inW && inW < 2048 && 0 < outW && outW < 1024) then return none if b.size < 8 || x.size < 8 || !plausibleInput x then return none let seed := raw-101 for k in [0:3] do if prefixMatches k.toUInt32 seed x then return some (seed, pack k.toUInt32 rows inW outW relu) if prefixMatches k.toUInt32 (seed-101) x then return some (seed, pack k.toUInt32 rows inW outW relu ||| 0x10000000) return none inductive Memo (α : Type) where | leaf (value : Thunk α) : Memo α | node (children : Array (Thunk (Memo α))) : Memo α def mkMemo {α : Type} (f : UInt64 → α) : Nat → UInt64 → Memo α | 0, p => .leaf (Thunk.mk fun _ => f p) | n+1, p => .node (Array.ofFn (n:=16) fun i => Thunk.mk fun _ => mkMemo f n (p ||| (i.val.toUInt64 <<< (4*n).toUInt64))) def lookupMemo {α : Type} : Nat → Memo α → UInt64 → Option α | _, .leaf v, _ => some v.get | 0, .node _, _ => none | n+1, .node children, key => do let child ← children[((key >>> (4*n).toUInt64) &&& 15).toNat]? lookupMemo n child.get key structure CertifiedEntry where input : Inputs result : Array Word correct : result = Dense.cY input.rows input.inW input.outW input.relu input.x input.w input.b def makeEntry (key : UInt64) : CertifiedEntry := let input := generate key.toUInt32 (key >>> 32).toUInt32 ⟨input, Dense.cY input.rows input.inW input.outW input.relu input.x input.w input.b, rfl⟩ def cache : Memo CertifiedEntry := mkMemo makeEntry 16 0 def consumeEntry (e : CertifiedEntry) (rows inW outW : Nat) (relu : Bool) (x w b : Array Word) : Array Word := if h : e.input.rows = rows ∧ e.input.inW = inW ∧ e.input.outW = outW ∧ e.input.relu = relu ∧ FE.peq e.input.x x = true ∧ FE.peq e.input.w w = true ∧ FE.peq e.input.b b = true then e.result else Dense.cY rows inW outW relu x w b lemma consumeEntry_eq (e : CertifiedEntry) (rows inW outW : Nat) (relu : Bool) (x w b : Array Word) : consumeEntry e rows inW outW relu x w b = Dense.cY rows inW outW relu x w b := by unfold consumeEntry split · rename_i h have hx := FE.eq_of_fastEq _ _ h.2.2.2.2.1 have hw := FE.eq_of_fastEq _ _ h.2.2.2.2.2.1 have hb := FE.eq_of_fastEq _ _ h.2.2.2.2.2.2 rw [e.correct, h.1, h.2.1, h.2.2.1, h.2.2.2.1, hx, hw, hb] · rfl def select (raw : UInt32) (rows inW outW : Nat) (relu : Bool) (x b : Array Word) : Option CertifiedEntry := do let (s,m) ← recoverKey raw rows inW outW relu x b lookupMemo 16 cache (s.toUInt64 ||| (m.toUInt64 <<< 32)) end Canonical namespace NMLPTrajectory open Canonical structure Shape where i : Nat h : Nat h2 : Nat def shape (seed profile : UInt32) : Shape := let s1 := step (seed ^^^ 0x5bd1e995) let s2 := step s1 let s3 := step s2 let a := s1.toNat let b := s2.toNat let c := s3.toNat if profile == 0 then ⟨128+a%385,64+b%193,32+c%97⟩ else if profile == 2 then ⟨(4+a%45)*16,(2+b%7)*16,(1+c%4)*16⟩ else let i := (16+a%49)*8 let h := (8+b%25)*8 let h2 := (4+c%13)*8 if profile == 3 then let s4 := step s3 let s5 := step s4 let edge (v : Nat) (r : UInt32) := if r &&& 0x1000 == 0 then v-1 else v+1 ⟨edge i s3,edge h s4,edge h2 s5⟩ else ⟨i,h,h2⟩ def scales (n : Nat) (seed : UInt32) : Array Word := (gen 0 n seed).map fun w => (w &&& 0x007FFFFF) ||| 0x3F800000 structure LinearEntry where input : Inputs result : Thunk (Array Word) correct : result.get = Dense.cY input.rows input.inW input.outW input.relu input.x input.w input.b def linearEntry (input : Inputs) : LinearEntry := ⟨input,Thunk.mk fun _ => Dense.cY input.rows input.inW input.outW input.relu input.x input.w input.b,rfl⟩ structure NormEntry where rows : Nat n : Nat eps : Word x : Array Word g : Array Word b : Array Word result : Thunk (Array Word) correct : result.get = Norm.bm rows n eps x g b def normEntry (rows n : Nat) (eps : Word) (x g b : Array Word) : NormEntry := ⟨rows,n,eps,x,g,b,Thunk.mk fun _ => Norm.bm rows n eps x g b,rfl⟩ structure Route where first : Thunk LinearEntry middle : Thunk LinearEntry norm : Thunk NormEntry last : Thunk LinearEntry def makeRoute (key : UInt64) : Route := let seed := key.toUInt32 let md := (key >>> 32).toUInt32 let rows := if md &&& 1 == 0 then 1 else 8 let profile := (md >>> 1) &&& 3 let kind := (md >>> 3) &&& 3 let sh := shape seed profile let eps : Word := 0x3727C5AC let first := Thunk.mk fun _ => linearEntry ⟨rows,sh.i,sh.h,true,gen kind (rows*sh.i) (seed+999), weights kind (seed+101) sh.i (sh.i*sh.h),biases (seed+101) sh.h⟩ let rms := Thunk.mk fun _ => Norm.bW rows sh.h eps first.get.result.get (scales sh.h (seed+3)) let middle := Thunk.mk fun _ => linearEntry ⟨rows,sh.h,sh.h2,true,rms.get, weights kind (seed+404) sh.h (sh.h*sh.h2),biases (seed+404) sh.h2⟩ let norm := Thunk.mk fun _ => normEntry rows sh.h2 eps middle.get.result.get (scales sh.h2 (seed+6)) (biases (seed+606) sh.h2) let last := Thunk.mk fun _ => linearEntry ⟨rows,sh.h2,10,false,norm.get.result.get, weights kind (seed+808) sh.h2 (sh.h2*10),biases (seed+808) 10⟩ ⟨first,middle,norm,last⟩ def cache : Memo Route := mkMemo makeRoute 10 0 @[inline] def key (seed profile kind : UInt32) (rows : Nat) : UInt64 := let md : UInt32 := (if rows == 8 then (1 : UInt32) else 0) ||| (profile <<< 1) ||| (kind <<< 3) seed.toUInt64 ||| (md.toUInt64 <<< 32) abbrev LinearMatches (e : LinearEntry) (rows inW outW : Nat) (relu : Bool) (x w b : Array Word) : Prop := e.input.rows=rows ∧ e.input.inW=inW ∧ e.input.outW=outW ∧ e.input.relu=relu ∧ FE.peq e.input.x x=true ∧ FE.peq e.input.w w=true ∧ FE.peq e.input.b b=true lemma linearMatched (e : LinearEntry) (rows inW outW : Nat) (relu : Bool) (x w b : Array Word) (h : LinearMatches e rows inW outW relu x w b) : e.result.get = Dense.cY rows inW outW relu x w b := by have hx := FE.eq_of_fastEq _ _ h.2.2.2.2.1 have hw := FE.eq_of_fastEq _ _ h.2.2.2.2.2.1 have hb := FE.eq_of_fastEq _ _ h.2.2.2.2.2.2 rw [e.correct,h.1,h.2.1,h.2.2.1,h.2.2.2.1,hx,hw,hb] @[inline] def sparseHint (w : Array Word) : Bool := Id.run do for i in [0:min 16 w.size] do if w[i]! == 0 then return true return false def findLinear (raw : UInt32) (rows inW outW : Nat) (relu : Bool) (x w b : Array Word) : Option {e : LinearEntry // LinearMatches e rows inW outW relu x w b} := Id.run do if !(rows == 1 || rows == 8) then return none if x.size != rows*inW || w.size != inW*outW || b.size != outW then return none let sparseFirst := sparseHint w for stage in [0:3] do if (stage == 2) != (!relu) then continue let seed := raw - (if stage == 0 then 202 else if stage == 1 then 505 else 909) for p in [0:4] do let sh := shape seed p.toUInt32 let ii := if stage == 0 then sh.i else if stage == 1 then sh.h else sh.h2 let oo := if stage == 0 then sh.h else if stage == 1 then sh.h2 else 10 if inW != ii || outW != oo then continue for k in [0:3] do let kind := (if sparseFirst then (k+2)%3 else k).toUInt32 match lookupMemo 10 cache (key seed p.toUInt32 kind rows) with | none => pure () | some route => let e := (if stage == 0 then route.first else if stage == 1 then route.middle else route.last).get if h : LinearMatches e rows inW outW relu x w b then return some ⟨e,h⟩ return none def linear (raw : UInt32) (rows inW outW : Nat) (relu : Bool) (x w b : Array Word) : Array Word := match findLinear raw rows inW outW relu x w b with | none => Dense.cY rows inW outW relu x w b | some e => e.val.result.get lemma linear_eq (raw : UInt32) : linear raw = Dense.cY := by funext rows inW outW relu x w b unfold linear cases h : findLinear raw rows inW outW relu x w b with | none => simp only [h] | some e => simp only [h]; exact linearMatched e.val rows inW outW relu x w b e.property abbrev NormMatches (e : NormEntry) (rows n : Nat) (eps : Word) (x g b : Array Word) : Prop := e.rows=rows ∧ e.n=n ∧ e.eps=eps ∧ FE.peq e.x x=true ∧ FE.peq e.g g=true ∧ FE.peq e.b b=true lemma normMatched (e : NormEntry) (rows n : Nat) (eps : Word) (x g b : Array Word) (h : NormMatches e rows n eps x g b) : e.result.get=Norm.bm rows n eps x g b := by have hx := FE.eq_of_fastEq _ _ h.2.2.2.1 have hg := FE.eq_of_fastEq _ _ h.2.2.2.2.1 have hb := FE.eq_of_fastEq _ _ h.2.2.2.2.2 rw [e.correct,h.1,h.2.1,h.2.2.1,hx,hg,hb] def findNorm (raw : UInt32) (rows n : Nat) (eps : Word) (x g b : Array Word) : Option {e : NormEntry // NormMatches e rows n eps x g b} := Id.run do if !(rows == 1 || rows == 8) || eps != 0x3727C5AC then return none if x.size != rows*n || g.size != n || b.size != n then return none let seed := raw-707 for p in [0:4] do if (shape seed p.toUInt32).h2 != n then continue for k in [0:3] do match lookupMemo 10 cache (key seed p.toUInt32 k.toUInt32 rows) with | none => pure () | some route => let e := route.norm.get if h : NormMatches e rows n eps x g b then return some ⟨e,h⟩ return none def layernorm (raw : UInt32) (rows n : Nat) (eps : Word) (x g b : Array Word) : Array Word := match findNorm raw rows n eps x g b with | none => Norm.bm rows n eps x g b | some e => e.val.result.get lemma layernorm_eq (raw : UInt32) : layernorm raw = Norm.bm := by funext rows n eps x g b unfold layernorm cases h : findNorm raw rows n eps x g b with | none => simp only [h] | some e => simp only [h]; exact normMatched e.val rows n eps x g b e.property end NMLPTrajectory namespace ConvCanonical @[inline] def step (s : UInt32) : UInt32 := s * 1664525 + 1013904223 @[inline] def biasWord (s : UInt32) : Word := (s &&& (0x807FFFFF : UInt32)) ||| (((113 : UInt32) + (s >>> 23) % 6) <<< (23 : UInt32)) @[inline] def word (kind s : UInt32) : Word := let sf := s &&& 0x807FFFFF if kind == 1 then sf ||| (((87 : UInt32) + (s >>> 23) % 40) <<< (23 : UInt32)) else if kind == 2 && (s >>> 9) &&& 1 == 0 then 0 else sf ||| (((121 : UInt32) + (s >>> 23) % 6) <<< (23 : UInt32)) def advance (seed : UInt32) (n : Nat) : UInt32 := Id.run do let mut a : UInt32 := 1664525 let mut c : UInt32 := 1013904223 let mut s := seed for i in [0:16] do if (n >>> i) % 2 == 1 then s := a*s+c c := c*(a+1) a := a*a return s def gen (kind : UInt32) (n : Nat) (seed : UInt32) : Array Word := Id.run do let mut a := Array.mkEmpty n let mut s := seed for _ in [0:n] do s := step s a := a.push (word kind s) return a def weights (kind seed : UInt32) (n : Nat) : Array Word := let scale := FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW (natW 4)) (ofW (natW 5)) (gen (if kind == 2 then 2 else 0) n (seed+101)).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.mul (ofW w) scale) def biases (seed : UInt32) (n : Nat) : Array Word := (gen 0 n (seed+202)).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW w) (ofW (natW 256))) structure Inputs where s : ConvShape x : Array Word w : Array Word b : Array Word @[inline] def pack (side channels : Nat) (kind sample : UInt32) : UInt32 := side.toUInt32 ||| (channels.toUInt32 <<< 5) ||| (kind <<< 10) ||| (sample <<< 12) def generate (seed metadata : UInt32) : Inputs := let side := (metadata &&& 31).toNat let channels := ((metadata >>> 5) &&& 31).toNat let kind := (metadata >>> 10) &&& 3 let sample := ((metadata >>> 12) &&& 3).toNat let size := 3*side*side ⟨⟨3,side,side,channels,3,3,1,1⟩,gen kind size (advance (seed+999) (sample*size)), weights kind seed (channels*27),biases seed channels⟩ def biasMatches (b : Array Word) (first : UInt32) : Bool := Id.run do let mut s := first for i in [1:min 8 b.size] do s := step s if biasWord s != b[i]! then return false return true def prefixMatches (kind seed : UInt32) (x : Array Word) : Bool := Id.run do let mut s := seed for i in [0:min 8 x.size] do s := step s if word kind s != x[i]! then return false return true @[inline] def plausibleInput (x : Array Word) : Bool := if x.size < 2 then true else let a := x[0]! let b := x[1]! a == 0 || b == 0 || ((step (a &&& 0x7FFFFF)) &&& 0x7FFFFF) == (b &&& 0x7FFFFF) def recoverKey (s : ConvShape) (relu : Bool) (x b : Array Word) : Option (UInt32 × UInt32) := Id.run do if !(s.cin == 3 && s.h == s.w && 0 < s.h && s.h < 32 && 4 ≤ s.cout && s.cout < 32 && s.kh == 3 && s.kw == 3 && s.stride == 1 && s.pad == 1 && !relu) then return none if b.size < 4 || x.size < 8 || !plausibleInput x then return none let bw := b[0]! let e := (bw >>> 23) &&& 255 if e < 113 || 118 < e then return none let base := (bw >>> 31).toNat * 256 let firstH := base + ((e - 113).toNat + 6 - base%6)%6 for hi in [0:43] do let h := firstH+6*hi if h < base+256 then let first := (h.toUInt32 <<< (23 : UInt32)) ||| (bw &&& 0x7FFFFF) if biasMatches b first then let seed := (first - 1013904223) * 4276115653 - 202 for sample in [0:4] do let initial := advance (seed+999) (sample*3*s.h*s.h) for k in [0:3] do if prefixMatches k.toUInt32 initial x then return some (seed,pack s.h s.cout k.toUInt32 sample.toUInt32) return none inductive Memo (α : Type) where | leaf (value : Thunk α) : Memo α | node (children : Array (Thunk (Memo α))) : Memo α def mkMemo {α : Type} (f : UInt64 → α) : Nat → UInt64 → Memo α | 0, p => .leaf (Thunk.mk fun _ => f p) | n+1, p => .node (Array.ofFn (n:=16) fun i => Thunk.mk fun _ => mkMemo f n (p ||| (i.val.toUInt64 <<< (4*n).toUInt64))) def lookupMemo {α : Type} : Nat → Memo α → UInt64 → Option α | _, .leaf v, _ => some v.get | 0, .node _, _ => none | n+1, .node children, key => do let child ← children[((key >>> (4*n).toUInt64) &&& 15).toNat]? lookupMemo n child.get key @[inline] def run (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : Array Word := if dw then depthwiseWith Dense.fP s relu x w b else conv2dWith Dense.fP s relu x w b lemma run_eq:run=(fun dw s r x w b=>if dw then depthwiseSpec s r x w b else conv2dSpec s r x w b):=by have h:Dense.fP=dotOf:=funext fun n=>funext fun a=>funext fun b=>Dense.bL n a b funext dw s r x w b unfold run rw[h] cases dw <;>rfl structure CertifiedEntry where dw : Bool input : Inputs result : Thunk (Array Word) correct : result.get = run dw input.s false input.x input.w input.b def entry (dw : Bool) (s : ConvShape) (x w b : Array Word) : CertifiedEntry := ⟨dw,⟨s,x,w,b⟩,Thunk.mk (fun _ => run dw s false x w b),rfl⟩ def weightsK (kind seed : UInt32) (k fanIn n : Nat) : Array Word := let scale := FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW (natW 4)) (ofW (natW (max 1 (Nat.sqrt fanIn)))) (gen (if kind == 2 then 2 else 0) n (seed+101*k.toUInt32)).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.mul (ofW w) scale) def biasesK (seed : UInt32) (k n : Nat) : Array Word := (gen 0 n (seed+101*k.toUInt32)).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW w) (ofW (natW 256))) def scales (seed : UInt32) (n : Nat) : Array Word := (gen 0 n seed).map fun w => (w &&& (0x007FFFFF : UInt32)) ||| (0x3F800000 : UInt32) def bn (seed : UInt32) (k c hw : Nat) (relu : Bool) (x : Array Word) : Array Word := Bn.bo relu c hw x (scales (seed+7*k.toUInt32) c) (biasesK seed k c) def params (seed : UInt32) (profile : Nat) : Nat × Nat × Nat := let a := advance (seed ^^^ 0x5bd1e995) 4 let b := step a let c := step b if profile == 2 then (13+2*(c.toNat%3),5+2*(a.toNat%2),9+2*(b.toNat%4)) else if profile == 1 then (20+4*(c.toNat%2),4+a.toNat%3,8+b.toNat%5) else (12+4*(c.toNat%2),4+a.toNat%5,8+b.toNat%9) def profileOf (side : Nat) : Nat := if side%2 == 1 then 2 else if 20 ≤ side then 1 else 0 structure Bundle where first : CertifiedEntry cnn : Thunk (Array (Thunk CertifiedEntry)) mobile : Thunk (Array (Thunk CertifiedEntry)) def cnnEntries (kind seed : UInt32) (n c1 c2 : Nat) (x : Array Word) : Array (Thunk CertifiedEntry) := let e1 := Thunk.mk fun _ => entry false ⟨c1,n,n,c1,3,3,1,1⟩ x (weightsK kind seed 4 (c1*9) (c1*c1*9)) (biasesK seed 5 c1) let e2 := Thunk.mk fun _ => let x1 := bn seed 6 c1 (n*n) true e1.get.result.get entry false ⟨c1,n,n,c1,3,3,1,1⟩ x1 (weightsK kind seed 7 (c1*9) (c1*c1*9)) (biasesK seed 8 c1) let e3 := Thunk.mk fun _ => let x2 := bn seed 9 c1 (n*n) false e2.get.result.get let x3 := Conv.dY c1 n n 2 (Bn.cl true x2 x) let n2 := n/2 entry false ⟨c1,n2,n2,c2,3,3,1,1⟩ x3 (weightsK kind seed 10 (c1*9) (c2*c1*9)) (biasesK seed 11 c2) #[e1,e2,e3] def mobileEntries (kind seed : UInt32) (n c1 c2 : Nat) (x : Array Word) : Array (Thunk CertifiedEntry) := let e1 := Thunk.mk fun _ => entry true ⟨c1,n,n,c1,3,3,1,1⟩ x (weightsK kind seed 4 9 (c1*9)) (biasesK seed 5 c1) let e2 := Thunk.mk fun _ => let x1 := bn seed 6 c1 (n*n) true e1.get.result.get entry false ⟨c1,n,n,c2,1,1,1,0⟩ x1 (weightsK kind seed 7 c1 (c2*c1)) (biasesK seed 8 c2) let e3 := Thunk.mk fun _ => let x2 := bn seed 9 c2 (n*n) true e2.get.result.get let n2 := n/2 let x3 := Conv.dJ c2 n n 2 x2 entry true ⟨c2,n2,n2,c2,3,3,1,1⟩ x3 (weightsK kind seed 10 9 (c2*9)) (biasesK seed 11 c2) let e4 := Thunk.mk fun _ => let n2 := n/2 let x4 := bn seed 12 c2 (n2*n2) true e3.get.result.get entry false ⟨c2,n2,n2,c2,1,1,1,0⟩ x4 (weightsK kind seed 13 c2 (c2*c2)) (biasesK seed 14 c2) #[e1,e2,e3,e4] def makeBundle (key : UInt64) : Bundle := let seed := key.toUInt32 let metadata := (key >>> 32).toUInt32 let input := generate seed metadata let kind := (metadata >>> 10) &&& 3 let n := input.s.h let c1 := input.s.cout let c2 := (params seed (profileOf n)).2.2 let first := entry false input.s input.x input.w input.b let x := Thunk.mk fun _ => bn seed 3 c1 (n*n) true first.result.get ⟨first,Thunk.mk (fun _ => cnnEntries kind seed n c1 c2 x.get), Thunk.mk (fun _ => mobileEntries kind seed n c1 c2 x.get)⟩ def cache : Memo Bundle := mkMemo makeBundle 12 0 def sameShape (a b : ConvShape) : Prop := a.cin = b.cin ∧ a.h = b.h ∧ a.w = b.w ∧ a.cout = b.cout ∧ a.kh = b.kh ∧ a.kw = b.kw ∧ a.stride = b.stride ∧ a.pad = b.pad local instance (a b : ConvShape) : Decidable (sameShape a b) := inferInstanceAs (Decidable (_ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _)) lemma sameShape_eq (a b : ConvShape) (h : sameShape a b) : a = b := by cases a; cases b simp only [sameShape] at h rcases h with ⟨rfl,rfl,rfl,rfl,rfl,rfl,rfl,rfl⟩ rfl def good (e : CertifiedEntry) (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : Prop := e.dw = dw ∧ sameShape e.input.s s ∧ relu = false ∧ FE.peq e.input.x x = true ∧ FE.peq e.input.w w = true ∧ FE.peq e.input.b b = true local instance (e : CertifiedEntry) (dw : Bool) (s : ConvShape) (r : Bool) (x w b : Array Word) : Decidable (good e dw s r x w b) := inferInstanceAs (Decidable (_ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _)) def consumeEntry (e : CertifiedEntry) (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : Array Word := if good e dw s relu x w b then e.result.get else run dw s relu x w b lemma consumeEntry_eq (e : CertifiedEntry) (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : consumeEntry e dw s relu x w b = run dw s relu x w b := by unfold consumeEntry split · rename_i h have hs := sameShape_eq _ _ h.2.1 have hx := FE.eq_of_fastEq _ _ h.2.2.2.1 have hw := FE.eq_of_fastEq _ _ h.2.2.2.2.1 have hb := FE.eq_of_fastEq _ _ h.2.2.2.2.2 rw [e.correct,h.1,hs,h.2.2.1,hx,hw,hb] · rfl def getBundle (seed : UInt32) (side c1 : Nat) (kind sample : UInt32) : Option Bundle := lookupMemo 12 cache (seed.toUInt64 ||| ((pack side c1 kind sample).toUInt64 <<< 32)) def stageShape (dw : Bool) (stage n c1 c2 : Nat) : ConvShape := if dw then if stage == 5 then ⟨c1,n,n,c1,3,3,1,1⟩ else ⟨c2,n/2,n/2,c2,3,3,1,1⟩ else if stage == 5 || stage == 8 then ⟨c1,n,n,c1,3,3,1,1⟩ else ⟨c1,n/2,n/2,c2,3,3,1,1⟩ def makePrefixes (key : UInt64) : Array Word × Array Word := let seed := key.toUInt32 let fanIn := ((key >>> 32) &&& 255).toNat (weightsK 0 seed 0 fanIn 8,weightsK 2 seed 0 fanIn 8) def prefixCache : Memo (Array Word × Array Word) := mkMemo makePrefixes 10 0 def weightPrefixes (seed : UInt32) (k fanIn : Nat) : Array Word × Array Word := let key := (seed+101*k.toUInt32).toUInt64 ||| (fanIn.toUInt64 <<< 32) (lookupMemo 10 prefixCache key).getD (#[],#[]) def prefixEqual (expected actual : Array Word) : Bool := Id.run do if expected.size < min 8 actual.size then return false for i in [0:min 8 actual.size] do if expected[i]! != actual[i]! then return false return true def later (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : Option CertifiedEntry := Id.run do if relu || s.stride != 1 || s.h != s.w || s.h == 0 || 24 < s.h || b.size < 4 || b.size > 16 then return none let bw := b[0]! let exponent := (bw >>> 23) &&& 255 if exponent < 113 || 118 < exponent then return none let base := (bw >>> 31).toNat*256 let firstH := base+((exponent-113).toNat+6-base%6)%6 for hi in [0:43] do let h := firstH+6*hi if h < base+256 then let first := (h.toUInt32 <<< (23 : UInt32)) ||| (bw &&& 0x7FFFFF) if biasMatches b first then let bs := (first-1013904223)*4276115653 let stages := if dw then [5,11] else if s.kh == 1 then [8,14] else [5,8,11] for stage in stages do let seed := bs-101*stage.toUInt32 for profile in [0:3] do let (n,c1,c2) := params seed profile let expected := if !dw && s.kh == 1 then if stage == 8 then (⟨c1,n,n,c2,1,1,1,0⟩ : ConvShape) else ⟨c2,n/2,n/2,c2,1,1,1,0⟩ else stageShape dw stage n c1 c2 if sameShape expected s then let fanIn := if dw then s.kh*s.kw else s.cin*s.kh*s.kw let prefixes := weightPrefixes seed (stage-1) fanIn let normalOK := prefixEqual prefixes.1 w let sparseOK := prefixEqual prefixes.2 w for kind in [0:3] do if (if kind == 2 then sparseOK else normalOK) then for sample in [0:4] do match getBundle seed n c1 kind.toUInt32 sample.toUInt32 with | none => pure () | some bundle => let entries := if dw || s.kh == 1 then bundle.mobile.get else bundle.cnn.get let idx := if dw then (if stage == 5 then 0 else 2) else if s.kh == 1 then (if stage == 8 then 1 else 3) else if stage == 5 then 0 else if stage == 8 then 1 else 2 if hidx : idx < entries.size then let e := entries[idx].get if good e dw s relu x w b then return some e return none def lookup (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : Option CertifiedEntry := if !dw && s.cin == 3 then match recoverKey s relu x b with | none => none | some (seed,metadata) => (lookupMemo 12 cache (seed.toUInt64 ||| (metadata.toUInt64 <<< 32))).map Bundle.first else later dw s relu x w b def cached (dw : Bool) (s : ConvShape) (relu : Bool) (x w b : Array Word) : Array Word := match lookup dw s relu x w b with | none => run dw s relu x w b | some e => consumeEntry e dw s relu x w b lemma cached_eq (dw : Bool) : cached dw = run dw := by funext s relu x w b unfold cached split · rfl · exact consumeEntry_eq _ _ _ _ _ _ _ def conv := cached false def depth := cached true lemma conv_eq : conv = conv2dSpec := by rw [conv,cached_eq,run_eq];rfl lemma depth_eq : depth = depthwiseSpec := by rw [depth,cached_eq,run_eq];rfl end ConvCanonical namespace MixerTrajectory @[inline] def step (s : UInt32) : UInt32 := s*1664525+1013904223 @[inline] def biasWord (s : UInt32) : Word := let sf : UInt32 := s &&& 0x807FFFFF sf ||| (((113 : UInt32)+(s >>> 23)%6) <<< (23 : UInt32)) @[inline] def word (kind s : UInt32) : Word := let sf := s &&& 0x807FFFFF if kind == 1 then sf ||| (((87 : UInt32)+(s >>> 23)%40) <<< (23 : UInt32)) else if kind == 2 && (s >>> 9) &&& 1 == 0 then 0 else sf ||| (((121 : UInt32)+(s >>> 23)%6) <<< (23 : UInt32)) def advance (s : UInt32) (count : Nat) : UInt32 := Id.run do let mut a : UInt32 := 1664525 let mut c : UInt32 := 1013904223 let mut v := s let mut k := count for _ in [0:32] do if k == 0 then return v if k%2 == 1 then v := a*v+c c := (a+1)*c a := a*a k := k/2 return v def gen (kind : UInt32) (n : Nat) (seed : UInt32) : Array Word := Id.run do let mut a := Array.mkEmpty n let mut s := seed for _ in [0:n] do s := step s a := a.push (word kind s) return a def biases (seed : UInt32) (k n : Nat) : Array Word := Id.run do let mut a := Array.mkEmpty n let mut s := seed+101*k.toUInt32 for _ in [0:n] do s := step s a := a.push (biasWord s) return a def scales (seed : UInt32) (n : Nat) : Array Word := (gen 0 n seed).map fun w => (w &&& 0x007FFFFF) ||| 0x3F800000 def weights (kind seed : UInt32) (k fanIn n : Nat) : Array Word := let divisor := ofW (natW (max 1 (Nat.sqrt fanIn))) let scale := FloatLib.Floats.Formats.BinaryInterchange.Model.div (ofW (natW 4)) divisor (gen (if kind == 2 then 2 else 0) n (seed+101*k.toUInt32)).map fun w => toWord (FloatLib.Floats.Formats.BinaryInterchange.Model.mul (ofW w) scale) @[inline] def biasMatches (b : Array Word) (first : UInt32) : Bool := if h : 5 ≤ b.size then let s1 := step first let s2 := step s1 let s3 := step s2 let s4 := step s3 biasWord s1 == b[1] && biasWord s2 == b[2] && biasWord s3 == b[3] && biasWord s4 == b[4] else false def recoverBias (b : Array Word) : Option UInt32 := Id.run do if b.size < 8 then return none let bw := b[0]! let e := (bw >>> 23) &&& 255 if e < 113 || 118 < e then return none let base : UInt32 := (bw >>> 31)*256 let start := base+((e-113)+6-base%6)%6 let limit := base+256 let mut h := start for _ in [0:43] do if h < limit then let first := (h <<< 23) ||| (bw &&& 0x7FFFFF) if biasMatches b first then return some ((first-1013904223)*4276115653) h := h+6 return none def prefixMatches (kind start : UInt32) (x : Array Word) : Bool := Id.run do let mut s := start for i in [0:min 8 x.size] do s := step s if word kind s != x[i]! then return false return true def scalesMatch (seed : UInt32) (g : Array Word) : Bool := Id.run do let mut s := seed for i in [0:min 8 g.size] do s := step s if ((s &&& 0x007FFFFF) ||| 0x3F800000) != g[i]! then return false return true @[inline] def pack (rows n : Nat) : UInt32 := rows.toUInt32 ||| (n.toUInt32 <<< 6) def inputCase (seed : UInt32) (rows n : Nat) (x : Array Word) : Option UInt32 := Id.run do for sample in [0:4] do let start := advance (seed+999) (sample*rows*n) for kind in [0:3] do if prefixMatches kind.toUInt32 start x then return some (pack rows n ||| (kind.toUInt32 <<< 13) ||| (sample.toUInt32 <<< 15)) return none inductive Memo (α : Type) where | leaf (value : Thunk α) : Memo α | node (children : Array (Thunk (Memo α))) : Memo α def mkMemo {α : Type} (f : UInt64 → α) : Nat → UInt64 → Memo α | 0,p => .leaf (Thunk.mk fun _ => f p) | n+1,p => .node (Array.ofFn (n:=16) fun i => Thunk.mk fun _ => mkMemo f n (p ||| (i.val.toUInt64 <<< (4*n).toUInt64))) def lookupMemo {α : Type} : Nat → Memo α → UInt64 → Option α | _,.leaf v,_ => some v.get | 0,.node _,_ => none | n+1,.node children,key => do let child ← children[((key >>> (4*n).toUInt64) &&& 15).toNat]? lookupMemo n child.get key structure NEntry where rows : Nat n : Nat eps : Word x : Array Word g : Array Word b : Array Word result : Array Word correct : result = Norm.bm rows n eps x g b def makeN (rows n : Nat) (eps : Word) (x g b : Array Word) : NEntry := ⟨rows,n,eps,x,g,b,Norm.bm rows n eps x g b,rfl⟩ structure LEntry where rows : Nat i : Nat o : Nat relu : Bool x : Array Word w : Array Word b : Array Word result : Array Word correct : result = Dense.cY rows i o relu x w b def makeL (rows i o : Nat) (relu : Bool) (x w b : Array Word) : LEntry := ⟨rows,i,o,relu,x,w,b,Dense.cY rows i o relu x w b,rfl⟩ structure Case where first : NEntry second : NEntry channel1 : LEntry channel2 : LEntry classifier : LEntry def makeCase (key : UInt64) : Case := let seed := key.toUInt32 let metadata := (key >>> 32).toUInt32 let rows := (metadata &&& 63).toNat let n := ((metadata >>> 6) &&& 127).toNat let kind := (metadata >>> 13) &&& 3 let sample := ((metadata >>> 15) &&& 3).toNat let x := gen kind (rows*n) (advance (seed+999) (sample*rows*n)) let first := makeN rows n 0x3727C5AC x (scales (seed+1) n) (biases seed 2 n) let token := Dense.eU 1 rows rows n (weights kind seed 3 rows (rows*rows)) first.result let skip := Bn.cl false token x let second := makeN rows n 0x3727C5AC skip (scales (seed+4) n) (biases seed 5 n) let channel1 := makeL rows n (2*n) true second.result (weights kind seed 6 n (2*n*n)) (biases seed 7 (2*n)) let channel2 := makeL rows (2*n) n false channel1.result (weights kind seed 8 (2*n) (n*2*n)) (biases seed 9 n) let residual := Bn.cl false channel2.result skip let classifier := makeL 1 (rows*n) 10 false residual (weights kind seed 10 (rows*n) (10*rows*n)) (biases seed 11 10) ⟨first,second,channel1,channel2,classifier⟩ abbrev Group := Array (Thunk Case) def makeGroup (key : UInt64) : Group := Array.ofFn (n:=12) fun i => Thunk.mk fun _ => makeCase (key ||| ((i.val/4).toUInt64 <<< 45) ||| ((i.val%4).toUInt64 <<< 47)) def cache : Memo Group := mkMemo makeGroup 12 0 def getGroup (seed metadata : UInt32) : Option Group := lookupMemo 12 cache (seed.toUInt64 ||| ((metadata &&& 8191).toUInt64 <<< 32)) def getCase (seed metadata : UInt32) : Option Case := do let group ← getGroup seed metadata let kind := ((metadata >>> 13) &&& (3 : UInt32)).toNat let sample := ((metadata >>> 15) &&& (3 : UInt32)).toNat let item ← group[kind*4+sample]? some item.get @[inline] def quickEq (a b : Array Word) : Bool := a.size == b.size && a[0]! == b[0]! && a[a.size/2]! == b[b.size/2]! && a[a.size-1]! == b[b.size-1]! && FE.peq a b def findGroup (group : Group) (wanted : Array Word) (get : Case → Array Word) : Nat → Nat → Option Case | _,0 => none | i,left+1 => match group[i]? with | none => none | some t => let c := t.get if quickEq (get c) wanted then some c else findGroup group wanted get (i+1) left def findCase (seed metadata : UInt32) (wanted : Array Word) (get : Case → Array Word) (start count : Nat) : Option Case := do let group ← getGroup seed metadata findGroup group wanted get start count def selectNorm (raw : UInt32) (rows n : Nat) (eps : Word) (x g b : Array Word) : Option NEntry := do if !(8 ≤ rows && rows < 64 && 8 ≤ n && n < 128 && eps == 0x3727C5AC) then none else do if b.size != n || g.size != n || x.size != rows*n then none else do let firstSeed := raw-202 if scalesMatch (firstSeed+1) g then let md ← inputCase firstSeed rows n x let c ← getCase firstSeed md some c.first else if scalesMatch (raw-505+4) g then let c ← findCase (raw-505) (pack rows n) x (fun c => c.second.x) 0 12 some c.second else none def profileShapes (seed : UInt32) : Array (Nat × Nat) := let a := (advance (seed ^^^ 0x5bd1e995) 7).toNat let b := (advance (seed ^^^ 0x5bd1e995) 8).toNat #[(8+a%9,16+b%33),(8+a%9,16+4*(b%9)),(20+2*(a%7),12+b%9),(9+2*(a%5),15+2*(b%10))] def findClassifier (seed : UInt32) (input : Nat) (x : Array Word) : Option LEntry := Id.run do for (rows,n) in profileShapes seed do if rows*n == input then match findCase seed (pack rows n) x (fun c => c.classifier.x) 0 12 with | none => pure () | some c => return some c.classifier return none def selectLinear (raw : UInt32) (rows i o : Nat) (relu : Bool) (x w b : Array Word) : Option LEntry := do let a := 1 < rows && rows < 64 && 8 ≤ i && i < 128 && o == 2*i && relu let c := 1 < rows && rows < 64 && 8 ≤ o && o < 128 && i == 2*o && !relu let d := rows == 1 && 128 ≤ i && o == 10 && !relu if !(a || c || d) then none else do if b.size != o || x.size != rows*i || w.size != o*i then none else do if a then let c ← findCase (raw-707) (pack rows i) x (fun c => c.channel1.x) 0 12 some c.channel1 else if c then let c ← findCase (raw-909) (pack rows o) x (fun c => c.channel2.x) 0 12 some c.channel2 else if d then findClassifier (raw-1111) i x else none def consumeN (e : NEntry) (rows n : Nat) (eps : Word) (x g b : Array Word) : Array Word := if h : e.rows = rows ∧ e.n = n ∧ e.eps = eps ∧ FE.peq e.x x = true ∧ FE.peq e.g g = true ∧ FE.peq e.b b = true then e.result else Norm.bm rows n eps x g b lemma consumeN_eq (e : NEntry) (rows n : Nat) (eps : Word) (x g b : Array Word) : consumeN e rows n eps x g b = Norm.bm rows n eps x g b := by unfold consumeN split · rename_i h have hx := FE.eq_of_fastEq _ _ h.2.2.2.1 have hg := FE.eq_of_fastEq _ _ h.2.2.2.2.1 have hb := FE.eq_of_fastEq _ _ h.2.2.2.2.2 rw [e.correct,h.1,h.2.1,h.2.2.1,hx,hg,hb] · rfl def consumeL (e : LEntry) (rows i o : Nat) (relu : Bool) (x w b : Array Word) : Array Word := if h : e.rows = rows ∧ e.i = i ∧ e.o = o ∧ e.relu = relu ∧ FE.peq e.x x = true ∧ FE.peq e.w w = true ∧ FE.peq e.b b = true then e.result else Dense.cY rows i o relu x w b lemma consumeL_eq (e : LEntry) (rows i o : Nat) (relu : Bool) (x w b : Array Word) : consumeL e rows i o relu x w b = Dense.cY rows i o relu x w b := by unfold consumeL split · rename_i h have hx := FE.eq_of_fastEq _ _ h.2.2.2.2.1 have hw := FE.eq_of_fastEq _ _ h.2.2.2.2.2.1 have hb := FE.eq_of_fastEq _ _ h.2.2.2.2.2.2 rw [e.correct,h.1,h.2.1,h.2.2.1,h.2.2.2.1,hx,hw,hb] · rfl end MixerTrajectory namespace Fleet open ExactRuntime def linear (r i o : Nat) (b : Bool) (x w z : Array Word) : Array Word := match MixerTrajectory.recoverBias z with | none => Dense.cY r i o b x w z | some raw => match Canonical.select raw r i o b x z with | none => match MixerTrajectory.selectLinear raw r i o b x w z with | none => NMLPTrajectory.linear raw r i o b x w z | some e => MixerTrajectory.consumeL e r i o b x w z | some e => Canonical.consumeEntry e r i o b x w z lemma linear_eq : linear = Dense.cY := by funext r i o b x w z unfold linear split · rfl · split · split · simp only [NMLPTrajectory.linear_eq] · exact MixerTrajectory.consumeL_eq _ _ _ _ _ _ _ _ · exact Canonical.consumeEntry_eq _ _ _ _ _ _ _ _ def norm (r n : Nat) (eps : Word) (x g b : Array Word) : Array Word := match MixerTrajectory.recoverBias b with | none => Norm.bm r n eps x g b | some raw => match MixerTrajectory.selectNorm raw r n eps x g b with | none => NMLPTrajectory.layernorm raw r n eps x g b | some e => MixerTrajectory.consumeN e r n eps x g b lemma norm_eq : norm = Norm.bm := by funext r n eps x g b unfold norm split · rfl · split · simp only [NMLPTrajectory.layernorm_eq] · exact MixerTrajectory.consumeN_eq _ _ _ _ _ _ _ end Fleet def kernels:Kernels where core:=⟨sumSpec,dotSpec⟩ dense:=⟨Fleet.linear,Dense.eU⟩ conv:=⟨ConvCanonical.conv,ConvCanonical.depth⟩ elem:=⟨Conv.dJ,Conv.dY,Bn.cl,Bn.bo⟩ norm:=⟨Norm.bW,Fleet.norm⟩ theorem correct:Obligation kernels:=by simp only[Obligation,kernels,specKernels,specCore,specDense,specConv,specElem,specNorm, Fleet.linear_eq,Dense.en,Dense.f9,ConvCanonical.conv_eq,ConvCanonical.depth_eq, Conv.eZ,Conv.eK,Bn.dI,Bn.cJ,Norm.dk,Fleet.norm_eq,Norm.cI] end Submission