import ContractExact namespace Submission open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open Nat renaming mod_eq_of_lt→γ,shiftRight_eq_div_pow→ζ,shiftLeft_eq→ι,and_two_pow_sub_one_eq_mod→ξ,mul_le_mul_right→τ,mul_lt_mul_of_pos_right→υ,pow_le_pow_right→ψ,mod_lt→Ν,zero_add→Ο,add_zero→Τ,mul_assoc→Υ,add_mul_mod_self_right→ϋ,mul_lt_mul''→ύ,mul_comm→ϐ,add_comm→ϒ,add_mul_div_right→Ϙ,div_eq_of_lt→ϙ,two_pow_add_eq_or_of_lt→Ϡ,zero_mul→ϡ,succ_mul→Ϣ,mul_le_mul_left→ϧ,log2_self_le→Ϩ,mul_one→ϩ,div_div_eq_div_mul→Ϫ,pos_of_ne_zero→ϫ,div_add_mod→Ϭ,div_lt_iff_lt_mul→ϭ,div_lt_of_lt_mul→ϯ,mul_lt_mul_of_lt_of_le→ϰ,lt_log2_self→ϱ,add_one_mul→϶,toUInt64_eq→Ϸ,one_le_two_pow→ϸ,mul_pos→Ϻ,one_shiftLeft→ϻ open UInt64 renaming le_iff_toNat_le→ε,toNat_sub_of_le→η,toNat_add→θ,toNat_shiftRight→κ,lt_iff_toNat_lt→ν,toNat_shiftLeft→ο,toNat_inj→ς,toNat_sub→Ε,toNat_zero→ώ,toNat_toUInt32→Ϗ,toNat_and→ϑ,toNat_mul→Ϛ,toNat_ofNat→ϛ open USize renaming lt_iff_toNat_lt→μ,toNat_add→Ι,le_size→Ξ,toNat_ofNat_of_lt_32→ϔ open Finset renaming sum_congr→χ,sum_eq_sum_Ico_succ_bot→Η,sum_range_succ→Λ,mem_range→Μ,sum_mul→ϊ,Ico_eq_empty_of_le→ϗ,sum_range_succ'→ϟ,sum_add_distrib→ϣ,range_eq_Ico→ϴ open Bool renaming false_eq_true→Α,and_eq_true→Ζ,or_eq_true→ϖ,eq_iff_iff→Ϟ open UInt32 renaming toNat_inj→Β,lt_iff_toNat_lt→Ρ,toNat_toUInt64→Χ,toNat_and→ό,toNat_shiftRight→ϝ,toNat_ofNat'→ϥ,toNat_add→ϲ open Array renaming getElem_ofFn→Θ,size_ofFn→ϕ,getElem?_eq_getElem→ϳ open Model renaming isNaN_eq_false_of_toDyadic?_some→Κ,isInf_eq_false_of_toDyadic?_some→Ϝ,roundDyadicGeneral_eq_roundDyadic→Ϯ,roundedMantissa_shift_quotient→ϵ open BitVec renaming toInt_eq_toNat_cond→ϓ open Model.Reduction.Internal renaming dotState_exact_toRat→Ϥ open Int.ModEq renaming add_right→Ϧ open FloatLib.Numerics.Dyadic renaming add_toRat→Ϲ local notation "А" => by omega local notation "Б" => by decide local notation "В" => by positivity local notation "Г" => by norm_num local notation "Д" => UInt64 local notation "Е" => UInt32 structure Acc where pos:Array Nat neg:Array Nat special:Bool negZero:Bool def Acc.jq (acc:Acc):Int:=(limbVal acc.pos.toList:Int) - limbVal acc.neg.toList @[inline] def Acc.add (acc:Acc) (m idx:Nat) (neg:Bool):Acc := match acc with | ⟨pos,ng,sp,nz⟩ => if m=0 then ⟨pos,ng,sp,nz && neg⟩ else if neg then ⟨pos,addLimbs64 ng m.toUInt64 idx,sp,false⟩ else ⟨addLimbs64 pos m.toUInt64 idx,ng,sp,false⟩ section open FloatLib.Numerics lemma cQ (s:Bool) (m:Nat) (e:Int) (j:Nat) (h:j+25≤ m.log2) : Model.roundDyadic Fmt ⟨s,shiftRightJam m j,e+j⟩ = Model.roundDyadic Fmt ⟨s,m,e⟩ := by have hm0:m≠0:=by rintro rfl;simp at h have hpow:2^m.log2≤ m:=Ϩ hm0 have hm:2^(j+1)≤ m:=le_trans (ψ (Г) (А)) hpow have hlog:(shiftRightJam m j).log2=m.log2 - j:=log2_shiftRightJam m j hm have hne:shiftRightJam m j≠0 := shiftRightJam_ne_zero m j (le_trans (ψ (Г) (А)) hm) rw[← Ϯ,← Ϯ] unfold Model.roundDyadicGeneral simp only[hne,hm0,beq_iff_eq,ite_false,hlog] have htot:((m.log2 - j:Nat):Int)+(e+j)=(m.log2:Int)+e:=А rw[htot] have hfw:Fmt.fracWidth=23:=rfl have hsub:Fmt.minSubnormalExponent = -149:=rfl have hmin:Fmt.minNormalExponent = -126:=rfl rw[hfw,hsub,hmin] split_ifs with h1 h2 h3 h4<;>try omega ·rfl ·congr 1 obtain ⟨a,ha⟩ : ∃ a:Nat,e - -149=Int.negSucc a:=⟨(-(e+149) - 1).toNat,by omega⟩ have hb:e+j - -149=Int.negSucc (a - j):=А rw[ha,hb] dsimp only rw[show a - j+1=(a+1) - j by omega] exact roundShiftRightEven_shiftRightJam m j (a+1) (А) ·congr 1 rw[show m.log2 - j - 23=(m.log2 - 23) - j by omega] exact roundShiftRightEven_shiftRightJam m j _ (А) end lemma al (n:Nat) (f:Nat→ Е) (k:Nat) (hk:k< n) : (Array.ofFn (n:=n) fun i=>f i.val)[k]! = f k:=by rw[getElem!_pos _ k (by simpa using hk),Θ] namespace Core def tm (a b:Word):Int:=sv a*sv b*2^(idxOf a+idxOf b) def aB (n:Nat) (fa fb:Nat→ Word):Int := ∑ k∈ Finset.range n,tm (fa k) (fb k) def fJ (n:Nat) (fa fb:Nat→ Word):Prop := ∀ k,k< n→ expOf (fa k)≠255∧expOf (fb k)≠255 lemma dv (n:Nat) (fa fb:Nat→ Word) : aB (n+1) fa fb=aB n fa fb+tm (fa n) (fb n):=by unfold aB;rw[Λ] lemma gQ (A B:Array Е) (i c:Nat) : dsum A B i c = ∑ k∈ Finset.range c,tm A[i+k]! B[i+k]! := by induction c generalizing i with | zero=>simp[dsum] | succ c ih => rw[dsum,ih (i+1),ϟ,add_comm] exact congrArg₂ _ (χ rfl fun k _=>by rw[show i+1+k=i+(k+1) by omega]) rfl lemma dk (n:Nat) (fa fb:Nat→ Word) : dsum (Array.ofFn (n:=n) fun i=>fa i.val) (Array.ofFn (n:=n) fun i=>fb i.val) 0 n = aB n fa fb:=by rw[gQ,aB] exact χ rfl fun k hk=>by rw[Μ] at hk;simp only[Ο,al n fa k hk,al n fb k hk] lemma er (n:Nat) (fa fb:Nat→ Word) (hfin:fJ n fa fb) (hS:aB n fa fb≠0) : dotOf n fa fb=finishWord (aB n fa fb) (-298) false:=by unfold dotOf set A:=Array.ofFn (n:=n) fun i=>fa i.val with hA set B:=Array.ofFn (n:=n) fun i=>fb i.val with hB have hall : ∀ k,k< n→ expOf A[k]! ≠ 255∧expOf B[k]! ≠ 255:=fun k hk=>by rw[hA,hB,al n fa k hk,al n fb k hk];exact hfin k hk have hF : ∀ X:Array Word,X.size=n→(∀ k,k< n→ expOf X[k]! ≠ 255) → ∀ k (hk:k<(X.map (Model.ofUInt32 (fmt:=Fmt))).size), Model.isFinite (X.map (Model.ofUInt32 (fmt:=Fmt)))[k]=true:=by intro X hX h k hk have hk':k< X.size:=by simpa using hk have:=h k (А);rw[getElem!_pos X k hk'] at this;simp[isFinite_ofUInt32,this] set L:=A.map (Model.ofUInt32 (fmt:=Fmt)) with hL set R:=B.map (Model.ofUInt32 (fmt:=Fmt)) with hR have hLR:L.size=R.size:=by simp[hL,hR,hA,hB] have hLfin:=hF A (by simp[hA]) fun k hk=>(hall k hk).1 have hRfin:=hF B (by simp[hB]) fun k hk=>(hall k hk).2 have hslice:Model.Reduction.Semantics.finiteDotSlice L R 0 L.size (by simp) (by simp[hLR])=(aB n fa fb:ℚ)*2^(-298:ℤ) := (finiteDotSlice_eq A B 0 L.size (by simp[hL]) (by simp[hL,hA,hB]) fun k _ k2=>hall k (by simpa[hL,hA] using k2)).trans (by simp[hL,hA,hB,dk]) unfold dotSpec Model.dot rw[Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L R .nearestEven hLR hLfin hRfin (by rw[Model.Reduction.Semantics.finiteDot_toList_eq_slice L R hLR];intro h;injection h with h;rw[hslice] at h;simp at h;exact hS h)] exact (finishWord_of_ne _ (aB n fa fb) (-298) false hS (by rw[Ϥ (destination:=Fmt) L R hLR hLfin hRfin,hslice])).symm @[inline] def gC (w:Е):Д:=if (w >>> 23) &&& 0xFF != 0 then 1 else 0 @[inline] def mW (w:Е):Д:=(w &&& 0x7FFFFF).toUInt64 ||| (gC w <<< 23) @[inline] def iW (w:Е):Д:=((w >>> 23) &&& 0xFF).toUInt64 - gC w @[inline] def sW (w:Е):Д:=if w >>> 31 != 0 then (0:Д) - mW w else mW w def aa (x:Д):Int:=x.toBitVec.toInt lemma eF (w:Е):(w &&& 0x7FFFFF).toNat<2^23:=by rw[ό];exact lt_of_le_of_lt Nat.and_le_right (Б) lemma af (w:Е):(mW w).toNat=mantOf w:=by have hf:=eF w unfold mW gC mantOf expOf fracOf by_cases he:(w >>> 23) &&& 0xFF=0 ·simp[he] ·have he':((w >>> 23) &&& 0xFF != 0)=true:=by simpa using he simp only[he',he,ite_true,ite_false] rw[UInt64.toNat_or,Χ,show ((1:Д) <<< 23).toNat=2^23*1 from rfl,Nat.or_comm, ← Ϡ hf,ϩ,ϒ] lemma an (w:Е):(iW w).toNat=idxOf w:=by unfold iW gC idxOf expOf have hlt:=expOf_toNat_lt w unfold expOf at hlt by_cases he:(w >>> 23) &&& 0xFF=0 ·simp[he] ·have hpos:1≤((w >>> 23) &&& 0xFF).toNat := Nat.one_le_iff_ne_zero.2 fun h=>he (Β.mp (by simpa using h)) simp only[show ((w >>> 23) &&& 0xFF != 0)=true by simpa using he,he,ite_true,ite_false] rw[η _ _ (ε.mpr (by rw[Χ];simpa using hpos)), Χ] rfl lemma aG (w:Е):signOf w=true↔2^31≤ w.toNat:=by unfold signOf have hw:=w.toNat_lt have h1:(w &&& 0x80000000).toNat=w.toNat &&& 2^31:=by rw[ό];rfl rw[Nat.and_two_pow,Nat.testBit_eq_decide_div_mod_eq] at h1 simp only[bne_iff_ne,ne_eq,← Β,h1] by_cases h:w.toNat / 2^31 % 2=1<;>simp[h]<;>omega lemma aZ (w:Е):(w >>> 31 != 0)=signOf w:=by have h2:(w >>> 31).toNat=w.toNat / 2^31:=by rw[ϝ];simp[ζ] have:=w.toNat_lt rw[Ϟ,bne_iff_ne,ne_eq,← Β,h2,aG];simp<;>omega lemma aR (w:Е):aa (sW w)=sv w:=by have hm:=af w have hlt:=mantOf_lt_24 w unfold sW aa sv rw[aZ] cases signOf w<;>simp only[Α,ite_false,ite_true]<;>rw[ϓ] ·rw[show (mW w).toBitVec.toNat=mantOf w from hm];simp;omega ·rw[show ((0:Д) - mW w).toBitVec.toNat=(2^64 - mantOf w) % 2^64 by show ((0:Д) - mW w).toNat=_;rw[Ε,hm];simp] simp only[Nat.reducePow];split<;>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 bf (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 gF (value shift:Д):Д := let quotient:=value >>> shift let remainder:=value &&& ((1 <<< shift) - 1) let half:=(1:Д) <<< (shift - 1) if remainder< half then quotient else if remainder> half then quotient+1 else if (quotient &&& 1) == 0 then quotient else quotient+1 @[inline] def d8 (value shift:Д):Д := let quotient:=value >>> shift let remainder:=value &&& ((1 <<< shift) - 1) let half:=(1:Д) <<< (shift - 1) quotient+(if remainder+(quotient &&& 1)> half then 1 else 0) @[inline] def bj (value shift:Д):Д := if shift == 0 then value else if shift<64 then d8 value shift else if shift == 64 then (if value>0x8000000000000000 then 1 else 0) else 0 @[inline] def d4 (sign:Bool) (e f:Е):Е := (if sign then (0x80000000:Е) else 0) ||| ((e &&& 0xff) <<< 23) ||| (f &&& 0x007fffff) @[inline] def e9 (n:Д):Е := (if n<0x800000 then 0 else n - 0x800000).toUInt32 @[inline] def aT (sign:Bool) (product scale:Д):Е := if product == 0 then if sign then 0x80000000 else 0 else let leading:=bf product let position:=leading+scale if position<172 then let fraction := if scale<149 then bj product (149 - scale) else product <<< (scale - 149) if fraction == 0 then (if sign then 0x80000000 else 0) else if fraction == 0x800000 then d4 sign 1 0 else d4 sign 0 fraction.toUInt32 else let roundedMantissa := if leading<23 then product <<< (23 - leading) else bj product (leading - 23) let carry:=roundedMantissa == 0x1000000 let normalizedPosition:=if carry then position+1 else position if normalizedPosition>425 then (if sign then 0xff800000 else 0x7f800000) else let normalizedMantissa:=if carry then 0x800000 else roundedMantissa d4 sign (normalizedPosition - 171).toUInt32 (e9 normalizedMantissa) open Model.NativeBinary32 in lemma fg (n k:Nat) (h:n >>> k≠0):n.log2=k+(n >>> k).log2:=by rw[ζ] at h ⊢ have h1:=(Nat.le_div_iff_mul_le (Nat.two_pow_pos k)).1 (Ϩ h) have h2:=(ϭ (Nat.two_pow_pos k)).1 (ϱ (n:=n / 2^k)) rw[Nat.log2_eq_iff (by rintro rfl;simp at h)] simp only[Nat.pow_succ,Nat.pow_add] at h2 ⊢ constructor<;>nlinarith lemma ff (x:Д):x.toNat.log2<64:=by by_cases h:x.toNat=0 ·simp[h] ·exact (Nat.log2_lt h).mpr x.toNat_lt lemma c9 (x0 r x k:Д) (hk:k.toNat≤32) (hk0:0< k.toNat) (hinv:x0.toNat.log2=r.toNat+x.toNat.log2) (hb:x.toNat<2^(2*k.toNat)) : x0.toNat.log2=(sr k x r).toNat+(sx k x).toNat.log2∧(sx k x).toNat<2^k.toNat:=by have hs:(x >>> k).toNat=x.toNat >>> k.toNat:=by rw[κ,γ (А)] unfold sx sr by_cases hz:x >>> k=0 ·simp only[hz,beq_self_eq_true,Bool.cond_true] exact ⟨hinv,by simpa[hs,ζ,Nat.div_eq_zero_iff] using congrArg UInt64.toNat hz⟩ ·simp only[show (x >>> k == 0)=false by simpa using hz,Bool.cond_false] have hl:=fg x.toNat k.toNat fun h=>hz (ς.mp (by simpa[hs] using h)) have h64:=ff x0 refine ⟨by rw[θ,γ (А),hs];omega,?_⟩ rw[hs,ζ] exact ϯ (by rw[← Nat.pow_add];exact lt_of_lt_of_eq hb (by congr 1;omega)) lemma ev (n:Nat) (h:n<2):n.log2=0:=by rw[Nat.log2_def,if_neg (А)] lemma bu (x:Д):bf x=x.log2:=by apply ς.mp rw[show x.log2.toNat=x.toNat.log2 from rfl] have b0:x.toNat<2^(2*(32:Д).toNat):=x.toNat_lt obtain ⟨e1,b1⟩ := c9 x 0 x 32 (Б) (Б) (by simp) b0 obtain ⟨e2,b2⟩ := c9 x _ _ 16 (Б) (Б) e1 (by simpa using b1) obtain ⟨e3,b3⟩ := c9 x _ _ 8 (Б) (Б) e2 (by simpa using b2) obtain ⟨e4,b4⟩ := c9 x _ _ 4 (Б) (Б) e3 (by simpa using b3) obtain ⟨e5,b5⟩ := c9 x _ _ 2 (Б) (Б) e4 (by simpa using b4) obtain ⟨e6,b6⟩ := c9 x _ _ 1 (Б) (Б) e5 (by simpa using b5) rw[ev (sx 1 (sx 2 (sx 4 (sx 8 (sx 16 (sx 32 x)))))).toNat (by simpa using b6)] at e6 unfold bf dsimp only omega lemma g2 (v s:Д) (h0:s≠0) (h:s<64):d8 v s=gF v s:=by have hs:s.toNat<64:=h have p2:(2:Nat)^s.toNat<18446744073709551616 := lt_of_lt_of_le (Nat.pow_lt_pow_right (Г) hs) (Г) have hr:(v &&& ((1 <<< s) - 1)).toNat=v.toNat % 2^s.toNat:=by rw[ϑ,η,ο]<;>simp[ε, γ hs,ϻ,γ p2,ξ,ϸ] have hq:((v >>> s) &&& 1).toNat=(v >>> s).toNat % 2:=by simp[ϑ,Nat.and_one_is_mod] have hm:=Ν v.toNat (show 0<2^s.toNat by positivity) have ha:((v &&& ((1 <<< s) - 1))+((v >>> s) &&& 1)).toNat=v.toNat % 2^s.toNat+(v >>> s).toNat % 2:=by rw[θ,hr,hq,γ (А)] have hb:((v >>> s) &&& 1 == 0)=decide ((v >>> s).toNat % 2=0):=by rw[← hq,Ϟ,beq_iff_eq,decide_eq_true_iff,← ς,ώ] unfold d8 gF simp only[gt_iff_lt,ν,ha,hr,hb,decide_eq_true_eq] split_ifs<;>first | rfl | omega | simp lemma f2 (value shift:Д) : bj value shift=FloatLib.Numerics.FixedWord.roundShiftRightEven value shift.toNat:=by have hB:bj value shift=(if shift == 0 then value else if shift<64 then gF value shift else if shift == 64 then (if value>0x8000000000000000 then 1 else 0) else 0):=by unfold bj;split_ifs with a b<;>first | rfl | exact g2 _ _ (by simpa using a) b rw[hB] unfold gF FloatLib.Numerics.FixedWord.roundShiftRightEven have hs:=shift.toNat_lt by_cases h0:shift=0 ·subst h0;rfl ·have h0':shift.toNat≠0:=fun h=>h0 (ς.mp (by simpa using h)) simp only[h0,beq_iff_eq,h0',reduceIte] have e2:UInt64.ofNat (shift.toNat - 1)=shift - 1:=by apply ς.mp rw[η _ _ (by rw[ε];simp;omega)];simp;omega have c1:(shift<64)↔shift.toNat<64:=ν simp only[UInt64.ofNat_toNat,e2,← c1,show shift=64↔shift.toNat=64 by rw[← ς];rfl] open Model.NativeBinary32 in lemma fP (sign:Bool) (e f:Nat) : d4 sign (UInt32.ofNat e) (UInt32.ofNat f)=mkBits sign e f:=by unfold d4 mkBits cases sign<;>rfl lemma cw (x:Д):x.toUInt32=UInt32.ofNat x.toNat:=by rfl lemma dV (n:Д):e9 n=UInt32.ofNat (n.toNat - 0x800000):=by unfold e9;split<;>rename_i h<;>rw[ν] at h<;>simp only[cw] ·rw[show n.toNat - 0x800000=0 by simp at h;omega];rfl ·rw[η _ _ (by rw[ε];simp at h ⊢;omega)];rfl open Model.NativeBinary32 in lemma bW (sign:Bool) (product scale:Д) : aT sign product scale=roundProduct sign product scale:=by unfold aT roundProduct simp only[bu,f2,dV,cw] rw[show (1:Е)=UInt32.ofNat 1 from rfl,show (0:Е)=UInt32.ofNat 0 from rfl] simp only[fP] open Model.NativeBinary32 in lemma bV (w:Е):toWord (ofUInt32 w)=w:=by have h:=toUInt32_ofUInt32 w unfold toUInt32 at h;unfold toWord conv_rhs=>rw[← h] exact Β.mp (γ (BitVec.isLt _)) open Model.NativeBinary32 in lemma bJ (sign:Bool) (m scale:Д) (hs:scale.toNat≤506) : aT sign m scale=toWord (Model.roundDyadic Fmt ⟨sign,m.toNat,(scale.toNat:Int) - 298⟩):=by rw[bW,roundProduct_eq_roundDyadic _ _ _ hs] have e:Model.roundDyadic Fmt ⟨sign,m.toNat,(scale.toNat:Int) - 298⟩ = ofUInt32 (roundDyadic ⟨sign,m.toNat,Int.ofNat scale.toNat - 298⟩) := (ofUInt32_roundDyadic _).symm rw[e,bV] def ag (hi lo:Д):Int:=aa hi*2^64+lo.toNat @[inline] def fj (hi lo:Д):Д:=if hi >>> 63 != 0 then (0:Д) - lo else lo @[inline] def bq (hi lo:Д):Д := if hi >>> 63 != 0 then (if lo == 0 then (0:Д) - hi else ~~~hi) else hi lemma gX (hi:Д):(hi >>> 63 != 0)=decide (2^63≤ hi.toNat):=by have h2:(hi >>> 63).toNat=hi.toNat / 2^63:=by rw[κ];simp[ζ] have:=hi.toNat_lt rw[Ϟ,bne_iff_ne,ne_eq,← ς,h2,decide_eq_true_iff];simp lemma cl (hi lo:Д) : ag hi lo=(hi.toNat*2^64+lo.toNat:Int) - (if 2^63≤ hi.toNat then 2^128 else 0):=by unfold ag aa rw[ϓ,UInt64.toNat_toBitVec] split<;>split<;>push_cast<;>omega lemma gm (hi lo:Д) : (ag hi lo).natAbs=(bq hi lo).toNat*2^64+(fj hi lo).toNat ∧ decide (ag hi lo<0)=(hi >>> 63 != 0):=by have hh:=hi.toNat_lt have hl:=lo.toNat_lt unfold bq fj;rw[cl,gX] by_cases hn:2^63≤ hi.toNat ·simp only[hn,decide_true,ite_true] by_cases hz:lo=0 ·subst hz simp only[beq_self_eq_true,ite_true,ώ] rw[Ε];simp;constructor<;>omega ·have hz':lo.toNat≠0:=fun h=>hz (ς.mp (by simpa using h)) simp only[show (lo == 0)=false by simpa using hz,Α,ite_false] rw[Ε,UInt64.toNat_not];simp;constructor<;>omega ·simp only[hn,decide_false,Α,ite_false];simp;omega @[inline] def aw (hi lo B:Д):Д := if hi == 0 && lo == 0 then 0x100000000 else if B>442 then 0x100000000 else let neg:=hi >>> 63 != 0 let am:=fj hi lo let ap:=bq hi lo if ap == 0 then (aT neg am B).toUInt64 else if ap >>> 32 == 0 then let q:=(ap <<< 32)+(am >>> 32) (aT neg (if am &&& 0xFFFFFFFF == 0 then q else q ||| 1) (B+32)).toUInt64 else (aT neg (if am == 0 then ap else ap ||| 1) (B+64)).toUInt64 lemma toUInt32_toUInt64 (x:Е):x.toUInt64.toUInt32=x:=by apply Β.mp;simp lemma iX (ap am:Д) (h:ap.toNat<2^32) : (if am &&& 0xFFFFFFFF == 0 then (ap <<< 32)+(am >>> 32) else ((ap <<< 32)+(am >>> 32)) ||| 1).toNat = FloatLib.Numerics.shiftRightJam (ap.toNat*2^64+am.toNat) 32:=by have hl:=am.toNat_lt have hq:((ap <<< 32)+(am >>> 32)).toNat=ap.toNat*2^32+am.toNat / 2^32:=by rw[θ,ο,κ] simp only[UInt64.reduceToNat,Nat.reduceMod,ι,ζ] rw[γ (a:=ap.toNat*2^32) (А)] apply γ;omega have hm:(am &&& 0xFFFFFFFF).toNat=am.toNat % 2^32:=by rw[ϑ];exact ξ _ 32 unfold FloatLib.Numerics.shiftRightJam simp only[show (ap.toNat*2^64+am.toNat) / 2^32=ap.toNat*2^32+am.toNat / 2^32 by omega, show (ap.toNat*2^64+am.toNat) % 2^32=am.toNat % 2^32 by omega, show (am &&& 0xFFFFFFFF == 0)=decide (am.toNat % 2^32=0) by rw[← hm,Ϟ,beq_iff_eq,decide_eq_true_iff,← ς,ώ]] split_ifs<;>simp_all[UInt64.toNat_or] lemma iY (ap am:Д) : (if am == 0 then ap else ap ||| 1).toNat = FloatLib.Numerics.shiftRightJam (ap.toNat*2^64+am.toNat) 64:=by have hl:=am.toNat_lt have hdiv:(ap.toNat*2^64+am.toNat) / 2^64=ap.toNat:=А have hmod:(ap.toNat*2^64+am.toNat) % 2^64=am.toNat:=А unfold FloatLib.Numerics.shiftRightJam simp only[hdiv,hmod] by_cases hz:am.toNat=0<;>simp[hz,UInt64.toNat_or,← ς] lemma fZ (s:Bool) (q B J:Д) (M:Nat) (hq:q.toNat=FloatLib.Numerics.shiftRightJam M J.toNat) (hB:B.toNat≤442) (hJ:J.toNat≤64) (hM:2^(J.toNat+25)≤ M) : aT s q (B+J)=toWord (Model.roundDyadic Fmt ⟨s,M,(B.toNat:Int) - 298⟩):=by have hs:(B+J).toNat=B.toNat+J.toNat:=by rw[θ];simp;omega rw[bJ _ _ _ (А),hq,hs,← cQ s M _ J.toNat ((Nat.le_log2 (Nat.pos_iff_ne_zero.1 (lt_of_lt_of_le (В) hM))).2 hM)] congr 3;push_cast;ring lemma es (hi lo B:Д) (h:aw hi lo B<0x100000000) : ag hi lo≠0∧B.toNat≤442 ∧ (aw hi lo B).toUInt32 = toWord (Model.roundDyadic Fmt (ofIntDyadic (ag hi lo) ((B.toNat:Int) - 298))):=by obtain ⟨hmag,hneg⟩ := gm hi lo have hl:=lo.toNat_lt have hh:=hi.toNat_lt unfold aw at h ⊢ by_cases hz:(hi == 0 && lo == 0)=true ·simp[hz] at h ·simp only[hz,Α,ite_false] at h ⊢ have hv:ag hi lo≠0:=fun h0=>hz (by rw[cl] at h0;simp only[Ζ,beq_iff_eq,← ς,ώ] split at h0<;>omega) by_cases hB:B>442 ·simp[hB] at h ·simp only[hB,ite_false] at h ⊢ have hB':B.toNat≤442:=by simpa[ν] using hB refine ⟨hv,hB',?_⟩ unfold ofIntDyadic rw[hneg,hmag] have r:=κ (bq hi lo) 32 simp only[ζ] at r split ·rename_i h0 rw[(by simpa using congrArg UInt64.toNat (beq_iff_eq.mp h0):(bq hi lo).toNat=0),ϡ,Ο, toUInt32_toUInt64,bJ _ _ _ (А)] ·rename_i h0 have hne:(bq hi lo).toNat≠0:=fun h1=>h0 (by simp[← ς,h1]) split ·rename_i h1 have hsm:(bq hi lo).toNat<2^32:=by have:=congrArg UInt64.toNat (beq_iff_eq.mp h1);simp at this r;omega rw[toUInt32_toUInt64];exact fZ _ _ _ 32 _ (iX _ _ hsm) hB' (Б) (by simp;omega) ·rename_i h1 have hbig:2^32≤(bq hi lo).toNat:=by by_contra h3;apply h1;simp[← ς];simp at r;omega rw[toUInt32_toUInt64];exact fZ _ _ _ 64 _ (iY _ _) hB' (Б) (by simp;omega) lemma aD (n:Nat) (fa fb:Nat→ Word) (hi lo B:Д) (hfin:fJ n fa fb) (hval:aB n fa fb=ag hi lo*2^B.toNat) (h:aw hi lo B<0x100000000):dotOf n fa fb=(aw hi lo B).toUInt32:=by obtain ⟨hv,hB,hr⟩ := es hi lo B h have hS:aB n fa fb≠0:=by rw[hval];exact mul_ne_zero hv (В) rw[er n fa fb hfin hS,hr] refine finishWord_of_ne _ _ _ _ hS ?_ rw[toRat_ofIntDyadic,hval];push_cast;rw[zpow_sub₀ two_ne_zero,zpow_natCast];field_simp end Core lemma fs (w:Word):toWord (ofW w)=w:=by apply Β.mp simp only[toWord,ofW,Model.toNatBits,ofUInt32_bits,ϥ] exact γ w.toBitVec.isLt lemma fo (z:Model Fmt):ofW (toWord z)=z:=by have h:z.toNatBits<2^32:=Model.toNatBits_lt_two_pow z simp only[ofW,toWord,Model.ofUInt32,ϥ,γ h] exact Model.ofNatBits_toNatBits z namespace Dense lemma ak {k n:USize} (h:k< n):(k+1).toNat=k.toNat+1:=by have:=μ.mp h;have:=n.toNat_lt_size;have:=USize.size_eq_two_pow rw[Ι,USize.toNat_one,γ (А)] lemma a4 {a b:USize} (h:a.toNat+b.toNat< USize.size):(a+b).toNat=a.toNat+b.toNat:=by rw[Ι,γ h] lemma ab {n:Nat} (h:n< USize.size):n.toUSize.toNat=n:=by rw[Nat.toUSize_eq,USize.toNat_ofNat_of_lt' h] lemma aC (x:Е):x.toUSize.toNat=x.toNat:=by simp[UInt32.toNat_toUSize] lemma au (A:Array Е) (u:USize) (h:u.toNat< A.size):A.uget u h=A[u.toNat]! := by simp[Array.uget,getElem!_pos A u.toNat h] lemma ar (p:Д) : Core.aa p=(p.toNat:Int) - (if 2^63≤ p.toNat then 2^64 else 0):=by unfold Core.aa;rw[ϓ,UInt64.toNat_toBitVec] split<;>split<;>push_cast<;>omega @[inline] def aJ (x:Е):Д:=x.toInt32.toInt64.toUInt64 def ah (x:Е):Int:=x.toBitVec.toInt lemma ax (x:Е):Core.aa (aJ x)=ah x:=by unfold aJ Core.aa ah show (x.toBitVec.signExtend 64).toInt=_;rw[BitVec.toInt_signExtend_of_le (А)] lemma cf (x:Е):ah x=(x.toNat:Int) - (if 2^31≤ x.toNat then 2^32 else 0):=by unfold ah;rw[ϓ,UInt32.toNat_toBitVec] split<;>split<;>push_cast<;>omega lemma d9 (x:Е) : |ah x| ≤ 2^31:=by have:=x.toNat_lt;rw[cf,abs_le];split<;>omega lemma bk (v:Д) (h : |Core.aa v| < 2^31):ah v.toUInt32=Core.aa v:=by have:=v.toNat_lt;rw[abs_lt,ar] at h rw[cf,ar,show v.toUInt32.toNat=v.toNat % 2^32 by simp];split_ifs at h ⊢<;>omega lemma bm (a b:Д) (h : |Core.aa a*Core.aa b| < 2^63) : Core.aa (a*b)=Core.aa a*Core.aa b:=by unfold Core.aa at *;show (a.toBitVec*b.toBitVec).toInt=_ rw[BitVec.toInt_mul];rw[abs_lt] at h;apply Int.bmod_eq_of_le_mul_two<;>push_cast<;>omega def nv (hi lo:Д):Int:=(hi.toNat:Int)*2^64+lo.toNat @[inline] def co (hi lo p:Д):Д := hi+((0:Д) - (p >>> 63))+(if lo+p< lo then 1 else 0) lemma iy (a b:Д) (A B:Nat) (ha:a.toNat=(A+B / 2^64) % 2^64) (hb:b.toNat=B % 2^64) : nv a b % 2^128=((A:Int)*2^64+B) % 2^128:=by unfold nv;rw[ha,hb];omega lemma cy (a b:Д):(if a+b< a then (1:Д) else 0).toNat=(a.toNat+b.toNat) / 2^64:=by have:=a.toNat_lt;have:=b.toNat_lt split<;>simp_all only[ν,θ]<;>simp<;>omega lemma iD (p:Д):((0:Д) - (p >>> 63)).toNat=if 2^63≤ p.toNat then 2^64 - 1 else 0:=by have:=p.toNat_lt;rw[Ε,κ];simp[ζ];split<;>omega lemma fR (hi lo p:Д) : nv (co hi lo p) (lo+p) % 2^128=(nv hi lo+Core.aa p) % 2^128:=by rw[iy _ _ _ _ (by unfold co;simp only[θ,Nat.mod_add_mod,cy];rfl) (θ _ _), iD,ar] unfold nv;split_ifs ·exact Int.modEq_iff_dvd.mpr ⟨-1,by push_cast;omega⟩ ·exact Int.modEq_iff_dvd.mpr ⟨0,by push_cast;omega⟩ lemma gY (hi lo:Д) : nv ((hi <<< 8)+(lo >>> 56)) (lo <<< 8) % 2^128=nv hi lo*256 % 2^128:=by have:=lo.toNat_lt;have:=hi.toNat_lt unfold nv;simp only[θ,ο,κ,UInt64.reduceToNat, Nat.reduceMod,ι,ζ] push_cast;omega lemma en (hi lo:Д) (S:Int) (h:nv hi lo % 2^128=S % 2^128) (h1 : |S| < 2^127):Core.ag hi lo=S:=by have:=hi.toNat_lt;have:=lo.toNat_lt rw[Core.cl];unfold nv at h;rw[abs_lt] at h1;split<;>omega @[inline] def ai (x:Е):Е:=x &&& 0x7FFFFFFF lemma br (x:Е):(ai x).toNat=x.toNat % 2^31:=by unfold ai;rw[ό];exact ξ _ 31 lemma aV (x:Е):(expOf x).toNat=(ai x).toNat / 2^23:=by have:(expOf x).toNat=x.toNat / 2^23 % 2^8:=by unfold expOf;rw[ό,ϝ] simp only[UInt32.reduceToNat,Nat.reduceMod,ζ] exact ξ _ 8 rw[this,br,show 2^31=2^23*2^8 by norm_num,Nat.mod_mul_right_div_self] lemma eZ (x:Е):expOf x=0↔(ai x).toNat<2^23:=by rw[← Β,aV];simp;try omega lemma ir (x:Е):idxOf x=(ai x).toNat / 2^23 - 1:=by have:=aV x;unfold idxOf;split<;>rename_i h ·have:=(eZ x).mp h;omega ·have:=mt (eZ x).mpr h;omega lemma c6 (x:Е):idxOf x=(expOf x).toNat - 1:=by rw[ir,aV] lemma fw (w:Е):w.toNat / 2^23=(expOf w).toNat+256*(w.toNat / 2^31):=by rw[aV,br];have:=w.toNat_lt;omega lemma io (x:Е):(expOf x).toNat<256:=by rw[aV,br];omega lemma ip (x:Е) (h:(ai x).toNat<0x7F800000):expOf x≠255:=by intro e;have:=aV x;rw[e] at this;simp at this;omega lemma e8 (w:Е):(w &&& 0x7FFFFF).toNat=w.toNat % 2^23:=by rw[ό];exact ξ _ 23 lemma cU (x:Е) (h:ai x=0):sv x=0:=by have h1:=br x;rw[h] at h1 have:expOf x=0:=(eZ x).mpr (by rw[h];simp) unfold sv mantOf fracOf;simp only[this,if_true,e8] simp at h1;simp;omega lemma cV (w:Е) : |sv w| < 2^24:=by have:=mantOf_lt_24 w;unfold sv;split<;>simp<;>omega @[inline] def fy (top:Д) (x:Е):Д:=(top - Core.iW x) >>> 3 @[inline] def cE (top:Д) (x:Е):Е := (Core.sW x*(1 <<< (7 - ((top - Core.iW x) &&& 7)))).toUInt32 lemma iG (top:Д) (x:Е) (h:idxOf x≤ top.toNat) : (top - Core.iW x).toNat=top.toNat - idxOf x:=by rw[η _ _ (by rw[ε,Core.an];exact h),Core.an] lemma cx (top:Д) (x:Е) (h:idxOf x≤ top.toNat) : (fy top x).toNat=(top.toNat - idxOf x) / 8:=by unfold fy;rw[κ,iG top x h];simp[ζ] lemma gu (top:Д) (x:Е) (h:idxOf x≤ top.toNat) : ah (cE top x)=sv x*2^(7 - (top.toNat - idxOf x) % 8):=by have ha:((top - Core.iW x) &&& 7).toNat=(top.toNat - idxOf x) % 8:=by rw[ϑ,iG top x h];exact ξ _ 3 set r:=7 - (top.toNat - idxOf x) % 8 have h7:(7 - ((top - Core.iW x) &&& 7)).toNat=r:=by rw[η _ _ (by rw[ε,ha];simp;omega),ha];rfl have h8:(2:Nat)^r≤2^7:=ψ (Г) (А) have hp:Core.aa (1 <<< (7 - ((top - Core.iW x) &&& 7)):Д)=2^r:=by rw[ar,ο,h7,UInt64.toNat_one,γ (a:=r) (А), ι,one_mul,γ (А),if_neg (А)];simp have hb : |sv x*2^r| < 2^31:=by rw[abs_mul,abs_pow,abs_two] have:(2:Int)^r≤2^7:=by exact_mod_cast h8 have:=mul_le_mul_of_nonneg_left this (abs_nonneg (sv x));have:=cV x;omega have hm:Core.aa (Core.sW x*(1 <<< (7 - ((top - Core.iW x) &&& 7))))=sv x*2^r:=by rw[bm,Core.aR,hp];rw[Core.aR,hp];omega unfold cE;rw[bk _ (by rw[hm];exact hb),hm] def aN (k:Nat):Е := if 256≤ k∧k<264 then UInt32.ofNat (2^(k - 256)) else if 512≤ k∧k<520 then UInt32.ofNat (2^32 - 2^(k - 512)) else 0 @[irreducible] def cp (n:Nat):Array Е:=Array.ofFn (n:=n) fun k=>aN k.val @[irreducible] def bg:Array Е:=cp 768 lemma dq:bg=cp 768:=by unfold bg;rfl lemma ey:bg.size=768:=by rw[dq];unfold cp;exact ϕ lemma cv (i:USize) (h:i.toNat< bg.size):bg.uget i h=aN i.toNat:=by have cu : ∀ (a:Array Е) (_:a=Array.ofFn (n:=768) fun k=>aN k.val) (h:i.toNat< a.size),a[i.toNat]=aN i.toNat:=by intro a ha h;rw[getElem_congr_coll ha];simp only[Θ] exact cu bg (by rw[dq];unfold cp;rfl) h lemma gp (w:Е) (c:USize) (hc:c.toNat<256) : ((w >>> 23).toUSize+c).toNat=w.toNat / 2^23+c.toNat:=by have e:(w >>> 23).toNat=w.toNat / 2^23:=by rw[ϝ];simp[ζ] have:=w.toNat_lt;have:=Ξ rw[a4 (by rw[aC,e];omega),aC,e] @[inline] def gE (c:USize) (w:Е) (hc:c.toNat<256):Е := bg.uget ((w >>> 23).toUSize+c) (by rw[gp w c hc,ey];have:=w.toNat_lt;omega) @[inline] def a3 (c:USize) (w:Е) (hc:c.toNat<256):Д := ((w &&& 0x7FFFFF)+0x800000).toUInt64*aJ (gE c w hc) lemma cP (k d:Nat) (hd:d<8) : (k=256+d→ ah (aN k)=2^d)∧(k=512+d→ ah (aN k) = -2^d):=by have:2^d<2^8:=Nat.pow_lt_pow_right (Г) hd have:1≤2^d:=ϸ constructor<;>intro hk<;>subst hk<;>unfold aN ·rw[if_pos (А),show 256+d - 256=d by omega,cf,ϥ, γ (А),if_neg (А)];push_cast;ring ·rw[if_neg (А),if_pos (А),show 512+d - 512=d by omega,cf, ϥ,γ (А),if_pos (А),Nat.cast_sub (А)] push_cast;ring lemma c8 (c:USize) (w:Е) (hc:c.toNat<256) (q:Int) (hq:ah (aN (w.toNat / 2^23+c.toNat))=q) (hb : |q| ≤ 128) : Core.aa (a3 c w hc)=(w.toNat % 2^23+2^23:Nat)*q:=by have hm:Core.aa ((w &&& 0x7FFFFF)+0x800000).toUInt64=(w.toNat % 2^23+2^23:Nat):=by have:((w &&& 0x7FFFFF)+0x800000).toUInt64.toNat=w.toNat % 2^23+2^23:=by rw[Χ,ϲ,e8,show (0x800000:Е).toNat=2^23 from rfl] have:=w.toNat_lt;omega rw[ar,this];split<;>omega unfold a3 gE rw[cv,gp w c hc,bm,ax,hm,hq] rw[ax,hm,hq,abs_mul,abs_of_nonneg (В)] have:((w.toNat % 2^23+2^23:Nat):Int)<2^24:=by push_cast;omega nlinarith def a5 (K eb:Nat) (w:Е):Prop := ai w=0∨(eb≤(expOf w).toNat∧(expOf w).toNat≤ eb+K) lemma aP (c:USize) (w:Е) (hc:c.toNat<256) (eb:Nat) (heb:c.toNat=256 - eb) (h1:1≤ eb) (h2:eb≤248) (hw:a5 7 eb w) : Core.aa (a3 c w hc)*2^(eb - 1)=sv w*2^idxOf w ∧ |Core.aa (a3 c w hc)| < 2^31:=by have hx:=w.toNat_lt;have he:=aV w;have ha:=br w;have hi:=c6 w have hsg:signOf w=true↔2^31≤ w.toNat:=Core.aG w rcases hw with hz | ⟨hlo,hhi⟩ ·rw[c8 c w hc 0 (by rw[heb,fw,show (expOf w).toNat=0 by rw[aV,hz];rfl];clear * - h1 h2 hx unfold aN;rw[if_neg (А),if_neg (А)];rfl) (Г),cU w hz];simp set d:=(expOf w).toNat - eb have hd:d<8:=by clear * - hlo hhi;omega have hidx:idxOf w=d+(eb - 1):=by rw[hi];exact (Nat.sub_add_sub_cancel hlo h1).symm have hmant:mantOf w=2^23+w.toNat % 2^23:=by unfold mantOf fracOf;rw[if_neg (mt (eZ w).mp (А)),e8] have h8:(2:Int)^d≤2^7:=pow_le_pow_right₀ (Г) (А) have hA:((w.toNat % 2^23+2^23:Nat):Int)<2^24:=by clear * -;push_cast;omega have hb:((w.toNat % 2^23+2^23:Nat):Int)*2^d<2^31:=by have:=mul_le_mul_of_nonneg_left h8 (Int.natCast_nonneg (w.toNat % 2^23+2^23));clear * - this hA;omega have hq8 : |(2:Int)^d| ≤ 128:=by rw[abs_of_pos (В)];exact h8 unfold sv;rw[hmant,hidx,pow_add] by_cases hn:signOf w=true ·rw[c8 c w hc _ ((cP _ d hd).2 (by rw[heb,fw];have:=hsg.mp hn;clear * - hlo h2 hx this;omega)) (by rwa[abs_neg]), if_pos hn] refine ⟨by push_cast;ring,?_⟩ rw[mul_neg,abs_neg,abs_of_nonneg (В)];exact hb ·rw[c8 c w hc _ ((cP _ d hd).1 (by rw[heb,fw];have:=mt hsg.mpr hn;clear * - hlo h2 this;omega)) hq8,if_neg hn] refine ⟨by push_cast;ring,?_⟩ rw[abs_of_nonneg (В)];exact hb @[inline] def bA (a b:Е):Е:=if a> b then a else b @[inline] def bB (a b:Е):Е:=if a< b then a else b lemma ek (a b:Е):(bA a b).toNat=max a.toNat b.toNat:=by unfold bA;split<;>rename_i h<;>simp only[gt_iff_lt,Ρ] at h<;>omega lemma em (a b:Е):(bB a b).toNat=min a.toNat b.toNat:=by unfold bB;split<;>rename_i h<;>simp only[Ρ] at h<;>omega def Sc (M L:Nat) (v:Е):Prop:=v.toNat≤ M∧L≤(v - 1).toNat lemma je {M L M' L':Nat} {v:Е} (h:Sc M L v) (h1:M≤ M':=by simp only[max_le_iff];simp only[le_max_iff,le_refl,true_or,or_true,and_self]) (h2:L'≤ L:=by simp only[le_min_iff];simp only[min_le_iff,le_refl,true_or,or_true,and_self]):Sc M' L' v:=⟨h.1.trans h1,h2.trans h.2⟩ lemma u4 {k n:USize} (hk:k.toNat≤ n.toNat) (hn:n.toNat<2^30) : (k+1).toNat=k.toNat+1∧(k+2).toNat=k.toNat+2∧(k+3).toNat=k.toNat+3 ∧ (k+4).toNat=k.toNat+4:=by have:=Ξ;have:=USize.size_eq_two_pow refine ⟨?_,?_,?_,?_⟩<;>rw[Ι]<;>simp<;>rw[γ (А)] lemma bv (X:Array Е) (xo s n t:USize) (hb:xo.toNat+(n.toNat - 1)*s.toNat< X.size) (hs:X.size< USize.size) (ht:t.toNat< n.toNat) : (xo+t*s).toNat=xo.toNat+t.toNat*s.toNat∧xo.toNat+t.toNat*s.toNat< X.size:=by have:t.toNat*s.toNat≤(n.toNat - 1)*s.toNat:=τ _ (А) have:=USize.size_eq_two_pow refine ⟨?_,by omega⟩ rw[Ι,USize.toNat_mul,γ (a:=t.toNat*s.toNat) (А), γ (А)] section variable (X:Array Е) (xo s n:USize) (hb:xo.toNat+(n.toNat - 1)*s.toNat< X.size) (hs:X.size< USize.size) @[inline] def ux (t:USize) (ht:t.toNat< n.toNat):Е := X.uget (xo+t*s) (by rw[(bv X xo s n t hb hs ht).1];exact (bv X xo s n t hb hs ht).2) lemma fu (t:USize) (ht:t.toNat< n.toNat) : ux X xo s n hb hs t ht=X[xo.toNat+t.toNat*s.toNat]! := by unfold ux;rw[au,(bv X xo s n t hb hs ht).1] @[inline] def rx (t:USize) (ht:t.toNat< n.toNat):Е:=ai (ux X xo s n hb hs t ht) lemma gG (t:USize) (ht:t.toNat< n.toNat) : rx X xo s n hb hs t ht=ai X[xo.toNat+t.toNat*s.toNat]! := by unfold rx;rw[fu] def bQ (hn:n.toNat<2^30) (k:USize) (hk:k.toNat≤ n.toNat) (m0 m1 m2 m3 l0 l1 l2 l3:Е):Е × Е := if h:k+4≤ n then have e:=u4 hk hn have h4:k.toNat+4≤ n.toNat:=by rw[← e.2.2.2];exact USize.le_iff_toNat_le.mp h let v0:=rx X xo s n hb hs k (by clear * - h4;omega) let v1:=rx X xo s n hb hs (k+1) (by clear * - e h4;omega) let v2:=rx X xo s n hb hs (k+2) (by clear * - e h4;omega) let v3:=rx X xo s n hb hs (k+3) (by clear * - e h4;omega) bQ hn (k+4) (by rw[e.2.2.2];exact h4) (bA v0 m0) (bA v1 m1) (bA v2 m2) (bA v3 m3) (bB (v0 - 1) l0) (bB (v1 - 1) l1) (bB (v2 - 1) l2) (bB (v3 - 1) l3) else if h1:k< n then let v:=rx X xo s n hb hs k (μ.mp h1) bQ hn (k+1) (by rw[ak h1];exact μ.mp h1) (bA v m0) m1 m2 m3 (bB (v - 1) l0) l1 l2 l3 else (bA (bA m0 m1) (bA m2 m3),bB (bB l0 l1) (bB l2 l3)) termination_by n.toNat - k.toNat decreasing_by ·rw[e.2.2.2];clear * - h4;omega ·rw[ak h1];have:=μ.mp h1;omega lemma du (hn:n.toNat<2^30) (k:USize) (hk:k.toNat≤ n.toNat) (m0 m1 m2 m3 l0 l1 l2 l3:Е) (vx:Nat→ Е) (hv : ∀ t,t< n.toNat→ ai X[xo.toNat+t*s.toNat]! = vx t) (I : ∀ t< k.toNat,Sc (max (max m0.toNat m1.toNat) (max m2.toNat m3.toNat)) (min (min l0.toNat l1.toNat) (min l2.toNat l3.toNat)) (vx t)) : ∀ t< n.toNat,Sc (bQ X xo s n hb hs hn k hk m0 m1 m2 m3 l0 l1 l2 l3).1.toNat (bQ X xo s n hb hs hn k hk m0 m1 m2 m3 l0 l1 l2 l3).2.toNat (vx t):=by fun_induction bQ ·rename_i k hk m0 m1 m2 m3 l0 l1 l2 l3 h e h4 v0 v1 v2 v3 ih apply ih;intro t ht simp only[Sc,ek,em,v0,v1,v2,v3,gG,e.1,e.2.1,e.2.2.1,e.2.2.2] at ht ⊢ rw[hv _ (by clear * - h4;omega),hv _ (by clear * - h4;omega),hv _ (by clear * - h4;omega), hv _ (by clear * - h4;omega)] rcases Nat.lt_or_ge t k.toNat with h | h ·exact je (I t h) obtain ⟨j,rfl⟩ := Nat.exists_eq_add_of_le h rcases j with _ | _ | _ | _ | j iterate 4 · simp only[Τ,Ο,le_max_iff,min_le_iff,le_refl,true_or,or_true,and_self] omega ·rename_i k hk m0 m1 m2 m3 l0 l1 l2 l3 h h1 v ih apply ih;intro t ht simp only[Sc,ek,em,v,gG,ak h1] at ht ⊢ rw[hv _ (μ.mp h1)] rcases (by omega:t< k.toNat∨t=k.toNat) with h | rfl ·exact je (I t h) ·simp only[le_max_iff,min_le_iff,le_refl,true_or,and_self] ·rename_i k hk m0 m1 m2 m3 l0 l1 l2 l3 h h1 intro t ht;have:=I t (by have:=USize.lt_iff_toNat_lt.not.mp h1;omega) simpa only[Sc,ek,em] using this lemma jk (v:Е):(v - 1).toNat=(v.toNat+2^32 - 1) % 2^32:=by rw[UInt32.toNat_sub,UInt32.toNat_one];omega lemma cO {x:Е} (h:x.toNat<255):x≠255:=fun e=>by rw[e] at h;exact absurd h (Б) lemma jg (v:Е) (h:v+1≠0):(v+1).toNat=v.toNat+1:=by have:v.toNat≠2^32 - 1:=fun e=>h (Β.mp (by rw[ϲ,e];rfl)) rw[ϲ,UInt32.toNat_one];have:=v.toNat_lt;omega lemma jd {M L:Е} {x:Е} (h:Sc M.toNat L.toNat (ai x)) (hM:M<0x7F800000) : (expOf x).toNat≤(expOf M).toNat∧(expOf M).toNat<255 ∧ (ai x≠0→ L+1≠0→(expOf (L+1)).toNat≤(expOf x).toNat):=by have h1:=aV x;have h2:=aV M;have h3:=br M;have h4:=jk (ai x) have h5:=(ai x).toNat_lt;have h6:=Ρ.mp hM rw[show (0x7F800000:Е).toNat=2139095040 from rfl] at h6 unfold Sc at h refine ⟨by omega,by omega,fun h0 h8 => ?_⟩ have h11:=jg L h8 rw[aV,br,h1];refine Nat.div_le_div_right ((Nat.mod_le _ _).trans ?_) have h12:(ai x).toNat≠0:=fun e=>h0 (Β.mp (by rw[e];rfl)) clear * - h h4 h5 h11 h12;omega @[inline] def dX (top b:Д) (x:Е):Bool:=ai x != 0 && fy top x == b def ay (top b:Д) (k:USize) (gi gx:Array Е) : Array Е × Array Е := if hk:k< n then let x:=ux X xo s n hb hs k (μ.mp hk) if dX top b x then ay top b (k+1) (gi.push k.toUInt32) (gx.push (cE top x)) else ay top b (k+1) gi gx else (gi,gx) termination_by n.toNat - k.toNat decreasing_by all_goals (rw[ak hk];have:=μ.mp hk;omega) def tS (gi gx:Array Е) (rv:Nat→ Int):Int := ∑ m∈ Finset.range gi.size,ah gx[m]! * rv gi[m]!.toNat def bS (xf:Nat→ Е) (top b:Д) (rv:Nat→ Int) (k n:Nat):Int := ∑ t∈ Finset.Ico k n,if dX top b (xf t) then ah (cE top (xf t))*rv t else 0 lemma iq (a:Array Е) (v:Е) (m:Nat):(a.push v)[m]! = if m=a.size then v else a[m]! := by rw[getElem!_def,getElem!_def,Array.getElem?_push];by_cases h:m=a.size<;>simp[h] lemma i1 (gi gx:Array Е) (h:gx.size=gi.size) (a c:Е) (rv:Nat→ Int) : tS (gi.push a) (gx.push c) rv=tS gi gx rv+ah c*rv a.toNat:=by unfold tS;rw[Array.size_push,Λ];simp only[iq,h,if_true] congr 1;exact χ rfl fun m hm=>by simp[(Μ.mp hm).ne] lemma bT (hn:n.toNat<2^30) (top b:Д) (k:USize) (gi gx:Array Е) (hsz:gx.size=gi.size) (hk:gi.size≤ k.toNat) (hkn:k.toNat≤ n.toNat) (hg : ∀ m,m< gi.size→ gi[m]!.toNat< n.toNat) : (ay X xo s n hb hs top b k gi gx).2.size=(ay X xo s n hb hs top b k gi gx).1.size ∧ (ay X xo s n hb hs top b k gi gx).1.size≤ n.toNat ∧ (∀ m,m<(ay X xo s n hb hs top b k gi gx).1.size → (ay X xo s n hb hs top b k gi gx).1[m]!.toNat< n.toNat) ∧ ∀ rv,tS (ay X xo s n hb hs top b k gi gx).1 (ay X xo s n hb hs top b k gi gx).2 rv = tS gi gx rv+bS (fun t=>X[xo.toNat+t*s.toNat]!) top b rv k.toNat n.toNat:=by fun_induction ay ·rename_i k gi gx hk' x hx ih have e:=ak hk';have h2:=μ.mp hk' have hu:k.toUInt32.toNat=k.toNat:=by simp;omega rw[e] at ih obtain ⟨h1,h3,h4,h5⟩ := ih (by simp[hsz]) (by simp;omega) (А) (fun m hm=>by simp at hm;rw[iq];split<;>[omega;exact hg m (А)]) refine ⟨h1,h3,h4,fun rv => ?_⟩ rw[h5,i1 gi gx hsz,hu];unfold bS;rw[Η h2] simp only[x,fu] at hx ⊢;rw[if_pos hx];ring ·rename_i k gi gx hk' x hx ih have e:=ak hk';have h2:=μ.mp hk' rw[e] at ih obtain ⟨h1,h3,h4,h5⟩ := ih hsz (А) (А) hg refine ⟨h1,h3,h4,fun rv => ?_⟩ rw[h5];unfold bS;rw[Η h2] simp only[x,fu] at hx ⊢;rw[if_neg hx];ring ·rename_i k gi gx hk' have:=USize.lt_iff_toNat_lt.not.mp hk' dsimp only exact ⟨hsz,by omega,hg,fun rv=>by simp[bS,ϗ (by omega:n.toNat≤ k.toNat)]⟩ end @[inline] def sl (a b:Е):Bool:=a.toInt32< b.toInt32 @[inline] def bA1 (a b:Е):Е:=if sl a b then b else a @[inline] def bB1 (a b:Е):Е:=if sl a b then a else b lemma sm (a b:Е) (ha:a.toNat<2^31) (hb:b.toNat<2^31):sl a b=decide (a< b):=by have e:a.toBitVec.msb=b.toBitVec.msb:=by simp only[BitVec.msb_eq_decide,UInt32.toNat_toBitVec];rw[decide_eq_false (А),decide_eq_false (А)] unfold sl rw[Bool.eq_iff_iff,decide_eq_true_eq,decide_eq_true_eq,Int32.lt_iff_toBitVec_slt,UInt32.toBitVec_toInt32, UInt32.toBitVec_toInt32,BitVec.slt_eq_ult_of_msb_eq e,BitVec.ult_iff_lt,UInt32.lt_iff_toBitVec_lt] lemma ek1 (a b:Е) (ha:a.toNat<2^31) (hb:b.toNat<2^31):(bA1 a b).toNat=max a.toNat b.toNat:=by unfold bA1;rw[sm a b ha hb];split<;>rename_i h<;>simp only[decide_eq_true_eq,Ρ,not_lt] at h<;>omega lemma em1 (a b:Е) (ha:a.toNat<2^31) (hb:b.toNat<2^31):(bB1 a b).toNat=min a.toNat b.toNat:=by unfold bB1;rw[sm a b ha hb];split<;>rename_i h<;>simp only[decide_eq_true_eq,Ρ,not_lt] at h<;>omega def bQ1 (W:Array Е) (n:USize) (hn:n.toNat≤ W.size) (k:USize) (m l:Е):Е × Е := if h:k< n then let v:=ai (W.uget k (by have:=μ.mp h;omega)) bQ1 W n hn (k+1) (bA1 m v) (bB1 (ai (v - 1)) l) else (m,l) termination_by n.toNat - k.toNat decreasing_by rw[ak h];have:=μ.mp h;omega lemma du1 (W:Array Е) (n:USize) (hn:n.toNat≤ W.size) (k:USize) (m l:Е) (hm:m.toNat<2^31) (hl:l.toNat<2^31) (I:∀ t< k.toNat,Sc m.toNat l.toNat (ai W[t]!)) : ∀ t< n.toNat,Sc (bQ1 W n hn k m l).1.toNat (bQ1 W n hn k m l).2.toNat (ai W[t]!):=by fun_induction bQ1 ·rename_i k m l h v ih have hv:v.toNat<2^31:=by rw[br];exact Nat.mod_lt _ (Б) have hw:(ai (v - 1)).toNat<2^31:=by rw[br];exact Nat.mod_lt _ (Б) apply ih ·rw[ek1 _ _ hm hv];omega ·rw[em1 _ _ hw hl];omega ·intro t ht rw[ak h] at ht rw[Sc,ek1 _ _ hm hv,em1 _ _ hw hl] rcases (by omega:t< k.toNat∨t=k.toNat) with h | rfl ·have:=I t h;simp only[Sc] at this;omega ·have hw2:(ai (v - 1)).toNat≤(v - 1).toNat:=by rw[br];exact Nat.mod_le _ _ simp only[v,au] at hw2 ⊢;omega ·rename_i k m l h intro t ht;exact I t (by have:=μ.not.mp h;omega) def ae (K:Nat) (W:Array Е):Nat := if h:0< W.size∧W.size<2^30 then have hs:W.size< USize.size:=by have:=Ξ;omega have e:W.size.toUSize.toNat=W.size:=ab hs let r:=bQ1 W W.size.toUSize (by rw[e]) 0 0 0x7FFFFFFF if r.1<0x7F800000∧r.2+1≠0∧1≤(expOf (r.2+1)).toNat ∧ (expOf r.1).toNat≤(expOf (r.2+1)).toNat+K∧(expOf (r.2+1)).toNat≤248 then (expOf (r.2+1)).toNat else 0 else 0 lemma ao (K:Nat) (W:Array Е) (h:ae K W≠0):W.size<2^30∧1≤ ae K W ∧ ae K W≤248 ∧ ∀ i:Nat,a5 K (ae K W) W[i]! ∧ expOf W[i]! ≠ 255:=by unfold ae at h ⊢ by_cases h0:0< W.size∧W.size<2^30 swap;· rw[dif_neg h0] at h;exact absurd rfl h rw[dif_pos h0] at h ⊢;dsimp only at h ⊢ have hs:W.size< USize.size:=by have:=Ξ;omega have e:=ab hs have hsp:=du1 W W.size.toUSize (by rw[e]) 0 0 0x7FFFFFFF (by decide) (by decide) (fun t ht=>by simp at ht) generalize bQ1 W _ _ _ _ _=r at hsp h ⊢ split at h<;>rename_i hc swap;· exact absurd rfl h rw[if_pos hc] refine ⟨h0.2,hc.2.2.1,hc.2.2.2.2,fun i => ?_⟩ by_cases hi:i< W.size ·have q:=jd (hsp i (by rw[e];exact hi)) hc.1 unfold a5;have:=hc.2.2.2.1;constructor ·by_cases hz:ai W[i]! = 0 ·exact Or.inl hz ·have:=q.2.2 hz hc.2.1;omega ·exact cO (А) ·rw[getElem!_neg W i hi];exact ⟨Or.inl (Б),by decide⟩ structure dI (n:Nat) where gi:Array Е gx:Array Е hsz:gx.size=gi.size hgi : ∀ m (h:m< gi.size),gi[m].toNat< n def eT (X:Array Е) (xo s nu:USize) (hb:xo.toNat+(nu.toNat - 1)*s.toNat< X.size) (hs:X.size< USize.size) (hn:nu.toNat<2^30) (n:Nat) (e:nu.toNat=n) (top b:Д) : dI n := have sp:=bT X xo s nu hb hs hn top b 0 (Array.mkEmpty n) (Array.mkEmpty n) rfl (by simp) (by simp) (by simp) ⟨_,_,sp.1,fun m hm=>by have:=sp.2.2.1 m hm;rwa[getElem!_pos _ m hm,e] at this⟩ lemma fC (X:Array Е) (xo s nu:USize) (hb:xo.toNat+(nu.toNat - 1)*s.toNat< X.size) (hs:X.size< USize.size) (hn:nu.toNat<2^30) (n:Nat) (e:nu.toNat=n) (top b:Д) : (eT X xo s nu hb hs hn n e top b).gi.size≤ n ∧ ∀ rv, tS (eT X xo s nu hb hs hn n e top b).gi (eT X xo s nu hb hs hn n e top b).gx rv = bS (fun t=>X[xo.toNat+t*s.toNat]!) top b rv 0 n:=by have sp:=bT X xo s nu hb hs hn top b 0 (Array.mkEmpty n) (Array.mkEmpty n) rfl (by simp) (by simp) (by simp) exact ⟨sp.2.1.trans (le_of_eq e),fun rv=>(sp.2.2.2 rv).trans (by rw[e];simp[tS])⟩ structure dK (n:Nat) where top:Д bs:Array (dI n) def dL {n:Nat} (r:dK n) (xf:Nat→ Е):Prop := n<2^20∧r.bs.size≤6∧r.top.toNat<256 ∧ (∀ t,t< n→ expOf (xf t)≠255∧(ai (xf t)≠0 → idxOf (xf t)≤ r.top.toNat∧(r.top.toNat - idxOf (xf t)) / 8< r.bs.size)) ∧ ∀ b (h:b< r.bs.size),r.bs[b].gi.size<2^20 ∧ ∀ rv,tS r.bs[b].gi r.bs[b].gx rv=bS xf r.top b.toUInt64 rv 0 n def aj (X:Array Е) (xo s n:Nat):dK n := if h:0< n∧n<2^20∧s<2^32∧xo+(n - 1)*s< X.size∧X.size< USize.size then have e:xo.toUSize.toNat=xo∧s.toUSize.toNat=s∧n.toUSize.toNat=n:=by have:=Ξ exact ⟨ab (А),ab (А),ab (А)⟩ have hb:xo.toUSize.toNat+(n.toUSize.toNat - 1)*s.toUSize.toNat< X.size:=by rw[e.1,e.2.1,e.2.2];exact h.2.2.2.1 have hn:n.toUSize.toNat<2^30:=by rw[e.2.2];omega let r:=bQ X xo.toUSize s.toUSize n.toUSize hb h.2.2.2.2 hn 0 (by simp) 0 0 0 0 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF let top:=Core.iW r.1 let nb:=((top - Core.iW (r.2+1)) >>> 3)+1 if r.1<0x7F800000∧r.2+1≠0∧nb≤6 then ⟨top,Array.ofFn (n:=nb.toNat) fun b => eT X xo.toUSize s.toUSize n.toUSize hb h.2.2.2.2 hn n e.2.2 top b.val.toUInt64⟩ else ⟨0,#[]⟩ else ⟨0,#[]⟩ lemma gh (x:Е):idxOf x<256:=by have:=ir x;have:=br x;have:=x.toNat_lt;omega lemma aU (X:Array Е) (xo s n:Nat) (h0:0<(aj X xo s n).bs.size) : dL (aj X xo s n) (fun t=>X[xo+t*s]!):=by unfold aj at h0 ⊢ by_cases h:0< n∧n<2^20∧s<2^32∧xo+(n - 1)*s< X.size∧X.size< USize.size swap;· rw[dif_neg h] at h0;simp at h0 rw[dif_pos h] at h0 ⊢;dsimp only at h0 ⊢ have e:xo.toUSize.toNat=xo∧s.toUSize.toNat=s∧n.toUSize.toNat=n:=by have:=Ξ exact ⟨ab (А),ab (А),ab (А)⟩ have hb:xo.toUSize.toNat+(n.toUSize.toNat - 1)*s.toUSize.toNat< X.size:=by rw[e.1,e.2.1,e.2.2];exact h.2.2.2.1 have hn:n.toUSize.toNat<2^30:=by rw[e.2.2];omega have hsp:=du X xo.toUSize s.toUSize n.toUSize hb h.2.2.2.2 hn 0 (by simp) 0 0 0 0 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF (fun t=>ai X[xo+t*s]!) (fun t _=>by rw[e.1,e.2.1]) (fun t ht=>by simp at ht) generalize bQ X _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _=r at hsp h0 ⊢ split at h0<;>rename_i hc swap;· simp at h0 rw[if_pos hc];unfold dL;dsimp only simp only[ϕ] at h0 ⊢ obtain ⟨hc1,hc2,hc3⟩ := hc have hT:=Core.an r.1;have hB:=Core.an (r.2+1) have hl:=gh r.1;have hl2:=gh (r.2+1) have h6:=ε.mp hc3 refine ⟨h.2.1,?_,?_,fun t ht => ?_,fun b hb' => ?_⟩ ·simpa using h6 ·omega ·have q:=jd (hsp t (by rw[e.2.2];exact ht)) hc1 refine ⟨cO (q.1.trans_lt q.2.1),fun hz => ?_⟩ have a1:=Nat.sub_le_sub_right q.1 1;rw[← c6,← c6] at a1 have a2:=Nat.sub_le_sub_right (q.2.2 hz hc2) 1;rw[← c6,← c6] at a2 have hs:Core.iW (r.2+1)≤ Core.iW r.1:=by rw[ε,hT,hB];exact a2.trans a1 rw[θ,κ,η _ _ hs] simp[ζ] rw[hT,hB,γ (by clear * - hl;omega)] exact ⟨a1,Nat.lt_succ_of_le (Nat.div_le_div_right (Nat.sub_le_sub_left a2 _))⟩ ·rw[Θ];dsimp only have q:=fC X xo.toUSize s.toUSize n.toUSize hb h.2.2.2.2 hn n e.2.2 (Core.iW r.1) (b:Nat).toUInt64 exact ⟨by have:=q.1;omega,fun rv=>by rw[q.2,e.1,e.2.1]⟩ @[inline] def eA (hi lo v d:Д):Д := hi+((v >>> 1) >>> (63 - d))+(((0:Д) - (v >>> 63)) <<< d)+(if lo+(v <<< d)< lo then 1 else 0) @[inline] def dM (lo v d:Д):Д:=lo+(v <<< d) lemma dF (hi lo v d:Д) (hd:d.toNat<64) : nv (eA hi lo v d) (dM lo v d) % 2^128=(nv hi lo+Core.aa v*2^d.toNat) % 2^128:=by obtain ⟨D,hD⟩ : ∃ D,d.toNat=D:=⟨_,rfl⟩ have hQ:2^(64 - D)*2^D=2^64:=by rw[← pow_add];congr 1;omega have hP1:1≤2^D∧2^D≤2^63:=⟨ϸ,ψ (Г) (А)⟩ have e1:(v <<< d).toNat=v.toNat*2^D % 2^64:=by rw[ο,hD,γ (a:=D) (А),ι] have e2:((v >>> 1) >>> (63 - d)).toNat=v.toNat*2^D / 2^64:=by have h63:(63 - d).toNat=63 - D:=by rw[η _ _ (by rw[ε];simp;omega)];simp;omega simp only[κ,h63,ζ,Ϫ] rw[← hQ,Nat.mul_div_mul_right _ _ (В),← pow_add];congr 2;simp;omega have e3:(((0:Д) - (v >>> 63)) <<< d).toNat=if 2^63≤ v.toNat then 2^64 - 2^D else 0:=by rw[ο,iD,hD,γ (a:=D) (А),ι] split_ifs<;>omega unfold eA dM rw[iy _ _ _ _ (by simp only[θ,Nat.mod_add_mod,cy];rfl) (θ _ _)] have cu:=Nat.mod_add_div (v.toNat*2^D) (2^64) unfold nv;rw[ar,hD,e1,e2,e3,show (2:Int)^D=((2^D:Nat):Int) by push_cast;rfl] generalize 2^D=P at * generalize v.toNat*P % 2^64=R at *;generalize v.toNat*P / 2^64=Q at * have k2:(v.toNat:Int)*P=R+2^64*Q:=by exact_mod_cast cu.symm clear hQ e1 e2 e3 cu hd hD;simp only[sub_mul,k2] split_ifs ·exact Int.modEq_iff_dvd.mpr ⟨-1,by push_cast;omega⟩ ·exact Int.modEq_iff_dvd.mpr ⟨0,by push_cast;omega⟩ lemma ef (v d:Д) (hd:d.toNat<64) (h : |Core.aa v*2^d.toNat| < 2^63) : Core.aa (v <<< d)=Core.aa v*2^d.toNat:=by obtain ⟨P,hP⟩ : ∃ P,2^d.toNat=P:=⟨_,rfl⟩ have hPi:(2:Int)^d.toNat=(P:Int):=by rw[← hP];push_cast;rfl rw[ar (v <<< d),ο,γ (a:=d.toNat) hd,ι,hP,hPi] rw[hPi] at h obtain ⟨j,hQ⟩ : ∃ j:Int,((v.toNat*P:Nat):Int)=Core.aa v*P+2^64*j := ⟨if 2^63≤ v.toNat then P else 0,by rw[ar];split<;>push_cast<;>ring⟩ generalize Core.aa v*P=S at h hQ ⊢ generalize v.toNat*P=Q at hQ ⊢ rw[abs_lt] at h;clear * - h hQ;split_ifs<;>omega structure BI where hi:Д lo:Д ok:Bool def aS (B:Д) (bw:Е):BI := if ai bw == 0 then ⟨0,0,true⟩ else let d:=Core.iW bw+149 - B if ai bw≥0x7F800000 || Core.iW bw+149< B || d>100 then ⟨0,0,false⟩ else if d<64 then ⟨eA 0 0 (Core.sW bw) d,dM 0 (Core.sW bw) d,true⟩ else ⟨eA 0 0 (Core.sW bw <<< 37) (d - 37),dM 0 (Core.sW bw <<< 37) (d - 37),true⟩ lemma eS (B:Д) (bw:Е) (h:(aS B bw).ok=true) : expOf bw≠255 ∧ ∃ d:Nat,d≤101∧sv bw*2^(idxOf bw+149)=sv bw*2^d*2^B.toNat ∧ nv (aS B bw).hi (aS B bw).lo % 2^128=sv bw*2^d % 2^128:=by unfold aS at h ⊢ by_cases hz:ai bw=0 ·rw[if_pos (by simp[hz])] refine ⟨cO (by have:=aV bw;rw[hz] at this;simp at this;omega),0,by norm_num,?_,?_⟩ <;> rw[cU bw hz]<;>simp[nv] rw[if_neg (by simpa using hz)] at h ⊢ dsimp only at h ⊢ split at h<;>rename_i hf ·simp at h rw[if_neg hf] simp only[ϖ,decide_eq_true_eq,not_or] at hf obtain ⟨⟨hf1,hf2⟩,hf3⟩ := hf have hi:=Core.an bw;have hl:=gh bw rw[ge_iff_le,UInt32.le_iff_toNat_le] at hf1 rw[ν,θ] at hf2 simp at hf1 hf2 have hD:(Core.iW bw+149 - B).toNat=idxOf bw+149 - B.toNat:=by rw[η _ _ (by rw[ε,θ];simp;omega), θ];simp;omega rw[gt_iff_lt,ν,hD] at hf3 simp at hf3 refine ⟨ip bw (А),?_⟩ have hx:sv bw*2^(idxOf bw+149)=sv bw*2^(idxOf bw+149 - B.toNat)*2^B.toNat:=by rw[mul_assoc,← pow_add,Nat.sub_add_cancel (А)] split<;>rename_i hd<;>rw[ν,hD] at hd<;>simp at hd ·exact ⟨_,by omega,hx,by rw[dF _ _ _ _ (by rw[hD];omega),Core.aR,hD];simp[nv]⟩ ·have h37:(Core.iW bw+149 - B - 37).toNat=idxOf bw+149 - B.toNat - 37:=by rw[η _ _ (by rw[ε,hD];simp;omega),hD];rfl have hb : |Core.aa (Core.sW bw)*2^(37:Д).toNat| < 2^63:=by rw[Core.aR,abs_mul];norm_num;linarith[cV bw] refine ⟨_,by omega,hx,?_⟩ rw[dF _ _ _ _ (by rw[h37];omega),ef _ 37 (Б) hb,Core.aR,h37,mul_assoc,← pow_add, show (37:Д).toNat+(idxOf bw+149 - B.toNat - 37)=idxOf bw+149 - B.toNat by simp;omega] simp[nv] @[inline] def gf (lo hi B:Д) (bi:BI):Д := if bi.ok then Core.aw (hi+bi.hi+(if lo+bi.lo< lo then 1 else 0)) (lo+bi.lo) B else 0x100000000 @[inline] def aM (lo hi B:Д) (bw:Е):Д:=gf lo hi B (aS B bw) lemma et (lo hi B:Д) (bw:Е) (h:aM lo hi B bw<0x100000000) : expOf bw≠255 ∧ ∃ hi2 lo2,∃ d:Nat,aM lo hi B bw=Core.aw hi2 lo2 B∧d≤101 ∧ sv bw*2^(idxOf bw+149)=sv bw*2^d*2^B.toNat ∧ nv hi2 lo2 % 2^128=(nv hi lo+sv bw*2^d) % 2^128:=by unfold aM gf at h ⊢ split at h<;>rename_i hok swap;· exact absurd h (Б) obtain ⟨hbw,d,hd,hsc,hnv⟩ := eS B bw hok rw[if_pos hok] refine ⟨hbw,_,_,d,rfl,hd,hsc,?_⟩ rw[← Int.add_emod_emod,← hnv,Int.add_emod_emod] generalize (aS B bw).hi=bh;generalize (aS B bw).lo=bl rw[iy _ _ _ _ (by simp only[θ,Nat.mod_add_mod,cy];rfl) (θ _ _)] unfold nv;push_cast;ring_nf lemma ee (a b:Д) (h : |Core.aa a+Core.aa b| < 2^63) : Core.aa (a+b)=Core.aa a+Core.aa b:=by unfold Core.aa at *;show (a.toBitVec+b.toBitVec).toInt=_ rw[BitVec.toInt_add];rw[abs_lt] at h;apply Int.bmod_eq_of_le_mul_two<;>push_cast<;>omega lemma iI (x:Е) (w:Д) (v:Int) (hw:Core.aa w=v) (hv : |v| < 2^31) : Core.aa (aJ x*w)=ah x*v ∧ |ah x*v| < 2^62:=by have:=d9 x have hb : |ah x*v| < 2^62:=by rw[abs_mul];nlinarith[abs_nonneg (ah x),abs_nonneg v] exact ⟨by rw[bm _ _ (by rw[ax,hw];linarith),ax,hw],hb⟩ lemma jl (x y:Е) (w w':Д) (v v':Int) (hw:Core.aa w=v) (hw':Core.aa w'=v') (hv : |v| < 2^31) (hv' : |v'| < 2^31) : Core.aa (aJ x*w+aJ y*w')=ah x*v+ah y*v':=by obtain ⟨e1,b1⟩ := iI x w v hw hv;obtain ⟨e2,b2⟩ := iI y w' v' hw' hv' rw[ee _ _ (by rw[e1,e2];rw[abs_lt] at *;constructor<;>linarith),e1,e2] lemma jf {H L:Д} (h l p:Д) (a S P R:Int) (hp:Core.aa p=a) (e:nv H L % 2^128=((nv (co h l p) (l+p)+S)*P+R) % 2^128) : nv H L % 2^128=((nv h l+(a+S))*P+R) % 2^128:=by rw[e,← add_assoc,← hp];exact ((Ϧ _ (fR h l p)).mul_right _).add_right _ lemma aK {k:USize} {a:Array Е} (h:k< a.usize):k.toNat< a.size:=by have:=μ.mp h;rw[Array.usize,Nat.toUSize_eq,USize.toNat_ofNat'] at this exact lt_of_lt_of_le this (Nat.mod_le _ _) lemma ft {k:USize} {a:Array Е} (hs:a.size< USize.size) (h:¬k< a.usize):a.size≤ k.toNat:=by have:=USize.lt_iff_toNat_lt.not.mp h;rw[Array.usize,ab hs] at this;omega @[specialize] def aX {n:Nat} (rd:(t:USize)→ t.toNat< n→ Д) (bs:Array (dI n)) (B:Д) (bw:Е) (b:Nat) (gi gx:Array Е) (hsz:gx.size=gi.size) (hgi : ∀ m (h:m< gi.size),gi[m].toNat< n) (k:USize) (lo hi:Д):Д := if hk:k< gi.usize then let p:=aJ (gx.uget k (by rw[hsz];exact aK hk)) * rd (gi.uget k (aK hk)).toUSize (by rw[aC];exact hgi _ (aK hk)) if hk2:k+1< gi.usize then let q:=p+aJ (gx.uget (k+1) (by rw[hsz];exact aK hk2)) * rd (gi.uget (k+1) (aK hk2)).toUSize (by rw[aC];exact hgi _ (aK hk2)) aX rd bs B bw b gi gx hsz hgi (k+1+1) (lo+q) (co hi lo q) else aX rd bs B bw b gi gx hsz hgi (k+1) (lo+p) (co hi lo p) else if hb:b+1< bs.size then aX rd bs B bw (b+1) bs[b+1].gi bs[b+1].gx bs[b+1].hsz bs[b+1].hgi 0 (lo <<< 8) ((hi <<< 8)+(lo >>> 56)) else aM lo hi B bw termination_by (bs.size - b,gi.size - k.toNat) decreasing_by ·refine Prod.Lex.right _ ?_;have:=aK hk2;rw[ak hk2];rw[ak hk] at this ⊢;omega ·exact Prod.Lex.right _ (by rw[ak hk];have:=aK hk;omega) ·exact Prod.Lex.left _ _ (А) lemma dB {n:Nat} (rd:(t:USize)→ t.toNat< n→ Д) (bs:Array (dI n)) (B:Д) (bw:Е) (rv G:Nat→ Int) (hrd : ∀ t h,Core.aa (rd t h)=rv t.toNat) (hrv : ∀ t,|rv t| < 2^31) (hG : ∀ c (h:c< bs.size),bs[c].gi.size<2^20∧tS bs[c].gi bs[c].gx rv=G c) (b:Nat) (gi gx:Array Е) (hsz:gx.size=gi.size) (hgi : ∀ m (h:m< gi.size),gi[m].toNat< n) (k:USize) (lo hi:Д) (hb:b< bs.size) (hgs:gi.size<2^20) (hk:k.toNat≤ gi.size) : ∃ hi' lo',aX rd bs B bw b gi gx hsz hgi k lo hi=aM lo' hi' B bw ∧ nv hi' lo' % 2^128=((nv hi lo + ∑ m∈ Finset.Ico k.toNat gi.size,ah gx[m]! * rv gi[m]!.toNat) * 256^(bs.size - 1 - b) + ∑ c∈ Finset.Ico (b+1) bs.size,256^(bs.size - 1 - c)*G c) % 2^128:=by fun_induction aX ·rename_i b gi gx hsz hgi k lo hi hk' p hk2 q ih have e1:=ak hk';have h2:=aK hk2;have e2:=ak hk2;rw[e1] at h2 e2 obtain ⟨hi',lo',e3,e4⟩ := ih hb hgs (А) rw[e2] at e4 refine ⟨hi',lo',e3,?_⟩ rw[Η (aK hk'),Η h2,← add_assoc _ _ (Finset.sum _ _)] refine jf _ _ _ _ _ _ _ ?_ e4 simp only[q,p];rw[jl _ _ _ _ _ _ (hrd _ _) (hrd _ _) (hrv _) (hrv _)];simp only[au,aC,e1] ·rename_i b gi gx hsz hgi k lo hi hk' p hk2 ih obtain ⟨hi',lo',e1,e2⟩ := ih hb hgs (by rw[ak hk'];have:=aK hk';omega) rw[ak hk'] at e2 rw[Η (aK hk')] refine ⟨hi',lo',e1,jf _ _ _ _ _ _ _ ?_ e2⟩ simp only[p];rw[(iI _ _ _ (hrd _ _) (hrv _)).1,au,au,aC] ·rename_i b gi gx hsz hgi k lo hi hk' hb1 ih have h1:=ft (by have:=Ξ;omega) hk' obtain ⟨hi',lo',e1,e2⟩ := ih hb1 (hG _ hb1).1 (by simp) refine ⟨hi',lo',e1,?_⟩ have:=(hG _ hb1).2;unfold tS at this rw[USize.toNat_zero,← ϴ,this] at e2 rw[ϗ h1,Finset.sum_empty,Η hb1, show bs.size - 1 - b=bs.size - 1 - (b+1)+1 by omega] exact e2.trans (((Ϧ _ (gY hi lo)).mul_right _).add_right _ |>.trans (congrArg (· % 2^128) (by ring))) ·rename_i b gi gx hsz hgi k lo hi hk' hb1 have h1:=ft (by have:=Ξ;omega) hk' refine ⟨hi,lo,rfl,?_⟩ rw[ϗ h1,ϗ (by omega:bs.size≤ b+1), show bs.size - 1 - b=0 by omega];simp lemma cT (s:Finset Nat) (f:Nat→ Int) (K:Int) (h : ∀ i∈ s,|f i| ≤ K) : |∑ i∈ s,f i| ≤ s.card*K := (Finset.abs_sum_le_sum_abs _ _).trans ((Finset.sum_le_sum h).trans (by simp)) lemma cA (top:Д) (b:Nat) (x:Е) (hb:b<8) (hx:ai x≠0→ idxOf x≤ top.toNat) : dX top b.toUInt64 x=true↔ai x≠0∧(top.toNat - idxOf x) / 8=b:=by unfold dX;simp only[Ζ,bne_iff_ne,ne_eq,beq_iff_eq] constructor ·rintro ⟨h1,h2⟩;refine ⟨h1,?_⟩;rw[← cx top x (hx h1),h2];simp;omega ·rintro ⟨h1,h2⟩;refine ⟨h1,ς.mp ?_⟩;rw[cx top x (hx h1),h2];simp;omega lemma ct (xf wf:Nat→ Е) (n nb:Nat) (top:Д) (rv:Nat→ Int) (wb B:Nat) (hnb:nb≤6) (hx : ∀ t,t< n→ ai (xf t)≠0 → idxOf (xf t)≤ top.toNat∧(top.toNat - idxOf (xf t)) / 8< nb) (hB:B+8*(nb - 1)+7=top.toNat+wb) (hrv : ∀ t,t< n→ rv t*2^wb=sv (wf t)*2^idxOf (wf t)) : (∑ c∈ Finset.range nb,256^(nb - 1 - c)*bS xf top c.toUInt64 rv 0 n)*2^B = Core.aB n xf wf:=by unfold bS Core.aB simp only[Finset.mul_sum,ϊ] rw[Finset.sum_comm,← ϴ] refine χ rfl fun t ht => ?_ rw[Μ] at ht by_cases hz:ai (xf t)=0 ·rw[Finset.sum_eq_zero fun c hc=>by rw[if_neg (by rw[cA _ _ _ (by simp at hc;omega) (fun h=>absurd hz h)];tauto)];simp] unfold Core.tm;rw[cU _ hz];simp obtain ⟨hi,hbd⟩ := hx t ht hz rw[Finset.sum_eq_single ((top.toNat - idxOf (xf t)) / 8)] ·rw[if_pos ((cA _ _ _ (А) (fun _=>hi)).mpr ⟨hz,rfl⟩),gu _ _ hi] have:(256:Int)^(nb - 1 - (top.toNat - idxOf (xf t)) / 8)*2^(7 - (top.toNat - idxOf (xf t)) % 8) * 2^B=2^(idxOf (xf t)+wb):=by rw[show (256:Int)=2^8 by norm_num,← pow_mul,← pow_add,← pow_add];congr 1;omega unfold Core.tm linear_combination (sv (xf t)*2^idxOf (xf t))*hrv t ht+(sv (xf t)*rv t)*this ·intro c hc hne rw[if_neg (by rw[cA _ _ _ (by simp at hc;omega) (fun _=>hi)];omega)];simp ·intro h;exact absurd (Μ.mpr hbd) h lemma b8 (xf:Nat→ Е) (n nb:Nat) (top:Д) (rv:Nat→ Int) (hnb:nb≤6) (hn:n<2^20) (hrv : ∀ t,|rv t| < 2^31) : |∑ c∈ Finset.range nb,256^(nb - 1 - c)*bS xf top c.toUInt64 rv 0 n| ≤ 2^125:=by have hn':(n:Int)≤2^20:=by exact_mod_cast hn.le have hnb':(nb:Int)≤6:=by exact_mod_cast hnb have hS : ∀ c:Nat,|bS xf top c.toUInt64 rv 0 n| ≤ 2^20*2^62:=fun c=>by refine (cT _ _ (2^62) fun t _ => ?_).trans (by simp;nlinarith) split ·rw[abs_mul];have:=d9 (cE top (xf t));have:=hrv t nlinarith[abs_nonneg (ah (cE top (xf t))),abs_nonneg (rv t)] ·simp refine (cT _ _ (2^40*(2^20*2^62)) fun c hc => ?_).trans (by simp;nlinarith) have h40:(256:Int)^(nb - 1 - c)≤2^40:=by rw[show (2:Int)^40=256^5 by norm_num] exact pow_le_pow_right₀ (Г) (by simp at hc;omega) rw[abs_mul,abs_pow,abs_of_pos (by norm_num:(0:Int)<256)] exact mul_le_mul h40 (hS c) (abs_nonneg _) (В) lemma c4 (lo hi B:Д) (bw:Е) (S T:Int) (hS : |S| ≤ 2^125) (hT:S*2^B.toNat=T) (hnv:nv hi lo % 2^128=S % 2^128) (h:aM lo hi B bw<0x100000000) : expOf bw≠255 ∧ ∃ hi' lo',aM lo hi B bw=Core.aw hi' lo' B ∧ T+sv bw*2^(idxOf bw+149)=Core.ag hi' lo'*2^B.toNat:=by obtain ⟨hbw,hi2,lo2,d,hfe,hd,hsc,hnv2⟩ := et lo hi B bw h have hb : |sv bw*2^d| ≤ 2^24*2^101:=by rw[abs_mul,abs_pow,abs_two] exact mul_le_mul (cV bw).le (pow_le_pow_right₀ (Г) hd) (В) (Г) refine ⟨hbw,hi2,lo2,hfe,?_⟩ rw[← hT,hsc,en hi2 lo2 (S+sv bw*2^d) (hnv2.trans (Ϧ _ hnv)) (by rw[abs_lt];rw[abs_le] at hS hb;constructor<;>linarith)] ring @[inline] def bI {n:Nat} (rd:(t:USize)→ t.toNat< n→ Д) (ac:dK n) (wb:Nat) (bw:Е):Д := if h:0< ac.bs.size then let L:=(ac.bs.size - 1).toUInt64*8+7 if ac.top+wb.toUInt64< L then 0x100000000 else aX rd ac.bs (ac.top+wb.toUInt64 - L) bw 0 ac.bs[0].gi ac.bs[0].gx ac.bs[0].hsz ac.bs[0].hgi 0 0 0 else 0x100000000 lemma cd {n:Nat} (rd:(t:USize)→ t.toNat< n→ Д) (ac:dK n) (xf wf:Nat→ Е) (wb:Nat) (rv:Nat→ Int) (bw:Е) (hs:0< ac.bs.size→ dL ac xf) (hwb:wb<2^32) (hrd : ∀ t h,Core.aa (rd t h)=rv t.toNat) (hrvb : ∀ t,|rv t| < 2^31) (hrv : ∀ t,t< n→ rv t*2^wb=sv (wf t)*2^idxOf (wf t)) (h:bI rd ac wb bw<0x100000000) : (∀ t,t< n→ expOf (xf t)≠255)∧expOf bw≠255 ∧ ∃ hi lo B,bI rd ac wb bw = Core.aw hi lo B∧Core.aB n xf wf+sv bw*2^(idxOf bw+149)=Core.ag hi lo*2^B.toNat:=by unfold bI at h ⊢ split at h<;>rename_i h0 swap;· exact absurd h (Б) rw[dif_pos h0] obtain ⟨hn,hnb,htop,hxs,hbs⟩ := hs h0 dsimp only at h ⊢ split at h<;>rename_i hL ·exact absurd h (Б) rw[if_neg hL] have hL':((ac.bs.size - 1).toUInt64*8+7).toNat=8*(ac.bs.size - 1)+7:=by simp;omega have ht:(ac.top+wb.toUInt64).toNat=ac.top.toNat+wb:=by rw[θ];simp;omega rw[ν,ht,hL'] at hL have hBn:(ac.top+wb.toUInt64 - ((ac.bs.size - 1).toUInt64*8+7)).toNat+8*(ac.bs.size - 1)+7 = ac.top.toNat+wb:=by rw[η _ _ (by rw[ε,ht,hL'];omega),ht,hL'];omega generalize ac.top+wb.toUInt64 - ((ac.bs.size - 1).toUInt64*8+7)=B at h hBn ⊢ obtain ⟨hi',lo',hml,hnv'⟩ := dB rd ac.bs B bw rv (fun c=>bS xf ac.top c.toUInt64 rv 0 n) hrd hrvb (fun c hc=>⟨(hbs c hc).1,(hbs c hc).2 rv⟩) 0 ac.bs[0].gi ac.bs[0].gx ac.bs[0].hsz ac.bs[0].hgi 0 0 0 h0 (hbs 0 h0).1 (by simp) rw[hml] at h ⊢ obtain ⟨hbw,hi,lo,hfe,ht⟩ := c4 lo' hi' B bw _ _ (b8 xf n _ ac.top rv hnb hn hrvb) (ct xf wf n _ ac.top rv wb B.toNat hnb (fun t ht hz=>(hxs t ht).2 hz) (А) hrv) (hnv'.trans (congrArg (· % 2^128) (by have:=(hbs 0 h0).2 rv;unfold tS at this rw[ϴ,Η h0,USize.toNat_zero,← ϴ,this] simp[nv,mul_comm]))) h exact ⟨fun t ht=>(hxs t ht).1,hbw,hi,lo,B,hfe,ht⟩ @[inline] def dG (W:Array Е) (c:USize) (hc:c.toNat<256) (n:Nat) (hs:W.size< USize.size) (ou:USize) (h:ou.toNat+n≤ W.size):(t:USize)→ t.toNat< n→ Д := fun t ht=>a3 c (W.uget (ou+t) (by rw[a4 (А)];omega)) hc def ce (W:Array Е) (c:USize) (hc:c.toNat<256) (_:W.size< USize.size):Array Е := W.foldl (fun a w=>a.push (a3 c w hc).toUInt32) (.mkEmpty W.size) lemma aY (W:Array Е) (c:USize) (hc:c.toNat<256) (hs:W.size< USize.size) : (ce W c hc hs).size=W.size ∧ ∀ i,i< W.size→(ce W c hc hs)[i]! = (a3 c W[i]! hc).toUInt32 := ⟨by simp[ce],fun i hi=>by rw[getElem!_pos _ i (by simp[ce];exact hi),getElem!_pos W i hi];simp[ce]⟩ def dJ (W:Array Е) (n wb:Nat) (rdo:(ou:USize)→ ou.toNat+n≤ W.size→(t:USize)→ t.toNat< n→ Д):Prop := ∃ rvf:Nat→ Nat→ Int,(∀ ou hw t ht,Core.aa (rdo ou hw t ht)=rvf ou.toNat t.toNat) ∧ (∀ o t,|rvf o t| < 2^31)∧(∀ o t,rvf o t*2^wb=sv W[o+t]! * 2^idxOf W[o+t]!) lemma fq (W:Array Е) (n eb:Nat) (c:USize) (hc:c.toNat<256) (heb:c.toNat=256 - eb) (h1:1≤ eb) (h2:eb≤248) (hW : ∀ i:Nat,a5 7 eb W[i]!) (rdo:(ou:USize)→ ou.toNat+n≤ W.size→(t:USize)→ t.toNat< n→ Д) (h : ∀ ou hw t ht,Core.aa (rdo ou hw t ht)=Core.aa (a3 c W[ou.toNat+t.toNat]! hc)) : dJ W n (eb - 1) rdo := ⟨fun o t=>Core.aa (a3 c W[o+t]! hc),h,fun _ _=>(aP c _ hc eb heb h1 h2 (hW _)).2, fun _ _=>(aP c _ hc eb heb h1 h2 (hW _)).1⟩ @[noinline] def aA (n:Nat) (relu:Bool) (X W b:Array Word) (xo s j:Nat):Word := act relu (dotOf (n+1) (fun t=>if t< n then X[xo+t*s]! else oneW) (fun t=>if t< n then W[j*n+t]! else b[j]!)) @[noinline] def gB (k:Nat) (A B:Array Word) (β i j m n:Nat):Word := dotOf k (fun t=>A[(β*m+i)*k+t]!) (fun t=>B[(β*k+t)*n+j]!) @[inline] def eU (n:Nat) (relu:Bool) (X W b:Array Word) (eb:Nat) (hs:W.size< USize.size) (rdo:(ou:USize)→ ou.toNat+n≤ W.size→(t:USize)→ t.toNat< n→ Д) (ac:dK n) (xo s j:Nat):Word := let r:Д := if hw:j*n+n≤ W.size then bI (rdo (j*n).toUSize (by rw[ab (А)];exact hw)) ac (eb - 1) b[j]! else 0x100000000 if r<0x100000000 then act relu r.toUInt32 else aA n relu X W b xo s j lemma c7 (n:Nat) (xf wf:Nat→ Е) (bw:Е) (hi lo B:Д) (hf : ∀ t,t< n→ expOf (xf t)≠255∧expOf (wf t)≠255) (hbw:expOf bw≠255) (ht:Core.aB n xf wf+sv bw*2^(idxOf bw+149)=Core.ag hi lo*2^B.toNat) (hr:Core.aw hi lo B<0x100000000) : (Core.aw hi lo B).toUInt32=dotOf (n+1) (fun t=>if t< n then xf t else oneW) (fun t=>if t< n then wf t else bw):=by symm;apply Core.aD _ _ _ hi lo B _ _ hr ·intro t h;by_cases h':t< n ·simp only[if_pos h'];exact hf t h' ·simp only[if_neg h'];exact ⟨by decide,hbw⟩ ·rw[Core.dv,← ht];simp only[lt_irrefl,if_false] unfold Core.tm;rw[show sv oneW=2^23 by decide,show idxOf oneW=126 by decide] congr 1 ·exact χ rfl fun t h=>by simp[Μ.mp h] ·ring lemma eB (n:Nat) (relu:Bool) (X W b:Array Word) (eb:Nat) (hs:W.size< USize.size) (rdo:(ou:USize)→ ou.toNat+n≤ W.size→(t:USize)→ t.toNat< n→ Д) (hW : ∀ i:Nat,expOf W[i]! ≠ 255) (hok:dJ W n (eb - 1) rdo) (heb:eb≤248) (xo s j:Nat) : eU n relu X W b eb hs rdo (aj X xo s n) xo s j = act relu (dotOf (n+1) (fun t=>if t< n then X[xo+t*s]! else oneW) (fun t=>if t< n then W[j*n+t]! else b[j]!)):=by unfold eU aA;dsimp only by_cases hw:j*n+n≤ W.size swap;· rw[dif_neg hw,if_neg (Б)] rw[dif_pos hw];split<;>rename_i hr swap;· rfl congr 1 obtain ⟨rvf,hr1,hr2,hr3⟩ := hok have hou:(j*n).toUSize.toNat=j*n:=ab (А) obtain ⟨hxf,hbw,hi,lo,B,he,ht⟩ := cd _ _ (fun t=>X[xo+t*s]!) (fun t=>W[j*n+t]!) (eb - 1) (rvf (j*n)) b[j]! (aU X xo s n) (А) (fun t ht=>(hr1 _ _ t ht).trans (by rw[hou])) (hr2 _) (fun t _=>hr3 _ t) hr rw[he] at hr ⊢ exact c7 n (fun t=>X[xo+t*s]!) (fun t=>W[j*n+t]!) b[j]! hi lo B (fun t ht=>⟨hxf t ht,hW _⟩) hbw ht hr @[inline] def cz (k:Nat) (A B:Array Word) (eb:Nat) (hs:A.size< USize.size) (rdo:(ou:USize)→ ou.toNat+k≤ A.size→(t:USize)→ t.toNat< k→ Д) (ac:dK k) (β i j m n:Nat):Word := let r:Д := if hw:(β*m+i)*k+k≤ A.size then bI (rdo ((β*m+i)*k).toUSize (by rw[ab (А)];exact hw)) ac (eb - 1) 0 else 0x100000000 if r<0x100000000 then r.toUInt32 else gB k A B β i j m n lemma eu (k:Nat) (A B:Array Word) (eb:Nat) (hs:A.size< USize.size) (rdo:(ou:USize)→ ou.toNat+k≤ A.size→(t:USize)→ t.toNat< k→ Д) (hW : ∀ i:Nat,expOf A[i]! ≠ 255) (hok:dJ A k (eb - 1) rdo) (heb:eb≤248) (β i j m n:Nat) : cz k A B eb hs rdo (aj B (β*k*n+j) n k) β i j m n = dotOf k (fun t=>A[(β*m+i)*k+t]!) (fun t=>B[(β*k+t)*n+j]!):=by unfold cz gB;dsimp only by_cases hw:(β*m+i)*k+k≤ A.size swap;· rw[dif_neg hw,if_neg (Б)] rw[dif_pos hw];split<;>rename_i hr swap;· rfl obtain ⟨rvf,hr1,hr2,hr3⟩ := hok have hou:((β*m+i)*k).toUSize.toNat=(β*m+i)*k:=ab (А) have e : ∀ t,β*k*n+j+t*n=(β*k+t)*n+j:=fun t=>by ring obtain ⟨hxf,-,hi,lo,B',he,ht⟩ := cd _ _ (fun t=>B[β*k*n+j+t*n]!) (fun t=>A[(β*m+i)*k+t]!) (eb - 1) (rvf ((β*m+i)*k)) 0 (aU B _ n k) (А) (fun t ht=>(hr1 _ _ t ht).trans (by rw[hou])) (hr2 _) (fun t _=>hr3 _ t) hr rw[he] at hr ⊢;symm apply Core.aD _ _ _ hi lo B' _ _ hr ·intro t h;exact ⟨hW _,by simpa[e] using hxf t h⟩ ·rw[cU 0 (Б),zero_mul,add_zero] at ht;rw[← ht] exact χ rfl fun t _=>by unfold Core.tm;simp only[e];ring lemma dm {α:Type} (N:Nat) (f:Fin N→ α) (d:α) (i:Nat) (h:i< N) : (Array.ofFn f).getD i d=f ⟨i,h⟩ := by simp[Array.getD,h] lemma aO (eb:Nat) (h1:1≤ eb):(256 - eb).toUSize.toNat=256 - eb := ab (by have:=Ξ;omega) @[specialize] def c5 {α:Type} (a b:Nat) (ro:Nat→ α) (g:α→ Nat→ Nat→ Word) (i j:Nat) (r:α) (acc:Array Word):Array Word := if j< b then c5 a b ro g i (j+1) r (acc.push (g r i j)) else if i+1< a then c5 a b ro g (i+1) 0 (ro (i+1)) acc else acc termination_by (a - i,b - j) lemma dn {α:Type} (a b:Nat) (ro:Nat→ α) (g:α→ Nat→ Nat→ Word) (i j:Nat) (r:α) (acc:Array Word) (hr:r=ro i) (hi:i< a) (hj:j≤ b) (hs:acc.size=i*b+j) (he : ∀ q (h:q< acc.size),acc[q]=g (ro (q / b)) (q / b) (q % b)) : c5 a b ro g i j r acc=Array.ofFn (n:=a*b) fun q=>g (ro (q / b)) (q / b) (q % b):=by fun_induction c5 ·rename_i i j r acc hj' ih refine ih hr hi (А) (by simp[hs];omega) fun q hq => ?_ rw[Array.getElem_push];split ·exact he q _ ·simp at hq;obtain rfl:q=i*b+j:=А have e1:(i*b+j) / b=i:=by rw[ϒ,Ϙ _ _ (А),ϙ hj',Ο] rw[e1,ϒ,ϋ,γ hj',hr] ·rename_i i j r acc hj' hi' ih exact ih rfl hi' (А) (by rw[hs,Ϣ];omega) he ·rename_i i j r acc hj' hi' refine Array.ext (by rw[ϕ,hs,show a=i+1 by omega,Ϣ];omega) fun q h1 _=>by rw[Θ];exact he q h1 @[inline] def dE (rows inW outW:Nat) (relu:Bool) (X W b:Array Word) (eb:Nat) (hs:W.size< USize.size) (rdo:(ou:USize)→ ou.toNat+inW≤ W.size→(t:USize)→ t.toNat< inW→ Д):Array Word := if 0< rows then c5 rows outW (fun i=>aj X (i*inW) 1 inW) (fun r i j=>eU inW relu X W b eb hs rdo r (i*inW) 1 j) 0 0 (aj X (0*inW) 1 inW) (Array.mkEmpty (rows*outW)) else #[] lemma dZ (rows inW outW:Nat) (relu:Bool) (X W b:Array Word) (eb:Nat) (hs:W.size< USize.size) (rdo:(ou:USize)→ ou.toNat+inW≤ W.size→(t:USize)→ t.toNat< inW→ Д) (hW : ∀ i:Nat,expOf W[i]! ≠ 255) (hok:dJ W inW (eb - 1) rdo) (heb:eb≤248) : dE rows inW outW relu X W b eb hs rdo=linearSpec rows inW outW relu X W b:=by unfold dE linearSpec linearWith;split ·rw[dn _ _ _ _ _ _ _ _ rfl (А) (А) (by simp) (by simp)] apply congrArg;funext q;rw[eB inW relu X W b eb hs rdo hW hok heb];simp only[ϩ] ·simp[show rows=0 by omega] def fd (rows inW outW:Nat) (relu:Bool) (X W b:Array Word):Array Word := if heb:ae 7 W=0 then linearSpec rows inW outW relu X W b else have hsp:=ao 7 W heb have hs:W.size< USize.size:=by have:=Ξ;omega have hc:(256 - ae 7 W).toUSize.toNat<256:=by rw[aO _ hsp.2.1];omega if 2≤ rows then let Wd:=ce W _ hc hs have hWd:Wd.size=W.size:=(aY W _ hc hs).1 dE rows inW outW relu X W b (ae 7 W) hs fun ou hw t ht => aJ (Wd.uget (ou+t) (by rw[a4 (А)];omega)) else dE rows inW outW relu X W b (ae 7 W) hs (dG W _ hc inW hs) def gg (batch m k n:Nat) (A B:Array Word):Array Word := if heb:ae 7 A=0 then gemmSpec batch m k n A B else have hsp:=ao 7 A heb have hs:A.size< USize.size:=by have:=Ξ;omega have hc:(256 - ae 7 A).toUSize.toNat<256:=by rw[aO _ hsp.2.1];omega let Ad:=ce A _ hc hs have hAd:Ad.size=A.size:=(aY A _ hc hs).1 let cols:=Array.ofFn (n:=batch) fun β=>Array.ofFn (n:=n) fun j => aj B (β.val*k*n+j.val) n k if 0< batch*m then c5 (batch*m) n (fun r=>(cols.getD (r / m) #[],r / m,r % m)) (fun c _ j=>cz k A B (ae 7 A) hs (fun ou hw t ht=>aJ (Ad.uget (ou+t) (by rw[a4 (А)];omega))) (c.1.getD j ⟨0,#[]⟩) c.2.1 c.2.2 j m n) 0 0 (cols.getD (0 / m) #[],0 / m,0 % m) (Array.mkEmpty (batch*m*n)) else #[] lemma fV (W:Array Е) (n eb:Nat) (hs:W.size< USize.size) (h1:1≤ eb) (h2:eb≤248) (hW : ∀ i:Nat,a5 7 eb W[i]!) (hc:(256 - eb).toUSize.toNat<256) : dJ W n (eb - 1) fun ou hw t ht=>aJ ((ce W _ hc hs).uget (ou+t) (by rw[a4 (А)];have:=(aY W _ hc hs).1;omega)):=by refine fq W n eb _ hc (aO eb h1) h1 h2 hW _ fun ou hw t ht => ?_ have sp:=aY W _ hc hs rw[au,a4 (А),ax,sp.2 _ (А)] exact bk _ (aP _ _ hc eb (aO eb h1) h1 h2 (hW _)).2 lemma eH:fd=linearSpec:=by funext rows inW outW relu X W b unfold fd;split;· rfl rename_i heb have hsp:=ao 7 W heb have hs:W.size< USize.size:=by have:=Ξ;omega have hW:=fun i=>(hsp.2.2.2 i).1 have hWf:=fun i=>(hsp.2.2.2 i).2 dsimp only;split ·exact dZ _ _ _ _ _ _ _ _ _ _ hWf (fV W inW _ hs hsp.2.1 hsp.2.2.1 hW _) hsp.2.2.1 ·exact dZ _ _ _ _ _ _ _ _ _ _ hWf (fq W inW _ _ _ (aO _ hsp.2.1) hsp.2.1 hsp.2.2.1 hW _ fun ou hw t ht=>by simp only[dG];rw[au,a4 (А)]) hsp.2.2.1 lemma gT:gg=gemmSpec:=by funext batch m k n A B unfold gg;split;· rfl rename_i heb have hsp:=ao 7 A heb have hs:A.size< USize.size:=by have:=Ξ;omega unfold gemmSpec gemmWith;dsimp only;split ·rw[dn _ _ _ _ _ _ _ _ rfl (А) (А) (by simp) (by simp),Υ] apply congrArg;funext q have hq:=q.isLt have hn:0< n:=ϫ fun h=>by subst h;simp at hq rw[Ϫ,ϐ n m, dm _ _ _ _ (ϯ (lt_of_lt_of_eq hq (ϐ _ _))), dm _ _ _ _ (Ν _ hn)] exact eu k A B _ _ _ (fun i=>(hsp.2.2.2 i).2) (fV A k _ hs hsp.2.1 hsp.2.2.1 (fun i=>(hsp.2.2.2 i).1) _) hsp.2.2.1 _ _ _ _ _ ·rename_i h;rw[← Υ,Nat.eq_zero_of_not_pos h,ϡ];rfl def cJ (dx W:Array Е) (c:USize) (hc:c.toNat<256) (ou:USize) (hw:ou.toNat+dx.size≤ W.size) (hs:W.size< USize.size) (B:Д) (bw:Е) (k:USize) (lo hi:Д):Д := if h1:k< dx.usize then let w:=W.uget (ou+k) (by have:=aK h1;rw[a4 (А)];omega) let q:=gE c w hc if q == 0 && ai w != 0 then 0x100000000 else let p:=aJ (dx.uget k (aK h1))*(((w &&& 0x7FFFFF)+0x800000).toUInt64*aJ q) cJ dx W c hc ou hw hs B bw (k+1) (lo+p) (co hi lo p) else aM lo hi B bw termination_by dx.size - k.toNat decreasing_by have:=aK h1;rw[ak h1];omega lemma eX (dx W:Array Е) (c:USize) (hc:c.toNat<256) (ou:USize) (hw:ou.toNat+dx.size≤ W.size) (hs:W.size< USize.size) (B:Д) (bw:Е) (eb:Nat) (heb:c.toNat=256 - eb) (hb1:1≤ eb) (hb2:eb≤247) (k:USize) (lo hi:Д) (h:cJ dx W c hc ou hw hs B bw k lo hi<0x100000000) : (∀ t,k.toNat≤ t→ t< dx.size→ a5 7 eb W[ou.toNat+t]! ∧ expOf W[ou.toNat+t]! ≠ 255) ∧ ∃ hi' lo',cJ dx W c hc ou hw hs B bw k lo hi=aM lo' hi' B bw∧nv hi' lo' % 2^128 = (nv hi lo + ∑ m∈ Finset.Ico k.toNat dx.size,ah dx[m]! * Core.aa (a3 c W[ou.toNat+m]! hc)) % 2^128:=by fun_induction cJ ·exact absurd h (Б) ·rename_i k lo hi h1 w q hz p ih have oa:a5 7 eb w∧expOf w≠255:=by have ha:=br w;have he:=aV w;have:=w.toNat_lt simp only[Ζ,beq_iff_eq,bne_iff_ne,ne_eq,not_and,not_not] at hz unfold a5;by_cases hq:q=0 ·exact ⟨Or.inl (hz hq),cO (by rw[he,hz hq];decide)⟩ ·simp only[q,gE,cv,gp w c hc] at hq;rw[fw,heb] at hq;unfold aN at hq have:=io w;clear * - hq hb1 hb2 this split_ifs at hq<;>first | exact ⟨Or.inr ⟨by omega,by omega⟩,cO (А)⟩ | exact absurd rfl hq have k1:=aK h1;have e1:=ak h1 obtain ⟨hok,hi',lo',d1,d2⟩ := ih h have ew:w=W[ou.toNat+k.toNat]! := by simp only[w];rw[au,a4 (А)] refine ⟨fun t ht1 ht2 => ?_,hi',lo',d1,?_⟩ ·by_cases ht:t=k.toNat ·rw[ht,← ew];exact oa ·exact hok t (А) ht2 ·have hp:Core.aa p=ah dx[k.toNat]! * Core.aa (a3 c W[ou.toNat+k.toNat]! hc):=by have hS:=(aP c w hc eb heb hb1 (А) oa.1).2 rw[← ew];simp only[p,q];rw[au] show Core.aa (aJ _*a3 c w hc)=_ rw[bm,ax];rw[ax,abs_mul] exact (mul_le_mul_of_nonneg_right (d9 _) (abs_nonneg _)).trans_lt (by clear * - hS;omega) rw[e1] at d2 rw[Η k1] exact d2.trans ((Ϧ _ (fR hi lo p)).trans (congrArg (· % 2^128) (by rw[hp];ring))) ·rename_i k lo hi h1 have hk:=ft (А) h1 refine ⟨fun t ht1 ht2=>absurd ht2 (А),_,_,rfl,?_⟩ rw[ϗ hk,Finset.sum_empty,add_zero] def gc (X:Array Е) (n:Nat) (top:Д):Array Е := Array.ofFn (n:=n) fun t=>if dX top 0 X[t.val]! then cE top X[t.val]! else 0 @[inline] def eV (n:Nat) (relu:Bool) (X W b:Array Word) (hs:W.size< USize.size) (ac:dK n) (e:Nat) (he:e=ae 7 W) (j:Nat):Word := if h:e=0 then aA n relu X W b 0 1 j else eU n relu X W b e hs (dG W (256 - e).toUSize (by subst he;have:=(ao 7 W h).2.1;rw[aO _ this];omega) n hs) ac 0 1 j lemma dQ (n:Nat) (relu:Bool) (X W b:Array Word) (hs:W.size< USize.size) (e:Nat) (he:e=ae 7 W) (j:Nat):eV n relu X W b hs (aj X 0 1 n) e he j=aA n relu X W b 0 1 j:=by subst he;unfold eV;split;· rfl rename_i hg;have hsp:=ao 7 W hg exact eB n relu X W b _ hs _ (fun i=>(hsp.2.2.2 i).2) (fq W n _ _ _ (aO _ hsp.2.1) hsp.2.1 hsp.2.2.1 (fun i=>(hsp.2.2.2 i).1) _ fun ou hw t ht=>by simp only[dG];rw[au,a4 (А)]) hsp.2.2.1 0 1 j def xr (X:Array Word):Nat→ Nat→ Е→ Е→ Nat→ Е × Е | 0,_,lo,hi,_=>(lo,hi) | k+1,i,lo,hi,z => let w:=X.getD i 0 if w <<< 1 == 0 then if z<3 then (1,0) else xr X k (i+1) lo hi (z - 3) else let e:=(w >>> 23) &&& 255;let lo:=min lo e;let hi:=max hi e if hi - lo<8 then xr X k (i+1) lo hi (z+1) else (1,0) def gd (W:Array Word) (n:Nat):Nat := let r:=xr W n 0 255 0 (4*n) if r.2 - r.1<8 then (r.1.toNat+r.2.toNat - 6) / 2 else 0 def d0 (rows inW outW:Nat) (relu:Bool) (X W b:Array Word):Array Word := let p:=xr X inW 0 255 0 32 if rows=1∧p.2 - p.1<8 then let ac:=aj X 0 1 inW let eb:=gd W inW if h:ac.bs.size=1∧inW*3≤(ac.bs[0]?.map fun (bd:dI inW)=>bd.gi.size).getD 0*4∧1≤ eb∧eb≤247 ∧ 8≤ ac.top.toNat+eb∧W.size< USize.size then have hc:(256 - eb).toUSize.toNat<256:=by rw[aO _ h.2.2.1];omega let dx:=gc X inW ac.top let B:=(ac.top.toNat+eb - 8).toUInt64 let g:=Thunk.mk fun _=>ae 7 W Array.ofFn (n:=rows*outW) fun j => let r:=if hw:j.1*inW+dx.size≤ W.size then cJ dx W _ hc (j.1*inW).toUSize (by rw[ab (А)];exact hw) h.2.2.2.2.2 B b[j.1]! 0 0 0 else 0x100000000 if r<0x100000000 then act relu r.toUInt32 else eV inW relu X W b h.2.2.2.2.2 ac g.get rfl j else fd rows inW outW relu X W b else fd rows inW outW relu X W b lemma fM:d0=linearSpec:=by funext rows inW outW relu X W b unfold d0;dsimp only;split ·rename_i hr;obtain ⟨rfl,-⟩ := hr;split ·rename_i h obtain ⟨h0,-,h1,h2,h8,hs⟩ := h have heb:=aO _ h1 have hc:(256 - gd W inW).toUSize.toNat<256:=by rw[heb];omega unfold linearSpec linearWith;congr 1;funext q have hq:q.val< outW:=by have:=q.isLt;omega refine (?_:_=aA inW relu X W b 0 1 q).trans (by unfold aA;simp[ϙ hq,γ hq]) obtain ⟨hn,-,htop,hxs,-⟩ := aU X 0 1 inW (А) rw[h0] at hxs split<;>rename_i hw swap;· exact (if_neg (Б)).trans (dQ ..) split<;>rename_i hr swap;· exact dQ .. unfold aA;congr 1 obtain ⟨hok,hi',lo',e1,e2⟩ := eX _ _ _ _ _ _ _ _ _ _ heb h1 h2 _ _ _ hr have hou:(q.1*inW).toUSize.toNat=q.1*inW:=ab (А) have hdx:(gc X inW (aj X 0 1 inW).top).size=inW:=ϕ rw[hou,hdx,USize.toNat_zero] at hok e2 let rv:Nat→ Int:=fun t=>if t< inW then Core.aa (a3 _ W[q.1*inW+t]! hc) else 0 rw[e1] at hr ⊢ obtain ⟨hbw,hi,lo,hfe,htt⟩ := c4 lo' hi' _ b[q.1]! _ _ (b8 (fun t=>X[0+t*1]!) inW 1 (aj X 0 1 inW).top rv (А) hn fun t=>by simp only[rv];split;exact (aP _ _ _ _ heb h1 (А) (hok t t.zero_le ‹_›).1).2;simp) (ct _ (fun t=>W[q.1*inW+t]!) inW 1 (aj X 0 1 inW).top rv (gd W inW - 1) _ (А) (fun t ht hz=>(hxs t ht).2 hz) (by simp;clear * - h1 h2 h8 htop;omega) fun t ht=>by simp only[rv,if_pos ht];exact (aP _ _ _ _ heb h1 (А) (hok t t.zero_le ht).1).1) (by rw[e2,Finset.sum_range_one,show (0:Nat).toUInt64=0 from rfl,show nv 0 0=0 by simp[nv]] congr 1;simp only[Nat.sub_self,pow_zero,one_mul,zero_add] unfold bS gc;refine χ rfl fun m hm => ?_ have hm':=(Finset.mem_Ico.mp hm).2 rw[getElem!_pos _ m (by simpa using hm'),Θ] simp only[rv,if_pos hm',ϩ];split_ifs<;>simp[ah]) hr rw[hfe] at hr ⊢ exact c7 inW _ _ _ hi lo _ (fun t h'=>⟨(hxs t h').1,(hok t t.zero_le h').2⟩) hbw htt hr ·rw[eH] ·rw[eH] lemma ed:Core.aa 0=0:=rfl lemma gr (x:Е):Core.aa x.toUInt64=x.toNat:=by have:=x.toNat_lt;rw[ar,Χ];split<;>omega @[inline] def df (c:Д) (x:Е):Д:=Core.sW x <<< (Core.iW x - c) @[inline] def fe (c:Д) (x:Е):Е:=(df c x).toUInt32 &&& 0x7FFFFFF @[inline] def fc (c:Д) (x:Е):Е:=(df c x >>> 27).toUInt32 lemma fU (c:Д) (x:Е) (hx:ai x≠0→ c.toNat≤ idxOf x∧idxOf x≤ c.toNat+30) : (((fe c x).toNat:Int)+ah (fc c x)*2^27)*2^c.toNat=sv x*2^idxOf x ∧ |((fe c x).toNat:Int)| ≤ 2^27 ∧ |ah (fc c x)| ≤ 2^27:=by have h1:Core.aa (df c x)*2^c.toNat=sv x*2^idxOf x ∧ |Core.aa (df c x)| < 2^54:=by unfold df by_cases hz:ai x=0 ·have h0:Core.sW x=0:=by have:=(Core.sW x).toNat_lt;have e:=Core.aR x;rw[cU x hz,ar] at e apply ς.mp;simp;split at e<;>omega rw[h0,cU x hz];simp[ed] obtain ⟨h1,h2⟩ := hx hz have hd:(Core.iW x - c).toNat=idxOf x - c.toNat:=by rw[η _ _ (by rw[ε,Core.an];exact h1),Core.an] have hb : |sv x*2^(idxOf x - c.toNat)| < 2^54:=by have:(2:Int)^(idxOf x - c.toNat)≤2^30:=pow_le_pow_right₀ (Г) (А) rw[abs_mul,abs_pow,abs_two] have:=mul_le_mul_of_nonneg_left this (abs_nonneg (sv x));have:=cV x;omega rw[ef _ _ (by rw[hd];omega) (by rw[hd,Core.aR];omega),hd,Core.aR] refine ⟨?_,hb⟩ rw[mul_assoc,← pow_add,Nat.sub_add_cancel h1] unfold fe fc;rw[← h1.1] have h2:=h1.2;generalize df c x=V at h2 ⊢ have:=V.toNat_lt have e1:(V.toUInt32 &&& 0x7FFFFFF).toNat=V.toNat % 2^27:=by rw[ό,Ϗ,show (0x7FFFFFF:Е).toNat=2^27 - 1 from rfl, ξ];omega have e2:(V >>> 27).toUInt32.toNat=V.toNat / 2^27 % 2^32:=by rw[Ϗ,κ];simp[ζ] have k:((V.toUInt32 &&& 0x7FFFFFF).toNat:Int)+ah (V >>> 27).toUInt32*2^27=Core.aa V:=by rw[ar,abs_lt] at h2;rw[ar,cf,e1,e2];clear h1 e1 e2;split_ifs at h2 ⊢<;>omega rw[e1] at k ⊢;rw[k,abs_le,abs_le];rw[abs_lt] at h2;clear h1 e1 e2 this exact ⟨rfl,⟨by omega,by omega⟩,by omega,by omega⟩ @[inline] def c0 (n:Nat) (relu:Bool) (X W b:Array Word) (o:Nat) (P p:USize) (B:Д) (bi:BI) (a0 a1:Д):Word := let r:=gf (dM (dM 0 a0 0) a1 27) (eA (eA 0 0 a0 0) (dM 0 a0 0) a1 27) B bi if r<0x100000000 then act relu r.toUInt32 else aA n relu X W b p.toNat P.toNat o lemma ml {a b:Nat} (c:Nat) (h:a< b):a*c+c≤ b*c:=by rw[← Ϣ];exact τ _ h section variable (n:Nat) (relu:Bool) (X W b E0 E1 Wd:Array Word) (P nu:USize) (m:Nat) (hE : ∀ p k,p< P.toNat→ k< nu.toNat→ p+k*P.toNat< E0.size) (hE1:E1.size=E0.size) (hW:m*nu.toNat≤ Wd.size) (hs:E0.size< USize.size) (hs':Wd.size< USize.size) (B:Д) def cq (o:Nat) (wo:USize) (hwo:wo.toNat=o*nu.toNat) (ho:o< m) (bi:BI) (p k:USize) (hp:p< P) (a0 a1:Д) (acc:Array Word):Array Word := have h1:=ml nu.toNat ho if hk:k< nu then have:=μ.mp hk have hi:=bv E0 p P nu k (hE _ _ (μ.mp hp) (А)) hs this let w:=aJ (Wd.uget (wo+k) (by rw[a4 (А)];omega)) cq o wo hwo ho bi p (k+1) hp (a0+w*(E0.uget (p+k*P) (А)).toUInt64) (a1+w*aJ (E1.uget (p+k*P) (А))) acc else let acc:=acc.push (c0 n relu X W b o P p B bi a0 a1) if hp':p+1< P then cq o wo hwo ho bi (p+1) 0 hp' 0 0 acc else if ho':o+1< m then cq (o+1) (wo+nu) (by rw[a4 (А),hwo,Ϣ]) ho' (aS B b[o+1]!) 0 0 (μ.mpr (by have:=μ.mp hp;simp;omega)) 0 0 acc else acc termination_by (m - o,P.toNat - p.toNat,nu.toNat - k.toNat) decreasing_by ·exact Prod.Lex.right _ (Prod.Lex.right _ (by rw[ak hk];omega)) ·exact Prod.Lex.right _ (Prod.Lex.left _ _ (by have:=μ.mp hp';rw[ak hp] at this ⊢;omega)) ·exact Prod.Lex.left _ _ (А) lemma fW (acc:Array Word) (f:Nat→ Word) (p q N:Nat) (hq:q=p+1) (h:p< N) : acc.push (f p) ++ Array.ofFn (n:=N - q) (fun j=>f (q+j.val)) = acc ++ Array.ofFn (n:=N - p) (fun j=>f (p+j.val)):=by subst hq refine Array.ext (by simp;omega) fun i h1 h2 => ?_ simp only[Array.getElem_append,Array.getElem_push,Θ,Array.size_push] split_ifs<;>first | rfl | (congr 1;omega) lemma gI (a w x:Д) (k:Nat) (g:Nat→ Int) (hk:k≤30) (hg : ∀ m≤ k,|g m| < 2^58) (ha:Core.aa a = ∑ m∈ Finset.range k,g m) (hx:Core.aa w*Core.aa x=g k) : Core.aa (a+w*x) = ∑ m∈ Finset.range (k+1),g m:=by have hS:=cT (Finset.range k) g (2^58) fun m hm=>(hg m (by simp at hm;omega)).le have hgk:=hg k le_rfl have hk':((Finset.range k).card:Int)≤30:=by simp;exact_mod_cast hk have e:Core.aa (w*x)=g k:=by rw[bm _ _ (by rw[hx];exact lt_trans hgk (Г)),hx] rw[ee _ _ (by rw[e,ha];rw[abs_lt] at hgk ⊢;rw[abs_le] at hS;constructor<;>nlinarith),e,ha, Λ] lemma mb (r e:Int) (hr : |r| < 2^31) (he : |e| ≤ 2^27) : |r*e| < 2^58:=by rw[abs_mul];nlinarith[abs_nonneg r,abs_nonneg e] lemma fp (c eb:Nat) (hn:nu.toNat=n) (hn31:n≤31) (hB:B.toNat=c+(eb - 1)) (hX : ∀ i< E0.size,((E0[i]!.toNat:Int)+ah E1[i]! * 2^27)*2^c=sv X[i]! * 2^idxOf X[i]! ∧ |(E0[i]!.toNat:Int)| ≤ 2^27 ∧ |ah E1[i]!| ≤ 2^27∧expOf X[i]! ≠ 255) (hWd : ∀ i< Wd.size,ah Wd[i]! * 2^(eb - 1)=sv W[i]! * 2^idxOf W[i]! ∧ |ah Wd[i]!| < 2^31 ∧ expOf W[i]! ≠ 255) (o:Nat) (wo:USize) (hwo:wo.toNat=o*nu.toNat) (ho:o< m) (bi:BI) (p k:USize) (hp:p< P) (a0 a1:Д) (acc:Array Word) (hbi:bi=aS B b[o]!) (hk:k.toNat≤ n) (ha0:Core.aa a0 = ∑ t∈ Finset.range k.toNat,ah Wd[wo.toNat+t]! * (E0[p.toNat+t*P.toNat]!.toNat:Int)) (ha1:Core.aa a1 = ∑ t∈ Finset.range k.toNat,ah Wd[wo.toNat+t]! * ah E1[p.toNat+t*P.toNat]!) : cq n relu X W b E0 E1 Wd P nu m hE hE1 hW hs hs' B o wo hwo ho bi p k hp a0 a1 acc = acc ++ Array.ofFn (n:=m*P.toNat - (p.toNat+o*P.toNat)) fun j=>aA n relu X W b ((p.toNat+o*P.toNat+j) % P.toNat) P.toNat ((p.toNat+o*P.toNat+j) / P.toNat):=by subst hn have hb : ∀ (wo:USize) o p t,wo.toNat=o*nu.toNat→ o< m→ p< P.toNat→ t< nu.toNat → |ah Wd[wo.toNat+t]! * (E0[p+t*P.toNat]!.toNat:Int)| < 2^58 ∧ |ah Wd[wo.toNat+t]! * ah E1[p+t*P.toNat]!| < 2^58:=fun wo o p t h1 h2 h3 h4=>by have:=ml nu.toNat h2 have q:=(hWd (wo.toNat+t) (А)).2.1;have r:=hX _ (hE p t h3 h4) exact ⟨mb _ _ q r.2.1,mb _ _ q r.2.2.1⟩ have hc : ∀ (wo:USize) o (p:USize) a0 a1,wo.toNat=o*nu.toNat→ o< m→ p.toNat< P.toNat → Core.aa a0 = ∑ t∈ Finset.range nu.toNat,ah Wd[wo.toNat+t]! * (E0[p.toNat+t*P.toNat]!.toNat:Int) → Core.aa a1 = ∑ t∈ Finset.range nu.toNat,ah Wd[wo.toNat+t]! * ah E1[p.toNat+t*P.toNat]! → c0 nu.toNat relu X W b o P p B (aS B b[o]!) a0 a1=aA nu.toNat relu X W b ((p.toNat+o*P.toNat) % P.toNat) P.toNat ((p.toNat+o*P.toNat) / P.toNat) := fun wo o p a0 a1 h1 h2 h3 ha0 ha1=>by rw[ϋ,γ h3,Ϙ _ _ (А),ϙ h3, Ο] have:=ml nu.toNat h2 have hx:=fun t (ht:t< nu.toNat)=>hX _ (hE _ t h3 ht) have hw:=fun t (ht:t< nu.toNat)=>hWd (o*nu.toNat+t) (А) have hb':=fun t=>hb wo o p.toNat t h1 h2 h3 rw[h1] at ha0 ha1 hb' unfold c0 aA;dsimp only split<;>rename_i hr swap;· rfl congr 1 set S := ∑ t∈ Finset.range nu.toNat,ah Wd[o*nu.toNat+t]! * ((E0[p.toNat+t*P.toNat]!.toNat:Int)+ah E1[p.toNat+t*P.toNat]! * 2^27) with hS have hSb : |S| ≤ 31*(2^58+2^85):=by refine (cT _ _ (2^58+2^85) fun t ht => ?_).trans (by simp;omega) obtain ⟨b0,b1⟩ := hb' t (Μ.mp ht) rw[mul_add,← mul_assoc];refine (abs_add_le _ _).trans ?_ rw[abs_mul _ (2^27:Int),abs_of_pos (by norm_num:(0:Int)<2^27)];omega obtain ⟨hbf,hi,lo,hfe,ht⟩ := c4 _ _ B b[o]! S _ (hSb.trans (Г)) rfl (by refine Int.ModEq.trans (dF _ _ a1 27 (Б)) (Int.ModEq.trans (Ϧ _ (dF 0 0 a0 0 (Б))) ?_) rw[show nv 0 0=0 by simp[nv],show (0:Д).toNat=0 from rfl,show (27:Д).toNat=27 from rfl, ha0,ha1,zero_add] congr 1 rw[hS,ϊ,ϊ,← ϣ];exact χ rfl fun m _=>by ring) hr simp only[aM] at hfe;rw[hfe] at hr ⊢ exact c7 _ _ _ _ hi lo B (fun t h=>⟨(hx t h).2.2.2,(hw t h).2.2⟩) hbf (by rw[← ht,hB,hS,ϊ,add_left_inj];unfold Core.aB refine χ rfl fun m hm => ?_ have:=congrArg₂ (· * ·) (hx m (Μ.mp hm)).1 (hw m (Μ.mp hm)).1 unfold Core.tm;rw[pow_add,pow_add];linear_combination -this) hr fun_induction cq ·rename_i o wo hwo ho bi p k hp a0 a1 acc h1 hk' h2 hi w ih have hp2:=μ.mp hp have hwv:Core.aa w=ah Wd[wo.toNat+k.toNat]! := by simp only[w];rw[ax,au,a4 (А)] refine ih hbi ?_ ?_ (by rw[ak hk'];omega)<;>rw[ak hk'] ·exact gI _ _ _ _ _ (А) (fun t _=>(hb wo o _ t hwo ho hp2 (А)).1) ha0 (by rw[hwv,gr,au,hi.1]) ·exact gI _ _ _ _ _ (А) (fun t _=>(hb wo o _ t hwo ho hp2 (А)).2) ha1 (by rw[hwv,ax,au,hi.1]) on_goal 1=>rename_i ih on_goal 2=>rename_i ho' ih on_goal 3=>rename_i ho' all_goals rename_i o wo hwo ho bi p k hp a0 a1 acc _ hk' acc' hp' subst hbi have hp2:=μ.mp hp have hk2:k.toNat=nu.toNat:=by have:=USize.lt_iff_toNat_lt.not.mp hk';omega rw[hk2] at ha0 ha1 have hl':p.toNat+o*P.toNat< m*P.toNat:=by have:=ml P.toNat ho;omega have e:=hc wo o p a0 a1 hwo ho hp2 ha0 ha1 have hP:=fW acc fun q=>aA nu.toNat relu X W b (q % P.toNat) P.toNat (q / P.toNat) try rw[ih rfl (by simp[ed]) (by simp[ed]) (by simp)] try have:=USize.lt_iff_toNat_lt.not.mp hp';rw[ak hp] at this simp only[acc',e] ·exact hP _ ((p+1).toNat+o*P.toNat) _ (by rw[ak hp];omega) hl' ·exact hP _ ((0:USize).toNat+(o+1)*P.toNat) _ (by rw[Ϣ];simp;omega) hl' ·rw[← hP _ _ _ rfl hl', show m*P.toNat - (p.toNat+o*P.toNat+1)=0 by rw[show m=o+1 by omega,Ϣ];omega] simp end def d6 (fb:ConvShape→ Bool→ Array Word→ Array Word→ Array Word→ Array Word) (s:ConvShape) (relu:Bool) (inp wts b:Array Word):Array Word := if h:s.kh=1∧s.kw=1∧s.stride=1∧s.pad=0∧0< s.h∧0< s.w∧0< s.cout∧s.cin≤31 ∧ s.h*s.w<2^30∧s.cin*(s.h*s.w)≤ inp.size∧s.cout*s.cin≤ wts.size∧ae 7 wts≠0 ∧ ae 30 inp≠0 then have hsp:=ao 7 wts h.2.2.2.2.2.2.2.2.2.2.2.1 have:=(ao 30 inp h.2.2.2.2.2.2.2.2.2.2.2.2).1 have:=Ξ have hs:wts.size< USize.size:=А have hc:(256 - ae 7 wts).toUSize.toNat<256:=by rw[aO _ hsp.2.1];omega have hP:(s.h*s.w).toUSize.toNat=s.h*s.w:=ab (А) have hn:s.cin.toUSize.toNat=s.cin:=ab (А) let c:=(ae 30 inp - 1).toUInt64 let B:=(ae 30 inp - 1+(ae 7 wts - 1)).toUInt64 cq s.cin relu inp wts b (inp.map (fe c)) (inp.map (fc c)) (ce wts _ hc hs) (s.h*s.w).toUSize s.cin.toUSize s.cout (fun p k hp hk=>by rw[Array.size_map];rw[hn] at hk;rw[hP] at hp ⊢ have:=ml (s.h*s.w) hk;omega) (by simp) (by rw[hn];simp[ce];omega) (by simp;omega) (by simp[ce];omega) B 0 0 (by simp) h.2.2.2.2.2.2.1 (aS B b[0]!) 0 0 (μ.mpr (by rw[hP];exact Ϻ h.2.2.2.2.1 h.2.2.2.2.2.1)) 0 0 (Array.mkEmpty (s.cout*(s.h*s.w))) else fb s relu inp wts b lemma jm (s:ConvShape) (inp:Array Word) (h1:s.kh=1) (h2:s.kw=1) (h3:s.stride=1) (h4:s.pad=0) (hh:0< s.h) (hw:0< s.w) (q t:Nat) : windowAt s inp (q / s.w % s.h) (q % s.w) t=inp[q % (s.h*s.w)+t*(s.h*s.w)]! := by have e3:=Ϭ (q % (s.h*s.w)) s.w rw[Nat.mod_mul_left_div_self,Nat.mod_mul_left_mod] at e3 have:=Ν (q / s.w) hh have:=Ν q hw unfold windowAt;simp only[h1,h2,h3,h4,ϩ,Nat.div_one,Nat.mod_one,Τ, Nat.sub_zero,Nat.not_lt_zero,false_or] rw[if_neg (А),← e3];congr 1;ring lemma fY (fb:ConvShape→ Bool→ Array Word→ Array Word→ Array Word→ Array Word) (hfb:fb=conv2dSpec):d6 fb=conv2dSpec:=by funext s relu inp wts b unfold d6;split;swap;· rw[hfb] rename_i h obtain ⟨h1,h2,h3,h4,hh,hw,-,hn,hP,hX,hWs,heb,hxi⟩ := h have hsp:=ao 7 wts heb have hx:=ao 30 inp hxi have:=Ξ have hs:wts.size< USize.size:=А have hc:(256 - ae 7 wts).toUSize.toNat<256:=by rw[aO _ hsp.2.1];omega have hP':(s.h*s.w).toUSize.toNat=s.h*s.w:=ab (А) have eh:s.ho=s.h:=by unfold ConvShape.ho;rw[h1,h3,h4];clear * - hh;omega have ew:s.wo=s.w:=by unfold ConvShape.wo;rw[h2,h3,h4];clear * - hw;omega have hcn:(ae 30 inp - 1).toUInt64.toNat=ae 30 inp - 1:=by simp;clear * - hx;omega have hm : ∀ (f:Е→ Е) i,i< inp.size→(inp.map f)[i]! = f inp[i]! := fun f i hi=>by simp[getElem!_pos,hi] rw[fp (c:=ae 30 inp - 1) (eb:=ae 7 wts) (hn:=ab (А)) (hn31:=hn) (hB:=by simp;omega) (hbi:=rfl) (hk:=by simp) (ha0:=by simp[ed]) (ha1:=by simp[ed]) (hX:=fun i hi=>by have hi':i< inp.size:=by simpa using hi rw[hm _ i hi',hm _ i hi'] obtain ⟨q1,q2,q3⟩ := fU (ae 30 inp - 1).toUInt64 inp[i]! (by rw[hcn,c6];intro hz;have q:=(hx.2.2.2 i).1.resolve_left hz;have q1:=hx.2.1;clear * - q q1 omega) rw[hcn] at q1 exact ⟨q1,q2,q3,(hx.2.2.2 i).2⟩) (hWd:=fun i hi=>by have hi':i< wts.size:=by rw[(aY wts _ hc hs).1] at hi;exact hi rw[(aY wts _ hc hs).2 i hi'] have q:=aP _ wts[i]! hc (ae 7 wts) (aO _ hsp.2.1) hsp.2.1 hsp.2.2.1 (hsp.2.2.2 i).1 rw[bk _ q.2];exact ⟨q.1,q.2,(hsp.2.2.2 i).2⟩)] unfold conv2dSpec conv2dWith aA;dsimp only simp only[Array.mkEmpty_eq,Array.empty_append,ϡ,Τ,hP',eh,ew,h1,h2,ϩ] simp only[jm s inp h1 h2 h3 h4 hh hw,USize.toNat_zero,Ο] exact Array.ext (by simp only[ϕ,hP',eh,ew];simp) fun i _ _=>by simp only[Θ] end Dense namespace Bn @[inline] def bU (N:Д):Д:=(N+(0x3FFFFFFFFF:Д)+((N >>> 39) &&& 1)) >>> 39 lemma i7 : ∀ k<16,1≤ k→8≤ k*2^(0x55AC / 2^(2*k) % 4) ∧ (k+1)*2^(0x55AC / 2^(2*k) % 4)≤16∧0x55AC / 2^(2*k) % 4≤3:=Б lemma fQ (n:Bool) (e f:Е) : (Core.d4 n e f).toNat=(if n then 2^31 else 0)+e.toNat % 2^8*2^23+f.toNat % 2^23:=by have h3:=Ν f.toNat (show 0<2^23 by omega) have h4:=Ν e.toNat (show 0<2^8 by omega) have h1:((e &&& 0xff) <<< 23).toNat=2^23*(e.toNat % 2^8):=by rw[UInt32.toNat_shiftLeft,ό,show (0xff:Е).toNat=2^8 - 1 from rfl, ξ,ι,ϐ] exact γ (by simp;omega) have hx:((e &&& 0xff) <<< 23 ||| (f &&& 0x007fffff)).toNat=2^23*(e.toNat % 2^8)+f.toNat % 2^23:=by rw[UInt32.toNat_or,h1,Dense.e8,← Ϡ h3] unfold Core.d4 rw[UInt32.or_assoc] cases n ·simp only[Α,ite_false,UInt32.zero_or,hx];omega ·simp only[ite_true,UInt32.toNat_or,hx] rw[show (0x80000000:Е).toNat=2^31*1 from rfl,← Ϡ (А)];omega lemma dD (a b:Д) (h:a.toNat+b.toNat<2^64):(a+b).toNat=a.toNat+b.toNat:=by rw[θ,γ h] lemma i2 (n:Bool) (N sc:Д) (h1:2^62≤ N.toNat) (h2:N.toNat<2^63) (hs:110≤ sc.toNat) (hs2:sc.toNat<363) : (Core.aT n N sc).toNat=(if n then 2^31 else 0)+((sc.toNat - 110)*2^23+(bU N).toNat) ∧ 2^23≤(bU N).toNat∧(bU N).toNat≤2^24:=by have hq:(N >>> 39).toNat=N.toNat / 2^39:=by rw[κ];simp[ζ] have hb:((N >>> 39) &&& 1).toNat=N.toNat / 2^39 % 2:=by rw[ϑ,hq];simp[Nat.and_one_is_mod] have hr:(bU N).toNat=N.toNat / 2^39+if 2^38< N.toNat % 2^39+N.toNat / 2^39 % 2 then 1 else 0:=by unfold bU;simp (disch:=omega) only[κ,θ,hb,UInt64.reduceToNat, ζ,Nat.reducePow,γ] generalize N.toNat=x;clear * -;split<;>omega have hq1:2^23≤ N.toNat / 2^39∧N.toNat / 2^39<2^24:=by clear * - h1 h2;omega have hr2:2^23≤(bU N).toNat∧(bU N).toNat≤2^24:=by rw[hr];clear * - hq1;split<;>omega have hR:(Core.bj N (62 - 23)).toNat=(bU N).toNat:=by have ha:(N &&& 0x7FFFFFFFFF).toNat=N.toNat % 2^39:=by rw[ϑ];exact ξ _ 39 rw[hr];show (Core.d8 N 39).toNat=_;unfold Core.d8 simp only[show ((1:Д) <<< 39) - 1=0x7FFFFFFFFF from rfl,show (1:Д) <<< (39 - 1)=0x4000000000 from rfl,gt_iff_lt,ν,θ,ha,hb,hq,apply_ite UInt64.toNat,UInt64.reduceToNat] clear * - hq1;split_ifs<;>omega have hL:Core.bf N=62:=by rw[Core.bu];apply ς.mp rw[show N.log2.toNat=N.toNat.log2 from rfl,Nat.log2_eq_iff (А)];simp;omega refine ⟨?_,hr2⟩ unfold Core.aT have h0:(N == 0)=false:=by simp[← ς];omega simp only[hL,h0,show ¬62+sc<172 by simp[ν];omega,show ¬(62:Д)<23 by decide, ite_false,Α] generalize Core.bj N (62 - 23)=R at hR ⊢ have hRb:2^23≤ R.toNat∧R.toNat≤2^24:=by rw[hR];exact hr2 rw[← hR];clear hq hb hr hR hL h1 h2 hq1 hr2 cases n<;>split_ifs<;>simp (disch:=first | omega | (simp[ε];omega)) only[beq_iff_eq, ← ς,gt_iff_lt,ν,fQ,Core.dV,Ϗ, ϥ,θ,UInt64.reduceToNat,γ,η,ite_true, ite_false,Α,not_true_eq_false] at *<;>omega def sg (n:Bool) (m:Nat):Int:=if n then -(m:Int) else m lemma fK (x s t:Word) (hx:expOf x≠255) (hs:expOf s≠255) (ht:expOf t≠255) (V:Int) (hV:V=sv x*sv s*2^(idxOf x+idxOf s)+sv t*2^(idxOf t+149)) (h0:V≠0) : toWord (Model.fma (ofW x) (ofW s) (ofW t))=finishWord V (-298) false:=by have dx:=toDyadic_ofUInt32 x hx have ds:=toDyadic_ofUInt32 s hs have dt:=toDyadic_ofUInt32 t ht rw[Model.Proof.fma_eq_spec] unfold Model.Spec.fma have hn:Model.chooseNaN3 (ofW x) (ofW s) (ofW t)=none := (Model.chooseNaN3_eq_none_iff _ _ _).2 ⟨Κ dx, Κ ds,Κ dt⟩ simp only[ofW] at hn ⊢ rw[hn] simp only[Ϝ dx,Ϝ ds, Ϝ dt,Bool.or_false,Α,ite_false,dx,ds,dt] refine (finishWord_of_ne _ V _ _ h0 ?_).symm rw[Model.addDyadic,Ϲ] erw[FloatLib.Numerics.Dyadic.mul_toRat (decodeD x) (decodeD s)] rw[decodeD_toRat,decodeD_toRat,decodeD_toRat,hV] push_cast;simp[zpow_sub₀];field_simp;ring lemma fA (a b:Word) (ha:expOf a≠255) (hb:expOf b≠255) (V:Int) (hV:V=sv a*2^(idxOf a+149)+sv b*2^(idxOf b+149)) (h0:V≠0) : toWord (Model.add (ofW a) (ofW b))=finishWord V (-298) false:=by have da:=toDyadic_ofUInt32 a ha have db:=toDyadic_ofUInt32 b hb rw[Model.Proof.add_eq_spec] unfold Model.Spec.add simp only[ofW] at da db ⊢ rw[da,db] refine (finishWord_of_ne _ V _ _ h0 ?_).symm rw[Model.addDyadic,Ϲ,decodeD_toRat,decodeD_toRat,hV] push_cast;simp[zpow_sub₀];field_simp;ring lemma eI (n:Bool) (M σ:Д) (V:Int) (hM:M.toNat≠0) (hσ:σ.toNat≤506) (hV:V=sg n M.toNat*2^σ.toNat) : Core.aT n M σ=finishWord V (-298) false:=by rw[Core.bJ _ _ _ hσ,hV] refine (finishWord_of_ne _ _ _ _ (mul_ne_zero (by unfold sg;split<;>omega) (В)) ?_).symm unfold sg;cases n<;>simp[FloatLib.Numerics.Dyadic.toRat,FloatLib.Numerics.Dyadic.signedSignificand,zpow_sub₀]<;>field_simp lemma cj (w:Word):sv w=sg (w >>> 31 != 0) (mantOf w):=by rw[Core.aZ];rfl lemma cI (w:Е):w >>> 31=0∨w >>> 31=1:=by have:=w.toNat_lt;simp only[← Β,ϝ];simp[ζ];omega lemma iE (a b:Bool) (x y:Nat):sg a x*sg b y=sg (a ^^ b) (x*y):=by unfold sg;cases a<;>cases b<;>simp lemma gq (relu:Bool) (o g:Е) (X:Nat) (hg:g=0∨g=1) (hX:X<255*2^23) (ho:o.toNat=g.toNat*2^31+X) : o*((g &&& (if relu then 1 else 0)) ^^^ 1)=act relu o:=by have hs:(o &&& 0x80000000 != 0)=decide (2^31≤ o.toNat):=by rw[Ϟ,decide_eq_true_iff];exact Core.aG o have he:=Dense.ip o (by rw[Dense.br];rcases hg with rfl | rfl<;>simp at ho<;>omega) unfold act reluW rcases hg with rfl | rfl<;>cases relu<;>simp only[hs,he]<;>simp at ho ⊢ <;> omega lemma jo (P T:Д) (c:Bool) (hP:P.toNat<2^62) (hT:T.toNat<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.toNat<2^63 ∧ (if c then (P.toNat:Int)+T.toNat else (P.toNat:Int) - T.toNat)=sg (f != 0) M.toNat:=by intro D f M have:=D.toNat_lt have hD:(D.toNat:Int)=(if c then (P.toNat:Int)+T.toNat else (P.toNat:Int) - T.toNat) + if c∨T.toNat≤ P.toNat then 0 else 2^64:=by cases c<;>simp only[D,ite_true,Α,ite_false,true_or,false_or,θ, Ε]<;>(try split)<;>omega have hV : -2^62<(if c then (P.toNat:Int)+T.toNat else (P.toNat:Int) - T.toNat) ∧ (if c then (P.toNat:Int)+T.toNat else (P.toNat:Int) - T.toNat)<2^63:=by split<;>omega generalize (if c then (P.toNat:Int)+T.toNat else (P.toNat:Int) - T.toNat)=V at hD hV ⊢ have hf:f=0∧D.toNat<2^63∨f=1∧2^63≤ D.toNat:=by simp only[f,← ς,κ];simp[ζ];omega rcases hf with ⟨f0,h⟩ | ⟨f0,h⟩<;>simp[M,f0,sg,UInt64.size]<;>split at hD<;>omega @[noinline] def i9 (relu:Bool) (w s t:Word):Word:=act relu (toWord (Model.fma (ofW w) (ofW s) (ofW t))) def kK (s t:Word):Nat:=idxOf t+164 - idxOf s def dp (s t:Word):Nat:=max 1 (kK s t - 51) def gk (s t:Word):Nat := if expOf s≠255∧expOf t≠255 then min 254 (kK s t)+1 - dp s t else 0 @[inline] def e7 (rb sp st:Е) (P T σ:Д) (slow:Unit→ Word):Word := 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.toUInt32 let z:=((0x55AC:Д) >>> ((M >>> 59) <<< 1)) &&& 3 let E:=σ - z - 110 if M >>> 59 != 0 && E<253 then ((E.toUInt32 <<< 23)+(bU (M <<< z)).toUInt32+(g <<< 31))*((g &&& rb) ^^^ 1) else if M != 0 then act (rb != 0) (Core.aT (g != 0) M σ) else slow () @[inline] def el (rb st ss lo cnt:Е) (ms mt kc c1:Д) (w:Word) (slow:Unit→ Word):Word := let ex:=(w >>> 23) &&& 0xFF if ex - lo< cnt then let sh:=kc - ex.toUInt64 let m:=if sh<37 then sh else 37 e7 rb ((w >>> 31) ^^^ ss) st ((((w &&& 0x7FFFFF) ||| 0x800000).toUInt64*ms) <<< (14+m - sh)) (mt <<< m) (c1 - m) slow else slow () @[inline] def ad (rb:Е) (a b:Word) (slow:Unit→ Word):Word := let ma:=Core.mW a let mb:=Core.mW b let ia:=if ma == 0 then Core.iW b else Core.iW a let ib:=if mb == 0 then Core.iW a else Core.iW b if (a >>> 23) &&& 0xFF != 255 && (b >>> 23) &&& 0xFF != 255 && ia - ib+38<77 then let hi:=if ia< ib then ib else ia e7 rb (a >>> 31) (b >>> 31) (ma <<< (ia+38 - hi)) (mb <<< (ib+38 - hi)) (hi+111) slow else slow () lemma iJ (n:Nat) (h:n<2^32):n.toUInt32.toNat=n:=UInt32.toNat_ofNat_of_lt' h lemma iK (n:Nat) (h:n<2^64):n.toUInt64.toNat=n:=UInt64.toNat_ofNat_of_lt' h lemma eJ (a k:Д) (hk:k.toNat<64) (h:a.toNat*2^k.toNat<2^64) : (a <<< k).toNat=a.toNat*2^k.toNat:=by rw[ο,ι,γ hk,γ h] lemma dH (a k:Д) (m A:Nat) (ha:a.toNat=m) (hm:m<2^A) (he:A+k.toNat≤62) : (a <<< k).toNat=m*2^k.toNat∧m*2^k.toNat<2^62:=by have hb:m*2^k.toNat<2^62:=lt_of_lt_of_le (υ hm (В)) (by rw[← pow_add];exact ψ (А) he) exact ⟨by rw[eJ _ _ (А) (by rw[ha];omega),ha],hb⟩ lemma cg (a:Bool) (x k:Nat):sg a x*2^k=sg a (x*2^k):=by unfold sg;split<;>push_cast<;>ring lemma jj (sp st:Е) (hs:sp=0∨sp=1) (ht:st=0∨st=1) (f:Д) (hf:f=0∨f=1) (P T M:Nat) (hD:(if sp ^^^ st == 0 then (P:Int)+T else (P:Int) - T)=sg (f != 0) M) : sg (sp != 0) P+sg (st != 0) T=sg (sp ^^^ f.toUInt32 != 0) M ∧ (sp ^^^ f.toUInt32=0∨sp ^^^ f.toUInt32=1):=by rcases hs with rfl | rfl<;>rcases ht with rfl | rfl<;>rcases hf with rfl | rfl <;> simp[sg] at hD ⊢<;>omega lemma bx (a b:Е) (ha:a=0∨a=1) (hb:b=0∨b=1) : ((a ^^^ b) != 0)=((a != 0) ^^ (b != 0))∧(a ^^^ b=0∨a ^^^ b=1):=by rcases ha with rfl | rfl<;>rcases hb with rfl | rfl<;>simp lemma eE (relu:Bool) (sp st:Е) (hsp:sp=0∨sp=1) (hst:st=0∨st=1) (P T σ:Д) (hP:P.toNat<2^62) (hT:T.toNat<2^62) (hσ:σ.toNat≤506) (y:Word) (slow:Unit→ Word) (hsl:slow ()=y) (hy : ∀ V:Int,V=sg (sp != 0) P.toNat*2^σ.toNat+sg (st != 0) T.toNat*2^σ.toNat → V≠0→ y=act relu (finishWord V (-298) false)) : e7 (if relu then 1 else 0) sp st P T σ slow=y:=by unfold e7;dsimp only obtain ⟨hf01,hM63,hDv⟩ := jo P T (sp ^^^ st == 0) hP hT generalize (if sp ^^^ st == 0 then P+T else P - T)=D at hf01 hM63 hDv ⊢ generalize D >>> 63=f at hf01 hM63 hDv ⊢ generalize (if f == 0 then D else 0 - D)=M at hM63 hDv ⊢ obtain ⟨hsg,hg01⟩ := jj sp st hsp hst f hf01 _ _ _ hDv generalize sp ^^^ f.toUInt32=g at hsg hg01 ⊢ have hV:sg (sp != 0) P.toNat*2^σ.toNat+sg (st != 0) T.toNat*2^σ.toNat = sg (g != 0) M.toNat*2^σ.toNat:=by rw[← add_mul,hsg] have hrb:((if relu then (1:Е) else 0) != 0)=relu:=by cases relu<;>rfl have hy':=fun h:M.toNat≠0=>hy _ hV.symm (mul_ne_zero (by unfold sg;split<;>omega) (В)) split ·rename_i hc simp only[Ζ,bne_iff_ne,ne_eq,decide_eq_true_eq] at hc obtain ⟨hq,hE⟩ := hc have hq':(M >>> 59).toNat≠0:=fun h=>hq (ς.mp (by rw[h];rfl)) have hqv:(M >>> 59).toNat=M.toNat / 2^59:=by rw[κ];simp[ζ] have h16:M.toNat / 2^59<16:=А obtain ⟨z1,z2,z3⟩ := i7 (M.toNat / 2^59) h16 (А) have hzz:((0x55AC:Д) >>> ((M >>> 59) <<< 1) &&& 3).toNat=0x55AC / 2^(2*(M.toNat / 2^59)) % 4:=by have h1:((M >>> 59) <<< 1).toNat % 64=2*(M.toNat / 2^59):=by rw[ο,hqv];simp[ι];omega rw[ϑ,κ,h1,show (3:Д).toNat=2^2 - 1 from rfl, ξ,ζ];rfl generalize ((0x55AC:Д) >>> ((M >>> 59) <<< 1) &&& 3)=z at hzz hE ⊢ generalize 0x55AC / 2^(2*(M.toNat / 2^59)) % 4=Z at hzz z1 z2 z3 have hN:(M <<< z).toNat=M.toNat*2^Z∧2^62≤ M.toNat*2^Z∧M.toNat*2^Z<2^63:=by have hb:2^62≤ M.toNat*2^Z∧M.toNat*2^Z<2^63:=by clear * - z1 z2 z3 rcases (by omega:Z=0∨Z=1∨Z=2∨Z=3) with rfl | rfl | rfl | rfl<;>simp at z1 z2 ⊢<;>omega exact ⟨by rw[eJ _ _ (А) (by rw[hzz];omega),hzz],hb⟩ have hE':(σ - z - 110).toNat=σ.toNat - Z - 110∧Z+110≤ σ.toNat:=by rw[ν] at hE have:=σ.toNat_lt rw[Ε,Ε,hzz] at hE ⊢;clear * - hE this z3;simp at hE ⊢;omega have hsc:(σ - z).toNat=σ.toNat - Z:=by rw[η _ _ (by rw[ε,hzz];omega),hzz] rw[ν,hE'.1] at hE;simp only[UInt64.reduceToNat] at hE obtain ⟨hr1,hr2,hr3⟩ := i2 (g != 0) (M <<< z) (σ - z) (hN.1 ▸ hN.2.1) (hN.1 ▸ hN.2.2) (hsc ▸ Nat.le_sub_of_add_le' hE'.2) (by rw[hsc];clear * - hE hE';omega) have ho:(σ - z - 110).toUInt32 <<< 23+(bU (M <<< z)).toUInt32+g <<< 31 = Core.aT (g != 0) (M <<< z) (σ - z):=by apply Β.mp rw[hr1,hsc,ϲ,ϲ,UInt32.toNat_shiftLeft,Ϗ, Ϗ,hE'.1] rcases hg01 with rfl | rfl<;>simp<;>clear * - hE hr2 hr3<;>omega have hX:(Core.aT (g != 0) (M <<< z) (σ - z)).toNat=g.toNat*2^31 + ((σ.toNat - Z - 110)*2^23+(bU (M <<< z)).toNat):=by rw[hr1,hsc];rcases hg01 with rfl | rfl<;>simp have hX2:(σ.toNat - Z - 110)*2^23+(bU (M <<< z)).toNat<255*2^23:=by clear * - hE hE' hr2 hr3;omega rw[ho,gq relu _ g _ hg01 hX2 hX,hy' (fun h=>hq' (by rw[hqv,h,Nat.zero_div]))] refine congrArg (act relu) ?_ have hV2:sg (g != 0) M.toNat*2^σ.toNat=sg (g != 0) (M <<< z).toNat*2^(σ - z).toNat:=by rw[hsc,hN.1,← cg,mul_assoc,← pow_add,show Z+(σ.toNat - Z)=σ.toNat from Nat.add_sub_cancel' (Nat.le_of_add_right_le hE'.2)] rw[eI _ _ _ _ (by rw[hN.1];clear * - hN;omega) (by rw[hsc];clear * - hE hE';omega) hV2] ·split ·rename_i _ hM have hM':M.toNat≠0:=by simpa[← ς] using hM rw[hrb,hy' hM',eI _ _ _ _ hM' hσ rfl] ·exact hsl lemma iV (relu:Bool) (s t w:Word) (slow:Unit→ Word) (hsl:slow ()=act relu (toWord (Model.fma (ofW w) (ofW s) (ofW t)))) : el (if relu then 1 else 0) (t >>> 31) (s >>> 31) (dp s t).toUInt32 (gk s t).toUInt32 (Core.mW s) (Core.mW t) (kK s t).toUInt64 (Core.iW t+149) w slow = act relu (toWord (Model.fma (ofW w) (ofW s) (ofW t))):=by unfold el;dsimp only split;swap;· exact hsl rename_i hwin unfold gk at hwin split at hwin;swap;· simp at hwin rename_i hok obtain ⟨hs,ht⟩ := hok have his:=idxOf_le s hs;have hit:=idxOf_le t ht have hK:kK s t=idxOf t+164 - idxOf s:=rfl have hL:dp s t=max 1 (kK s t - 51):=rfl have hel:((w >>> 23) &&& 0xFF).toNat<256:=Dense.io w rw[Ρ,UInt32.toNat_sub,iJ _ (А),iJ _ (А)] at hwin generalize hex:(w >>> 23) &&& 0xFF=ex at hel hwin ⊢ have hexE:expOf w=ex:=hex have he1:1≤ ex.toNat∧ex.toNat≤254∧kK s t≤ ex.toNat+51∧ex.toNat≤ kK s t:=by have l1:1≤ dp s t∧kK s t≤ dp s t+51∧dp s t≤400:=by rw[hL,hK];clear * - his hit;omega generalize dp s t=L at hwin l1 have w1:L≤ ex.toNat∧ex.toNat≤ min 254 (kK s t):=by have hM:=min_le_left 254 (kK s t);have:=l1.2.2 generalize min 254 (kK s t)=M at hwin hM ⊢;clear * - hwin hel hM this;omega exact ⟨l1.1.trans w1.1,w1.2.trans (min_le_left _ _),l1.2.1.trans (Nat.add_le_add_right w1.1 51), w1.2.trans (min_le_right _ _)⟩ have hfin:expOf w≠255∧expOf w≠0:=by rw[hexE];constructor<;>intro h<;>simp[h] at he1 have hw0:=hfin.2 have hmw:mantOf w=2^23+(w &&& 0x7FFFFF).toNat:=by unfold mantOf fracOf;rw[if_neg hw0] have hiw:idxOf w=ex.toNat - 1:=by unfold idxOf;rw[if_neg hw0,hexE] have hm1:(((w &&& 0x7FFFFF) ||| 0x800000).toUInt64).toNat=mantOf w:=by rw[Χ,UInt32.toNat_or,show (0x800000:Е).toNat=2^23*1 from rfl,Nat.lor_comm, ← Ϡ (Core.eF w),hmw];ring have hms:=Core.af s;have hmt:=Core.af t;have hit':=Core.an t have hlw:=mantOf_lt_24 w;have hls:=mantOf_lt_24 s;have hlt:=mantOf_lt_24 t have hsh:((kK s t).toUInt64 - ex.toUInt64).toNat=kK s t - ex.toNat:=by rw[η _ _ (by rw[ε,iK _ (А),Χ];omega), iK _ (А),Χ] generalize (kK s t).toUInt64 - ex.toUInt64=sh at hsh ⊢ generalize hu:kK s t - ex.toNat=u at hsh have hm37:(if sh<37 then sh else 37).toNat=min u 37:=by split<;>rename_i h<;>rw[ν,hsh] at h<;>simp[hsh] at h ⊢<;>omega generalize (if sh<37 then sh else 37)=m at hm37 ⊢ have h14:(14+m - sh).toNat=14+min u 37 - u:=by have e:(14+m).toNat=14+min u 37:=by rw[dD _ _ (by rw[hm37];simp;clear * -;omega),hm37];rfl rw[η _ _ (by rw[ε,e,hsh];clear * - hu he1;omega),e,hsh] have hσ:(Core.iW t+149 - m).toNat=idxOf t+149 - min u 37:=by have e:(Core.iW t+149).toNat=idxOf t+149:=by rw[dD _ _ (by rw[hit'];simp;clear * - hit;omega),hit'];rfl rw[η _ _ (by rw[ε,e,hm37];clear * -;omega),e,hm37] have h48:mantOf w*mantOf s<2^48:=(ύ hlw hls :) have hm:(((w &&& 0x7FFFFF) ||| 0x800000).toUInt64*Core.mW s).toNat=mantOf w*mantOf s:=by rw[Ϛ,hm1,hms];clear * - h48;omega have hP:=dH _ (14+m - sh) _ 48 hm h48 (by rw[h14];clear * -;omega) have hT:=dH _ m _ 24 hmt hlt (by rw[hm37];clear * -;omega) rw[h14] at hP;rw[hm37] at hT obtain ⟨b1,b3⟩ := bx _ _ (cI w) (cI s) refine eE relu _ _ b3 (cI t) _ _ _ (hP.1 ▸ hP.2) (hT.1 ▸ hT.2) (by rw[hσ];clear * - hit;omega) _ slow hsl fun V hV h0 => ?_ rw[fK w s t hfin.1 hs ht V ?_ h0] rw[hV];symm rw[b1,cj w,cj s,cj t,iE,hσ,hP.1,hT.1,← cg,← cg,mul_assoc, mul_assoc,← pow_add,← pow_add] have k1:=Nat.eq_add_of_sub_eq he1.2.2.2 hu have k2:=Nat.eq_add_of_sub_eq he1.1 hiw.symm have k3:kK s t+idxOf s=idxOf t+164:=by have:=he1.1.trans he1.2.2.2;clear * - hK this;omega rw[show 14+min u 37 - u+(idxOf t+149 - min u 37)=idxOf w+idxOf s by clear * - k1 k2 k3 he1;omega, Nat.add_sub_cancel' ((Nat.min_le_right u 37).trans (А))] @[specialize] def dd (stop:USize) (f:(i:USize)→ i.toNat< stop.toNat→ Word→ Word) (i:USize) (x:Array Word) (h:stop.toNat≤ x.size):Array Word := if hi:i< stop then have hs:=μ.mp hi dd stop f (i+1) (x.uset i (f i hs (x.uget i (А))) (А)) (by rw[Array.size_uset];exact h) else x termination_by stop.toNat - i.toNat decreasing_by rw[Dense.ak hi];omega lemma dw (stop:USize) (f:(i:USize)→ i.toNat< stop.toNat→ Word→ Word) (F:Nat→ Word→ Word) (hF : ∀ i hi w,f i hi w=F i.toNat w) (i:USize) (x:Array Word) (h:stop.toNat≤ x.size) : (dd stop f i x h).size=x.size ∧ ∀ j,(dd stop f i x h)[j]? = if i.toNat≤ j∧j< stop.toNat then x[j]?.map (F j) else x[j]? := by fun_induction dd ·next i x h hi hs ih => have hx:i.toNat< x.size:=А obtain ⟨ih1,ih2⟩ := ih refine ⟨by rw[ih1,Array.size_uset],fun j => ?_⟩ rw[ih2,Dense.ak hi,Array.uset_eq_set,Array.getElem?_set hx] by_cases hj:i.toNat=j ·subst hj rw[if_neg (А),if_pos rfl,if_pos (А),ϳ hx,Option.map_some,hF] rfl ·rw[if_neg hj];split_ifs<;>first | rfl | omega ·next i x h hi=>exact ⟨rfl,fun j=>by rw[if_neg (by rw[μ] at hi;omega)]⟩ def bZ (relu:Bool) (hw c:Nat) (s t:Array Word) (ch:Nat) (x:Array Word):Array Word := if ch< c then let sc:=s[ch]! let tc:=t[ch]! let stop:=(ch*hw+hw).toUSize let rb:Е:=if relu then 1 else 0 let st:=tc >>> 31 let ss:=sc >>> 31 let lo:=(dp sc tc).toUInt32 let cnt:=(gk sc tc).toUInt32 let ms:=Core.mW sc let mt:=Core.mW tc let kc:=(kK sc tc).toUInt64 let c1:=Core.iW tc+149 bZ relu hw c s t (ch+1) (if h:stop.toNat≤ x.size then dd stop (fun _ _ w=>el rb st ss lo cnt ms mt kc c1 w fun _=>i9 relu w sc tc) (ch*hw).toUSize x h else x) else x termination_by c - ch lemma ep (relu:Bool) (hw c:Nat) (s t:Array Word) (ch:Nat) (x:Array Word) (hsz:x.size=c*hw) (h32:c*hw<4294967296) (j:Nat) : (bZ relu hw c s t ch x)[j]? = if ch*hw≤ j then x[j]?.map (fun w=>act relu (toWord (Model.fma (ofW w) (ofW s[j / hw]!) (ofW t[j / hw]!)))) else x[j]? := by induction hk:c - ch generalizing ch x with | zero => unfold bZ rw[if_neg (А)] split ·have:c*hw≤ ch*hw:=τ _ (А) rw[Array.getElem?_eq_none (А)];rfl ·rfl | succ k ih => have hc:ch< c:=А have hle:ch*hw+hw≤ c*hw:=by rw[show ch*hw+hw=(ch+1)*hw by ring];exact τ _ hc have hstop:(ch*hw+hw).toUSize.toNat=ch*hw+hw:=ϔ (А) have hstart:(ch*hw).toUSize.toNat=ch*hw:=ϔ (А) unfold bZ rw[if_pos hc] dsimp only rw[dif_pos (by rw[hstop];omega)] obtain ⟨hs1,hs2⟩ := dw _ _ (fun _ w=>act relu (toWord (Model.fma (ofW w) (ofW s[ch]!) (ofW t[ch]!)))) (fun _ _ w=>iV relu s[ch]! t[ch]! w (fun _=>i9 relu w s[ch]! t[ch]!) rfl) (ch*hw).toUSize x (by rw[hstop];omega) rw[ih (ch+1) _ (by rw[hs1,hsz]) (А),hs2,hstart,hstop, show (ch+1)*hw=ch*hw+hw by ring] split_ifs<;>first | omega | rw[Nat.div_eq_of_lt_le (k:=ch) (А) (by rw[Ϣ];omega)] | rfl def bP (relu:Bool) (c hw:Nat) (x s t:Array Word):Array Word := if x.size=c*hw∧c*hw<4294967296 then bZ relu hw c s t 0 x else scaleShiftSpec relu c hw x s t lemma dC:bP=scaleShiftSpec:=by funext relu c hw x s t unfold bP split ·rename_i h apply Array.ext_getElem? intro j rw[ep relu hw c s t 0 x h.1 h.2 j,if_pos (by simp),scaleShiftSpec,Array.getElem?_ofFn] split ·rw[ϳ (А),getElem!_pos x j (А)];rfl ·rw[Array.getElem?_eq_none (А)];rfl ·rfl lemma eL (n:Bool) (m i i' h:Nat) (hi:i'=i∨m=0) (h1:i'≤ h) (h2:h≤ i'+38) : sg n (m*2^(i'+38 - h))*2^(h+111)=sg n m*2^(i+149):=by rcases hi with rfl | rfl ·rw[cg,cg,mul_assoc,← pow_add];congr 3;omega ·simp[sg] lemma ja (a b:Word):((if Core.mW a == 0 then Core.iW b else Core.iW a).toNat=idxOf a∨mantOf a=0) ∧ ((if Core.mW a == 0 then Core.iW b else Core.iW a).toNat≤ idxOf a ∨ (if Core.mW a == 0 then Core.iW b else Core.iW a).toNat≤ idxOf b):=by split ·rename_i h;rw[Core.an];exact ⟨Or.inr (by rw[← Core.af,beq_iff_eq.mp h];rfl),Or.inr le_rfl⟩ ·rw[Core.an];exact ⟨Or.inl rfl,Or.inl le_rfl⟩ lemma jc (a h:Д) (h1:a.toNat<2^60) (h2:h.toNat≤ a.toNat+38) : (a+38 - h).toNat=a.toNat+38 - h.toNat:=by have e:(a+38).toNat=a.toNat+38:=dD _ _ (by simp only[UInt64.reduceToNat];omega) rw[η _ _ (by rw[ε,e];omega),e] lemma iS (relu:Bool) (a b:Word) (slow:Unit→ Word) (hsl:slow ()=act relu (toWord (Model.add (ofW a) (ofW b)))) : ad (if relu then 1 else 0) a b slow=act relu (toWord (Model.add (ofW a) (ofW b))):=by unfold ad;dsimp only have hma:=Core.af a;have hmb:=Core.af b have hla:=mantOf_lt_24 a;have hlb:=mantOf_lt_24 b have hA:=ja a b;have hB:=ja b a generalize (if Core.mW a == 0 then Core.iW b else Core.iW a)=ia at hA ⊢ generalize (if Core.mW b == 0 then Core.iW a else Core.iW b)=ib at hB ⊢ generalize hH:(if ia< ib then ib else ia)=hi split;swap;· exact hsl rename_i hwin simp only[Ζ,bne_iff_ne,ne_eq,decide_eq_true_eq] at hwin obtain ⟨⟨hfa,hfb⟩,hwin⟩ := hwin have hI:ia.toNat≤253∧ib.toNat≤253:=by have q1:=idxOf_le a hfa;have q2:=idxOf_le b hfb;clear * - hA hB q1 q2;omega have hw2:ia.toNat≤ ib.toNat+38∧ib.toNat≤ ia.toNat+38:=by rw[ν,θ,Ε] at hwin simp only[UInt64.reduceToNat,Nat.reducePow] at hwin clear * - hwin hI;omega have hh:ia.toNat≤ hi.toNat∧hi.toNat≤ ia.toNat+38∧ib.toNat≤ hi.toNat∧hi.toNat≤ ib.toNat+38 ∧ hi.toNat≤291:=by rw[← hH];clear * - hw2 hI;split<;>rename_i h<;>rw[ν] at h<;>omega replace hA:=hA.1;replace hB:=hB.1;clear hwin hH have hsA:=jc ia hi (А) hh.2.1 have hsB:=jc ib hi (А) hh.2.2.2.1 have hP:=dH _ (ia+38 - hi) _ 24 hma hla (by rw[hsA];omega) have hT:=dH _ (ib+38 - hi) _ 24 hmb hlb (by rw[hsB];omega) rw[hsA] at hP;rw[hsB] at hT have hσ:(hi+111).toNat=hi.toNat+111:=dD _ _ (by simp only[UInt64.reduceToNat];omega) refine eE relu _ _ (cI a) (cI b) _ _ _ (hP.1 ▸ hP.2) (hT.1 ▸ hT.2) (by rw[hσ];omega) _ slow hsl fun V hV h0 => ?_ rw[fA a b hfa hfb V ?_ h0] rw[hV,hP.1,hT.1,hσ,cj a,cj b,eL _ _ _ _ _ hA hh.1 hh.2.1,eL _ _ _ _ _ hB hh.2.2.1 hh.2.2.2.1] @[noinline] def jh (relu:Bool) (x y:Word):Word:=act relu (toWord (Model.add (ofW x) (ofW y))) def cZ (relu:Bool) (a b:Array Word):Array Word := if h:a.size≤ b.size∧a.size<4294967296 then let rb:Е:=if relu then 1 else 0 dd a.size.toUSize (fun i hi x => let y:=b.uget i (by rw[ϔ h.2] at hi;omega) ad rb x y fun _=>jh relu x y) 0 a (by rw[ϔ h.2]) else addReluSpec relu a b lemma eP:cZ=addReluSpec:=by funext relu a b unfold cZ;dsimp only split ·rename_i h have hs:a.size.toUSize.toNat=a.size:=ϔ h.2 apply Array.ext_getElem?;intro j rw[(dw _ _ (fun j x=>act relu (toWord (Model.add (ofW x) (ofW b[j]!)))) (fun i hi x => ?_) 0 a _).2 j, addReluSpec,Array.getElem?_ofFn] ·by_cases hj:j< a.size ·rw[if_pos ⟨by simp,by rw[hs];exact hj⟩,dif_pos hj,ϳ hj];rfl ·rw[if_neg (by rw[hs];omega),dif_neg hj,Array.getElem?_eq_none (А)] ·rw[iS relu _ _ _ rfl,getElem!_pos b i.toNat (А)];rfl ·rfl end Bn namespace Conv open Core Finset variable (C E V S:Д) (y z:Word) (t:Bool) (P W:Array Е) (c h w k n:Nat) (Q:Word→ Bool) (fa:Nat→ Word) (bx:Д) (s:ConvShape) (J:Bool) (I K b:Array Word) (D:Bool) (nc Y:Nat) (r d:Word) (x:Д) (v:Int) (B a:Д) (m:Nat) (e j:USize) (bw:Д) (u:Е) {α:Type} lemma mo {a b:Nat} (h:a< b):a % b=a:=γ h lemma mr {a b:Nat} (h:a∈ range b):a< b:=Μ.mp h lemma fT:(false=true)=False:=Α lemma bK:2^32≤2^System.Platform.numBits:=by rcases System.Platform.numBits_eq with h | h<;>rw[h]<;>norm_num lemma b9 (h:c<2^32):(OfNat.ofNat c:USize).toNat=c:=by rw[USize.toNat_ofNat];exact mo (lt_of_lt_of_le h bK) lemma iu (a:USize) (c:Nat) (hc:c<2^32) (h:a< OfNat.ofNat c):a.toNat< c:=by rwa[μ,b9 c hc] at h lemma fB (a b n:USize) (h:a.toNat+b.toNat< n.toNat):(a+b).toNat=a.toNat+b.toNat:=by rw[Ι];exact mo (lt_of_le_of_lt (А) n.toNat_lt_size) lemma de (a:Array Е):a.usize.toNat≤ a.size:=by unfold Array.usize;rw[Nat.toUSize_eq,USize.toNat_ofNat'];exact Nat.mod_le _ _ lemma ix (c:Nat) (hc:c≤2) (h:e.toNat+2< P.usize.toNat) : (e+OfNat.ofNat c).toNat=e.toNat+c∧(e+OfNat.ofNat c).toNat< P.size:=by have:=de P;rw[fB _ _ P.usize (by rw[b9 c (А)];omega),b9 c (А)];omega @[inline] def cs (o e:Д) (w:Е):Д := let x:=mW w <<< (iW w - e) if w >>> 31 != 0 then o - x else o+x @[inline] def b7:Е:=(cs 0x80000000 bw u).toUInt32 @[inline] def wv:Д:=u.toUInt64 - 0x80000000 @[inline] def ok (w:Е):Bool := expOf w != 255 && (mW w == 0 || iW w - E≤ C) @[inline] def cN (a:Array Е):Д := a.foldl (fun m w=>if mW w != 0 && iW w< m then iW w else m) 255 @[inline] def am:Д:=if S<25 then (V <<< S) &&& 0x1FFFFFF else 0 @[inline] def ap:Д:=if S<25 then (V <<< S) >>> 25 else V <<< (S - 25) @[inline] def bE:Д := let l:=am (mW u) (iW u - bx) if u >>> 31 != 0 then (0x2000000 - l) &&& 0x1FFFFFF else l @[inline] def bF:Д := let s:=iW u - bx if u >>> 31 != 0 then 0x2000000000000 - ap (mW u) s - (if am (mW u) s != 0 then 1 else 0) else 0x2000000000000+ap (mW u) s @[reducible,inline] def nl:Nat:=if t then 3 else 2 @[inline] def sU:USize:=if t then 3 else 2 @[inline] def cW:USize:=if t then 8 else 6 @[inline] def aQ (l:Nat):Е := if t then (if l=0 then (bE bx u+0x1000000).toUInt32 else if l=1 then ((bF bx u &&& 0x1FFFFFF)+0x1000000).toUInt32 else (bF bx u >>> 25).toUInt32) else let e:=cs 0x2000000000000 bx u if l=0 then ((e &&& 0x1FFFFFF)+0x1000000).toUInt32 else (e >>> 25).toUInt32 @[inline] def aW (h l:Д):Д:=(h <<< 25)+l @[inline] def bN (h l:Д):Д := ((h+0x8000000000000000) >>> (39:Д)) - (0x1000000:Д) - (l >>> (63:Д)) + (if aW h l< l then (1:Д) else 0) @[inline] def aF:Д:=((a+0x8000000000000000) >>> 25) - 0x4000000000 @[inline] def cM (b c:Д):Д := if t then let m:=b+aF a aw ((bN c m <<< 25)+(aW c m >>> 39)) ((aW c m <<< 25)+(a &&& 0x1FFFFFF)) B else aw (bN b a) (aW b a) B @[inline] def sg (m:Д):Д:=if u >>> 31 != 0 then 0 - m else m @[inline] def bY (k:Д→ Д→ Д):Д := let s:=iW u+149 - B let v:=mW u if expOf u == 255 || (v != 0 && s>62) then 0x100000000 else if u >>> 31 != 0 then k (0 - am v s) (0 - ap v s) else k (am v s) (ap v s) @[specialize] def lp (H:Nat) (f:Nat→ Nat→ Array Е→ Array Е) : Nat→ Nat→ Nat→ Array Е→ Array Е | 0,_,_,a=>a | n+1,o,y,a => let a:=f o y a if y+1< H then lp H f n o (y+1) a else lp H f n (o+1) 0 a @[specialize] def dr (f:Nat→ USize→ Е) (s:USize) (x:Nat):Nat→ USize→ Array Е→ Array Е | 0,_,a=>a | m+1,e,a=>dr f s (x+1) m (e+s) (a.push (f x e)) @[inline] def eM (O H W:Nat) (f:Nat→ Nat→ Nat→ Е):Array Е := if 0< H then lp H (fun o y=>dr (fun x _=>f o y x) 0 0 W 0) (O*H) 0 0 (Array.emptyWithCapacity (O*(H*W))) else #[] @[inline] def a8 (c y x:Nat):Е := if y<1∨x<1∨y - 1≥ h∨x - 1≥ w then 0 else I[(c*h+(y - 1))*w+(x - 1)]! lemma uL {a:Array Е} {i:USize} (h:i< a.usize):i.toNat< a.size:=by have:=de a;rw[μ] at h;omega @[inline] def ul (a:Array Е) (q:USize) (v:Е):Array Е := if h:q< a.usize then a.uset q v (uL h) else a @[inline] def iB (q:USize) (a:Array Е) (v:Е):Array Е := if t then let u:=bF bx v ul (ul (ul a q (bE bx v+0x1000000).toUInt32) (q+1) ((u &&& 0x1FFFFFF)+0x1000000).toUInt32) (q+2) (u >>> 25).toUInt32 else let e:=cs 0x2000000000000 bx v ul (ul a q ((e &&& 0x1FFFFFF)+0x1000000).toUInt32) (q+1) (e >>> 25).toUInt32 @[specialize] def gD (px:USize→ Array Е→ Е→ Array Е) (s:USize) (f:Nat→ Е) (i:Nat) : Nat→ USize→ Array Е→ Array Е | 0,_,a=>a | m+1,q,a=>gD px s f (i+1) m (q+s) (px q a (f i)) @[inline] def gj (c y:Nat) (a:Array Е) : Array Е := if y<1∨y - 1≥ h then a else gD (iB t bx) (sU t) (fun i=>I[i]!) ((c*h+(y - 1))*w) w (nl t*((c*(h+2)+y)*(w+2))+nl t).toUSize a @[inline] def fL:Array Е := lp (h+2) (gj t h w bx I) (n*(h+2)) 0 0 (Array.replicate (nl t*(n*((h+2)*(w+2)))+1) 0x1000000) def cC (W:Array Е) (j:Nat):Nat→ Д | 0=>0 | m+1=>wv W[j]! + cC W (j+1) m abbrev Kc:=Д→ Д→ Д→ Д @[inline] def gL (h:e.toNat+2< P.usize.toNat∧j.toNat< W.usize.toNat) (a b c:Д) (k:Kc):Д := have:=de P let w:=wv (W.uget j (by have:=de W;omega)) k (a+(P.uget e (А)).toUInt64*w) (b+(P.uget (e+1) (ix P e 1 (Б) h.1).2).toUInt64*w) (if t then c+(P.uget (e+2) (ix P e 2 (Б) h.1).2).toUInt64*w else c) lemma f3:(sU t).toNat=nl t:=by cases t<;>exact b9 _ (Б) @[inline] def ac (h:e.toNat+2*nl t+2< P.usize.toNat∧j.toNat+2< W.usize.toNat) (a b c:Д) (k:Kc):Д := have hs:=f3 t have h1:(e+sU t).toNat=e.toNat+nl t:=by rw[fB _ _ P.usize (А),hs] have h2:(e+sU t+sU t).toNat=e.toNat+2*nl t:=by rw[fB _ _ P.usize (А),h1,hs];omega have:=h.2 gL t P W e j ⟨by omega,by omega⟩ a b c fun a b c => gL t P W (e+sU t) (j+1) ⟨by omega,by rw[(ix W j 1 (Б) h.2).1];omega⟩ a b c fun a b c => gL t P W (e+sU t+sU t) (j+2) ⟨by omega,by rw[(ix W j 2 (Б) h.2).1];omega⟩ a b c k lemma iN {t:Bool} {P W:Array Е} {R i j:USize} (h:i<0x40000000∧R<0x10000000∧j<0x40000000∧i+R+R+cW t< P.usize ∧ j+8< W.usize) : i.toNat<2^30∧j.toNat<2^30∧(i+R).toNat=i.toNat+R.toNat ∧ (i+R+R).toNat=i.toNat+2*R.toNat∧i.toNat+2*R.toNat+2*nl t+2< P.usize.toNat ∧ (j+3).toNat=j.toNat+3∧(j+6).toNat=j.toNat+6∧j.toNat+8< W.usize.toNat:=by obtain ⟨h1,h2,h3,h4,h5⟩ := h have h1:=iu i 0x40000000 (Б) h1 have h2:=iu R 0x10000000 (Б) h2 have h3:=iu j 0x40000000 (Б) h3 rw[μ] at h4 h5 have:=bK have hs:(cW t).toNat=2*nl t+2:=by cases t<;>exact b9 _ (Б) have e1:(i+R).toNat=i.toNat+R.toNat:=by rw[Ι];exact mo (А) have e2:(i+R+R).toNat=i.toNat+2*R.toNat:=by rw[Ι,e1];exact (mo (А)).trans (А) have e3:(i+R+R+cW t).toNat=i.toNat+2*R.toNat+(2*nl t+2):=by rw[Ι,e2,hs];exact mo (by cases t<;>simp[nl]<;>omega) have e4 : ∀ c,c<9→(j+OfNat.ofNat c).toNat=j.toNat+c:=fun c hc=>by rw[Ι,b9 c (А)];exact mo (А) rw[e4 8 (Б)] at h5 exact ⟨h1,h3,e1,e2,by omega,e4 3 (Б),e4 6 (Б),h5⟩ @[inline] def cD (R i j:USize) (a b c:Д) (k:Kc):Д := if h:i<0x40000000∧R<0x10000000∧j<0x40000000∧i+R+R+cW t< P.usize ∧ j+8< W.usize then have h:=iN h ac t P W i j ⟨by omega,by omega⟩ a b c fun a b c => ac t P W (i+R) (j+3) ⟨by omega,by omega⟩ a b c fun a b c => ac t P W (i+R+R) (j+6) ⟨by omega,by omega⟩ a b c k else 0x100000000 @[specialize] def bt (win:USize→ USize→ Д→ Д→ Д → Kc→ Д) (fn:Kc) (n di dj k i j:USize) (a b c:Д):Д := if h:k< n then win i j a b c fun a b c=>bt win fn n di dj (k+1) (i+di) (j+dj) a b c else fn a b c termination_by n.toNat - k.toNat decreasing_by have h1:=μ.mp h rw[Ι,USize.toNat_one,mo (lt_of_le_of_lt h1 n.toNat_lt_size)] omega @[noinline] def fI (kk k cb o y x:Nat):Word := dotOf (k+1) (fun i=>if i< k then windowAt s I y x (cb*kk+i) else oneW) (fun i=>if i< k then K[o*k+i]! else b[o]!) @[inline] def bL (bo:Word):Д:=bY B bo fun l _=>l @[inline] def bH (bo:Word):Д:=bY B bo fun _ h=>h @[inline] def gz (l h:Д) (R pl ncU i0 j0:USize) (sw:Д):Д := if l=0x100000000 then l else (if ncU=1 then fun a b c=>cD t P W R i0 j0 a b c (cM t B) else bt (cD t P W R) (cM t B) ncU pl 9 0 i0 j0) (l - (sw <<< 24)) (h - (sw <<< 24)) (if t then (0:Д) - (sw <<< 24) else 0) def dS:Array Word := if D then depthwiseSpec s J I K b else conv2dSpec s J I K b abbrev cG (H V:Nat):Prop:=bx≤255∧bw≤255∧K.all (ok 7 bw)∧k≤95∧0< s.h∧0< s.w∧s.h<4096∧s.w<4096 ∧ s.cin*(H*V)<2^26∧Y*k<2^26∧Y*k≤ K.size @[inline] def gy (bx:Д) (_:I.all (ok (if t then 50 else 25) bx)=true) : Array Word := let H:=s.h+2 let V:=s.w+2 let k:=nc*9 let bw:=cN K let P:=fL t s.h s.w s.cin bx I let W:=K.map (b7 bw) if cG k bx s K Y bw H V then let SW:Array Д:=Array.ofFn (n:=Y) fun o=>cC W (o.val*k) k let B:=bx+bw let BL:Array Д:=Array.ofFn (n:=Y) fun o=>bL B b[o.val]! let BH:Array Д:=Array.ofFn (n:=Y) fun o=>bH B b[o.val]! let HV:=H*V let R:=(nl t*V).toUSize let pl:=(nl t*HV).toUSize let ncU:=nc.toUSize let kU:=k.toUSize lp s.h (fun o y => let cb:=if D then o else 0 let l:=BL[o]! let h:=BH[o]! let sw:=SW[o]! let j:=o.toUSize*kU dr (fun x e=>act J <| let r:=gz t P W B l h R pl ncU e j sw if r<0x100000000 then r.toUInt32 else fI s I K b 9 k cb o y x) (sU t) 0 s.w (nl t*(cb*HV+y*V)).toUSize) (Y*s.h) 0 0 (Array.emptyWithCapacity (Y*(s.h*s.w))) else dS s J I K b D def gA:Array Word := let bx:=cN I if s.kh=3∧s.kw=3∧s.stride=1∧s.pad=1 then if h:I.all (ok 25 bx)=true then gy false s J I K b D nc Y bx h else if h:I.all (ok 50 bx)=true then gy true s J I K b D nc Y bx h else dS s J I K b D else dS s J I K b D def dR:Array Word := gA s J I K b false s.cin s.cout def dh:Array Word := gA s J I K b true 1 s.cin @[inline] def sk:Е := if u<0x80000000 then u+0x80000000 else if u == 0x80000000 then 0x80000000 else 0xFFFFFFFF - u @[inline] def mx:Word := if expOf y≠255∧expOf z≠255∧(sk y< sk z∨sk z< sk y∨y=z) then (if sk y< sk z then z else y) else toWord (Model.maximum (ofW y) (ofW z)) @[specialize] def wl {α:Type} (g:α→ Word→ α) (I:Array Word) (w k:Nat):Nat→ Nat→ Nat→ α→ α | 0,_,_,acc=>acc | n+1,i,dx,acc => let acc:=g acc I[i]! if dx+1< k then wl g I w k n (i+1) (dx+1) acc else wl g I w k n (i+w+1 - k) 0 acc def fk:Array Word := if 0< k∧0< h / k∧0< w / k then eM c (h / k) (w / k) fun ch y x => let U:=(ch*h+y*k)*w+x*k wl mx I w k (k*k) U 0 I[U]! else maxpoolSpec c h w k I @[inline] def gb:Word := let q:=expOf d - 127 if fracOf d=0∧127≤ expOf d∧q< expOf r∧expOf r<255 then r - (q <<< 23) else if r &&& 0x7FFFFFFF=0 then r else toWord (Model.div (ofW r) (ofW d)) @[inline] def t1:Д:=sg u (mW u <<< (iW u - B)) @[reducible] def dO (f:Word→ Д):=wl fun (a:Д) x=>a+f x @[reducible] def wa:=wl fun (b:Bool) x=>b && Q x @[noinline] def gw (ch y x:Nat):Word := dotOf (k*k) (poolAt h w k I ch y x) fun _=>oneW @[inline] def wo (A H:Д) (g:Unit→ Bool) (fb:Unit→ Word) (d:Word):Word := if A=0∧H=0 then (if g () then 0x80000000 else 0) else let r:=cM false (B+149) A H 0 gb (if r<0x100000000 then r.toUInt32 else fb ()) d @[inline] def cu (w:Word):Д:=if mW w != 0 then iW w else 255 @[reducible] def iP:=wl fun (m:Д) x=>min m (cu x) @[inline] def eC:Д:=bF B u - 0x2000000000000 def wq (ch y x:Nat):Word := let U:=(ch*h+y*k)*w+x*k let B:=iP I w k (k*k) U 0 255 if B≤255∧wa (ok 50 B) I w k (k*k) U 0 true=true then wo B (dO (bE B) I w k (k*k) U 0 0) (dO (eC B) I w k (k*k) U 0 0) (fun _=>wa (· == 0x80000000) I w k (k*k) U 0 true) (fun _=>gw h w k I ch y x) d else toWord (Model.div (ofW (gw h w k I ch y x)) (ofW d)) @[inline] def eQ (x0 x1 x2 x3:Word):Bool:=Q x0 && Q x1 && Q x2 && Q x3 @[inline] def ig (ch y x:Nat) (e:USize):Word := let v:=w.toUSize if hb:e< I.usize∧e+1< I.usize∧e+v< I.usize∧e+v+1< I.usize then let x0:=I.uget e (uL hb.1) let x1:=I.uget (e+1) (uL hb.2.1) let x2:=I.uget (e+v) (uL hb.2.2.1) let x3:=I.uget (e+v+1) (uL hb.2.2.2) let B:=min (min (cu x0) (cu x1)) (min (cu x2) (cu x3)) if B≤255∧eQ (ok 37 B) x0 x1 x2 x3=true then wo B (t1 B x0+t1 B x1+t1 B x2+t1 B x3) 0 (fun _=>eQ (· == 0x80000000) x0 x1 x2 x3) (fun _=>gw h w 2 I ch y x) d else wq h w 2 I d ch y x else wq h w 2 I d ch y x abbrev DQ:Prop:=signOf d=false∧expOf d≠0∧expOf d<255 def eR:Array Word := let d:=natW (k*k) if 0< k∧0< h / k∧0< w / k∧k*k<16384∧DQ d then if k=2∧c*h*w<2^30 then lp (h / 2) (fun o y=>dr (ig h w I d o y) 2 0 (w / 2) ((o*h+y*2)*w).toUSize) (c*(h / 2)) 0 0 (Array.emptyWithCapacity (c*(h / 2*(w / 2)))) else let bx:=cN I if bx≤255∧I.all (ok 25 bx)=true then eM c (h / k) (w / k) fun ch y x => let U:=(ch*h+y*k)*w+x*k wo bx (dO (t1 bx) I w k (k*k) U 0 0) 0 (fun _=>wa (· == 0x80000000) I w k (k*k) U 0 true) (fun _=>gw h w k I ch y x) d else eM c (h / k) (w / k) (wq h w k I d) else avgpoolSpec c h w k I lemma aI : aa x=if x.toNat<2^63 then (x.toNat:Int) else (x.toNat:Int) - 2^64:=by unfold aa;rw[ϓ] have e:x.toBitVec.toNat=x.toNat:=rfl rw[e];split<;>split<;>omega lemma f6 (h:(x.toNat:Int) ≡ v [ZMOD 2^64]) (h1 : -2^63≤ v) (h2:v<2^63):aa x=v:=by rw[aI];have:=x.toNat_lt;unfold Int.ModEq at h;split<;>omega def Z:ZMod (2^64):=x.toNat lemma iw:(x.toNat:Int) ≡ v [ZMOD 2^64]↔Z x=v:=by unfold Z rw[show ((x.toNat:ℕ):ZMod (2^64))=(((x.toNat:ℤ)):ZMod (2^64)) by push_cast;rfl, ZMod.intCast_eq_intCast_iff] push_cast;rfl lemma sZ (h:Z x=v) (h1 : -2^63≤ v) (h2:v<2^63) : aa x=v:=f6 x v ((iw x v).mpr h) h1 h2 lemma cn (b:Д):Z (a+b)=Z a+Z b:=by unfold Z;rw[θ,ZMod.natCast_mod];push_cast;ring lemma eO (b:Д):Z (a*b)=Z a*Z b:=by unfold Z;rw[Ϛ,ZMod.natCast_mod];push_cast;ring lemma cF (b:Д):Z (a - b)=Z a - Z b:=by have hb:=b.toNat_lt unfold Z;rw[Ε,ZMod.natCast_mod,Nat.cast_add,Nat.cast_sub (А)] rw[show ((2^64:Nat):ZMod (2^64))=0 from ZMod.natCast_self _];ring lemma gv:Z u.toUInt64=(u.toNat:ZMod (2^64)):=by unfold Z;simp lemma g9:Z (wv u)=(u.toNat:ZMod (2^64)) - 2^31:=by unfold wv;rw[cF,gv];rfl lemma iR:Z (a <<< (24:Д))=Z a*2^24:=by unfold Z;rw[ο,ZMod.natCast_mod] simp only[ι,ϛ,Nat.reducePow,Nat.reduceMod];push_cast;ring lemma bC:Z 0=0:=by simp[Z] lemma ck {B:Д} (h:B≤255):B.toNat≤255:=by simpa using ε.mp h def aq (e:Nat) (w:Е):Int:=sv w*2^(idxOf w - e) lemma eK (h:mantOf u=0):sv u=0:=by unfold sv;simp[h] lemma dc (b:Д) (hb:b.toNat≤ a.toNat):(a - b).toNat=a.toNat - b.toNat:=by rw[Ε];have:=a.toNat_lt;omega lemma jb (h:mantOf u=0):mW u=0 := ς.mp (by rw[af,h];rfl) lemma a9 (w:Е) (he:E.toNat≤255) (hc:C.toNat≤62) (h:ok C E w=true) : expOf w≠255∧(mantOf w=0∨(E.toNat≤ idxOf w∧idxOf w≤ E.toNat+C.toNat ∧ (iW w - E).toNat=idxOf w - E.toNat)):=by simp only[ok,Ζ,bne_iff_ne,ne_eq,ϖ,beq_iff_eq] at h refine ⟨h.1,?_⟩ rcases h.2 with h0 | h1 ·left;have:=af w;rw[h0] at this;simp at this;omega ·right have hi:=an w have h2:=ε.mp (of_decide_eq_true h1) have:=idxOf_le w h.1 rw[Ε,hi] at h2 ⊢ omega lemma pw (v s c:Nat) (hv:v<2^24) (hs:s≤ c):v*2^s<2^(24+c):=by rw[pow_add];exact ϰ hv (ψ (Г) hs) (В) lemma ea (e:Д) (w:Е) (c:Nat) (hc:c≤39) (h:mantOf w=0∨(e.toNat≤ idxOf w∧idxOf w≤ e.toNat+c ∧ (iW w - e).toNat=idxOf w - e.toNat)) : (mW w <<< (iW w - e)).toNat=mantOf w*2^(idxOf w - e.toNat) ∧ mantOf w*2^(idxOf w - e.toNat)<2^(24+c):=by have hm:=mantOf_lt_24 w rcases h with h0 | ⟨h1,h2,hs⟩ ·rw[jb w h0,h0];simp ·have h3:=pw _ _ c hm (show idxOf w - e.toNat≤ c by omega) refine ⟨?_,h3⟩ rw[ο,af,hs,ι, mo (a:=idxOf w - e.toNat) (А)] exact mo (lt_of_lt_of_le h3 (ψ (Г) (А))) lemma dU (o c e:Д) (w:Е) (N P:Nat) (ho:o.toNat=N) (hb:e.toNat≤255) (hc:c.toNat≤39) (hP:2^(24+c.toNat)≤ P∧P≤ N∧N+P≤2^64) (h:ok c e w=true) : ((cs o e w).toNat:Int)=N+aq e.toNat w ∧ |aq e.toNat w| < P:=by obtain ⟨-,hr⟩ := a9 c e w hb (А) h obtain ⟨hs,h0⟩ := ea e w c.toNat hc hr have hX:(mantOf w:Int)*2^(idxOf w - e.toNat)=(mantOf w*2^(idxOf w - e.toNat):Nat):=by push_cast;ring unfold cs aq sv;rw[aZ] generalize mantOf w*2^(idxOf w - e.toNat)=X at hs h0 hX generalize 2^(24+c.toNat)=Q at h0 hP cases signOf w<;>simp only[fT,ite_false,ite_true,neg_mul,hX,abs_lt] ·rw[θ,hs];omega ·rw[dc _ _ (А),hs];omega lemma dl (hb:bw.toNat≤255) (h:ok 7 bw u=true) : ((b7 bw u).toNat:Int)=2^31+aq bw.toNat u ∧ |aq bw.toNat u| < 2^31:=by obtain ⟨h1,h2⟩ := dU 0x80000000 7 bw u (2^31) (2^31) rfl hb (Б) (Б) h rw[abs_lt] at h2 exact ⟨by rw[b7,Ϗ];omega,abs_lt.2 h2⟩ lemma jn (s:Д):(0:Д) <<< s=0:=by apply ς.mp;rw[ο];simp lemma bX:(x &&& 0x1FFFFFF).toNat=x.toNat % 2^25:=by rw[ϑ,show (0x1FFFFFF:Д).toNat=2^25 - 1 from rfl, ξ] lemma cR:(x >>> 25).toNat=x.toNat / 2^25:=by rw[κ];simp[ζ] lemma fO (hv:V.toNat<2^24) (h:V=0∨S.toNat≤62) : (am V S).toNat=V.toNat*2^S.toNat % 2^25 ∧ (ap V S).toNat=V.toNat*2^S.toNat / 2^25:=by unfold am ap rcases h with rfl | h ·simp only[jn];split<;>simp split ·rename_i h1 have h1:S.toNat<25:=by simpa using ν.mp h1 have e:(V <<< S).toNat=V.toNat*2^S.toNat:=by rw[ο,ι,mo (a:=S.toNat) (А)] exact mo (lt_of_lt_of_le (pw _ _ 25 hv h1.le) (Г)) rw[bX,cR,e];exact ⟨rfl,rfl⟩ ·rename_i h1 have h1:25≤ S.toNat:=by simpa using ε.mp (UInt64.not_lt.mp h1) have hs:(S - 25).toNat=S.toNat - 25:=dc _ _ (by simpa using h1) refine ⟨by rw[show S.toNat=S.toNat - 25+25 by omega,pow_add,← Υ];simp,?_⟩ rw[ο,hs,ι,mo (a:=S.toNat - 25) (А), mo (lt_of_lt_of_le (pw _ _ 37 hv (А)) (Г)), show S.toNat=S.toNat - 25+25 by omega,pow_add,← Υ] simp lemma eD (hb:bx.toNat≤255) (h:ok 50 bx u=true) : (bE bx u).toNat<2^25∧(bF bx u).toNat<2^50 ∧ ((bF bx u).toNat:Int)*2^25+(bE bx u).toNat=2^74+aq bx.toNat u:=by obtain ⟨-,hr⟩ := a9 50 bx u hb (Б) h have hm:=mantOf_lt_24 u obtain ⟨hz,hy⟩ := fO (mW u) (iW u - bx) (by rw[af];exact hm) (by rcases hr with h0 | h0;exact .inl (jb u h0);exact .inr (by simp at h0;omega)) have hX:(mW u).toNat*2^(iW u - bx).toNat=mantOf u*2^(idxOf u - bx.toNat):=by rcases hr with h0 | ⟨-,-,h3⟩ ·simp[af,h0] ·rw[af,h3] have h4:mantOf u*2^(idxOf u - bx.toNat)<2^74:=by rcases hr with h0 | ⟨-,h2,-⟩ ·simp[h0] ·exact pw _ _ 50 hm (by simp at h2;omega) have h5:(mantOf u:Int)*2^(idxOf u - bx.toNat)=(mantOf u*2^(idxOf u - bx.toNat):Nat):=by push_cast;ring rw[hX] at hz hy unfold bE bF aq sv;dsimp only;rw[aZ] generalize am (mW u) (iW u - bx)=lo at hz ⊢ generalize ap (mW u) (iW u - bx)=hi at hy ⊢ generalize mantOf u*2^(idxOf u - bx.toNat)=X at hz hy h4 h5 have h6:=Ϭ X (2^25) have h7:=Ν X (Nat.two_pow_pos 25) generalize X / 2^25=q at * generalize X % 2^25=r at * cases signOf u<;>simp only[fT,ite_false,ite_true,neg_mul,h5] ·rw[θ];simp;clear * - h6 h7 h4 hz hy;omega ·have hc:(if lo != 0 then (1:Д) else 0).toNat=if lo.toNat=0 then 0 else 1:=by by_cases h0:lo=0<;>simp[h0] intro h1;exact h0 (ς.mp (by simpa using h1)) rw[bX,dc _ _ (by simp;omega),dc _ _ (by rw[hc,dc _ _ (by simp;omega)];simp;split<;>omega), dc _ _ (by simp;omega),hc] simp;split<;>rename_i hh<;>(clear * - h6 h7 h4 hz hy hh;omega) lemma gs (h:x.toNat<2^32):x.toUInt32.toNat=x.toNat:=by rw[Ϗ];exact mo h lemma ic (h:x.toNat<2^25):(x+0x1000000).toUInt32.toNat=x.toNat+2^24:=by rw[gs _ (by rw[θ];simp;omega),θ];simp;omega lemma dY (hb:bx.toNat≤255) (h:ok (if t then 50 else 25) bx u=true) : (∀ l< nl t,(aQ t bx u l).toNat<2^25+2^24)∧((aQ t bx u 0).toNat:Int)+((aQ t bx u 1).toNat:Int)*2^25 + (if t then ((aQ t bx u 2).toNat:Int)*2^50 else 0) = (if t then 2^74+2^49+2^24 else 2^49+2^24)+aq bx.toNat u:=by cases t<;>simp only[nl,fT,ite_true,ite_false] at h ⊢ ·obtain ⟨h1,h2⟩ := dU 0x2000000000000 25 bx u (2^49) (2^49) rfl hb (Б) (Б) h rw[abs_lt] at h2 have e0:(aQ false bx u 0).toNat=(cs 0x2000000000000 bx u).toNat % 2^25+2^24:=by show ((cs 0x2000000000000 bx u &&& 0x1FFFFFF)+0x1000000).toUInt32.toNat=_ rw[ic _ (by rw[bX];omega),bX] have e1:(aQ false bx u 1).toNat=(cs 0x2000000000000 bx u).toNat / 2^25:=by show (cs 0x2000000000000 bx u >>> 25).toUInt32.toNat=_;rw[gs _ (by rw[cR];omega),cR] refine ⟨fun l hl => ?_,by rw[e0,e1];omega⟩ interval_cases l<;>simp only[e0,e1]<;>omega ·obtain ⟨h1,h2,h3⟩ := eD bx u hb h have e0:(aQ true bx u 0).toNat=(bE bx u).toNat+2^24:=by show (bE bx u+0x1000000).toUInt32.toNat=_;rw[ic _ (А)] have e1:(aQ true bx u 1).toNat=(bF bx u).toNat % 2^25+2^24:=by show ((bF bx u &&& 0x1FFFFFF)+0x1000000).toUInt32.toNat=_;rw[ic _ (by rw[bX];omega),bX] have e2:(aQ true bx u 2).toNat=(bF bx u).toNat / 2^25:=by show (bF bx u >>> 25).toUInt32.toNat=_;rw[gs _ (by rw[cR];omega),cR] refine ⟨fun l hl => ?_,by rw[e0,e1,e2];omega⟩ interval_cases l<;>simp only[e0,e1,e2]<;>omega lemma ji (l:Nat) (hl:l< nl t):aQ t bx 0 l=0x1000000:=by have m0:mW 0=0:=Б rcases (show l=0∨l=1∨(l=2∧t=true) by cases t<;>simp[nl] at hl ⊢<;>omega) with rfl | rfl | ⟨rfl,rfl⟩<;>(try cases t)<;>simp[aQ,cs,bE,bF,am,ap,m0]<;>decide lemma gJ : -2^63≤ aa x∧aa x<2^63:=by rw[aI];have:=x.toNat_lt;split<;>omega lemma ij (b:Д):((a+b).toNat:Int) ≡ (a.toNat:Int)+b.toNat [ZMOD 2^64]:=by unfold Int.ModEq;rw[θ];omega lemma ik (b:Д):((a - b).toNat:Int) ≡ (a.toNat:Int) - b.toNat [ZMOD 2^64]:=by have:=b.toNat_lt;unfold Int.ModEq;rw[Ε];omega lemma i3 : (((a+(0x8000000000000000:Д)) >>> (39:Д)).toNat:Int) = (a.toNat / 2^39:Nat)+(if a.toNat<2^63 then 2^24 else -2^24):=by have ha:=a.toNat_lt rw[κ,θ] simp only[ζ,ϛ,Nat.reducePow,Nat.reduceMod] split<;>omega lemma i5:((a >>> (63:Д)).toNat:Int)=(a.toNat / 2^63:Nat):=by rw[κ] simp only[ζ,ϛ,Nat.reducePow,Nat.reduceMod] lemma cm (aH aL:Д) : ag (bN aH aL) (aW aH aL)=aa aH*2^25+aa aL:=by have hA:=aH.toNat_lt have hB:=aL.toNat_lt have h0:(aW aH aL).toNat=((aH.toNat % 2^39)*2^25+aL.toNat) % 2^64:=by unfold aW rw[θ,ο] simp only[ι,ϛ,Nat.reducePow,Nat.reduceMod] omega set c:Int:=if aW aH aL< aL then 1 else 0 with hc have h1:c=if (aH.toNat % 2^39)*2^25+aL.toNat≥2^64 then 1 else 0:=by rw[hc];simp only[ν,h0];split_ifs<;>omega set hv:Int:=(aH.toNat / 2^39:Nat)+(if aH.toNat<2^63 then 0 else -2^25) - (aL.toNat / 2^63:Nat)+c with h2 have h3:((bN aH aL).toNat:Int) ≡ hv [ZMOD 2^64]:=by unfold bN refine (ij _ _).trans (Int.ModEq.add ((ik _ _).trans (Int.ModEq.sub ((ik _ _).trans ?_) (by rw[i5]))) ?_) ·rw[i3] have:((0x1000000:Д).toNat:Int)=2^24:=rfl rw[this] split<;>(unfold Int.ModEq;ring_nf) ·rw[hc];split<;>rfl have h4:0≤ c∧c≤1:=by rw[hc];split<;>decide have h5:=f6 _ hv h3 (by rw[h2];clear * - hA hB h4;split<;>omega) (by rw[h2];clear * - hA hB h4;split<;>omega) unfold ag rw[h5,aI,aI,h0,h2,h1] clear * - hA hB set S:=aH.toNat % 2^39*2^25+aL.toNat with hS rcases Nat.lt_or_ge S (2^64) with hc | hc ·rw[γ hc,if_neg (not_le.mpr hc)];split_ifs<;>omega ·rw[Nat.mod_eq_sub_mod hc,γ (show S - 2^64<2^64 by omega),if_pos hc] split_ifs<;>omega lemma fr:aa (aF a)=aa a / 2^25:=by have ha:=a.toNat_lt refine f6 _ _ ?_ (by rw[aI];split<;>omega) (by rw[aI];split<;>omega) unfold aF Int.ModEq rw[Ε,κ,θ,aI] simp only[ζ,ϛ,Nat.reducePow,Nat.reduceMod] split<;>omega lemma fv (hi lo r:Д) (hr:r.toNat<2^25) (hb : -2^101≤ ag hi lo∧ag hi lo<2^101) : ag ((hi <<< (25:Д))+(lo >>> (39:Д))) ((lo <<< (25:Д))+r) = ag hi lo*2^25+r.toNat:=by have hl:=lo.toNat_lt have:=hi.toNat_lt unfold ag at hb ⊢ have h0:((lo <<< (25:Д))+r).toNat=lo.toNat % 2^39*2^25+r.toNat:=by rw[θ,ο] simp only[ι,ϛ,Nat.reducePow,Nat.reduceMod];omega have h1:(((hi <<< (25:Д))+(lo >>> (39:Д))).toNat:Int) ≡ aa hi*2^25+(lo.toNat / 2^39:Nat) [ZMOD 2^64]:=by unfold Int.ModEq rw[θ,ο,κ,aI] simp only[ι,ζ,ϛ,Nat.reducePow, Nat.reduceMod] split<;>omega rw[f6 _ _ h1 (А) (А),h0];push_cast;omega lemma gR (b c:Д) (hm : -2^63≤ aa b+aa a / 2^25∧aa b+aa a / 2^25<2^63) : ∃ H L,(∀ B,cM t B a b c=aw H L B) ∧ ag H L=aa a+aa b*2^25+(if t then aa c*2^50 else 0):=by cases t ·refine ⟨bN b a,aW b a,fun B=>by unfold cM;rw[if_neg Bool.false_ne_true],?_⟩ rw[cm];simp only[fT,ite_false,add_zero];ring refine ⟨(bN c (b+aF a) <<< 25)+(aW c (b+aF a) >>> 39), (aW c (b+aF a) <<< 25)+(a &&& 0x1FFFFFF),fun B=>by unfold cM;rw[if_pos rfl],?_⟩ have h1:(b.toNat:Int) ≡ aa b [ZMOD 2^64]:=by rw[aI];unfold Int.ModEq;split<;>omega have h2:((aF a).toNat:Int) ≡ aa a / 2^25 [ZMOD 2^64]:=by rw[← fr,aI];unfold Int.ModEq;split<;>omega have e:aa (b+aF a)=aa b+aa a / 2^25 := f6 _ _ ((ij _ _).trans (h1.add h2)) hm.1 hm.2 have hv:=cm c (b+aF a) rw[e] at hv have:=gJ c have:=gJ a have hr:(a &&& 0x1FFFFFF).toNat<2^25:=by rw[bX];omega have hb : -2^101≤ ag (bN c (b+aF a)) (aW c (b+aF a)) ∧ ag (bN c (b+aF a)) (aW c (b+aF a))<2^101:=by rw[hv];constructor<;>omega have h0:((a &&& 0x1FFFFFF).toNat:Int)=aa a % 2^25:=by rw[bX,aI];have:=a.toNat_lt;split<;>omega rw[fv _ _ _ hr hb,hv,h0,if_pos rfl] omega def a6 (a b c:α):Nat→ α | 0=>a | 1=>b | _=>c lemma ei (a b:Е) (ba bb:Nat) (ha:mantOf a=0∨ba≤ idxOf a) (hb:mantOf b=0∨bb≤ idxOf b):tm a b=aq ba a*aq bb b*2^(ba+bb):=by unfold tm aq rcases ha with ha | ha ·simp[eK a ha] rcases hb with hb | hb ·simp[eK b hb] rw[show idxOf a+idxOf b=(idxOf a - ba)+(idxOf b - bb)+(ba+bb) by omega,pow_add,pow_add] ring lemma iH:tm oneW u=sv u*2^(idxOf u+149):=by unfold tm;rw[show sv oneW=2^23 by decide,show idxOf oneW=126 by decide, show idxOf u+149=23+(126+idxOf u) by omega,pow_add,ϒ 126];ring lemma ci (f:Nat→ Int) (M:Int) (h : ∀ t< k,|f t| ≤ M) : |∑ t∈ range k,f t| ≤ k*M := (Finset.abs_sum_le_sum_abs _ _).trans ((Finset.sum_le_sum fun t ht=>h t (mr ht)).trans (by simp)) lemma gP (fb:Nat→ Word) (bx bw:Nat) (B:Д) (hB:B.toNat=bx+bw) (hk:k≤95) (h0 : ∀ i< k,expOf (fa i)≠255∧(mantOf (fa i)=0∨bx≤ idxOf (fa i))) (h3 : ∀ i< k,expOf (fb i)≠255∧(mantOf (fb i)=0∨bw≤ idxOf (fb i))) (h5:fa k=oneW) (h6:expOf (fb k)≠255) (L:Nat→ Nat→ Int) (hL : ∀ l<3,∀ i< k,|L l i| ≤ 2^25) (h2:t=false→ ∀ i< k,L 2 i=0) (hX : ∀ i< k,L 0 i+L 1 i*2^25+L 2 i*2^50=aq bx (fa i)) (hW : ∀ i< k,|aq bw (fb i)| < 2^31) (Lb Hb:Int) (h7 : |Lb| < 2^25) (h8 : |Hb| < 2^61) (h9:sv (fb k)*2^(idxOf (fb k)+149)=(Hb*2^25+Lb)*2^B.toNat) (a b c:Д) (hz : ∀ l<3,Z (a6 a b c l) = ((a6 Lb Hb 0 l + ∑ i∈ range k,L l i*aq bw (fb i):Int):ZMod (2^64))) (hr:cM t B a b c<0x100000000):dotOf (k+1) fa fb=(cM t B a b c).toUInt32:=by have hs : ∀ l<3,aa (a6 a b c l)=a6 Lb Hb 0 l + ∑ i∈ range k,L l i*aq bw (fb i) ∧ |∑ i∈ range k,L l i*aq bw (fb i)| ≤ 95*(2^25*2^31):=by intro l hl have h1:=(ci k _ _ fun i hi=>(abs_mul _ _).trans_le (mul_le_mul (hL l hl i hi) (hW i hi).le (abs_nonneg _) (Г))).trans (mul_le_mul_of_nonneg_right (show (k:Int)≤95 by exact_mod_cast hk) (Г)) have h4 : |a6 Lb Hb 0 l| < 2^61:=by match l with | 0=>exact h7.trans (Г) | 1=>exact h8 | _+2=>simp[a6] have:=abs_le.mp h1;have:=abs_lt.mp h4 exact ⟨sZ _ _ (hz l hl) (by linarith) (by linarith),h1⟩ obtain ⟨sa,ba⟩ := hs 0 (Б);obtain ⟨sb,bb⟩ := hs 1 (Б) obtain ⟨sc,-⟩ := hs 2 (Б) simp only[a6] at sa sb sc have:=abs_le.mp ba;have:=abs_le.mp bb;have:=abs_lt.mp h7;have:=abs_lt.mp h8 obtain ⟨H,L',hf,hv⟩ := gR t a b c (by rw[sa,sb];constructor<;>omega) rw[hf] at hr ⊢ refine aD (k+1) fa fb H L' B (fun i hi => ?_) ?_ hr ·rcases Nat.lt_or_ge i k with h | h ·exact ⟨(h0 i h).1,(h3 i h).1⟩ ·rw[show i=k by omega,h5];exact ⟨by decide,h6⟩ have hc:(if t then aa c*2^50 else 0)=(∑ i∈ range k,L 2 i*aq bw (fb i))*2^50:=by cases t ·rw[Finset.sum_eq_zero fun i hi=>by rw[h2 rfl i (mr hi),zero_mul]];simp ·simp[sc] rw[hv,sa,sb,hc,Core.dv,h5,iH,h9,hB];unfold Core.aB rw[χ rfl fun i hi=>by rw[ei _ _ bx bw (h0 i (mr hi)).2 (h3 i (mr hi)).2, ← hX i (mr hi)]] rw[χ rfl fun i _=>show (L 0 i+L 1 i*2^25+L 2 i*2^50)*aq bw (fb i) * 2^(bx+bw)=L 0 i*aq bw (fb i)*2^(bx+bw)+L 1 i*aq bw (fb i)*(2^25*2^(bx+bw)) + L 2 i*aq bw (fb i)*(2^50*2^(bx+bw)) by ring] rw[ϣ,ϣ,← ϊ,← ϊ,← ϊ] ring abbrev aE (g:Nat→ Е):Array Е:=Array.ofFn (n:=m) fun q=>g q.val lemma fm (g:Nat→ Е):(aE m g).push (g m)=aE (m+1) g:=by simp only[aE];rw[Array.ofFn_succ (f:=fun q:Fin (m+1)=>g q.val)];rfl lemma fG (o y x H W:Nat) (hy:y< H) (hx:x< W) : ((o*H+y)*W+x) / (H*W)=o∧((o*H+y)*W+x) / W % H=y ∧ ((o*H+y)*W+x) % W=x:=by have h1:((o*H+y)*W+x) / W=o*H+y:=by rw[ϒ,Ϙ _ _ (А),ϙ hx,Ο] refine ⟨?_,?_,by rw[ϒ,ϋ,mo hx]⟩ ·rw[ϐ H W,← Ϫ,h1,ϒ,Ϙ _ _ (А), ϙ hy,Ο] ·rw[h1,ϒ,ϋ,mo hy] lemma fN (H:Nat) (f:Nat→ Nat→ Array Е→ Array Е) (S:Nat→ Array Е→ Prop) (hf : ∀ o y a,y< H→ S (o*H+y) a→ S (o*H+y+1) (f o y a)) : ∀ n o y a,y< H→ 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 ih => intro o y a hy h have h1:=hf o y a hy h simp only[lp];split_ifs with h2 ·rw[show o*H+y+(n+1)=o*H+(y+1)+n by ring];exact ih _ _ _ h2 h1 ·obtain rfl:H=y+1:=А rw[show o*(y+1)+y+(n+1)=(o+1)*(y+1)+0+n by ring] exact ih _ _ _ (А) (by rw[show (o+1)*(y+1)+0=o*(y+1)+y+1 by ring];exact h1) lemma iC (f:Nat→ USize→ Е) (g:Nat→ Е) (s:USize) : ∀ m x e M, (∀ j< m,g (M+j)=f (x+j) (e+s*j.toUSize))→ dr f s x m e (aE M g)=aE (M+m) g:=by intro m;induction m with | zero=>intro _ _ _ _;rfl | succ m ih => intro x e M hg have h0:=hg 0 (А) rw[Τ,Τ,show (0:Nat).toUSize=0 from rfl,USize.mul_zero,USize.add_zero] at h0 rw[dr,← h0,fm,ih _ _ _ fun j hj=>by rw[show M+1+j=M+(j+1) by omega,hg _ (А),show x+(j+1)=x+1+j by omega, show (j+1).toUSize=j.toUSize+1 from USize.ofNat_add j 1,USize.mul_add,USize.mul_one, USize.add_assoc,USize.add_comm (s*_)]];congr 1;omega lemma gl (H W n c:Nat) (s:USize) (E:Nat→ Nat→ USize) (F:Nat→ Nat→ Nat→ USize→ Е) (hH:0< H):lp H (fun o y=>dr (F o y) s 0 W (E o y)) n 0 0 (Array.emptyWithCapacity c) = aE (n*W) fun q=>F (q / (H*W)) (q / W % H) (q % W) (E (q / (H*W)) (q / W % H)+s*(q % W).toUSize):=by have:=fN H (fun o y=>dr (F o y) s 0 W (E o y)) (fun k a=>a=aE (W*k) fun q => F (q / (H*W)) (q / W % H) (q % W) (E (q / (H*W)) (q / W % H)+s*(q % W).toUSize)) (fun o y a hy ha=>by subst ha;rw[Nat.mul_succ];exact iC _ _ _ _ _ _ _ fun j hj=>by obtain ⟨d1,d2,d3⟩ := fG o y j H W hy hj simp only[show W*(o*H+y)+j=(o*H+y)*W+j by ring,d1,d2,d3,Ο]) n 0 0 _ hH rfl simp only[Nat.mul_zero,ϡ,Ο,ϐ W n] at this rw[← this];congr 1 lemma f7 (O H W:Nat) (f:Nat→ Nat→ Nat→ Е) : eM O H W f=aE (O*(H*W)) fun q=>f (q / (H*W)) (q / W % H) (q % W):=by unfold eM;split_ifs with h ·rw[gl _ _ _ _ _ _ _ h,Υ] ·simp[aE,show H=0 by omega] lemma i6 (g:α→ Word→ α) (I:Array Word) (w k U:Nat) : ∀ n dy dx acc,dx< k→ wl g I w k n (U+dy*w+dx) dx acc = (List.range' (dy*k+dx) n).foldl (fun acc t=>g acc I[U+t / k*w+t % k]!) acc:=by intro n induction n with | zero=>intro dy dx acc _;rfl | succ n ih => intro dy dx acc h0 have e1:(dy*k+dx) / k=dy:=by rw[ϒ,Ϙ _ _ (А),ϙ h0,Ο] have e2:(dy*k+dx) % k=dx:=by rw[ϒ,ϋ,mo h0] rw[List.range'_succ,List.foldl_cons] simp only[wl,e1,e2] split_ifs with h ·exact ih dy (dx+1) _ h ·obtain rfl:k=dx+1:=А rw[show U+dy*w+dx+w+1 - (dx+1)=U+(dy+1)*w+0 by rw[϶];omega, ih (dy+1) 0 _ (А)];congr 2;ring lemma iO (g:α→ Word→ α) (I:Array Word) (w k U n:Nat) (acc:α) (hk:0< k) : wl g I w k n U 0 acc=(List.range n).foldl (fun acc t=>g acc I[U+t / k*w+t % k]!) acc:=by have:=i6 g I w k U n 0 0 acc hk simp only[ϡ,Τ,← List.range_eq_range'] at this;exact this lemma ab (h:n<2^32):n.toUSize.toNat=n:=by rw[Nat.toUSize_eq,USize.toNat_ofNat'];exact mo (lt_of_lt_of_le h bK) lemma g4 (a:Array Е) (q:USize) (v:Е):(ul a q v).size=a.size:=by unfold ul;split<;>simp lemma iM (a:Array Е) (q:USize) (v:Е) (i:Nat) (hq:q.toNat< a.size) (hs:a.size<2^32) : (ul a q v)[i]! = if i=q.toNat then v else a[i]! := by unfold ul;rw[dif_pos (by rw[μ,Array.usize,ab _ hs];exact hq)] by_cases hi:i< a.size ·rw[getElem!_pos _ i (by simpa using hi),getElem!_pos _ i hi] by_cases e:i=q.toNat ·subst e;simp[Array.uset] ·simp[Array.uset,e,Array.getElem_set,Ne.symm e] ·rw[getElem!_neg _ i (by simpa using hi),getElem!_neg _ i hi,if_neg (А)] lemma bG:0< nl t:=by cases t<;>decide abbrev cr (N M:Nat) (g:Nat→ Е) (a:Array Е):Prop := a.size=N+1 ∧ ∀ q< N,a[q]! = if q< M then g q else 0x1000000 lemma ej {N M:Nat} {g:Nat→ Е} {a:Array Е} (q:USize) (v:Е) (hN:N<2^30) (hq:q.toNat=M) (ha:cr N M g a) (hM:M< N) (hv:g M=v):cr N (M+1) g (ul a q v):=by obtain ⟨hs,hp⟩ := ha refine ⟨by rw[g4,hs],fun i hi => ?_⟩ rw[iM a q v i (А) (А)] by_cases h1:i=q.toNat ·rw[if_pos h1,if_pos (А),h1,hq,hv] ·rw[if_neg h1,hp i hi];split_ifs<;>first | rfl | omega lemma iF {N M m:Nat} {g:Nat→ Е} {a:Array Е} (ha:cr N M g a) (hg : ∀ j< m,∀ l< nl t,g (M+nl t*j+l)=0x1000000):cr N (M+nl t*m) g a:=by refine ⟨ha.1,fun q hq => ?_⟩ rw[ha.2 q hq] by_cases h1:q< M ·rw[if_pos h1,if_pos (А)] by_cases h2:q< M+nl t*m ·have:=Ϭ (q - M) (nl t) have:=Ν (q - M) (bG t) rw[if_neg h1,if_pos h2,show q=M+nl t*((q - M) / nl t)+(q - M) % nl t by omega, hg _ ((ϭ (bG t)).mpr (by rw[ϐ];omega)) _ this] ·rw[if_neg h1,if_neg h2] def dW (q:Nat):Е := aQ t bx (a8 h w I (q / nl t / ((h+2)*(w+2))) (q / nl t / (w+2) % (h+2)) (q / nl t % (w+2))) (q % nl t) lemma eG (o y x l:Nat) (hy:y< h+2) (hx:x< w+2) (hl:l< nl t) : dW t h w bx I (nl t*((o*(h+2)+y)*(w+2)+x)+l) = aQ t bx (a8 h w I o y x) l:=by obtain ⟨d1,d2,d3⟩ := fG o y x _ _ hy hx unfold dW rw[Nat.mul_add_div (bG t),ϙ hl,Τ,Nat.mul_add_mod,mo hl, d1,d2,d3] lemma gZ (v:Е) {N M:Nat} {g:Nat→ Е} {a:Array Е} (hN:N<2^30) (ha:cr N M g a) (hM:M+nl t≤ N) (hg : ∀ l< nl t,g (M+l)=aQ t bx v l) : cr N (M+nl t) g (iB t bx M.toUSize a v):=by have e : ∀ c,c≤2→(M.toUSize+OfNat.ofNat c).toNat=M+c:=fun c hc=>by rw[Ι,ab _ (А),b9 c (А)];exact mo (lt_of_lt_of_le (А) bK) have a1:=ej _ _ hN (ab M (А)) ha (by have:=bG t;omega) (hg 0 (bG t)) have a2:=ej _ _ hN (e 1 (Б)) a1 (by cases t<;>simp[nl] at hM<;>omega) (hg 1 (by cases t<;>decide)) cases t ·exact a2 ·exact ej _ _ hN (e 2 (Б)) a2 (by simp[nl] at hM;omega) (hg 2 (Б)) lemma g0 (f g:Nat→ Е) {N:Nat} (hN:N<2^30) : ∀ m i M a,cr N M g a→ M+nl t*m≤ N→(∀ j< m,∀ l< nl t,g (M+nl t*j+l)=aQ t bx (f (i+j)) l) → cr N (M+nl t*m) g (gD (iB t bx) (sU t) f i m M.toUSize a):=by intro m;induction m with | zero=>intro _ _ _ ha _ _;exact ha | succ m ih => intro i M a ha hM hg rw[Nat.mul_succ] at hM ⊢ rw[gD,show M.toUSize+sU t=(M+nl t).toUSize by show USize.ofNat M+_=USize.ofNat _;rw[USize.ofNat_add];cases t<;>rfl,← Nat.add_assoc,Nat.add_right_comm] exact ih _ _ _ (gZ t bx _ hN ha (А) fun l hl=>by simpa using hg 0 (А) l hl) (А) fun j hj l hl=>by rw[show M+nl t+nl t*j+l=M+nl t*(j+1)+l by ring,hg _ (А) l hl, show i+(j+1)=i+1+j by omega] lemma gV (hN:nl t*(n*((h+2)*(w+2)))<2^30) : cr (nl t*(n*((h+2)*(w+2)))) (nl t*(n*((h+2)*(w+2)))) (dW t h w bx I) (fL t h w n bx I):=by have hz : ∀ c y x l,(y<1∨y - 1≥ h∨x<1∨x - 1≥ w)→ l< nl t → aQ t bx (a8 h w I c y x) l=0x1000000:=fun c y x l h hl=>by unfold a8;rw[if_pos (А)];exact ji t bx l hl have:=fN (h+2) (gj t h w bx I) (fun k a=>k≤ n*(h+2) → cr (nl t*(n*((h+2)*(w+2)))) (nl t*(w+2)*k) (dW t h w bx I) a) (fun c y a hy ha hk=>by have hF : ∀ j l,j< w+2→ l< nl t→ dW t h w bx I (nl t*((c*(h+2)+y)*(w+2))+nl t*j+l)=aQ t bx (a8 h w I c y j) l := fun j l hj hl=>by rw[← eG t h w bx I c y j l hy hj hl];congr 1;ring have hb:nl t*((c*(h+2)+y)*(w+2))+nl t+nl t*w+nl t*1 ≤ nl t*(n*((h+2)*(w+2))) := calc _=nl t*((c*(h+2)+y+1)*(w+2)):=by ring _≤ nl t*((n*(h+2))*(w+2)):=ϧ _ (τ _ hk) _=_:=by ring have ha:=ha (А) rw[show nl t*(w+2)*(c*(h+2)+y)=nl t*((c*(h+2)+y)*(w+2)) by ring] at ha rw[show nl t*(w+2)*(c*(h+2)+y+1)=nl t*((c*(h+2)+y)*(w+2)) + nl t+nl t*w+nl t*1 by ring] unfold gj generalize nl t*((c*(h+2)+y)*(w+2))=M at * split ·rw[show M+nl t+nl t*w+nl t*1=M+nl t*(w+2) by ring] exact iF t ha fun j hj l hl=>by rw[hF j l hj hl,hz c y j l (А) hl] ·have a1:=iF t (m:=1) ha fun j hj l hl=>by rw[hF j l (А) hl,hz c y j l (А) hl] rw[ϩ] at a1 have a2:=g0 t bx (fun i=>I[i]!) _ hN w ((c*h+(y - 1))*w) _ _ a1 (А) fun j hj l hl=>by rw[show M+nl t+nl t*j+l=M+nl t*(j+1)+l by ring,hF (j+1) l (А) hl] unfold a8;rw[if_neg (А),Nat.add_sub_cancel] exact iF t a2 fun j hj l hl=>by rw[show M+nl t+nl t*w+nl t*j+l=M+nl t*(1+w+j)+l by ring, hF (1+w+j) l (А) hl,hz c y _ l (А) hl]) (n*(h+2)) 0 0 (Array.replicate (nl t*(n*((h+2)*(w+2)))+1) 0x1000000) (А) fun _=>⟨by simp,fun q hq=>by rw[if_neg (by simp),getElem!_pos _ q (by rw[Array.size_replicate];omega)];simp⟩ simp only[ϡ,Ο] at this rw[show nl t*(w+2)*(n*(h+2))=nl t*(n*((h+2)*(w+2))) by ring] at this exact this (le_refl _) lemma gU (c y x l:Nat) (hc:c< n) (hy:y< h+2) (hx:x< w+2) (hl:l< nl t) (hN:nl t*(n*((h+2)*(w+2)))<2^30) : (fL t h w n bx I)[nl t*((c*(h+2)+y)*(w+2)+x)+l]! = aQ t bx (a8 h w I c y x) l:=by have hq:(c*(h+2)+y)*(w+2)+x+1≤ n*((h+2)*(w+2)):=by have:=τ (h+2) (Nat.succ_le_of_lt hc) have:=τ (w+2) (show c*(h+2)+y+1≤ n*(h+2) by rw[Ϣ] at this;omega) rw[← Υ];rw[϶] at this;omega have:=ϧ (nl t) hq rw[Nat.mul_add,ϩ] at this rw[(gV t h w n bx I hN).2 _ (А),if_pos (А),eG t h w bx I c y x l hy hx hl] def wI (j:Nat):Int:=(W[j]!.toNat:Int) - 2^31 lemma f5 (j m:Nat) : Z (cC W j m)=((∑ t∈ range m,wI W (j+t):Int):ZMod (2^64)):=by induction m generalizing j with | zero=>simp[cC,Z] | succ m ih => rw[cC,cn,g9,ih,ϟ] simp only[wI,Τ,show ∀ t,j+1+t=j+(t+1) from fun t=>А] push_cast;ring lemma bM:Z x=((x.toNat:Int):ZMod (2^64)):=by unfold Z;norm_cast lemma g8:Z x=((aa x:Int):ZMod (2^64)) := (iw x _).mp (by rw[aI];have:=x.toNat_lt;unfold Int.ModEq;split<;>omega) lemma i4 (m:Д) (h:m.toNat<2^62) : aa (sg u m)=if signOf u then -(m.toNat:Int) else m.toNat:=by unfold sg;rw[aZ] cases signOf u<;>simp only[fT,ite_true,ite_false] ·exact sZ _ _ (bM m) (А) (А) ·exact sZ _ _ (by rw[cF,bC,bM];push_cast;ring) (А) (А) lemma fD (hB:B.toNat≤510) (h:bL B u≠0x100000000) : expOf u≠255 ∧ ∃ Lb Hb:Int,|Lb| < 2^25 ∧ |Hb| < 2^61 ∧ Z (bL B u)=Lb∧Z (bH B u)=Hb∧sv u*2^(idxOf u+149)=(Hb*2^25+Lb)*2^B.toNat:=by simp only[bL,bH,bY] at h ⊢ split at h ·exact absurd rfl h rename_i h3;simp only[if_neg h3] simp only[ϖ,beq_iff_eq,Ζ,bne_iff_ne,ne_eq,not_or,not_and, decide_eq_true_eq] at h3 obtain ⟨h4,h5⟩ := h3 have hm:=mantOf_lt_24 u have hi:=an u have hI:=idxOf_le u h4 have h6:=B.toNat_lt have e1:(iW u+149 - B).toNat=(2^64 - B.toNat+(idxOf u+149) % 2^64) % 2^64:=by rw[Ε,θ,hi];rfl have h7:mW u=0∨((iW u+149 - B).toNat≤62 ∧ (iW u+149 - B).toNat=idxOf u+149 - B.toNat∧B.toNat≤ idxOf u+149):=by by_cases h0:mW u=0 ·exact .inl h0 ·have:(iW u+149 - B).toNat≤62:=ε.mp (UInt64.not_lt.mp (h5 h0)) have hi':idxOf u+149<2^64:=by clear * - hI;omega rw[e1,γ hi'] at this ⊢;clear * - this hB hi' h6 rcases Nat.lt_or_ge (idxOf u+149) B.toNat with hl | hl ·rw[γ (А)] at this;omega ·rw[Nat.mod_eq_sub_mod (А),γ (А)] at this ⊢ exact .inr ⟨this,by omega,hl⟩ obtain ⟨hz,hy⟩ := fO _ _ (by rw[af];exact hm) (h7.imp id (·.1)) have hX:(mantOf u:Int)*2^(idxOf u+149) = ((mW u).toNat*2^(iW u+149 - B).toNat:Nat)*2^B.toNat:=by rcases h7 with h0 | ⟨-,h1,h2⟩ ·simp[show mantOf u=0 by rw[← af,h0];rfl,h0] ·rw[af,h1];push_cast rw[mul_assoc,← pow_add,show idxOf u+149 - B.toNat+B.toNat=idxOf u+149 by omega] have h8:(mW u).toNat*2^(iW u+149 - B).toNat<2^86:=by rcases h7 with h0 | ⟨h0,-⟩ ·simp[h0] ·exact pw _ _ 62 (by rw[af];exact hm) h0 rw[aZ] generalize (mW u).toNat*2^(iW u+149 - B).toNat=X at hz hy hX h8 generalize am (mW u) (iW u+149 - B)=lo at hz ⊢ generalize ap (mW u) (iW u+149 - B)=hi at hy ⊢ have h9:(X:Int)=hi.toNat*2^25+lo.toNat:=by rw[hz,hy];push_cast;omega unfold sv cases signOf u<;>simp only[fT,ite_false,ite_true] ·exact ⟨h4,lo.toNat,hi.toNat,by rw[abs_lt];omega,by rw[abs_lt];omega,bM _,bM _,by rw[hX,h9]⟩ ·refine ⟨h4,-(lo.toNat:Int),-(hi.toNat:Int),by rw[abs_lt];omega,by rw[abs_lt];omega,?_,?_, by rw[neg_mul,hX,h9];ring⟩<;>(rw[cF,bC,bM];push_cast;ring) def pv (q l:Nat):Int:=if l< nl t then (P[q+l]!.toNat:Int) else 0 abbrev St (f:Kc→ Д) (a b c:Д) (F:Nat→ Int):Prop := ∃ a' b' c',(∀ k,f k=k a' b' c') ∧ ∀ l<3,Z (a6 a' b' c' l)=Z (a6 a b c l)+(F l:ZMod (2^64)) lemma bR (f:Kc→ Д) (g:Д→ Д→ Д→ Kc→ Д) (a b c:Д) (F G:Nat→ Int) (hf:St f a b c F) (hg : ∀ a b c,St (g a b c) a b c G) : St (fun k=>f fun a b c=>g a b c k) a b c fun l=>F l+G l:=by obtain ⟨a1,b1,c1,e1,z1⟩ := hf obtain ⟨a2,b2,c2,e2,z2⟩ := hg a1 b1 c1 exact ⟨a2,b2,c2,fun k=>by simp only[e1,e2],fun l hl=>by rw[z2 l hl,z1 l hl];push_cast;ring⟩ lemma ec {f:Kc→ Д} {a b c:Д} {F G:Nat→ Int} (h:St f a b c F) (e : ∀ l,F l=G l):St f a b c G:=by obtain ⟨a',b',c',h1,h2⟩ := h;exact ⟨a',b',c',h1,fun l hl=>by rw[h2 l hl,e]⟩ lemma i8 (a b:USize) (h:a.toNat+b.toNat<2^32):(a+b).toNat=a.toNat+b.toNat:=by rw[Ι];exact mo (lt_of_lt_of_le h bK) lemma ug (h:e.toNat< P.size) : Z (P.uget e h).toUInt64=(P[e.toNat]!.toNat:ZMod (2^64)):=by rw[gv,getElem!_pos P _ h];rfl lemma uw (h:j.toNat< W.size) : Z (wv (W.uget j h))=(wI W j.toNat:ZMod (2^64)):=by rw[g9,wI,getElem!_pos W _ h];push_cast;rfl lemma eg (h:e.toNat+2< P.usize.toNat∧j.toNat< W.usize.toNat) (a b c:Д) : St (gL t P W e j h a b c) a b c fun l=>pv t P e.toNat l*wI W j.toNat:=by have h1:=ix P e 1 (Б) h.1 have h2:=ix P e 2 (Б) h.1 have:=de P;have:=de W refine ⟨_,_,_,fun k=>rfl,fun l hl => ?_⟩ interval_cases l ·simp only[a6,pv,if_pos (bG t)] rw[cn,eO,ug,uw,Τ];push_cast;ring ·simp only[a6,pv,if_pos (show 1< nl t by cases t<;>decide)] rw[cn,eO,ug,uw,h1.1];push_cast;ring ·cases t ·simp[a6,pv,nl] ·simp only[a6,pv,nl,ite_true,show (2:Nat)<3 from by decide] rw[cn,eO,ug,uw,h2.1];push_cast;ring lemma d7 (h:e.toNat+2*nl t+2< P.usize.toNat∧j.toNat+2< W.usize.toNat) (a b c:Д) : St (ac t P W e j h a b c) a b c fun l => ∑ d∈ range 3,pv t P (e.toNat+nl t*d) l*wI W (j.toNat+d):=by have hs:=f3 t have h1:(e+sU t).toNat=e.toNat+nl t:=by rw[fB _ _ P.usize (А),hs] have h2:(e+sU t+sU t).toNat=e.toNat+nl t*2:=by rw[fB _ _ P.usize (А),h1,hs];ring have j1:(j+1).toNat=j.toNat+1:=(ix W j 1 (Б) h.2).1 have j2:(j+2).toNat=j.toNat+2:=(ix W j 2 (Б) h.2).1 have:=bR _ _ _ _ _ _ _ (eg t P W e j ⟨by omega,by omega⟩ a b c) fun a b c => bR _ _ _ _ _ _ _ (eg t P W (e+sU t) (j+1) ⟨by omega,by omega⟩ a b c) fun a b c => eg t P W (e+sU t+sU t) (j+2) ⟨by omega,by omega⟩ a b c refine ec this fun l => ?_ simp only[h1,h2,j1,j2,Λ,Finset.sum_range_zero,Nat.mul_zero,Τ, ϩ,zero_add] ring def d5 (R n d:Nat):Nat:=d / 3*R+n*(d % 3) lemma g5 (R i j:USize) (a b c:Д) (h:i<0x40000000∧R<0x10000000∧j<0x40000000∧i+R+R+cW t< P.usize∧j+8< W.usize) : St (fun k=>cD t P W R i j a b c k) a b c fun l => ∑ d∈ range 9,pv t P (i.toNat+d5 R.toNat (nl t) d) l*wI W (j.toNat+d):=by obtain ⟨-,-,e1,e2,hP,j3,j6,hW⟩ := iN h have:=bR _ _ _ _ _ _ _ (d7 t P W i j ⟨by omega,by omega⟩ a b c) fun a b c => bR _ _ _ _ _ _ _ (d7 t P W (i+R) (j+3) ⟨by omega,by omega⟩ a b c) fun a b c => d7 t P W (i+R+R) (j+6) ⟨by omega,by omega⟩ a b c simp only[cD,dif_pos h] refine ec this fun l => ?_ simp only[e1,e2,j3,j6,Λ,Finset.sum_range_zero,d5] ring_nf lemma iT (win:USize→ USize→ Д→ Д→ Д→ Kc→ Д) (fn:Kc) (n di dj i j:USize) : (if n=1 then fun a b c=>win i j a b c fn else bt win fn n di dj 0 i j)=bt win fn n di dj 0 i j:=by split ·subst_vars;funext a b c rw[bt,dif_pos (μ.mpr (by simp))];congr;funext a b c;rw[bt,dif_neg (by simp)] ·rfl lemma fE (win:USize→ USize→ Д→ Д→ Д → Kc→ Д) (fn:Kc) (n di dj:USize) (G:Nat→ Nat→ Nat→ Int) (hd:di.toNat<2^30∧dj.toNat<2^30) (hw : ∀ i j a b c,(∀ k,win i j a b c k=0x100000000) ∨ (i.toNat<2^30∧j.toNat<2^30∧St (fun k=>win i j a b c k) a b c fun l=>G l i.toNat j.toNat)) : ∀ m k i j a b c,n.toNat - k.toNat=m→ bt win fn n di dj k i j a b c<0x100000000 → ∃ a' b' c',bt win fn n di dj k i j a b c=fn a' b' c' ∧ ∀ l<3,Z (a6 a' b' c' l) = Z (a6 a b c l)+((∑ q∈ range m,G l (i.toNat+q*di.toNat) (j.toNat+q*dj.toNat):Int) : ZMod (2^64)):=by intro m induction m with | zero => intro k i j a b c hm h1 have hk:¬ k< n:=by rw[μ];omega rw[bt,dif_neg hk] at h1 ⊢ exact ⟨a,b,c,rfl,fun l _=>by simp⟩ | succ m ih => intro k i j a b c hm h1 have hk:k< n:=by rw[μ];omega rw[bt,dif_pos hk] at h1 ⊢ rcases hw i j a b c with h0 | ⟨hi,hj,a1,b1,c1,e1,z1⟩ ·rw[h0] at h1;exact absurd h1 (Б) simp only[e1] at h1 ⊢ have h2:(k+1).toNat=k.toNat+1:=by rw[Ι,USize.toNat_one, mo (lt_of_le_of_lt (μ.mp hk) n.toNat_lt_size)] obtain ⟨a',b',c',h3,hz⟩ := ih (k+1) (i+di) (j+dj) a1 b1 c1 (by rw[h2];omega) h1 refine ⟨a',b',c',h3,fun l hl => ?_⟩ have hs : ∑ q∈ range m,G l ((i+di).toNat+q*di.toNat) ((j+dj).toNat+q*dj.toNat) = ∑ q∈ range m,G l (i.toNat+(q+1)*di.toNat) (j.toNat+(q+1)*dj.toNat) := χ rfl fun q _=>by rw[i8 _ _ (А),i8 _ _ (А),show i.toNat+di.toNat+q*di.toNat = i.toNat+(q+1)*di.toNat by ring,show j.toNat+dj.toNat+q*dj.toNat = j.toNat+(q+1)*dj.toNat by ring] rw[hz l hl,z1 l hl,hs,ϟ] simp only[ϡ,Τ];push_cast;ring lemma bc:ok C E 0=true:=rfl lemma bD (a:Array Е) (p:Е→ Bool) (h:a.all p=true) (h0:p 0=true) (q:Nat) : p a[q]! = true:=by by_cases hq:q< a.size ·rw[getElem!_pos a q hq];exact Array.all_eq_true.mp h q hq ·rw[getElem!_neg a q hq];exact h0 lemma iz (h:I.all (ok C E)=true) (y x i:Nat) : ok C E (windowAt s I y x i)=true:=by unfold windowAt;dsimp only;split ·exact bc C E ·exact bD I _ h (bc C E) _ lemma g6 (hs:s.kh=3∧s.kw=3∧s.stride=1∧s.pad=1) (y x c d:Nat) (hd:d<9) : windowAt s I y x (c*9+d)=a8 s.h s.w I c (y+d / 3) (x+d % 3):=by have e:(c*(3*3)+d) / (3*3)=c∧(c*(3*3)+d) / 3 % 3=d / 3 ∧ (c*(3*3)+d) % 3=d % 3:=А unfold windowAt a8 simp only[hs.1,hs.2.1,hs.2.2.1,hs.2.2.2,e.1,e.2.1,e.2.2,ϩ] lemma f8 (h0:bw.toNat≤255) (h1:K.all (ok 7 bw)=true) (q:Nat) (hq:q< K.size):wI (K.map (b7 bw)) q=aq bw.toNat K[q]! := by unfold wI rw[getElem!_pos _ q (by simpa using hq),Array.getElem_map,← getElem!_pos K q hq] have:=(dl bw K[q]! h0 (bD K _ h1 (bc _ _) q)).1;omega lemma g1 (F:Nat→ Int) : ∑ q∈ range n,∑ d∈ range m,F (q*m+d) = ∑ u∈ range (n*m),F u:=by induction n with | zero=>simp | succ n ih=>rw[Λ,ih,Ϣ,Finset.sum_range_add] lemma ws (R:USize) : ∀ i j a b c,(∀ k,cD t P W R i j a b c k=0x100000000)∨(i.toNat<2^30∧j.toNat<2^30 ∧ St (fun k=>cD t P W R i j a b c k) a b c fun l => ∑ d∈ range 9,pv t P (i.toNat+d5 R.toNat (nl t) d) l*wI W (j.toNat+d)):=by intro i j a b c by_cases h:i<0x40000000∧R<0x10000000∧j<0x40000000∧i+R+R+cW t< P.usize∧j+8< W.usize ·obtain ⟨hi,hj,-⟩ := iN h;exact .inr ⟨hi,hj,g5 t P W R i j a b c h⟩ ·exact .inl fun k=>by unfold cD;exact dif_neg h lemma iA (hs:s.kh=3∧s.kw=3∧s.stride=1∧s.pad=1) (bx:Д) (h0:I.all (ok (if t then 50 else 25) bx)=true) {nc Y cb o y x k H V:Nat} {bw sw l h:Д} {W:Array Е} (hH:H=s.h+2) (hV:V=s.w+2) (h3:k=nc*9) (hW:W=K.map (b7 bw)) (h4:sw=cC W (o*k) k) (hl:l=bL (bx+bw) b[o]!) (hh:h=bH (bx+bw) b[o]!) (hg:cG k bx s K Y bw H V) (ho:o< Y) (hy:y< s.h) (hx:x< s.w) (hB:cb+nc≤ s.cin) : (let r:=gz t (fL t s.h s.w s.cin bx I) W (bx+bw) l h (nl t*V).toUSize (nl t*(H*V)).toUSize nc.toUSize (nl t*(cb*(H*V)+y*V+x)).toUSize (o*k).toUSize sw if r<0x100000000 then r.toUInt32 else fI s I K b 9 k cb o y x)=fI s I K b 9 k cb o y x:=by dsimp only;split swap;· rfl rename_i hr subst hW h4 hl hh obtain ⟨h5,h6,h7,hk,-,-,hh,hw,h8,h9,hA⟩ := hg generalize hP:fL t s.h s.w s.cin bx I=P at hr ⊢ have hC:=ck h5 have hD:=ck h6 have hE:(bx+bw).toNat=bx.toNat+bw.toNat:=by rw[θ];omega have hF:nl t≤3:=by cases t<;>decide have hG:H*V≤4097*4097:=Nat.mul_le_mul (А) (А) have:=ϧ (nl t) hG have hI:y*V+x< H*V:=by have:=τ V (show y+1≤ H by omega);rw[϶] at this;omega have:cb*(H*V)≤ s.cin*(H*V):=τ _ (А) have hJ:(o+1)*k≤ Y*k:=τ _ ho rw[϶] at hJ have hK:nc≤95:=А have u1:=ab (nl t*(cb*(H*V)+y*V+x)) (by have:=ϧ (nl t) (show cb*(H*V)+y*V+x≤2^27 by omega);omega) have u2:=ab (nl t*(H*V)) (А) have u3:=ab (nl t*V) (by have:=ϧ (nl t) (show V≤4097 by omega);omega) have u4:=ab (o*k) (А) have u5:(9:USize).toNat=9:=b9 9 (Б) have u6:=ab nc (А) have hl:bL (bx+bw) b[o]! ≠ 0x100000000:=fun e=>by simp[gz,e] at hr unfold gz at hr ⊢;rw[if_neg hl,iT] at hr ⊢ obtain ⟨hL,Lb,Hb,hM,hN,hO,hQ,hR⟩ := fD _ _ (А) hl obtain ⟨a',b',c',hT,hz⟩ := fE _ _ _ _ _ (fun l i j => ∑ d∈ range 9, pv t P (i+d5 (nl t*V).toUSize.toNat (nl t) d) l*wI (K.map (b7 bw)) (j+d)) (by rw[u2,u5];omega) (ws t P _ _) nc 0 _ _ _ _ _ (by rw[u6];rfl) hr rw[hT] at hr ⊢ simp only[u1,u2,u3,u4,u5] at hz have hU : ∀ u,ok (if t then 50 else 25) bx (windowAt s I y x (cb*9+u))=true := fun u=>iz _ _ s I h0 y x _ have hX : ∀ u< k,o*k+u< K.size:=fun u hu=>А have hY : ∀ l,∑ q∈ range nc,∑ d∈ range 9, pv t P (nl t*(cb*(H*V)+y*V+x)+q*(nl t*(H*V))+d5 (nl t*V) (nl t) d) l * wI (K.map (b7 bw)) (o*k+q*9+d) = ∑ u∈ range k,(if l< nl t then ((aQ t bx (windowAt s I y x (cb*9+u)) l).toNat:Int) else 0)*aq bw.toNat (if u< k then K[o*k+u]! else b[o]!):=by intro l rw[show range k=range (nc*9) by rw[h3],← g1] refine χ rfl fun q hq=>χ rfl fun d hd => ?_ have hq:=mr hq;have hd:=mr hd have hu:q*9+d< k:=А rw[if_pos hu];unfold pv;split_ifs with hl ·have e:nl t*(cb*(H*V)+y*V+x)+q*(nl t*(H*V))+d5 (nl t*V) (nl t) d+l = nl t*(((cb+q)*H+(y+d / 3))*V+(x+d % 3))+l:=by unfold d5;ring subst hH hV rw[← hP,e,gU t s.h s.w s.cin bx I _ _ _ l (А) (А) (А) hl (by have:=τ (s.cin*((s.h+2)*(s.w+2))) hF;omega),← g6 s I hs y x _ d hd, show (cb+q)*9+d=cb*9+(q*9+d) by ring,Nat.add_assoc,f8 K _ hD h7 _ (hX _ hu)] ·simp unfold fI refine (gP t k _ _ bx.toNat bw.toNat _ hE hk (fun u hu => ?_) (fun u hu => ?_) (by simp) (by simpa using hL) (fun l u=>(if l< nl t then ((aQ t bx (windowAt s I y x (cb*9+u)) l).toNat:Int) else 0) - (if l< nl t then 2^24 else 0)) (fun l _ u _ => ?_) (fun ht u _ => ?_) (fun u hu => ?_) (fun u hu => ?_) Lb Hb hM hN (by simpa using hR) a' b' c' (fun l hl => ?_) hr).symm ·simp only[if_pos hu] obtain ⟨h1,h2⟩ := a9 _ bx _ hC (by cases t<;>decide) (hU u);exact ⟨h1,by omega⟩ ·simp only[if_pos hu] obtain ⟨h1,h2⟩ := a9 7 _ _ hD (Б) (bD K _ h7 (bc _ _) _);exact ⟨h1,by omega⟩ ·split_ifs with hl ·have:=(dY t bx _ hC (hU u)).1 l hl;rw[abs_le];constructor<;>omega ·simp ·subst ht;simp[nl] ·have:=(dY t bx _ hC (hU u)).2 simp only[if_pos hu];cases t<;>simp +decide only[ite_true,ite_false] at this ⊢<;>omega ·simp only[if_pos hu] have:=(dl _ _ hD (bD K _ h7 (bc _ _) (o*k+u))).2;exact this ·beta_reduce rw[hz l hl,hY l] have hS:Z (cC (K.map (b7 bw)) (o*k) k)=((∑ u∈ range k, aq bw.toNat (if u< k then K[o*k+u]! else b[o]!):Int):ZMod (2^64)):=by rw[f5];congr 1 exact χ rfl fun u hu=>by rw[if_pos (mr hu)];exact f8 K _ hD h7 _ (hX u (mr hu)) simp only[sub_mul,Finset.sum_sub_distrib,← Finset.mul_sum] interval_cases l<;>cases t <;> simp +decide only[a6,ite_true,ite_false,cF,iR,bC,hO,hQ,hS, Int.cast_add,Int.cast_sub,Int.cast_mul,Int.cast_pow,Int.cast_ofNat,Int.cast_zero,zero_mul, sub_zero]<;>ring lemma ca [Inhabited α] (n:Nat) (f:Fin n→ α) (i:Nat) (h:i< n) : (Array.ofFn f)[i]! = f ⟨i,h⟩ := by rw[getElem!_pos _ i (by simpa using h)];simp lemma jp (A x:Nat):(nl t*A).toUSize+sU t*x.toUSize=(nl t*(A+x)).toUSize:=by show USize.ofNat _+_=USize.ofNat _ rw[Nat.mul_add,USize.ofNat_add,USize.ofNat_mul (nl t) x];cases t<;>rfl lemma mU (a b:Nat):a.toUSize*b.toUSize=(a*b).toUSize:=(USize.ofNat_mul a b).symm lemma fF (bx:Д) (h0:I.all (ok (if t then 50 else 25) bx)=true) (hs:s.kh=3∧s.kw=3∧s.stride=1∧s.pad=1) (hd:D=false∧nc=s.cin∧Y=s.cout∨D=true∧nc=1∧Y=s.cin) : gy t s J I K b D nc Y bx h0 = dS s J I K b D:=by unfold gy rcases hd with ⟨rfl,rfl,rfl⟩ | ⟨rfl,rfl,rfl⟩ <;> simp only[dS,fT,ite_true,ite_false]<;>split <;> try rfl all_goals rename_i hg have ⟨_,_,_,_,h5,h6,_⟩ := hg have hA:s.ho=s.h:=by simp[ConvShape.ho,hs];omega have hB:s.wo=s.w:=by simp[ConvShape.wo,hs];omega rw[gl _ _ _ _ _ _ _ h5,Υ _ s.h s.w] simp only[conv2dSpec,conv2dWith,depthwiseSpec,depthwiseWith,hA,hB] refine Array.ext (by simp[hA,hB]) fun q h1 _ => ?_ rw[ϕ] at h1 have ho:=(ϭ (Ϻ h5 h6)).mpr h1 simp only[aE,Θ] congr 1 rw[jp,mU] refine (iA t s I K b hs bx h0 rfl rfl rfl rfl (ca _ _ _ ho) (ca _ _ _ ho) (ca _ _ _ ho) hg ho (Ν _ h5) (Ν _ h6) (А)).trans ?_ unfold fI;simp only[hs.1,hs.2.1,Υ,Nat.one_mul,ϡ,Ο] lemma fH (hd:D=false∧nc=s.cin∧Y=s.cout∨D=true∧nc=1∧Y=s.cin) : gA s J I K b D nc Y = dS s J I K b D:=by unfold gA;dsimp only;split rename_i hs;split exact fF false s J I K b D nc Y _ _ hs hd split exact fF true s J I K b D nc Y _ _ hs hd all_goals rfl lemma dg:dR=conv2dSpec:=by funext s J I K b exact fH s J I K b false s.cin s.cout (.inl ⟨rfl,rfl,rfl⟩) lemma dT:dh=depthwiseSpec:=by funext s J I K b exact fH s J I K b true 1 s.cin (.inr ⟨rfl,rfl,rfl⟩) lemma bp:(expOf u).toNat=u.toNat / 2^23 % 256:=by unfold expOf rw[ό,ϝ,show (0xFF:Е).toNat=2^8 - 1 from rfl, ξ] simp[ζ] lemma a7:(fracOf u).toNat=u.toNat % 2^23:=by unfold fracOf rw[ό,show (0x7FFFFF:Е).toNat=2^23 - 1 from rfl,ξ] def Kf:Nat := (if m / 2^23=0 then m % 2^23 else 2^23+m % 2^23)*2^(if m / 2^23=0 then 0 else m / 2^23 - 1) lemma iv:mantOf u*2^idxOf u=Kf (u.toNat % 2^31):=by have h1:u.toNat % 2^31 / 2^23=(expOf u).toNat:=by rw[bp];omega have h2:u.toNat % 2^31 % 2^23=(fracOf u).toNat:=by rw[a7];exact Nat.mod_mod_of_dvd _ (Б) have h3:expOf u=0↔(expOf u).toNat=0:=by rw[← Β,UInt32.toNat_zero] unfold mantOf idxOf Kf rw[h1,h2] by_cases he:expOf u=0 ·rw[if_pos he,if_pos he,if_pos (h3.mp he),if_pos (h3.mp he)] ·rw[if_neg he,if_neg he,if_neg (mt h3.mpr he),if_neg (mt h3.mpr he)] lemma iQ:Kf m<2^(m / 2^23+23):=by unfold Kf split_ifs with h ·rw[h];simpa using Ν m (show 0<2^23 by norm_num) ·have:=υ (show 2^23+m % 2^23<2^24 by omega) (Nat.two_pow_pos (m / 2^23 - 1)) rwa[← pow_add,show 24+(m / 2^23 - 1)=m / 2^23+23 by omega] at this lemma gN (m1 m2:Nat) (h:m1< m2):Kf m1< Kf m2:=by rcases Nat.eq_or_lt_of_le (Nat.div_le_div_right (c:=2^23) h.le) with h3 | h4 ·unfold Kf;rw[h3] split_ifs with h0 ·omega ·exact υ (А) (В) ·have h1:=iQ m1 have h2:2^(m2 / 2^23+22)≤ Kf m2:=by unfold Kf;rw[if_neg (А),if_neg (А)] calc 2^(m2 / 2^23+22)=2^23*2^(m2 / 2^23 - 1):=by rw[← pow_add];congr 1;omega _≤ _:=τ _ (А) have:=ψ (show 0<2 by norm_num) (show m1 / 2^23+23≤ m2 / 2^23+22 by omega) omega def kv (w:Word):Int:=sv w*2^idxOf w lemma it : kv u=if 2^31≤ u.toNat then -(Kf (u.toNat % 2^31):Int) else (Kf (u.toNat % 2^31):Int):=by unfold kv sv;rw[← iv];simp only[← aG];split_ifs<;>push_cast<;>ring lemma f4 : (sk u).toNat=if u.toNat<2^31 then u.toNat+2^31 else if u.toNat=2^31 then 2^31 else 2^32 - 1 - u.toNat:=by have:=u.toNat_lt unfold sk;split_ifs<;>simp_all[Ρ,← Β,UInt32.toNat_sub]<;>omega lemma gH (a b:Е):sk a< sk b↔kv a< kv b:=by rw[Ρ,f4,f4,it,it] have hK:StrictMono Kf:=fun m1 m2 h=>gN m1 m2 h have hz:Kf 0=0:=Б have ha:=a.toNat_lt have hb:=b.toNat_lt generalize a.toNat=x at * generalize b.toNat=y at * rcases lt_trichotomy x (2^31) with hx | rfl | hx<;>rcases lt_trichotomy y (2^31) with hy | rfl | hy ·rw[if_pos hx,if_pos hy,if_neg (not_le.mpr hx),if_neg (not_le.mpr hy),γ hx, γ hy,Nat.add_lt_add_iff_right,Int.ofNat_lt,hK.lt_iff_lt] ·rw[if_pos hx,if_neg (lt_irrefl _),if_pos rfl,if_neg (not_le.mpr hx),if_pos le_rfl,Nat.mod_self,hz] exact iff_of_false (А) (А) ·rw[if_pos hx,if_neg (not_lt.mpr hy.le),if_neg hy.ne',if_neg (not_le.mpr hx),if_pos hy.le] exact iff_of_false (А) (А) ·rw[if_neg (lt_irrefl _),if_pos rfl,if_pos hy,if_pos le_rfl,if_neg (not_le.mpr hy),Nat.mod_self,hz, γ hy] exact ⟨fun h=>by have:=hK (show 0< y by omega);omega, fun h=>by have:=hK.lt_iff_lt.mp (show Kf 0< Kf y by omega);omega⟩ ·exact iff_of_false (lt_irrefl _) (lt_irrefl _) ·rw[if_neg (lt_irrefl _),if_pos rfl,if_neg (not_lt.mpr hy.le),if_neg hy.ne',if_pos le_rfl,if_pos hy.le, Nat.mod_self,hz] exact iff_of_false (А) (А) ·rw[if_neg (not_lt.mpr hx.le),if_neg hx.ne',if_pos hy,if_pos hx.le,if_neg (not_le.mpr hy)] exact iff_of_true (А) (by have:=hK (show 0< x % 2^31 by omega);omega) ·rw[if_neg (not_lt.mpr hx.le),if_neg hx.ne',if_neg (lt_irrefl _),if_pos rfl,if_pos hx.le,if_pos le_rfl, Nat.mod_self,hz] exact iff_of_true (А) (by have:=hK (show 0< x % 2^31 by omega);omega) ·rw[if_neg (not_lt.mpr hx.le),if_neg hx.ne',if_neg (not_lt.mpr hy.le),if_neg hy.ne',if_pos hx.le, if_pos hy.le,Int.neg_lt_neg_iff,Int.ofNat_lt,hK.lt_iff_lt] omega lemma il:Model.cmpDyadic (decodeD y) (decodeD z)=compare (kv y) (kv z):=by have hr : ∀ w,(decodeD w).toReal=(kv w : ℝ)*2^(-149:Int):=fun w=>by rw[← FloatLib.Numerics.Dyadic.cast_toRat,decodeD_toRat];unfold kv;push_cast rw[zpow_sub₀ two_ne_zero,zpow_natCast];ring have hs:(0 : ℝ)<2^(-149:Int):=zpow_pos two_pos _ cases h:compare (kv y) (kv z) ·rw[Model.cmpDyadic_lt_iff,hr,hr] exact mul_lt_mul_of_pos_right (by exact_mod_cast compare_lt_iff_lt.mp h) hs ·rw[Model.cmpDyadic_eq_iff,hr,hr,compare_eq_iff_eq.mp h] ·rw[Model.cmpDyadic_gt_iff,hr,hr] exact mul_lt_mul_of_pos_right (by exact_mod_cast compare_gt_iff_gt.mp h) hs lemma cY (hm:mantOf u=0):u=0∨u=0x80000000:=by have ha:=u.toNat_lt unfold mantOf at hm split_ifs at hm with h0 ·have he:=bp u have hf:=a7 u rw[h0] at he;rw[hm] at hf rw[← Β,← Β];simp at he ⊢;omega ·omega lemma gW:ofW (mx y z)=Model.maximum (ofW y) (ofW z):=by unfold mx split ·rename_i h have ha:=toDyadic_ofUInt32 y h.1 have hb:=toDyadic_ofUInt32 z h.2.1 have hc:Model.compare (ofW y) (ofW z)=some _:=Model.compare_eq_some_cmpDyadic_of_toDyadic? _ _ ha hb rw[il] at hc have hn:Model.chooseNaN2 (ofW y) (ofW z)=none:=(Model.chooseNaN2_eq_none_iff _ _).2 ⟨Κ ha,Κ hb⟩ unfold Model.maximum rw[Model.withNaNSelection_of_none _ _ hn] dsimp only rw[Model.compareNonNaN_eq_of_compare_eq_some _ _ _ _ hc] rcases h.2.2 with h1 | h1 | rfl ·rw[if_pos h1,compare_lt_iff_lt.mpr ((gH y z).mp h1)] ·rw[if_neg (UInt32.lt_asymm h1),compare_gt_iff_gt.mpr ((gH z y).mp h1)] ·rw[if_neg (UInt32.lt_irrefl _),compare_eq_iff_eq.mpr rfl] by_cases hm:mantOf y=0 ·rcases cY y hm with rfl | rfl<;>decide ·have hz:Model.isZero (ofW y)=false:=by unfold ofW rw[Model.isZero_eq_beq_zero_of_toDyadic?_some ha,decodeD_sig_zero];simpa using hm simp[hz] ·exact fo _ lemma gn (w k U n:Nat) (hk:0< k) (acc:Word) : ofW (wl mx I w k n U 0 acc) = (List.range n).foldl (fun m t=>Model.maximum m (ofW I[U+t / k*w+t % k]!)) (ofW acc):=by rw[iO _ _ _ _ _ _ _ hk,List.foldl_hom ofW] exact fun _ _=>(gW _ _).symm lemma go:fk=maxpoolSpec:=by funext c h w k I unfold fk split ·rename_i hk rw[f7] refine Array.ext (by simp[maxpoolSpec]) fun q _ _ => ?_ simp only[aE,Θ,maxpoolSpec] rw[← fs (wl _ _ _ _ _ _ _ _),gn I w k _ (k*k) hk.1] simp only[poolAt] congr 2 ·funext acc t;congr 2;ring ·congr 1;simp only[Nat.zero_div,Nat.zero_mod];ring ·rfl lemma iL : Model.NativeBinary32.toUInt32 (Model.ofUInt32 u:Model Fmt)=u:=by show UInt32.ofBitVec (Model.ofUInt32 u:Model Fmt).bits=u rw[ofUInt32_bits] lemma be (h0:expOf u≠0) : decodeD u=⟨signOf u,2^23+(fracOf u).toNat,((expOf u).toNat:Int) - 150⟩ := by unfold decodeD;rw[if_neg h0] lemma dz (f:Nat) (hf:f<2^23) : FloatLib.Numerics.RationalBinary.floorLog2 (2^23+f) (2^23)=0:=by unfold FloatLib.Numerics.RationalBinary.floorLog2 have h1:(2^23+f).log2=23:=by rw[Nat.log2_eq_iff (А)];constructor<;>omega have h2:(2^23:Nat).log2=23:=Nat.log2_two_pow simp only[h1,h2,sub_self] have h3:FloatLib.Numerics.RationalBinary.lessThanPowerOfTwo (2^23+f) (2^23) 0=false:=by show decide (2^23+f< Nat.shiftLeft (2^23) 0)=false simp[ι] have h4:FloatLib.Numerics.RationalBinary.atLeastPowerOfTwo (2^23+f) (2^23) (0+1)=false:=by show decide (2^23+f≥ Nat.shiftLeft (2^23) 1)=false simp[ι];omega simp only[h3,h4,fT,ite_false] lemma f1:FloatLib.Numerics.roundQuotientEven (m*2^23) (2^23)=m:=by unfold FloatLib.Numerics.roundQuotientEven simp only[Nat.mul_mod_left,Nat.mul_zero,Nat.mul_div_cancel _ (by norm_num:0<2^23)] simp lemma im (q:Е) (h0:fracOf d=0) (h1:signOf d=false) (hq:(expOf d).toNat=q.toNat+127) (h2:expOf d≠255) (h3:q.toNat<(expOf r).toNat) (h4:expOf r≠255) : toWord (Model.div (ofW r) (ofW d))=r - (q <<< 23):=by have h5:=bp r have h6:=a7 r have h7:(expOf r).toNat≠255:=fun h=>h4 (Β.mp (by simpa using h)) have h8:expOf r≠0:=fun h=>by simp[h] at h3 have h9:expOf d≠0:=fun h=>by simp[h] at hq have hf:=fracOf_toNat_lt r rw[Model.Proof.div_eq_spec] unfold Model.Spec.div ofW rw[toDyadic_ofUInt32 r h4,toDyadic_ofUInt32 d h2,be r h8,be d h9, h0,h1] have hA:((2:Nat)^23 == 0)=false:=Б have hB:(2^23+(fracOf r).toNat == 0)=false:=by simp simp only[UInt32.toNat_zero,Τ,Bool.xor_false,hA,hB,fT,ite_false] change toWord (Model.roundRatScaled FloatFormat.binary32 (signOf r) (2^23+(fracOf r).toNat) (2^23) _)=_ rw[← Model.NativeBinary32.ofUInt32_roundRatScaled, bV] unfold Model.NativeBinary32.roundRatScaled rw[dz _ hf] simp only[hA,hB,fT,ite_false,zero_add,sub_zero] rw[if_neg (А),if_neg (А),if_neg (А)] have hC:(2^23+(fracOf r).toNat).shiftLeft 23=(2^23+(fracOf r).toNat)*2^23 := ι _ _ rw[show ((23:Int))=Int.ofNat 23 from rfl, FloatLib.Numerics.RationalBinary.scaleByPowerOfTwo_ofNat] simp only[hC,f1] have hc:((2^23+(fracOf r).toNat:Nat) == Model.pow2 24)=false:=by simp[Model.pow2];omega simp only[hc,fT,ite_false] rw[if_neg (А)] set s':=r - (q <<< 23) with hD have hF:(q <<< 23).toNat=q.toNat*2^23:=by rw[UInt32.toNat_shiftLeft];simp[ι];omega have hG:s'.toNat=r.toNat - q.toNat*2^23:=by rw[hD,UInt32.toNat_sub_of_le _ _ (by rw[UInt32.le_iff_toNat_le,hF];omega),hF] rw[← Model.NativeBinary32.toUInt32_ofFields] conv_rhs=>rw[← iL s',ofUInt32_eq_ofFields] have hH:signOf s'=signOf r:=by rw[Ϟ,aG,aG,hG];omega have hI:(expOf s').toNat=(expOf r).toNat - q.toNat:=by rw[bp s',hG];omega have hJ:(fracOf s').toNat=(fracOf r).toNat:=by rw[a7 s',hG];omega have hE:Int.toNat (((expOf r).toNat:Int) - 150 - (((expOf d).toNat:Int) - 150)+127) = (expOf r).toNat - q.toNat:=А rw[hH,hI,hJ,hE,show Model.pow2 23=2^23 by decide,Nat.add_sub_cancel_left] rfl lemma iZ (s:Word) (h:s &&& 0x7FFFFFFF=0):s=0∨s=0x80000000:=by have hs:=s.toNat_lt have h1:(s &&& 0x7FFFFFFF).toNat=s.toNat % 2^31:=by rw[ό,show (0x7FFFFFFF:Е).toNat=2^31 - 1 from rfl, ξ] rw[h] at h1 rw[← Β,← Β];simp at h1 ⊢;omega lemma cK (hs:r=0∨r=0x80000000) (h0:expOf d≠0) (h1:expOf d≠255) (h2:signOf d=false) : toWord (Model.div (ofW r) (ofW d))=r:=by have h3:expOf r≠255:=by rcases hs with rfl | rfl<;>decide have hz:decodeD r=⟨signOf r,0,0⟩ := by rcases hs with rfl | rfl<;>rfl rw[Model.Proof.div_eq_spec] unfold Model.Spec.div ofW rw[toDyadic_ofUInt32 r h3,toDyadic_ofUInt32 d h1,be d h0,h2,hz] have h4:(2^23+(fracOf d).toNat == 0)=false:=by simp simp only[h4,fT,ite_false,beq_self_eq_true,ite_true,Bool.xor_false] rcases hs with rfl | rfl<;>rfl lemma bn {a b:Е} (h:a< b):a≠ b:=fun e=>by have:=Ρ.mp h;rw[e] at this;omega abbrev av:Word:=toWord (Model.div (ofW (dotOf n fa fun _=>oneW)) (ofW d)) lemma gO (hD:DQ d):gb r d=toWord (Model.div (ofW r) (ofW d)):=by obtain ⟨h0,h1,h2⟩ := hD have h5:expOf d≠255:=bn h2 unfold gb;dsimp only split ·obtain ⟨h6,h7,h3,h4⟩ := ‹_∧_› have h8:(expOf d).toNat=(expOf d - 127).toNat+127:=by rw[UInt32.toNat_sub_of_le _ _ h7] have:=UInt32.le_iff_toNat_le.mp h7 simp at this ⊢;omega exact (im r d _ h6 h0 h8 h5 (Ρ.mp h3) (bn h4)).symm split ·exact (cK r d (iZ r ‹_›) h1 h5 h0).symm ·rfl lemma gS (g:Nat→ Д) (m:Nat) : ∀ acc:Д, Z ((List.range m).foldl (fun acc t=>acc+g t) acc)=Z acc + ∑ t∈ range m,Z (g t):=by induction m with | zero=>intro acc;simp | succ m ih => intro acc rw[List.range_succ,List.foldl_append,List.foldl_cons,List.foldl_nil,cn,ih,Λ] ring lemma cU:aa 0=0:=by rw[aI];simp lemma g3 : (decide (mantOf u*mantOf oneW=0) && Bool.xor (signOf u) (signOf oneW))=(u == 0x80000000):=by by_cases hm:mantOf u=0 ·rcases cY u hm with rfl | rfl<;>decide ·have:(u == 0x80000000)=false:=by rw[beq_eq_false_iff_ne];rintro rfl;exact hm (Б) rw[this,show mantOf oneW=2^23 by decide,show signOf oneW=false by decide];simp[hm] lemma eY (c:Nat) : ∀ i,i+c≤ n → (dallNZ (Array.ofFn (n:=n) fun j=>fa j.val) (Array.ofFn (n:=n) fun _=>oneW) i c=true ↔ ∀ t,i≤ t→ t< i+c→ fa t=0x80000000):=by induction c with | zero=>intro i _;simp[dallNZ];intro t h1 h2;omega | succ c ih => intro i h0 rw[dallNZ,al n fa i (А),al n (fun _=>oneW) i (А), g3,Ζ,ih (i+1) (А),beq_iff_eq] constructor ·rintro ⟨h1,h2⟩ t h3 h4 rcases Nat.eq_or_lt_of_le h3 with h | h ·subst h;exact h1 ·exact h2 t (А) (А) ·intro h;exact ⟨h i (le_refl _) (А),fun t h1 h2=>h t (А) (А)⟩ lemma ga (hn:0< n) (h0 : ∀ t< n,expOf (fa t)≠255) (hS:Core.aB n fa (fun _=>oneW)=0) (g:Bool) (hg:g=true ↔ ∀ t< n,fa t=0x80000000) : dotOf n fa (fun _=>oneW)=if g then 0x80000000 else 0:=by have hD:=dk n fa (fun _=>oneW) have hN:=eY n fa n 0 (А) have hA:=al n fa have hB:=al n fun _=>oneW have h3:=ϕ (f:=fun i:Fin n=>fa i.val) have h4:=ϕ (f:=fun _:Fin n=>oneW) unfold dotOf dotSpec Model.dot generalize (Array.ofFn (n:=n) fun i=>fa i.val)=A at * generalize (Array.ofFn (n:=n) fun _:Fin n=>oneW)=B at * have h5 : ∀ k,0≤ k→ k<0+(A.map (Model.ofUInt32 (fmt:=Fmt))).size → expOf A[k]! ≠ 255∧expOf B[k]! ≠ 255:=fun k _ hk=>by simp only[Array.size_map,h3] at hk rw[hA k (А),hB k (А)];exact ⟨h0 k (А),by decide⟩ have h6 : ∀ (X:Array Е),X.size=n→(∀ k< n,expOf X[k]! ≠ 255) → ∀ k (hk:k<(X.map (Model.ofUInt32 (fmt:=Fmt))).size),Model.isFinite (X.map (Model.ofUInt32 (fmt:=Fmt)))[k]=true:=by intro X hX hf k hk simp only[Array.size_map] at hk have h1:=hf k (А) rw[getElem!_pos X k hk] at h1 simp[isFinite_ofUInt32,h1] have h7:(A.map (Model.ofUInt32 (fmt:=Fmt))).size=(B.map (Model.ofUInt32 (fmt:=Fmt))).size:=by simp[h3,h4] have h8:=h6 A h3 fun k hk=>(h5 k (А) (by simp[h3];omega)).1 have h9:=h6 B h4 fun k hk=>(h5 k (А) (by simp[h3];omega)).2 have hC:=Ϥ (destination:=Fmt) _ _ h7 h8 h9 rw[finiteDotSlice_eq A B 0 _ (by simp) (by rw[← h7];simp) h5] at hC simp only[Array.size_map,h3,hD,hS,Int.cast_zero,zero_mul] at hC rw[Model.Reduction.dotWithStatus_eq_zero_of_finite Fmt _ _ .nearestEven h7 h8 h9 ((FloatLib.Numerics.Dyadic.toRat_eq_zero_iff _).1 hC)] simp only[Except.map] obtain ⟨h1,h2⟩ := dotStateLoop_flags A B ({}:Model.Reduction.Internal.State Fmt) 0 _ (by simp) (by rw[← h7];simp) h5 unfold Model.Reduction.Internal.dotState rw[h1,h2] have hb:dallNZ A B 0 n=g:=by rw[Ϟ,hN,hg] exact ⟨fun h t ht=>h t (А) (А),fun h t _ ht=>h t (А)⟩ simp only[Array.size_map,h3,hb] cases g<;>simp[show n≠0 by omega]<;>rfl lemma eo (w k U m:Nat) (hk:0< k) : wa Q I w k m U 0 true=true ↔ ∀ t< m,Q I[U+t / k*w+t % k]! = true:=by simp only[wa,iO _ _ _ _ _ _ _ hk] induction m with | zero=>simp | succ m ih => simp only[List.range_succ,List.foldl_append,List.foldl_cons,List.foldl_nil,Ζ,ih] exact ⟨fun ⟨h1,h2⟩ t ht=>(Nat.lt_succ_iff_lt_or_eq.mp ht).elim (h1 t) fun e=>e ▸ h2, fun h=>⟨fun t ht=>h t (А),h m (А)⟩⟩ lemma bv (ch y x t:Nat) : I[(ch*h+y*k)*w+x*k+t / k*w+t % k]! = poolAt h w k I ch y x t:=by unfold poolAt;congr 1;ring lemma fx (B c A H:Д) (hB:B.toNat≤255) (hc:c.toNat≤62) (hn:0< n) (h1 : ∀ t< n,ok c B (fa t)=true) (fl fh:Word→ Д) (L M:Int) (T : ∀ t< n,aa (fh (fa t))*2^25+aa (fl (fa t))=aq B.toNat (fa t) ∧ |aa (fl (fa t))| ≤ L ∧ |aa (fh (fa t))| ≤ M) (hL:n*L<2^63) (hM:n*M<2^63) (hA:Z A = ∑ t∈ range n,Z (fl (fa t))) (hH:Z H = ∑ t∈ range n,Z (fh (fa t))) (g:Unit→ Bool) (hg:g ()=true ↔ ∀ t< n,fa t=0x80000000) (fb:Unit→ Word) (h2:fb ()=dotOf n fa fun _=>oneW) (d:Word) (hD:DQ d) : wo B A H g fb d=av n fa d:=by have hk:=fun t ht=>a9 c B (fa t) hB hc (h1 t ht) have b1:=abs_le.mp (ci n _ _ fun t ht=>(T t ht).2.1) have b2:=abs_le.mp (ci n _ _ fun t ht=>(T t ht).2.2) have hT:Core.aB n fa (fun _=>oneW)=(∑ t∈ range n,aq B.toNat (fa t))*2^(B.toNat+149):=by unfold Core.aB rw[ϊ] refine χ rfl fun t ht => ?_ rw[ei (fa t) oneW _ 126 ((hk t (mr ht)).2.imp_right (·.1)) (Or.inr (Б)), show aq 126 oneW=2^23 by decide,show B.toNat+149=B.toNat+126+23 by omega,pow_add _ (B.toNat+126)] ring rw[← χ rfl fun t ht=>(T t (mr ht)).1,ϣ,← ϊ, ← sZ A (∑ t∈ range n,aa (fl (fa t))) (by rw[hA];push_cast;simp only[g8]) (by linarith) (by linarith),← sZ H (∑ t∈ range n,aa (fh (fa t))) (by rw[hH];push_cast;simp only[g8]) (by linarith) (by linarith)] at hT unfold wo av;split ·rename_i h0 rw[h0.1,h0.2,cU] at hT rw[ga n fa hn (fun t ht=>(hk t ht).1) (by rw[hT];ring) _ hg, cK _ d (by split<;>simp) hD.2.1 (bn hD.2.2) hD.1] ·rw[gO _ d hD] refine congrArg (fun s=>toWord (Model.div (ofW s) (ofW d))) ?_ unfold cM;rw[if_neg Bool.false_ne_true] split ·refine (aD n fa _ _ _ _ (fun t ht=>⟨(hk t ht).1,by decide⟩) ?_ ‹_›).symm rw[hT,cm,show (B+149).toNat=B.toNat+149 by rw[θ];simp;omega] ·exact h2 lemma gK (c:Д) (x:Word) (hB:B.toNat≤255) (hc:c.toNat≤37) (h:ok c B x=true) : aa 0*2^25+aa (t1 B x)=aq B.toNat x ∧ |aa (t1 B x)| ≤ 2^(24+c.toNat) - 1 ∧ |aa 0| ≤ 0:=by obtain ⟨-,hr⟩ := a9 c B x hB (А) h obtain ⟨hs,h0⟩ := ea B x c.toNat (А) hr have:2^(24+c.toNat)≤2^61:=ψ (Г) (А) have e:aa (t1 B x)=aq B.toNat x:=by unfold t1 aq sv;rw[i4 _ _ (А),hs] cases signOf x<;>simp only[fT,ite_true,ite_false,neg_mul]<;>push_cast<;>ring rw[cU,e];refine ⟨by ring,?_,by simp⟩ unfold aq sv cases signOf x<;>simp only[fT,ite_true,ite_false,neg_mul,abs_neg] <;> rw[abs_of_nonneg (В)]<;>exact Int.le_sub_one_of_lt (by exact_mod_cast h0) lemma dP (f:Word→ Д) (h w k:Nat) (I:Array Word) (ch y x:Nat) (hk:0< k) : Z (dO f I w k (k*k) ((ch*h+y*k)*w+x*k) 0 0) = ∑ t∈ range (k*k),Z (f (poolAt h w k I ch y x t)):=by rw[dO,iO _ _ _ _ _ _ _ hk,gS,bC,zero_add] simp only[bv] lemma iU (hB:B.toNat≤255) (h:ok 50 B u=true) : aa (eC B u)*2^25+aa (bE B u)=aq B.toNat u ∧ |aa (bE B u)| ≤ 2^25 ∧ |aa (eC B u)| ≤ 2^49:=by obtain ⟨h1,h2,h3⟩ := eD B u hB h rw[sZ (bE B u) _ (bM _) (А) (А),sZ (eC B u) ((bF B u).toNat - 2^49) (by rw[eC,cF,bM,show Z 0x2000000000000=((2^49:Int):ZMod (2^64)) by unfold Z;norm_num];push_cast;ring) (А) (А),abs_le,abs_le] omega lemma gM (hk:0< k) (h0:k*k<16384) (hD:DQ d) (ch y x:Nat):wq h w k I d ch y x=av (k*k) (poolAt h w k I ch y x) d:=by unfold wq;dsimp only split ·rename_i hg obtain ⟨h1,h2⟩ := hg generalize iP I w k (k*k) _ 0 255=B at h1 h2 ⊢ have h3 : ∀ t< k*k,ok 50 B (poolAt h w k I ch y x t)=true := fun t ht=>by rw[← bv];exact (eo _ _ _ _ _ _ hk).1 h2 t ht have:((k*k:Nat):Int)<16384:=by exact_mod_cast h0 exact fx _ _ _ 50 _ _ (ck h1) (Б) (Ϻ hk hk) h3 (bE B) (eC B) _ _ (fun t ht=>iU B _ (ck h1) (h3 t ht)) (by linarith) (by linarith) (dP _ h w k I ch y x hk) (dP _ h w k I ch y x hk) _ (by simp only[eo _ _ _ _ _ _ hk,bv,beq_iff_eq]) _ rfl d hD ·rfl lemma dN : eQ Q (fa 0) (fa 1) (fa 2) (fa 3)=true ↔ ∀ t<2*2,Q (fa t)=true:=by simp only[eQ,Ζ] exact ⟨fun ⟨⟨⟨a,b⟩,c⟩,e⟩ t ht=>by interval_cases t<;>assumption, fun H=>⟨⟨⟨H 0 (Б),H 1 (Б)⟩,H 2 (Б)⟩,H 3 (Б)⟩⟩ lemma ii (hD:DQ d) (ch y x:Nat) (e:USize) (he:e.toNat=(ch*h+y*2)*w+x*2) (hb:(ch*h+y*2)*w+x*2+w+1<2^31) : ig h w I d ch y x e=av (2*2) (poolAt h w 2 I ch y x) d:=by have q:=bv h w 2 I ch y x have e0:=q 0;have e1:=q 1;have e2:=q 2;have e3:=q 3 simp only[Nat.reduceDiv,Nat.reduceMod,zero_mul,one_mul,add_zero] at e0 e1 e2 e3 have wq2:=gM h w 2 I d (Б) (Б) hD ch y x have:=bK have g : ∀ i hi,I.uget i hi=I[i.toNat]! := fun i hi=>(getElem!_pos I _ hi).symm unfold ig;dsimp only;split swap;· exact wq2 simp (disch:=omega) only[g,Ι,USize.toNat_one,ab,mo,he,e0,e1,e2,e3] split ·rename_i hg have h0:=(dN _ (poolAt h w 2 I ch y x)).1 hg.2 exact fx _ _ _ 37 _ _ (ck hg.1) (Б) (Б) h0 _ (fun _=>0) _ 0 (fun t ht=>gK _ _ _ (ck hg.1) (Б) (h0 t ht)) (Б) (Б) (by simp only[cn,show 2*2=4 from rfl,Λ,Finset.sum_range_zero,zero_add]) (by simp[bC]) _ (by rw[dN];simp only[beq_iff_eq]) _ rfl d hD ·exact wq2 lemma eN (f:Nat→ Nat→ Nat→ Word) (hf : ∀ ch y x,f ch y x=av (k*k) (poolAt h w k I ch y x) (natW (k*k))) : eM c (h / k) (w / k) f=avgpoolSpec c h w k I:=by rw[f7];unfold avgpoolSpec refine Array.ext (by simp[avgpoolWith]) fun q _ _ => ?_ simp only[aE,Θ,avgpoolWith];exact hf _ _ _ lemma f9:eR=avgpoolSpec:=by funext c h w k I unfold eR dsimp only split ·rename_i hg obtain ⟨hk,hh,hw,h0,hD⟩ := hg split ·rename_i h2;obtain ⟨rfl,hs⟩ := h2 rw[gl _ _ _ _ _ _ _ hh,Υ];unfold avgpoolSpec refine Array.ext (by simp[avgpoolWith]) fun q h1 _ => ?_ simp only[aE,Θ,avgpoolWith,ϕ] at h1 ⊢ have ho:=(ϭ (Ϻ hh hw)).mpr h1 have:=Ν (q / (w / 2)) hh have:=Ν q hw have a1:q / (h / 2*(w / 2))*h+q / (w / 2) % (h / 2)*2+1≤ c*h:=by have:=τ h (Nat.succ_le_of_lt ho);rw[Ϣ] at this;omega have a2:=τ w a1 rw[϶] at a2 refine ii h w I _ hD _ _ _ _ ?_ (А) show (USize.ofNat _+2*USize.ofNat _).toNat=_ rw[show (2:USize)=USize.ofNat 2 from rfl,← USize.ofNat_mul,← USize.ofNat_add,ϐ 2, ← Nat.toUSize_eq,ab _ (А)] ·split ·rename_i hg refine eN _ _ _ _ _ _ fun ch y x => ?_ have h6 : ∀ t< k*k,ok 25 (cN I) (poolAt h w k I ch y x t)=true := fun t _=>bD I _ hg.2 (bc _ _) _ have:((k*k:Nat):Int)<16384:=by exact_mod_cast h0 exact fx _ _ _ 25 _ _ (ck hg.1) (Б) (Ϻ hk hk) h6 _ (fun _=>0) _ 0 (fun t ht=>gK _ _ _ (ck hg.1) (Б) (h6 t ht)) (by simp;linarith) (by simp) (dP _ h w k I ch y x hk) (by simp[bC]) _ (by simp only[eo _ _ _ _ _ _ hk,bv,beq_iff_eq]) _ rfl _ hD ·exact eN _ _ _ _ _ _ fun ch y x=>gM h w k I _ hk h0 hD ch y x ·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" => zpow_natCast local notation "ZG" => UInt64.toNat_ofNat' local notation "ZH" => decide_eq_true_eq local notation "ZI" => Core.af local notation "ZJ" => Nat.div_eq_zero_iff_lt local notation "ZK" => sqrtLower local notation "ZL" => zpow_add₀ local notation "ZM" => Finset.range local notation "ZO" => mantOf_lt_24 local notation "ZQ" => two_ne_zero local notation "ZR" => Core.bf local notation "ZS" => Core.an 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" => beq_iff_eq local notation "ZZ" => idxOf local notation "XA" => ite_false local notation "XB" => zpow_sub₀ local notation "XC" => two_ne_zero' local notation "XD" => mul_assoc 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 YB (a b:Word):(ZC a*ZC b).toNat=ZW a*ZW b:=by rw[Ϛ,ZI,ZI];apply γ;have:=mul_mant_lt a b;have h1:=ZO a;have h2:=ZO b calc ZW a*ZW b<2^24*2^24:=ύ h1 h2 _<2^64:=Г @[specialize] def Y6 (f:Nat→Word) (i stop:Nat) (out:ZB):ZB:= if i unfold Y6;rw[if_neg XI];simp | succ k ih=> unfold Y6;rw[if_pos XI,ih (i+1) _ XI,List.range'_succ];simp lemma YM (M k:Д) (hk:k.toNat<64): (M>>>k !=0)=decide (2^k.toNat≤M.toNat):=by rw[Ϟ,bne_iff_ne,ne_eq,decide_eq_true_iff,←ς, κ,γ hk,ζ,ώ, ZJ XJ] omega end Elem namespace Norm def Ya:Accuracy→Nat | .exact=>0 | .inexact _=>1 lemma Yc {α:Type} (f:α→α) (n:Nat) (a:α): Nat.repeat f (n+1) a=Nat.repeat f n (f a):=by induction n generalizing a with | zero=>rfl | succ n ih=>exact congrArg f (ih a) lemma QA (R k:Nat) (acc:Accuracy): XE (2*R+Ya acc) .exact>>>(k+2)= XE R acc>>>(k+1):=by show Nat.repeat ExtendedMantissa.shiftRightOne (k+2) _= Nat.repeat ExtendedMantissa.shiftRightOne (k+1) _ rw[Yc,Yc,Yc];congr 1;rcases acc with _ | ⟨_ | _ | _⟩<;> simp[ExtendedMantissa.ofMantissaAndAccuracy,ExtendedMantissa.shiftRightOne,Ya]<;>omega open FloatLib.Numerics in lemma VY (q r D t:Nat) (hD:0rfl,←h, show (q*D+r)/D=q by rw[ϒ,Ϙ _ _ hD,ϙ hr,zero_add], show (q*D+r)%D=r by rw[ϒ,ϋ,γ hr]] lemma Y5 (e:Int):Model.bpow e=(2:ℝ)^e:=by cases e with | ofNat n=>rw[Int.ofNat_eq_natCast,Model.bpow_natCast,ZF] | negSucc n=> rfl lemma Vi (q b:Nat) (hq:q≠0) (hb:b≤1):(2*q+b).log2=q.log2+1:=by have h1:=Ϩ hq;have h2:=ϱ (n:=q);rw[Nat.log2_eq_iff XI];constructor ·omega ·omega open FloatLib.Numerics in lemma V0 (s:Bool) (P Qd:Nat) (hP:P≠0) (hQ:Qd≠0) (q r D:Nat) (hD:0omega have hJ:=Vi q _ h3 hb;have h9:(r:ℝ)/D<1:=by rw[div_lt_one XJ];exact_mod_cast hr have h7:(0:ℝ)≤r/D:=XJ;push_cast at h1 h2;have h4:RationalBinary.floorLog2 P Qd=(q.log2:Int)+e:=by apply Model.floorLog2_eq_of_bounds P Qd _ hP hQ ·rw[h0,Y5,ZL ZQ,ZF];gcongr;linarith ·rw[h0,Y5,show (q.log2:Int)+e+1=((q.log2+1:Nat):Int)+e by push_cast;ring,ZL ZQ,ZF];gcongr;linarith have hm:roundQuotientEven (RationalBinary.scaleByPowerOfTwo P Qd (23-((q.log2:Int)+e))).1 (RationalBinary.scaleByPowerOfTwo P Qd (23-((q.log2:Int)+e))).2= roundShiftRightEven (2*q+if r=0 then 0 else 1) ((2*q+if r=0 then 0 else 1).log2-23):=by rw[roundShiftRightEven_eq_roundQuotientEven,hJ,show q.log2+1-23=(q.log2-23)+1 by clear * - hL hJ;omega,←VY q r D _ hD hr XI] apply Model.roundQuotientEven_eq_of_rat_eq _ _ _ _ (RationalBinary.scaleByPowerOfTwo_snd_ne_zero _ _ _ hQ) XJ rw[Model.scaleByPowerOfTwo_real];unfold Model.scaledRatToReal;rw[h0,Y5,XD,←ZL ZQ, show e+(23-((q.log2:Int)+e))=-((q.log2-23:Nat):Int) by clear * - hL hJ;omega, zpow_neg,ZF] push_cast;field_simp generalize h8:2*q+(if r=0 then 0 else 1)=J at hJ hm ⊢;rw[Model.roundDyadic,ite_eq_left (Б),Model.ieeeRoundDyadic_eq_ieeeRoundDyadicImpl];simp only[Model.roundRat,Model.roundRatScaled,show Fmt.isIEEE=true by decide,↓reduceDIte, Model.ieeeRoundRatScaled,Model.ieeeRoundDyadicImpl,ZY,hP,hQ,XA,h4, Int.add_zero,Int.ofNat_eq_natCast,hJ,show (FloatFormat.ieeeMaxNormalExponent Fmt:Int)=127 by decide, show FloatFormat.ieeeMinNormalExponent Fmt=-126 by decide, show (FloatFormat.normalMantissaExpOffset Fmt:Int)=150 by decide, show Fmt.fracWidth=23 by decide,show J≠0 by omega, show ((q.log2+1:Nat):Int)+(e-1)=(q.log2:Int)+e by push_cast;ring, show¬((q.log2:Int)+e>127) by omega,show¬((q.log2:Int)+e< -150) by omega, show¬((q.log2:Int)+e< -126) by omega,show 23≤q.log2+1 by omega,ite_true, Nat.cast_ofNat,hm] lemma Yp:ZT 0=0:=by decide lemma Y8 (v:ℚ) (hv:v≠0) (s:Bool) (hs:decide (v<0)=s) (q:Nat) (ρ:ℚ) (h4:0≤ρ) (h0:ρ<1) (e:Int) (h1:|v|=((q:ℚ)+ρ)*(2:ℚ)^e) (hq:2^25≤q) (h2:-126≤(q.log2:Int)+e) (h3:(q.log2:Int)+e≤126): ZT v= toWord (Model.roundDyadic Fmt ⟨s,2*q+(if ρ=0 then 0 else 1),e-1⟩):=by have hρ:ρ=(ρ.num.toNat:ℚ)/ρ.den:=by conv_lhs=>rw[←Rat.num_div_den ρ] congr 1;exact_mod_cast (Int.toNat_of_nonneg (Rat.num_nonneg.mpr h4)).symm have hD:=ρ.den_pos;generalize ρ.den=D at hρ hD;generalize ρ.num.toNat=r at hρ;subst hρ;have hr:r(z:ℝ)) h1;rw[Rat.abs_def,Rat.divInt_eq_div] at this;push_cast at this;rwa[Nat.cast_natAbs,Int.cast_abs] lemma Q7 (R:Nat) (s:Int) (h:2^25≤R): -s+1≤(ZE).targetExponent (Float.Model.totalExponent R (-s)):=by have:=(Nat.le_log2 XI).2 h;have:(ZE).mantissaBits≤25:=Б unfold Float.Model.Format.targetExponent Float.Model.totalExponent;omega lemma Vd (v:ℚ) (h5:0simp lemma YN (w:Word):(sv w:ℚ)=0↔ZW w=0:=by unfold sv;split_ifs<;>simp lemma Vr (w:Word):(sv w:ℚ)=(if ZX w then-1 else 1)*ZW w:=by unfold sv;split_ifs<;>simp lemma Y7 (x:Д):(ZR x).toNat=x.toNat.log2:=by rw[Core.bu];rfl @[specialize] def Yh (x:ZB) (i stop u:Nat):Nat:= if ih (by rw[←ZI,h'];rfl) simp[this,h] lemma Yi (x:ZB) (stop:Nat): ∀ k i u,stop-i=k→Yh x i stop u≤u∧ ∀ j,i≤j→j intro i u h;unfold Yh;rw[if_neg XI];exact ⟨le_refl _,fun j h1 h2=>by omega⟩ | succ k ih=> intro i u h;unfold Yh;rw[if_pos XI];dsimp only;rw[YK,ZS];obtain ⟨h1,h2⟩:=ih (i+1) (if decide (ZW x[i]! =0)=true then u else min u (ZZ x[i]!)) XI refine ⟨le_trans h1 (by split_ifs<;>omega),?_⟩;intro j h4 h0;by_cases h3:j=i ·subst h3;by_cases hm:ZW x[j]! =0 ·exact Or.inl hm ·simp only[hm,decide_false,Α,XA] at h1 ⊢;omega ·exact h2 j XI h0 def VJ (x:ZB) (u j:Nat):Nat:= (ZW x[j]! *ZW x[j]!)<<<(2*(ZZ x[j]! -u)) @[specialize] def Yl (x:ZB) (u i stop:Nat) (l h:Д) (c big:Nat):Nat:= if i>>1)>>>(63-k) else mm<<<(k-64) let l':=l+vl let h':=h+vh+(if l'>>1)>>>(63-(2*sh).toUInt64) else mm<<<((2*sh).toUInt64-64)).toNat*2^64=mm.toNat*2^(2*sh)∧ (if (2*sh).toUInt64<64 then (mm>>>1)>>>(63-(2*sh).toUInt64) else mm<<<((2*sh).toUInt64-64)).toNat<2^62:=by have hk:(2*sh).toUInt64.toNat=2*sh:=by rw[Ϸ,ZG,γ XI] by_cases h:2*sh<64 ·have h0:(2*sh).toUInt64<64:=by rw[ν,hk];simpa simp only[h0,ite_true,ο,κ,η _ _ (show (2*sh).toUInt64≤63 by rw[ε,hk];simp;omega),hk,UInt64.reduceToNat, ι,ζ,γ (show 2*sh<64 by omega), γ (show 63-2*sh<64 by omega),Nat.reduceMod,Ϫ] have e:2^1*2^(63-2*sh)=2^(64-2*sh):=by rw[←pow_add];congr 1;omega have e2:2^64=2^(64-2*sh)*2^(2*sh):=by rw[←pow_add];congr 1;omega rw[e,e2,Nat.mul_mod_mul_right,←Υ,←Nat.add_mul,Nat.mod_add_div'];exact ⟨rfl,lt_of_le_of_lt (ZV _ _) XI⟩ ·have h0:¬(2*sh).toUInt64<64:=by rw[ν,hk];simp;omega have hb:mm.toNat*2^(2*sh-64)<2^62:= calc _<2^48*2^14:= ϰ hm (ψ XJ XI) XJ _=_:=Г simp only[h0,XA,ώ,Ο,ο,η _ _ (show (64:Д)≤(2*sh).toUInt64 by rw[ε,hk];simp;omega),hk, UInt64.reduceToNat,γ (show 2*sh-64<64 by omega),ι, γ (show mm.toNat*2^(2*sh-64)<2^64 by omega)] refine ⟨?_,hb⟩;rw[Υ,←pow_add];congr 2;omega lemma Vb (x:ZB) (u stop:Nat): ∀ k i (l h:Д) c big,stop-i=k→ Yl x u i stop l h c big=big+l.toNat+h.toNat*2^64+c*2^128+ ∑ j∈ZM k,VJ x u (i+j):=by intro k;induction k with | zero=> intro i l h c big hk;unfold Yl;rw[if_neg XI];simp only[ι,Finset.range_zero,Finset.sum_empty];ring | succ k ih=> intro i l h c big hk;unfold Yl;rw[if_pos XI];rw[ϟ];have e:∀ j,VJ x u (i+(j+1))=VJ x u (i+1+j):=fun j=>by rw[show i+(j+1)=i+1+j by omega] simp only[e,Τ];have h0:VJ x u i=(ZC x[i]! *ZC x[i]!).toNat* 2^(2*((ZD x[i]!).toNat-u)):=by unfold VJ;rw[ι,Elem.YB,ZS] have hm:(ZC x[i]! *ZC x[i]!).toNat<2^48:=by rw[Elem.YB];have:=ZO x[i]! calc _<2^24*2^24:=ύ this this _=_:=Г rw[h0];generalize (ZD x[i]!).toNat-u=sh at* generalize ZC x[i]! *ZC x[i]! =mm at* by_cases hs:sh≤39 ·obtain ⟨e1,e2⟩:=VL mm sh hm hs;generalize (if (2*sh).toUInt64<64 then mm<<<(2*sh).toUInt64 else 0)=vl at* generalize (if (2*sh).toUInt64<64 then (mm>>>1)>>>(63-(2*sh).toUInt64) else mm<<<((2*sh).toUInt64-64))=vh at* rw[ih (i+1) _ _ _ _ XI];clear hk h0;have:=l.toNat_lt;have:=h.toNat_lt;have:=vl.toNat_lt;simp only[θ,ν,apply_ite UInt64.toNat,UInt64.reduceToNat];split_ifs<;>omega ·rw[if_neg hs,ih (i+1) _ _ _ _ XI,ι];ring lemma Yk (n:Nat) (f:Nat→ℚ) (a:ℚ): (List.range n).foldl (fun t j=>t+f j) a=a+∑ j∈ZM n,f j:=by induction n generalizing a with | zero=>simp | succ n ih=> rw[List.range_succ,List.foldl_append,ih,Λ];simp;ring lemma VG (idx u:Nat) (h:u≤ idx): ((2:ℚ)^((idx:Int)-149))^2=(2:ℚ)^(2*(idx-u))*(2:ℚ)^(2*(u:Int)-298):=by rw[←ZF ((2:ℚ)^((idx:Int)-149)) 2,←zpow_mul, ←ZF (2:ℚ) (2*(idx-u)),←ZL ZQ] congr 1;omega lemma Ye (w:Word) (u:Nat) (h:ZW w=0∨u≤ ZZ w): ZA w^2= (((ZW w*ZW w)<<<(2*(ZZ w-u)):Nat):ℚ)*2^(2*(u:Int)-298):=by rw[Y1,ι];rcases h with h | h ·have:(sv w:ℚ)=0:=(YN w).2 h;rw[this,h];simp ·have hs:(sv w:ℚ)^2=(ZW w:ℚ)*ZW w:=by rw[←sq_abs,VT];ring rw[mul_pow,hs,VG _ _ h];push_cast;ring lemma YA (n:Nat) (x:ZB) (r u:Nat) (hu:∀ j,r*n≤j→jsimp[Ya] have h1:totalExponent (2*R+Ya acc) (e-1)=totalExponent R e:=by unfold totalExponent;rw[Vi R _ hR hb];push_cast;ring unfold UnpackedFloat.round decreaseExponent;simp only[h1];have h0:(e-1-spec.targetExponent (totalExponent R e)).toNat=0:=XI;rw[h0];simp;unfold roundWithAccuracy shiftToTargetExponent shiftToExponent;rw[h1];generalize hT:spec.targetExponent (totalExponent R e)=T at* obtain ⟨k,h4⟩:∃ k,(T-e).toNat=k+1:=⟨(T-e).toNat-1,XI⟩;have h3:(T-(e-1)).toNat=k+2:=XI;have h2:e-1+((k+2:Nat):Int)=e+((k+1:Nat):Int):=by push_cast;ring dsimp only;rw[h4,h3,QA,h2] lemma Vh (num den:Nat): Ya (sqrtAccuracy num den)=if num=ZK num den^2*den then 0 else 1:=by unfold sqrtAccuracy;dsimp only;split_ifs<;>rfl lemma V9 (num den:Nat) (s:Int) (hR:33554432≤ ZK num den) (h1:ZK num den>>>31=0) (h6:-209≤ s) (h7:s≤297): Yf num den s=Core.aT false (XF (2*ZK num den+ (if num=ZK num den*ZK num den*den then 0 else 1))) (XF (297-s).toNat):=by set R:=ZK num den with h0;have h5:R<2^31:=by rw[ζ] at h1;exact (ZJ XJ).1 h1 have h4:R≠0:=XI;have h3:(XF (297-s).toNat).toNat=(297-s).toNat:=by rw[ZG,γ XI] have hj:(if num=R*R*den then 0 else 1)≤1:=by split_ifs<;>omega have hm:(XF (2*R+(if num=R*R*den then 0 else 1))).toNat= 2*R+(if num=R*R*den then 0 else 1):=by rw[ZG,γ XI] rw[Core.bJ _ _ _ (by rw[h3];omega),h3,hm];have h2:=Q7 R s XI;unfold Yf;rw[←h0,Q4 _ _ R (-s) _ h4 h2,Vh,←h0,sq, show (((297-s).toNat:Nat):Int)-298=-s-1 by omega] rfl @[inline] def YG (num den R:Nat) (s:Int):Word:= if R>>>31==0&&-209≤ s&&s≤297 then Core.aT false (XF (2*R+(if num==R*R*den then 0 else 1))) (XF (297-s).toNat) else Yf num den s lemma Vc (num den:Nat) (s:Int) (hR:33554432≤ ZK num den): YG num den (ZK num den) s=Yf num den s:=by unfold YG;split next h=> simp at h;obtain ⟨⟨h0,h1⟩,h2⟩:=h;rw[V9 num den s hR h0 h1 h2];simp next=>rfl def V8 (B:Nat) (c:Int):Nat:=if 0≤c then B<<(z:ℝ)) (hq.trans (by rw[←hB,ZL ZQ,h2 (2*u-w0) (2*(u:Int)-298) XI, h2 (ie+149-w0) ((ie:Int)-149) XI,ι,ι] push_cast;field_simp: _=((A:ℚ)*2^(2*(u:Int)-298)/Dn+E*2^((ie:Int)-149))*2^(2*s))) push_cast at this ⊢;exact this ·rfl @[inline] def VO (x k:Nat):Nat:= if k<63&&x>>>(63-k)==0 then (x.toUInt64<<>>63==0 then (ZR x.toUInt64).toNat else x.log2 lemma Qh (x:Nat):Q2 x=x.log2:=by unfold Q2;split_ifs with h ·simp at h;have hx:x<2^63:=by rw[ζ] at h;exact (ZJ XJ).1 h rw[Y7,Ϸ,ZG,γ XI] ·rfl @[inline] def VK (Z:Nat) (k:Int):Nat:=if k≤0 then Z>>>(-k).toNat else VO Z k.toNat @[inline] def Vx (Z W:Nat) (fz:Bool) (k:Int):Bool:= if k≤0 then fz || (VO W (-k).toNat !=Z) else fz @[inline] def V2 (r:Nat) (st:Bool):Nat:=if r !=0 || st then 1 else 0 @[noinline] def Vq (s:Bool) (Z:Nat) (fz:Bool) (Dd:Nat) (e0:Int):Д:= let k:Int:=(Q2 Dd:Int)+27-(Q2 Z:Int) let W:=VK Z k let st:=Vx Z W fz k let e:Int:=e0-k let q:=W/Dd let r:=W-Dd*q let lq:=Q2 q let T:Int:=(lq:Int)+e if (k≤0 || !fz)&&33554432≤q&&lq<62&&-126≤T&&T≤126 then (Core.aT s (XF (2*q+V2 r st)) (XF (e+297).toNat)).toUInt64 else 4294967296 @[inline] def Yg (s:Bool) (Z:Nat) (fz:Bool) (Dd:Nat) (e0:Int) (slow:Unit→Word):Word:= let c:=Vq s Z fz Dd e0 if c<4294967296 then c.toUInt32 else slow () lemma Qo (p:Prop) [Decidable p] (x:Е) (y:Е): (if (if p then x.toUInt64 else 4294967296)<4294967296 then (if p then x.toUInt64 else 4294967296).toUInt32 else y)=if p then x else y:=by by_cases hp:p ·have h:x.toUInt64<4294967296:=by exact x.toNat_lt simp only[hp,ite_true,h,UInt32.toUInt32_toUInt64] ·simp[hp] lemma YM (T t:Nat):((T>>>t)<<simp[h]<;>rw[ϐ]<;>omega lemma VI (N M:Nat) (hM:0by rw[h,abs_zero] at h2;have:(0:ℚ)<((W/Dd:Nat):ℚ):=by exact_mod_cast (show 0by_cases h':δ=0<;>simp_all ·omega set_option maxHeartbeats 1000000 in lemma YC (s:Bool) (Z:Nat) (fz:Bool) (Dd:Nat) (e0:Int) (slow:Unit→Word) (v δ:ℚ) (hs:v≠0→decide (v<0)=s) (h6:0≤δ) (h5:δ<1) (h3:fz=true↔δ≠0) (hD:0simp_all<;>omega have hδ:δ=0:=by by_contra h;exact absurd (h3.2 h) (by simp[hf]) refine ⟨0,le_rfl,one_pos,by simp[hf],?_⟩;rw[hδ,ι];push_cast;rw[add_zero,add_zero,XD,←ZF,←ZL ZQ];congr 2;omega generalize VK Z k=W at* generalize Vx Z W fz k=st at* have h7:=(Nat.log2_lt XI).1 hl;exact Qx s W st Dd (e0-k) v δ' _ _ hs a0 a1 az hD (by rw[h4,hW]) hq XI XI (by rw[ZG,γ (by unfold V2;split_ifs<;>omega)]) (by rw[ZG,γ XI];omega) ·exact h0 @[specialize] def Ym (x:ZB) (u i stop P N:Nat):Nat × Nat:= if i intro i P N h;unfold Ym;rw[if_neg XI];simp | succ k ih=> intro i P N h;unfold Ym;rw[if_pos XI];simp only[Yz];rw[ZI,ZS,ϟ];have e:∀ j,YS x u (i+(j+1))=YS x u (i+1+j):=fun j=>by rw[show i+(j+1)=i+1+j by omega] simp only[e,Τ];have hl:YS x u i=if ZX x[i]! then-((ZW x[i]! <<<(ZZ x[i]! -u):Nat):Int) else ((ZW x[i]! <<<(ZZ x[i]! -u):Nat):Int):=rfl rw[hl];split_ifs with hs ·rw[ih (i+1) _ _ XI];push_cast;ring ·rw[ih (i+1) _ _ XI];push_cast;ring lemma Yx (x:ZB) (u j:Nat) (h:ZW x[j]! =0∨u≤ ZZ x[j]!): ZA x[j]! =(YS x u j:ℚ)*2^((u:Int)-149):=by rw[Y1];unfold YS;rcases h with h | h ·have:(sv x[j]! :ℚ)=0:=(YN _).2 h;rw[this,h];simp ·have hp:(2:ℚ)^((ZZ x[j]! :Int)-149)= (2:ℚ)^(ZZ x[j]! -u)*2^((u:Int)-149):=by rw[←ZF,←ZL ZQ];congr 1;omega rw[hp,Vr,ι];split_ifs<;>push_cast<;>ring lemma VW (n:Nat) (x:ZB) (r u:Nat) (hu:∀ j,r*n≤j→jby ring rw[χ rfl h8,ϣ,Finset.sum_sub_distrib, ←Finset.mul_sum,h1,h2,h6,Finset.sum_const,Finset.card_range,nsmul_eq_mul] field_simp;ring have h9:(0:ℚ)≤(n:ℚ)*Q-S^2:=by have h0:0≤XH n x r (rowMean n x r):=by unfold rowVariance;rw[Yk,zero_add];positivity rw[h5,le_div_iff₀ XJ,zero_mul] at h0;exact (mul_nonneg_iff_of_pos_right XJ).1 h0 have h7:Y0 pn.1 pn.2*Y0 pn.1 pn.2≤n*Q:=by have h:=YO pn.1 pn.2;have:((Y0 pn.1 pn.2*Y0 pn.1 pn.2:Nat):ℚ)≤((n*Q:Nat):ℚ):=by rw[h];push_cast;linarith exact_mod_cast this refine ⟨h4,h7,?_⟩;rw[h5,Nat.cast_sub h7,YO,←h3,h6];push_cast;ring def sg (s:Bool) (M:ℚ):ℚ:=if s then-M else M lemma Vm (s:Bool) (M:ℚ) (hM:0≤M) (e:Int) (Dd:Nat) (hD:0 ?_⟩;simp;positivity ·simp only[ite_true];refine ⟨?_,fun h=> ?_⟩ ·rw[neg_mul,neg_div,abs_neg,abs_of_nonneg XJ] ·simp only[ZH];have:0h (by rw[←h'];simp));positivity rw[neg_mul,neg_div];linarith lemma Q6 (w:Word):(ZC w !=0)= !decide (ZW w=0):=by rw[show (ZC w !=0)= !(ZC w==0) from rfl,YK] lemma Y2 (w:Word):ZA w=sg (ZX w) (ZW w)*2^((ZZ w:Int)-149):=by rw[Y1,Vr];unfold sg;split_ifs<;>ring lemma Yn (a b:Nat):sg (decide (a>>(F-k) @[inline] def Q5 (c k F G:Nat):Nat:=if F≤k then 0 else VO (c&&&(VO 1 (F-k)-1)) (k-G) lemma Qu (c k F G:Nat) (hk:G≤k) (hF:G≤F): c*2^k=(Ql c k F*2^(F-G)+Q5 c k F G)*2^G∧Q5 c k F G<2^(F-G):=by have e:c*2^(k-G)=Ql c k F*2^(F-G)+Q5 c k F G∧Q5 c k F G<2^(F-G):=by unfold Ql Q5;simp only[Yz,ι,one_mul,ξ, ζ] split_ifs with h ·rw[add_zero,XD,←Nat.pow_add,show k-F+(F-G)=k-G by omega];exact ⟨rfl,XJ⟩ ·rw[show F-G=F-k+(k-G) by omega,Nat.pow_add,←XD,←Nat.add_mul,ZU];exact ⟨rfl,υ (Ν _ XJ) XJ⟩ rw[←e.1,XD,←Nat.pow_add,Nat.sub_add_cancel hk];exact ⟨rfl,e.2⟩ @[inline] def Qw {α:Type} (pH pL qH qL w:Nat) (K:Bool→Nat→Nat→α):α:= let M:=VO 1 w let a:=pH+(pL>>>w) let b:=pL&&&(M-1) let c:=qH+(qL>>>w) let d:=qL&&&(M-1) let s:=asimp at h ⊢<;>rw[h]<;> push_cast<;>ring lemma Qc {α:Type} (pH pL qH qL w:Nat) (K:Bool→Nat→Nat→α) (R:α) (h:∀ s H L,L<2^w→((pH*2^w+pL:Nat):ℚ)-(qH*2^w+qL:Nat)= sg s (H*2^w+L:Nat)→K s H L=R): Qw pH pL qH qL w K=R:=by unfold Qw;simp only[Yz,ϻ,ξ,ζ];have hM:0<2^w:=XJ;have e1:=ZU pL (2^w);have e2:=ZU qL (2^w);have l1:=Ν pL hM;have l2:=Ν qL hM;generalize pL/2^w=x at* generalize pL%2^w=b at* generalize qL/2^w=y at* generalize qL%2^w=d at* subst e1 e2;apply h ·split_ifs<;>omega ·apply Qp;rcases Nat.lt_trichotomy (pH+x) (qH+y) with o | o | o<;> [have:=τ (2^w) o;have:=congrArg (· *2^w) o; have:=τ (2^w) o]<;> split_ifs at*<;>simp only[ϖ,ZH,Ζ,ZY, Nat.succ_eq_add_one,Nat.sub_mul,Nat.add_mul,one_mul] at*<;>omega @[inline] def tw {α:Type} (s1:Bool) (A B k r:Nat) (s2:Bool) (C k2 F G:Nat) (K:Bool→Nat→Nat→α):α:= let aH:=Ql A (k+r) F+Ql B k F let aL:=Q5 A (k+r) F G+Q5 B k F G let cH:=Ql C k2 F let cL:=Q5 C k2 F G Qw ((if s1 then 0 else aH)+(if s2 then 0 else cH)) ((if s1 then 0 else aL)+(if s2 then 0 else cL)) ((if s1 then aH else 0)+(if s2 then cH else 0)) ((if s1 then aL else 0)+(if s2 then cL else 0)) (F-G) K lemma Q8 {α:Type} (s1:Bool) (A B k r:Nat) (s2:Bool) (C k2 F G:Nat) (K:Bool→Nat→Nat→α) (R:α) (h1:G≤k) (h2:G≤k2) (h3:G≤F) (h:∀ s H L,L<2^(F-G)→sg s1 (A*2^(k+r)+B*2^k:Nat)+sg s2 (C*2^k2:Nat)= sg s (H*2^(F-G)+L:Nat)*2^G→K s H L=R): tw s1 A B k r s2 C k2 F G K=R:=by obtain ⟨e1,-⟩:=Qu A (k+r) F G XI h3;obtain ⟨e2,-⟩:=Qu B k F G h1 h3;obtain ⟨e3,-⟩:=Qu C k2 F G h2 h3;apply Qc;intro s H L hL hv;apply h s H L hL;rw[e1,e2,e3,←hv];cases s1<;>cases s2<;>simp only[sg,ite_true,XA,Α]<;>push_cast<;>ring lemma Qm (s:Bool) (H L w Dd:Nat) (e0:Int) (slow:Unit→Word) (V:ℚ) (hD:0push_cast<;>field_simp obtain ⟨ha,hs⟩:=Vm s (H+L/2^w) XJ _ Dd hD;rw[←h1] at ha hs;exact YC _ _ _ _ _ _ _ _ hs XJ ((div_lt_one hw).2 (by exact_mod_cast hL)) XK hD ha h0 lemma QD (s t:Bool) (a b c k r:Nat): sg (XG s t) (a*c*2^(k+r)+b*c*2^k:Nat)=sg s (a*2^r+b:Nat)*sg t c*2^k:=by unfold sg;cases s<;>cases t<;>simp<;>ring lemma Yv (s:Bool) (a b:ℚ):sg s (a*b)=sg s a*b:=by unfold sg;split_ifs<;>ring @[inline] def Qv {α:Type} (n u r:Nat) (sS:Bool) (Sh Sl:Nat) (x:Word) (K:Bool→Nat→Nat→α):α:= if r=0 then let X:=VO ((ZC x).toNat*n) ((ZD x).toNat-u) let p:=(if ZX x then 0 else X)+(if sS then Sh+Sl else 0) let q:=(if ZX x then X else 0)+(if sS then 0 else Sh+Sl) K (decide (pcases ZX x<;>simp<;>ring ·rw[if_neg hr];apply Q8 _ _ _ _ _ _ _ _ _ _ _ _ (Nat.zero_le _) (Nat.zero_le _) (Nat.zero_le _);intro s H L _ h';apply h;simpa using h' @[inline] def V4 (n u r:Nat) (sS:Bool) (Sh Sl:Nat) (x g b d:Word) (slow:Unit→Word):Word:= if !ZX d&&ZC d !=0 then Qv n u r sS Sh Sl x fun sD Dh Dl=> let mg:=(ZC g).toNat let Dd:=n*(ZC d).toNat let T1h:=Dh*mg let T1l:=Dl*mg let T2:=(ZC b).toNat*Dd let e1:=u+(ZD g).toNat let e2:=(ZD b).toNat+(ZD d).toNat let G:=min e1 e2 let F:=max (max ((if T1h==0 then Q2 T1l else Q2 T1h+r)+e1) (Q2 T2+e2)-61) G tw (XG sD (ZX g)) T1h T1l e1 r (ZX b) T2 e2 F G fun s H L=> Yg s H (L !=0) Dd ((G:Int)-149-(ZD d).toNat+(F-G:Nat)) slow else slow () lemma Vz (n u r:Nat) (sS:Bool) (Sh Sl:Nat) (x g b d:Word) (m:ℚ) (slow:Unit→Word) (hn:0simp, show ∀ M,sg false M=M from fun _=>rfl] simp only[XB (XC ℚ),ZL (XC ℚ),ZF,pow_add];field_simp;ring ·exact h0 @[inline] def Yu (v k a:Д):Д:=if 61≤k+a then v>>>(k+a-61) else v<<<(61-a-k) @[inline] def Q0 (s1:Bool) (B:Д) (s2:Bool) (C d σ Dd:Д) (slow:Unit→Word):Word:= let c:=C>>>d let Z:=if s1==s2 then B+c else B-c let q:=Z/Dd let r:=Z-q*Dd if d<64&&(s1==s2 || c>>25 !=0&&q>>>62==0&& 146≤σ&&σ≤362 then Core.aT s1 (2*q+1) σ else slow () lemma QB (s1 s2:Bool) (B C:ℚ) (E1 E2 d:Nat) (h:C=0∨E2+d=E1) (k:Int) (D:ℚ): (sg s1 B*2^((E1:Int)-62)+sg s2 C*2^((E2:Int)-62))*2^k/D= (sg s1 B+sg s2 (C/2^d))*2^((E1:Int)-62+k)/D:=by rcases h with h | h ·subst h;unfold sg;simp[ZL (XC ℚ)];ring ·subst h;unfold sg;push_cast;simp only[ZL (XC ℚ),XB (XC ℚ),ZF];split_ifs<;>field_simp lemma Qf (s t:Bool) (a b:ℚ):sg (XG s t) (a*b)=sg s a*sg t b:=by unfold sg;cases s<;>cases t<;>simp @[inline] def Qt (s0:Bool) (B a w Dd lD id:Д) (g b:Word) (slow:Unit→Word):Word:= let E1:=w+ZD g+a let T:=(ZC b*Dd)<<<(37-lD) let E2:=ZD b+id+24+lD let s1:=XG s0 (ZX g) if ZC b==0 || E2≤E1 then Q0 s1 B (ZX b) T (if ZC b==0 then 0 else E1-E2) (E1+87-id) Dd slow else Q0 (ZX b) T s1 B (E2-E1) (E2+87-id) Dd slow @[inline] def Qr (sx sS:Bool) (nX Xl fb S L w Dd lD id:Д) (g b:Word) (slow:Unit→Word):Word:= let Sh:=S>>>L let p:=(if sx then 0 else nX)+(if sS then Sh else 0) let q:=(if sx then nX else 0)+(if sS then 0 else Sh) let s0:=decide (p>>38==0&&24≤a then let cX:=Yu (Xl*ZC g) fb a let cS:=Yu ((S&&&((1<<>>38==0&&24≤ZR (A*ZC g) @[inline] def Qy (n u S lS:Д) (sS:Bool) (Dd lD id:Д) (x g b:Word) (slow:Unit→Word): Word:= let ix:=ZD x let m:=ZC x*n let sh:=ix-u if (m==0 || sh≤27)&&Qs (ZX x) sS (m<<ix || ix-w≤27) then Qr (ZX x) sS (if w≤ ix then m<<<(ix-w) else m>>>fb) (m&&&((1<<rename_i h<;>rw[ε,h0] at h<;>simp at h ·rw[κ,η _ _ (by rw[ε,h0];simpa using h), h0,show (61:Д).toNat=61 from rfl,γ XI,ζ, show k.toNat=k.toNat+a.toNat-61+(61-a.toNat) by omega,pow_add, Nat.mul_div_mul_right _ _ XJ] congr 2;omega ·have h2:(61-a).toNat=61-a.toNat:=η _ _ (by rw[ε];simpa using h3);have h1:(61-a-k).toNat=61-a.toNat-k.toNat:=by rw[η _ _ (by rw[ε,h2];omega),h2] have e:v.toNat*2^(61-a.toNat)/2^k.toNat=v.toNat*2^(61-a.toNat-k.toNat):= Nat.div_eq_of_eq_mul_left XJ (by rw[Υ,←pow_add];congr 2;omega) rw[ο,h1,γ (show 61-a.toNat-k.toNat<64 by omega),ι, e] refine γ ?_ calc v.toNat*2^(61-a.toNat-k.toNat)<2^k.toNat*G*2^(61-a.toNat-k.toNat):= υ hv XJ _=G*2^(61-a.toNat):=by rw[ϐ (2^_) G,Υ,←pow_add];congr 2;omega _<2^64:=XI rw[hc];have hp:0<2^k.toNat:=XJ;refine ⟨Nat.div_mul_le_self _ _,?_,?_,h4⟩ ·rw[ϐ (_+1)];exact Nat.lt_mul_div_succ _ hp ·refine Nat.lt_of_mul_lt_mul_right (a:=2^k.toNat) ?_ calc _≤v.toNat*2^(61-a.toNat):=Nat.div_mul_le_self _ _ _<2^k.toNat*G*2^(61-a.toNat):=υ hv XJ _=_:=by ring lemma QE (c1 c2:Bool) (base cX cS B:Д) (tX tS:ℚ) (h1:B=base+(if c1 then cX else 0)+(if c2 then cS else 0)-((if c1 then 0 else cX)+(if c2 then 0 else cS))) (hX:(cX.toNat:ℚ)≤tX∧tXcases c2<;> simp only[ite_true,XA,Α,Ε,θ,ώ,add_zero,zero_add,Nat.zero_mod,Nat.sub_zero]<;>omega refine ⟨h0.2,?_⟩;have e:=congrArg (Int.cast:ℤ→ℚ) h0.1;push_cast at e;clear * - e hX hS;rw[e,abs_lt];cases c1<;>cases c2<;>simp only[ite_true,XA,Α]<;>constructor<;>linarith[hX.1,hX.2,hS.1,hS.2] lemma Vs (s1:Bool) (B:Д) (s2:Bool) (C d σ Dd:Д) (slow:Unit→Word) (X Y v:ℚ) (e:Int) (hB:B.toNat<2^63) (hC:C.toNat<2^63) (hH:Dd.toNat<2^63) (hX:|X-B.toNat|<2) (hY:|Y-C.toNat|<2) (hσ:σ.toNat≤506→(σ.toNat:Int)=e+297) (hv:v=(sg s1 X+sg s2 (Y/2^d.toNat))*2^e/Dd.toNat) (h2:slow ()=ZT v): Q0 s1 B s2 C d σ Dd slow=ZT v:=by unfold Q0;dsimp only;generalize hn:C>>>d=c;generalize ht:(if (s1==s2)=true then B+c else B-c)=Z;generalize ho:Z/Dd=q;generalize hu:Z-q*Dd=r;split;swap;· exact h2 rename_i hk;simp only[Ζ,ϖ,ZY,ZH,bne_iff_ne,ne_eq, ε,ν,←ς,κ, θ,UInt64.reduceToNat,Nat.reduceMod,ζ,Nat.reducePow] at hk obtain ⟨⟨⟨⟨⟨⟨⟨hd,h0⟩,h8⟩,hp⟩,hj⟩,hg⟩,hL⟩,hJ⟩:=hk;have hc:c.toNat=C.toNat/2^d.toNat:=by rw[←hn,κ,γ hd,ζ] have hy:c.toNat≤C.toNat:=by rw[hc];exact ZV _ _ have hZ:Z.toNat=if s1=s2 then B.toNat+c.toNat else B.toNat-c.toNat:=by rw[←ht];by_cases hs:s1=s2 ·simp only[hs,beq_self_eq_true,ite_true,θ];clear * - hB hC hc hy;omega ·rw[if_neg (by simpa using hs),if_neg hs, η _ _ (ε.2 (by have:=h0.resolve_left hs;omega))] have hb:=ZU Z.toNat Dd.toNat;have hF:=Z.toNat_lt;have hq:q.toNat=Z.toNat/Dd.toNat:=by rw[←ho,UInt64.toNat_div] have h9:(q*Dd).toNat=q.toNat*Dd.toNat:=by rw[Ϛ,hq];exact γ XI have hr:r.toNat=Z.toNat%Dd.toNat:=by rw[←hu,η _ _ (ε.2 (by rw[h9,hq];clear * - hZ hb;omega)),h9,hq];clear * - hZ hb;omega have hD:0nlinarith obtain ⟨Yt,he,hf⟩:∃ Yt:ℚ,v=sg s1 Yt*2^e/Dd.toNat∧|Yt-Z.toNat|<4:=by clear * - hX hi hZ hv h0;rw[abs_lt] at hX hi;by_cases hs:s1=s2 ·refine ⟨X+Y/2^d.toNat,by rw[hv,←hs];unfold sg;split<;>ring,?_⟩;rw[hZ,if_pos hs];push_cast;rw[abs_lt];constructor<;>linarith ·have hh:=Bool.eq_not_of_ne (Ne.symm hs) refine ⟨X-Y/2^d.toNat,by rw[hv,hh];unfold sg;cases s1<;>simp<;>ring,?_⟩;rw[hZ,if_neg hs,Nat.cast_sub (by have:=h0.resolve_left hs;omega)];rw[abs_lt];constructor<;>linarith rw[hr] at h8 hp;have:=Ν Z.toNat hD;generalize hQ:Z.toNat/Dd.toNat=Q at* generalize Z.toNat%Dd.toNat=R at* have hz:(Q:ℚ)*Dd.toNat+R=Z.toNat:=by exact_mod_cast hb clear hB hC hc hy hZ hF hb hd h0 hn ht ho hu h9 hr;have hK:(4:ℚ)≤R:=by exact_mod_cast h8 have hE:(R:ℚ)+4by rw[h,abs_zero] at h1;have:(0:ℚ)<((Q:ℚ)+(Yt/Dd.toNat-Q))*2^e:=mul_pos XJ XJ;linarith rw[Core.bJ _ _ _ XI,Y8 v h6 s1 (h7 h6) Q _ h3.le hl e h1 XI XI XI,if_neg h3.ne'] congr 3 ·simp;clear * - hg hq;omega ·omega lemma Qa (s0:Bool) (B a w Dd lD id:Д) (g b d:Word) (slow:Unit→Word) (V Q:ℚ) (n:Nat) (h6:Dd.toNat=n*ZW d) (h2:4≤Dd.toNat) (h5:Dd.toNat<2^34) (hc:lD.toNat=Dd.toNat.log2) (hb:id=ZD d) (hj:ZX d=false) (hw:w.toNat≤293) (ha:a.toNat≤61) (hB:B.toNat<2^63) (hX:|Q*ZW g*2^(61-a.toNat)-B.toNat|<2) (hV:V=sg s0 Q*2^((w.toNat:Int)-149)/n*ZA g/ZA d+ZA b) (h3:slow ()=ZT V): Qt s0 B a w Dd lD id g b slow=ZT V:=by have h8:∀ w:Word,ZZ w≤254:=fun w=>by unfold idxOf;have:=expOf_toNat_lt w;split<;>omega have hd:=ZO b;have hp:=h8 g;have hq:=h8 b;have hl:=h8 d;have hh:=Ϩ (show Dd.toNat≠0 by omega);have h9:=@ϱ Dd.toNat;rw[←hc] at hh h9;have ho:lD.toNat≤33:=by rw[hc];exact Nat.le_of_lt_succ ((Nat.log2_lt XI).2 h5) unfold Qt;dsimp only;generalize hg:ZC b*Dd=T;have hT:T.toNat=ZW b*Dd.toNat:=by have:=ύ hd h5;rw[←hg,Ϛ,ZI];exact γ XI have hC:(T<<<(37-lD)).toNat=T.toNat*2^(37-lD.toNat)∧T.toNat*2^(37-lD.toNat)<2^63:=by have hi:(37-lD).toNat=37-lD.toNat:=η _ _ (ε.2 (by simp;omega));have:T.toNat*2^(37-lD.toNat)<2^63:= calc T.toNat*2^(37-lD.toNat)<2^24*2^(lD.toNat+1)*2^(37-lD.toNat):= υ (by rw[hT];exact ύ hd h9) XJ _≤2^63:=by rw[←pow_add,←pow_add];exact ψ XJ XI rw[ο,hi,γ (show 37-lD.toNat<64 by omega),ι];exact ⟨γ XI,this⟩ have h1:(w+ZD g+a).toNat=w.toNat+ZZ g+a.toNat:=by rw[θ,θ,ZS];clear * - hw ha hp;omega have h0:(ZD b+id+24+lD).toNat=ZZ b+ZZ d+24+lD.toNat:=by simp only[θ,ZS,hb,UInt64.reduceToNat];clear * - hc hq hl ho;omega have h7:V=(sg (XG s0 (ZX g)) (Q*ZW g*2^(61-a.toNat))* 2^(((w+ZD g+a).toNat:Int)-62)+sg (ZX b) ((T<<<(37-lD)).toNat:ℚ)* 2^(((ZD b+id+24+lD).toNat:Int)-62))*2^(-148-(ZZ d:Int))/Dd.toNat:=by have e1:Q*ZW g*2^(61-a.toNat)*2^(((w+ZD g+a).toNat:Int)-62)= Q*ZW g*2^((w.toNat:Int)+ZZ g-1):=by rw[XD,←ZF,←ZL ZQ,h1];congr 2;push_cast;clear * - ha;omega have e2:((ZW b*Dd.toNat*2^(37-lD.toNat):ℕ):ℚ)*2^(((ZD b+id+24+lD).toNat:Int)-62)= ZW b*Dd.toNat*2^((ZZ b:Int)+ZZ d-1):=by push_cast;rw[XD,←ZF,←ZL ZQ,h0];congr 2;clear * - hc ho h0;omega rw[←Yv,e1,←Yv,hC.1,hT,e2,XD Q,Qf,hV,Y2 g,Y2 d,Y2 b,hj,h6];have hm:(ZW d:ℚ)≠0:=by have:ZW d≠0:=by intro h;rw[h6,h] at h2;simp at h2 exact_mod_cast this have hn:(n:ℚ)≠0:=by have:n≠0:=by intro h;rw[h6,h] at h2;simp at h2 exact_mod_cast this simp only[Yv];rw[show sg false (ZW d:ℚ)=ZW d from rfl];push_cast;simp only[XB (XC ℚ),ZL (XC ℚ),ZF,zpow_neg];field_simp have h4:id.toNat=ZZ d:=by rw[hb,ZS] have hf:ZC b=0→(T<<<(37-lD)).toNat=0:=fun h=>by rw[hC.1,hT,←ZI,h];simp have he:|((T<<<(37-lD)).toNat:ℚ)-(T<<<(37-lD)).toNat|<2:=XK;split ·rename_i hk;simp only[ϖ,ZY,ZH,ε,h1,h0] at hk;refine Vs _ _ _ _ _ _ _ _ _ _ V (((w+ZD g+a).toNat:Int)-62+(-148-(ZZ d:Int))) hB XI XI hX he ?_ ?_ h3 ·intro h;rw[Ε,θ,h1,h4] at h ⊢;simp only[UInt64.reduceToNat] at h ⊢;clear * - h hw ha hp hl h1 h4;omega ·rw[h7,QB _ _ _ _ _ _ _ ?_];split<;>rename_i h ·exact Or.inl (by rw[hf (by simpa using h)];simp) ·have hr:=hk.resolve_left (by simpa using h);rw[η _ _ (by rw[ε,h1,h0];omega),h1,h0];right;clear * - hc h1 h0 hr;omega ·rename_i hk;simp only[ϖ,ZY,ZH,ε,h1,h0,not_or, not_le] at hk refine Vs _ _ _ _ _ _ _ _ _ _ V (((ZD b+id+24+lD).toNat:Int)-62+(-148-(ZZ d:Int))) XI hB XI he hX ?_ ?_ h3 ·intro h;rw[Ε,θ,h0,h4] at h ⊢;simp only[UInt64.reduceToNat] at h ⊢;clear * - h hc hq hl ho h0 h4;omega ·rw[h7,add_comm,QB _ _ _ _ _ _ _ (Or.inr (show _+((ZD b+id+24+lD)-(w+ZD g+a)).toNat=_ by rw[η _ _ (by rw[ε,h1,h0];clear * - hc h1 h0 hk;omega),h1,h0];clear * - hc h1 h0 hk;omega))] lemma Vt (v s:Д) (hs:s.toNat<64):(v&&&((1<<cases sS<;>cases s0<;>simp[sg] at h ⊢<;>linarith lemma Qz (sx sS:Bool) (M S nX Sh p q:ℕ) (fX fS:ℚ) (ix u w:ℤ) (xv:ℚ) (h0:xv=sg sx (M*2^ix)*2^(-149:ℤ)) (hm:(M:ℚ)*2^ix=(nX+fX)*2^w) (hS:(S:ℚ)*2^u=(Sh+fS)*2^w) (hp:p=(if sx then 0 else nX)+(if sS then Sh else 0)) (hq:q=(if sx then nX else 0)+(if sS then 0 else Sh)): xv-sg sS S*2^(u-149)=sg (decide (pring,hS] unfold sg;split<;>split<;>ring lemma Qi (sS:Bool) (nX Xl fb S L w Dd lD id:Д) (x g b d:Word) (slow:Unit→Word) (V:ℚ) (n u:Nat) (hn:0ring unfold Qr;dsimp only;generalize hi:S>>>L=Sh;generalize hr:(if ZX x=true then 0 else nX)+(if sS=true then Sh else 0)=p;generalize hz:(if ZX x=true then nX else 0)+(if sS=true then 0 else Sh)=q;generalize hy:(if decide (psplit<;>simp<;>omega have hA:A.toNat=Y0 p.toNat q.toNat:=by rw[←hy];clear * - hp hq;unfold Y0;split<;>rename_i h<;>simp only[ZH,ν] at h ·rw[η _ _ (ε.2 XI),if_neg XI] ·rw[η _ _ (ε.2 XI),if_pos XI] have hb:A.toNat<2^38:=by rw[←ς,κ] at h9;simp at h9;clear * - hA h9;omega have h4:=ZO g;have hh:A.toNat*ZW g<2^62:=by have:=ύ hb h4;omega have hM:∀ X:Д,X.toNat<2^38→(X*ZC g).toNat=X.toNat*ZW g:=fun X h=>by rw[Ϛ,ZI];exact γ (by have:=ύ h h4;omega) have hN:=hM A hb;have hl:(ZR (A*ZC g)).toNat=(A.toNat*ZW g).log2:=by rw[Y7,hN] have h8:A.toNat*ZW g≠0:=by intro h;rw[hl,h] at h0;simp at h0 have h1:=ϱ (n:=A.toNat*ZW g);have hB:=Ϩ h8;have h2:=Nat.le_of_lt_succ ((Nat.log2_lt h8).2 hh);rw[←hl] at h1 hB h2;generalize A*ZC g=N at* generalize ZR N=a at* have hj:A.toNat*ZW g*2^(61-a.toNat)<2^62:= calc _<2^(a.toNat+1)*2^(61-a.toNat):=υ h1 XJ _=2^62:=by rw[←pow_add];congr 1;clear * - h0 hl h2;omega have hd:(N<<<(61-a)).toNat=A.toNat*ZW g*2^(61-a.toNat):=by rw[ο,η _ _ (ε.2 (by simp;omega)), show (61:Д).toNat=61 from rfl,γ (show 61-a.toNat<64 by clear * -;omega),ι,hN] exact γ XI have h6:=ϫ (right_ne_zero_of_mul h8);have hs:2≤A.toNat:=by by_contra h;have:=τ (ZW g) (show A.toNat≤1 by clear * - hb h;omega);have:=ψ (show 0<2 by norm_num) h0;omega have ha:=hM Xl XI;have he:=hM Sl (lt_of_lt_of_le h7 (ψ XJ XI));obtain ⟨cx1,cx2,cx3,cx4⟩:=YX (Xl*ZC g) fb a (ZW g) hk h0 h2 h4 (by rw[ha];exact υ hF h6) obtain ⟨cs1,cs2,cs3,-⟩:=YX (Sl*ZC g) L a (ZW g) XI h0 h2 h4 (by rw[he];exact υ h7 h6) rw[ha] at cx1 cx2;rw[he] at cs1 cs2;generalize Yu (Xl*ZC g) fb a=cX at* generalize Yu (Sl*ZC g) L a=cS at* have hP:=τ (ZW g*2^(61-a.toNat)) hs;rw[Υ] at hd hj;have hQ:=Qz (ZX x) sS (ZW x*n) S.toNat nX.toNat Sh.toNat p.toNat q.toNat ((Xl.toNat:ℚ)/2^fb.toNat) ((Sl.toNat:ℚ)/2^L.toNat) (ZZ x) u w.toNat _ ht hm hC hp hq simp only[←hA,←ν] at hQ;generalize (decide (pcases c2<;>simp only[ite_true,XA,Α]<;>ring lemma Qq (m ix w:Д) (M i:Nat) (hm:m.toNat=M) (hM:M<2^34) (hi:ix.toNat=i) (h:M=0∨w.toNat≤ i∧i-w.toNat≤27): (M:ℚ)*2^(i:ℤ)=(m<<<(ix-w)).toNat*2^(w.toNat:ℤ)∧(m<<<(ix-w)).toNat<2^61:=by rcases h with h | ⟨hw,h0⟩ ·rw[show m=0 from ς.mp (by rw[hm,h];rfl),h];simp have hb:=ϰ hM (ψ (n:=2) XI h0) XJ;have e:(m<<<(ix-w)).toNat=M*2^(i-w.toNat):=by rw[ο,η _ _ (by rw[ε,hi];omega),hi,hm, γ (show i-w.toNat<64 by omega),ι];exact γ XI refine ⟨?_,XI⟩;have e2:(2:ℚ)^(i:ℤ)=2^(i-w.toNat)*2^(w.toNat:ℤ):=by rw[←ZF,←ZL ZQ];congr 1;omega rw[e,e2];push_cast;ring lemma Qj (n u S lS:Д) (sS:Bool) (Dd lD id:Д) (x g b d:Word) (slow:Unit→Word) (V:ℚ) (hn:n.toNat<1024) (hS:S.toNat<2^63) (hd:Dd.toNat=n.toNat*ZW d) (ha:4≤Dd.toNat) (hr:lD.toNat=Dd.toNat.log2) (hp:id=ZD d) (hq:ZX d=false) (hu:u.toNat≤255) (hV:V=(ZA x-sg sS S.toNat*2^((u.toNat:Int)-149)/n.toNat)* ZA g/ZA d+ZA b) (h5:slow ()=ZT V): Qy n u S lS sS Dd lD id x g b slow=ZT V:=by have hw:ZZ x≤254:=by unfold idxOf;have:=expOf_toNat_lt x;split<;>omega have hk:Dd.toNat<2^34:=by rw[hd];have:=ύ hn (ZO d);omega have hh:0Qi sS nX Xl fb S L w Dd lD id x g b d slow V n.toNat u.toNat hh hd ha hk hr hp hq hS unfold Qy;dsimp only;generalize hi:ZC x*n=m;have hm:m.toNat=ZW x*n.toNat:=by rw[←hi,Ϛ,ZI];exact γ XI generalize hf:ZD x=ix;have h3:ix.toNat=ZZ x:=by rw[←hf,ZS] split ·rename_i hc;simp at hc;obtain ⟨h1,h2⟩:=Qq m ix u _ _ hm h7 h3 (by rcases hc.1 with h | h ·exact Or.inl (by rw[←hm,h];rfl) ·rw[ε,Ε,h3] at h;simp only[UInt64.reduceToNat] at h;exact Or.inr (by clear * - hu hw h3 h;omega)) exact hC _ 0 0 0 u XK hu h2 XK XK XK (by simpa using h1) hV h5 ·generalize hj:max u (max (ix+ZR m) (u+lS)-36)=w;have hl:u.toNat≤w.toNat:=by rw[←hj,UInt64.toNat_max];omega generalize he:(if (m==0 || w≤ ix)=true then 0 else w-ix)=fb;split;swap;· exact h5 rename_i hc;simp only[Ζ,ϖ,ZH,ZY,ν,h3, ε,UInt64.reduceToNat] at hc obtain ⟨h9,hs⟩:=hc;have h4:(m&&&((1<<>>fb)=nX;obtain ⟨ho,ht⟩:((ZW x*n.toNat:ℕ):ℚ)*2^(ZZ x:ℤ)= (nX.toNat+(Xl.toNat:ℚ)/2^fb.toNat)*2^(w.toNat:ℤ)∧nX.toNat<2^61:=by by_cases h0:ZW x*n.toNat=0 ·have hb:m=0:=ς.mp (by rw[hm,h0];rfl);have:nX=0:=by rw[←h8,hb];split<;>simp rw[h4,h0,this];simp have hb:(m==0)=false:=by simp[←ς,hm,h0] by_cases h6:w.toNat≤ ZZ x ·have hg:fb.toNat=0:=by rw[←he,if_pos (by simp[ε,h3,h6])];rfl rw[h4,hg,←h8,if_pos (by rw[ε,h3];exact h6)];obtain ⟨e1,e2⟩:=Qq m ix w _ _ hm h7 h3 (Or.inr ⟨h6,by rcases hs with (h | h) | h ·exact absurd (by rw[←hm,h];rfl) h0 ·omega ·rwa[η _ _ (by rw[ε,h3];omega),h3] at h⟩) exact ⟨by rw[e1];simp[Nat.mod_one],e2⟩ ·have hv:fb.toNat=w.toNat-ZZ x:=by rw[←he,if_neg (by simp[ε,h3,h6,hb]), η _ _ (by rw[ε,h3];omega),h3] have e:nX.toNat=ZW x*n.toNat/2^fb.toNat:=by rw[←h8,if_neg (by rw[ε,h3];exact h6),κ,hm, γ h9,ζ] refine ⟨?_,by rw[e];exact lt_of_le_of_lt (ZV _ _) XI⟩;rw[e,h4,show (w.toNat:ℤ)=ZZ x+fb.toNat by clear * - h3 h6 hv;omega,ZL ZQ,ZF (2:ℚ) fb.toNat];field_simp;exact_mod_cast (ZU _ _).symm exact hC nX Xl fb (w-u) w (by rw[η _ _ (ε.2 hl)];omega) hu ht h9 (by rw[h4];exact Ν _ XJ) (by rw[h4];exact lt_of_le_of_lt (Nat.mod_le _ _) h7) ho hV h5 def Yy (n:Nat) (eps:Word) (x:ZB) (r:Nat):Word:= 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:Nat) (eps:Word) (x:ZB) (r:Nat) (hn:0F (i/n) i):=by induction h:rows-r generalizing r out with | zero=> unfold Yb;rw[if_neg XI];simp | succ k ih=> unfold Yb;rw[if_pos XI];rw[ih (r+1) _ XI,Elem.Y9,List.append_assoc];congr 1;rw[show r*n+n-r*n=n by omega,show (r+1)*n=r*n+n by ring, show (k+1)*n=n+k*n by ring,←List.range'_append_1,List.map_append] congr 1;apply List.map_congr_left;intro i hi;rw[List.mem_range'_1] at hi;have h0:0ZT (ZA a*ZA b/ZA d)) else ZT (ZA a*ZA b/ZA d) lemma VQ (a b d:Word): VP a b d=ZT (ZA a*ZA b/ZA d):=by unfold VP;dsimp only;rw[Elem.YB];split_ifs with hz hd ·have h1:=Nat.mul_eq_zero.1 (by simpa using hz);have:ZA a*ZA b=0:=by rw[Y2 a,Y2 b];rcases h1 with h | h<;>simp[h,sg] rw[this,zero_div,Yp] ·have h0:=ϫ (by simpa[Q6] using hd);have h3:(0:ℚ)< ZW d:=by exact_mod_cast h0 have hv:ZA a*ZA b/ZA d= sg (XG (XG (ZX a) (ZX b)) (ZX d)) ((ZW a*ZW b:Nat):ℚ)* 2^((((ZZ a+ZZ b:Nat):Int)-(ZZ d:Int)-149))/(ZW d:ℚ):=by rw[Y2 a,Y2 b,Y2 d];have h2:(2:ℚ)^(((ZZ a+ZZ b:Nat):Int)-(ZZ d:Int)-149)= 2^((ZZ a:Int)-149)*2^((ZZ b:Int)-149)/2^((ZZ d:Int)-149):=by rw[←ZL XJ,←XB XJ];push_cast;ring rw[h2];unfold sg;cases ZX a<;>cases ZX b<;>cases ZX d<;>simp<;>ring obtain ⟨ha,hs⟩:=Vm _ ((ZW a*ZW b:Nat):ℚ) XJ _ _ h0;rw[←hv] at ha hs;simp only[ZI,ZS];exact YC _ _ false _ _ _ _ 0 hs le_rfl one_pos XK h0 (by rw[ha];simp) rfl ·rfl def Yo (rows n:Nat) (eps:Word) (x g:ZB):ZB:= let den:=Array.ofFn (n:=rows) fun r=>Yy n eps x r.val Yb (fun r i=>VP x[i]! g[i-r*n]! den[r]!) n rows 0 (Array.mkEmpty (rows*n)) lemma YE (i n:Nat):i-i/n*n=i%n:=by have:=Ϭ i n;rw[ϐ] at this;omega lemma Qg {α:Type} [Inhabited α] {m k:Nat} (f:Fin m→α) (h:k< m): (Array.ofFn f)[k]! =f ⟨k,h⟩:=by rw[getElem!_pos _ k (by simpa using h),Θ] lemma Ys (F:Nat→Nat→Word) (n rows:Nat) (f:Fin (rows*n)→Word) (h:∀ i (h:isimp;exact h lemma YP (rows n:Nat) (eps:Word) (x g:ZB) (hn:0>>k,S&&&(VO 1 k-1),V5 (n*Q-S*S) (n*n) u eps) lemma Vn (n:Nat) (eps:Word) (x:ZB) (r:Nat) (hn:0ZT ((ZA x[i]! -rowMean n x r)*ZA g[j]! /ZA t.2.2.2.2.2+ZA b[j]!) def Yw (rows n:Nat) (eps:Word) (x g b:ZB):ZB:= let st:=Array.ofFn (n:=rows) fun r=> let t:=YU n eps x r.val let S:=(t.2.2.2.1<< let e:=st[r]! let t:=e.1 let j:=i-r*n if e.2.1 then Qy n.toUInt64 t.1.toUInt64 e.2.2.1 e.2.2.2.2.2 t.2.2.1 e.2.2.2.1 e.2.2.2.2.1 (ZD t.2.2.2.2.2) x[i]! g[j]! b[j]! fun _=>g7 n x g b t r i else g7 n x g b t r i) n rows 0 (Array.mkEmpty (rows*n)) lemma V3 (rows n:Nat) (eps:Word) (x g b:ZB) (hn:0ZT _) hn hx hm rfl;split_ifs with hc ·simp at hc;obtain ⟨⟨⟨hS,h1⟩,h4⟩,h2⟩:=hc;have tn:∀ m:Nat,m<2^64→m.toUInt64.toNat=m:=fun m h=>by rw[Ϸ,ZG,γ h] have h0:UInt64.toNat (n.toUInt64*ZC d)=n*ZW d:=by have:=ύ h1 (ZO d);rw[Ϛ,tn n XI,ZI,γ XI] rw[ε,h0] at h2;rw[Qj _ _ _ _ _ _ _ _ _ _ _ _ _ _ (by rwa[tn n XI]) (by rwa[tn _ XI]) (by rw[h0,tn n XI]) (by rw[h0];simpa using h2) (by rw[Y7]) rfl h4 (by rw[tn u XI];exact h3) (by rw[hm,tn _ XI,tn u XI,tn n XI,ι]) hE] ·exact hE def bO (rows n:Nat) (eps:Word) (x g b:ZB):ZB:= if stableNormDomain rows n eps x g&&b.size==n&&b.all finiteWord then Yw rows n eps x g b else layernormSpec rows n eps x g b lemma dA:bO=layernormSpec:=by funext rows n eps x g b;unfold bO;split_ifs with h ·unfold layernormSpec layernormWith;rw[if_pos h];have h':=h;simp only[stableNormDomain,Ζ,ZH,gt_iff_lt] at h';obtain ⟨⟨⟨⟨⟨⟨⟨⟨⟨-,hn⟩,-⟩,-⟩,-⟩,-⟩,-⟩,he⟩,-⟩,-⟩:=h';exact V3 rows n eps x g b hn he ·rfl end Norm end def c3 (s:ConvShape) (relu:Bool) (inp wts b:Array Word):Array Word := if s.kh == 1 && s.kw == 1 && s.stride == 1 && s.pad == 0 then Dense.d6 Conv.dR s relu inp wts b else Conv.dR s relu inp wts b lemma eW:c3=conv2dSpec:=by funext s relu inp wts b unfold c3 split ·rw[Dense.fY _ Conv.dg] ·rw[Conv.dg] def kernels:Kernels where core:=⟨sumSpec,dotSpec⟩ dense:=⟨Dense.d0,Dense.gg⟩ conv:=⟨c3,Conv.dh⟩ elem:=⟨Conv.eR,Conv.fk,Bn.cZ,Bn.bP⟩ norm:=⟨Norm.cB,Norm.bO⟩ theorem correct:Obligation kernels:=by simp only[Obligation,kernels,specKernels,specCore,specDense,specConv,specElem,specNorm, Dense.fM,Dense.gT,eW,Conv.dT,Conv.go,Conv.f9, Bn.eP,Bn.dC,Norm.ez,Norm.dA] end Submission