import ContractExact open USize renaming size -> zz3 open List renaming range -> zz4 open Nat renaming mod_eq_of_lt -> zz5 open FloatLib.Floats.Formats.BinaryInterchange.Model.NativeBinary64 renaming ofUInt64 -> zz6 open Float renaming ofBits -> zz0 open FloatArray renaming emptyWithCapacity -> zz1 open Array renaming ofFn -> zz2 open ExactRuntime renaming rationalWord -> z9 open ExactRuntime renaming idxOf -> zz open ExactRuntime renaming mantOf -> z11 open ExactRuntime renaming expOf -> z12 local notation "ڎ" => UInt32 local notation "ڜ" => UInt64 local notation "ڟ" => Array local notation "ڡ" => Bool local notation "ڣ" => Nat local notation "ڨ" => FloatArray local notation "ڭ" => Float local notation "ڰ" => Real local notation "ڲ" => USize open FloatLib.Floats.Formats.BinaryInterchange.FloatFormat renaming binary64 -> Q0 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming ofFloatModel -> Q2 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming toReal -> Q3 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming isFinite -> Q4 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming toDyadic? -> Q5 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming roundDyadic -> Q6 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming roundAt -> Q7 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming toModel_ofFloatModel -> Q8 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming unpackedToReal -> Q12 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming unpackedToDyadic? -> Q13 open FloatLib.Floats.Formats.BinaryInterchange.Model renaming toDyadic?_ofFields_of_isFinite -> Q17 open UInt64 renaming toNat_and -> Q20 open Int renaming ofNat_eq_natCast -> Q21 open FloatLib.Floats.Formats.Flocq renaming bpow -> Q22 open FloatLib.Numerics renaming binaryRadix -> Q23 local notation "Q24" => (by omega) local notation "Q25" => (by norm_num) local notation "Q26" => (by decide) local notation "Q27" => (by positivity) local notation "Q29" => (by simp) set_option maxHeartbeats 4000000 set_option maxRecDepth 8192 namespace d8 open FloatLib.Floats.Formats.BinaryInterchange noncomputable def real (v:ڭ):ڰ:=Q3 (Q2 v.toModel) def finite (v:ڭ):Prop:=Q4 (Q2 v.toModel) @[inline] def gk (w:ڎ):ڡ:= let e:=(w>>>23)&&&255 e !=255 && (e !=0 || w&&&0x7fffff==0) @[inline] def convert (w:ڎ):ڭ:= let sg:=(w&&&0x80000000).toUInt64<<<32 if w&&&0x7fffffff==0 then zz0 sg else zz0 (sg ||| (((w&&&0x7fffffff).toUInt64<<<29)+0x3800000000000000)) def pack (A:ڟ ڎ) (i:ڣ) (P:ڨ):ڨ:= if i omega cases P rw [hr] simp [FloatArray.push] · rename_i h have hz:n-i=0:=by omega simp [hz] termination_by n-i @[inline] def fR (n:ڣ) (f:ڣ→ ڭ):ڨ:=f7 n f 0 (zz1 n) lemma dW (n:ڣ) (f:ڣ→ ڭ): (fR n f).data=((zz4 n).map f).toArray:=by rw [fR,e0] simp [zz1,List.range_eq_range'] lemma dX (n:ڣ) (f:ڣ→ ڭ):(fR n f).size=n:=by change (fR n f).data.size=n rw [dW] simp lemma eC (n:ڣ) (f:ڣ→ ڭ) (i:ڲ) (hi:i.toNat norm_num rw [h,hs] cases w.toNat.testBit 31 <;> rfl lemma eH (w:ڎ): (f9 w).toNat=(if signOf w then 2^63 else 0)+((z12 w).toNat+896)*2^52+(fracOf w).toNat*2^29:=by have he:=expOf_toNat_lt w have hf:=fracOf_toNat_lt w have ha:=fh w have hs:=fe w have hab:(w&&&0x7fffffff).toNat<2^31:=by omega have hl:((w&&&0x7fffffff).toNat*2^29+0x3800000000000000)<2^63:=by omega have hlow:(((w&&&0x7fffffff).toUInt64<<<29)+0x3800000000000000).toNat= (w&&&0x7fffffff).toNat*2^29+0x3800000000000000:=by simp only [UInt64.toNat_add,UInt64.toNat_shiftLeft,UInt32.toUInt64_toNat] norm_num [Nat.shiftLeft_eq] simp only [UInt32.toNat_and] at hl norm_num at hl ⊢ omega have hsign:((w&&&0x80000000).toUInt64<<<32).toNat=if signOf w then 2^63 else 0:=by simp only [UInt64.toNat_shiftLeft,UInt32.toUInt64_toNat,hs] cases signOf w <;> norm_num [Nat.shiftLeft_eq] simp only [f9,UInt64.toNat_or,hlow,hsign] have hor:(if signOf w then 2^63 else 0)|||((w&&&0x7fffffff).toNat*2^29+0x3800000000000000)= (if signOf w then 2^63 else 0)+((w&&&0x7fffffff).toNat*2^29+0x3800000000000000):=by cases signOf w · simp · simpa [Nat.shiftLeft_eq] using (Nat.shiftLeft_add_eq_or_of_lt (i:=63) hl 1).symm rw [hor,ha] ring lemma fo (fmt:FloatFormat) (sign:ڡ) (e f:ڣ) (he:e<2^fmt.expWidth) (hf:f<2^fmt.fracWidth): (Model.ofFields fmt sign e f).toNatBits= (if sign then 1<<<(fmt.expWidth+fmt.fracWidth) else 0)|||(e<< norm_num [Nat.shiftLeft_eq] lemma ct (w:ڎ): zz6 ((w&&&0x80000000).toUInt64<<<32)= Model.ofFields Q0 (signOf w) 0 0:=by have hnat:(zz6 ((w&&&0x80000000).toUInt64<<<32)).toNatBits= (Model.ofFields Q0 (signOf w) 0 0).toNatBits:=by change ((w&&&0x80000000).toUInt64<<<32).toNat=_ rw [d6,fo _ _ _ _ Q25 Q25] cases signOf w <;> norm_num [Nat.shiftLeft_eq,show FloatFormat.binary64.expWidth=11 from rfl,show FloatFormat.binary64.fracWidth=52 from rfl] rw [←Model.ofNatBits_toNatBits (zz6 ((w&&&0x80000000).toUInt64<<<32)),hnat,Model.ofNatBits_toNatBits] end d8 namespace d8 open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange lemma fi (v:ڜ): Model.toModel (Q2 (zz0 v).toModel)= Model.toModel (zz6 v):=by change Model.toModel (Model.canonicalizeModel (zz6 v))=_ exact Model.toModel_canonicalizeModel _ lemma eM (v:ڜ): Q5 (Q2 (zz0 v).toModel)= Q5 (zz6 v):=by rw [Model.toDyadic?_ieee_eq_model _ Q26,Model.toDyadic?_ieee_eq_model _ Q26,fi] lemma fu (v:ڜ):finite (zz0 v) ↔ Q4 (zz6 v)=true:=by have h:=congrArg Option.isSome (eM v) simp only [Model.toDyadic?_isSome_eq_isFinite] at h change Q4 (Q2 (zz0 v).toModel)=true ↔ _ rw [h] lemma f1 (v:ڜ):real (zz0 v)=Q3 (zz6 v):=by unfold real rw [Model.toReal_eq,Model.toReal_eq,eM] lemma d2 (w:ڎ):Q4 (zz6 (f9 w))=true:=by rw [d1,Model.isFinite_ofFields _ _ _ _ (by have:=expOf_toNat_lt w;change _<2^11;omega) (by have:=fracOf_toNat_lt w;change _<2^52;omega)] change ((z12 w).toNat+896 !=2047)=true simp only [bne_iff_ne] have:=expOf_toNat_lt w omega lemma cu (w:ڎ):Q4 (zz6 ((w&&&0x80000000).toUInt64<<<32))=true:=by rw [ct,Model.isFinite_ofFields _ _ _ _ (by change 0<2^11;norm_num) (by change 0<2^52;norm_num)] rfl lemma cZ (w:ڎ):finite (convert w):=by unfold convert split · rw [fu];exact cu w · rw [fu];exact d2 w lemma d0 (w:ڎ): Q5 (zz6 (f9 w))=some ⟨signOf w,(2^23+(fracOf w).toNat)*2^29,((z12 w).toNat:Int)-179⟩:=by have hfin:=d2 w rw [d1] at hfin ⊢ rw [Q17 _ _ _ _ (by have:=expOf_toNat_lt w;change _<2^11;omega) (by have:=fracOf_toNat_lt w;change _<2^52;omega) hfin] simp only [show FloatFormat.binary64.exponentBias=1023 from rfl,show FloatFormat.binary64.fracWidth=52 from rfl] rw [if_neg Q24,Model.pow2_eq_two_pow] congr 2 <;> (try simp only [Q21,Nat.cast_add,Nat.cast_ofNat]) <;> ring lemma cs (w:ڎ): Q5 (zz6 ((w&&&0x80000000).toUInt64<<<32))=some ⟨signOf w,0,0⟩:=by have hf:=cu w rw [ct] at hf ⊢ rw [Q17 _ _ _ _ (by change 0<2^11;norm_num) (by change 0<2^52;norm_num) hf] rfl lemma eK (w:ڎ) (h:gk w=true): z12 w≠255 ∧ (z12 w≠0 ∨ fracOf w=0):=by change ((z12 w !=255) && (z12 w !=0 || fracOf w==0))=true at h simpa only [Bool.and_eq_true,Bool.or_eq_true,bne_iff_ne,beq_iff_eq] using h lemma bd (w:ڎ) (h:gk w=true):real (convert w)=(decodeD w).toReal:=by have hv:=eK w h by_cases he:z12 w=0 · have hf:fracOf w=0:=hv.2.resolve_left (by simpa [he]) have hab:w&&&0x7fffffff=0:=by apply UInt32.toNat_inj.mp simpa only [fh,he,hf,UInt32.toNat_zero,Nat.zero_mul,Nat.zero_add] simp only [convert,hab,beq_self_eq_true,ite_true] rw [f1,Model.toReal_eq,cs] simp [decodeD,he,hf,Numerics.Dyadic.toReal,Numerics.Dyadic.signedSignificand] · have hab:w&&&0x7fffffff≠0:=by intro ha have hh:=fh w rw [ha,UInt32.toNat_zero] at hh have: (z12 w).toNat=0:=by omega exact he (UInt32.toNat_inj.mp this) simp only [convert,beq_iff_eq,hab,ite_false] change real (zz0 (f9 w))=_ rw [f1,Model.toReal_eq,d0] simp only [decodeD,he,ite_false,Numerics.Dyadic.toReal,Numerics.Dyadic.signedSignificand] split <;> push_cast all_goals rw [show ((z12 w).toNat:Int)-179=(((z12 w).toNat:Int)-150)-29 by ring,zpow_sub₀ (by norm_num: (2:ڰ)≠0)] all_goals norm_num all_goals ring lemma eb (w:ڎ) (h:gk w=true): real (convert w)=(sv w:ڰ)*2^((zz w:Int)-149):=by rw [bd w h,←Numerics.Dyadic.cast_toRat,decodeD_toRat] push_cast rfl end d8 namespace Submission open FloatLib.Floats.Formats.BinaryInterchange open FloatLib.Floats.Formats.Flocq lemma bn (x:ڰ) (E:Int) (he: -1021 ≤ E) (hx:|x|<(2:ڰ)^E): |Q7 Q0 x-x|≤(2:ڰ)^(E-53)/2:=by by_cases hz:x=0 · subst x rw [Model.roundAt_zero] simp only [sub_zero,abs_zero] positivity have hm:magnitude Q23 x≤E:= magnitude_le_of_abs_lt_bpow _ x E hz hx apply (Model.abs_roundAt_sub_le Q0 x).trans apply div_le_div_of_nonneg_right _ Q25 change ulp Q23 (Model.fexpOf Q0) x ≤ (2:ڰ)^(E-53) rw [ulp.of_ne_zero _ _ x hz] change (2:ڰ)^(max (magnitude Q23 x-53) (-1074))≤(2:ڰ)^(E-53) apply zpow_le_zpow_right₀ Q25 omega end Submission namespace d8 open FloatLib.Floats.Formats.BinaryInterchange open FloatLib.Floats.ExecFloat lemma dQ (v:ڭ): finite v ↔ v.isFinite=true:= by unfold finite rw [← Model.toDyadic?_isSome_eq_isFinite,Model.toDyadic?_ieee_eq_model _ Q26,Q8] change (Q13 v.toModel.unpack).isSome=true ↔ v.toModel.unpack.isFinite=true cases v.toModel.unpack <;> rfl lemma fM (x y:ڭ) (hx:finite x) (hy:finite y): Q2 (x+y).toModel = Model.add (Q2 x.toModel) (Q2 y.toModel):=by change Q2 (Float.Model.add x.toModel y.toModel) = _ rw [Float.Model.add,Model.ofFloatModel_pack] have h:=Model.add_eq_ofModel_add_of_isFinite (fmt:=Q0) Q26 (Q2 x.toModel) (Q2 y.toModel) (by simpa only [Q8,Float.isFinite,Float.Model.isFinite] using (dQ x).mp hx) (by simpa only [Q8,Float.isFinite,Float.Model.isFinite] using (dQ y).mp hy) rw [Q8,Q8] at h exact h.symm lemma cK (E:Int) (he:E≤512): (2:ڰ)^E ≤ Q3 (Model.posMaxFinite Q0):=by have h:=Model.abs_signed_mul_bpow_le_toReal_posMaxFinite Q0 false 1 E (by change 1 ≤ 4503599627370496+4503599627370495; omega) (by change E ≤ 971; omega) simp only [Bool.false_eq_true,ite_false,Nat.cast_one,one_mul] at h change |(2:ڰ)^E| ≤ _ at h simpa only [abs_of_pos (zpow_pos (by norm_num: (0:ڰ)<2) E)] using h lemma fz (x y:ڭ) (hx:finite x) (hy:finite y) (E:Int) (he:-1021≤E) (he':E≤512) (hb:|real x+real y|<(2:ڰ)^E): finite (x+y) ∧ real (x+y)=Q7 Q0 (real x+real y) ∧ |real (x+y)-(real x+real y)|≤(2:ڰ)^(E-53)/2:= by have hm:=fM x y hx hy have hf:=Model.isFinite_add_of_abs_toReal_add_le_posMaxFinite (Q2 x.toModel) (Q2 y.toModel) Q26 hx hy (hb.le.trans (cK E he')) have hr:=Model.toReal_add_eq_roundAt (Q2 x.toModel) (Q2 y.toModel) Q26 hx hy hf have hr':real (x+y)=Q7 Q0 (real x+real y):=by simpa only [real,hm] using hr exact ⟨by simpa only [finite,hm] using hf,hr',by rw [hr']; exact Submission.bn _ _ he hb⟩ lemma fN (x y:ڭ) (hx:finite x) (hy:finite y): Q2 (x-y).toModel = Model.sub (Q2 x.toModel) (Q2 y.toModel):=by change Q2 (Float.Model.sub x.toModel y.toModel) = _ rw [Float.Model.sub,Model.ofFloatModel_pack] have h:=Model.sub_eq_ofModel_sub_of_isFinite (fmt:=Q0) Q26 (Q2 x.toModel) (Q2 y.toModel) (by simpa only [Q8,Float.isFinite,Float.Model.isFinite] using (dQ x).mp hx) (by simpa only [Q8,Float.isFinite,Float.Model.isFinite] using (dQ y).mp hy) rw [Q8,Q8] at h exact h.symm lemma fT (x y:ڭ) (hx:finite x) (hy:finite y) (E:Int) (he:-1021≤E) (he':E≤512) (hb:|real x-real y|<(2:ڰ)^E): finite (x-y) ∧ real (x-y)=Q7 Q0 (real x-real y) ∧ |real (x-y)-(real x-real y)|≤(2:ڰ)^(E-53)/2:= by have hm:=fN x y hx hy have hf:=Model.isFinite_sub_of_abs_toReal_sub_le_posMaxFinite (Q2 x.toModel) (Q2 y.toModel) Q26 hx hy (hb.le.trans (cK E he')) have hr:=Model.toReal_sub_eq_roundAt (Q2 x.toModel) (Q2 y.toModel) Q26 hx hy hf have hr':real (x-y)=Q7 Q0 (real x-real y):=by simpa only [real,hm] using hr exact ⟨by simpa only [finite,hm] using hf,hr',by rw [hr']; exact Submission.bn _ _ he hb⟩ end d8 namespace d8 open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange open FloatLib.Floats.Formats.Flocq noncomputable def fO (u:Float.Model.UnpackedFloat):Prop:= match u with | .zero _=>True | .finite _ m e _=>∃M:ڣ,2^23≤ M ∧ M<2^24 ∧ m=M*2^29 ∧ -178≤ e ∧ e≤75 | _=>False lemma dS (v:ڭ):Q5 (Q2 v.toModel)=Q13 v.toModel.unpack:=by rw[Model.toDyadic?_ieee_eq_model _ Q26,Q8] lemma b0 (w:ڎ) (hv:gk w=true):fO (convert w).toModel.unpack:=by have he:=eK w hv by_cases hz:w&&&0x7fffffff=0 · have hd:Q13 (convert w).toModel.unpack=some ⟨signOf w,0,0⟩:=by rw[←dS] simp only[convert,hz,beq_self_eq_true,ite_true] rw[eM,cs] cases hu:(convert w).toModel.unpack with | notANumber=>simp only[hu,Q13]at hd;cases hd | infinity sg=>simp only[hu,Q13]at hd;cases hd | zero sg=>trivial | finite sg m e hm=> simp only[hu,Q13,Option.some.injEq,Numerics.Dyadic.mk.injEq]at hd have:m=0:=hd.2.1 omega · have hex:z12 w≠0:=by intro h have hf:fracOf w=0:=he.2.resolve_left (by simp only[h,ne_eq,not_true_eq_false,not_false_eq_true]) apply hz apply UInt32.toNat_inj.mp simp only[fh,h,hf,UInt32.toNat_zero,Nat.zero_mul,Nat.zero_add] have hd:Q13 (convert w).toModel.unpack=some ⟨signOf w,(2^23+(fracOf w).toNat)*2^29,((z12 w).toNat:Int)-179⟩:=by rw[←dS] simp only[convert,beq_iff_eq,hz,ite_false] change Q5 (Q2 (zz0 (f9 w)).toModel)=_ rw[eM,d0] cases hu:(convert w).toModel.unpack with | notANumber=>simp only[hu,Q13]at hd;cases hd | infinity sg=>simp only[hu,Q13]at hd;cases hd | zero sg=>trivial | finite sg m e hm=> simp only[hu,Q13,Option.some.injEq,Numerics.Dyadic.mk.injEq]at hd change ∃M:ڣ,2^23≤ M ∧ M<2^24 ∧ m=M*2^29 ∧ -178≤ e ∧ e≤75 refine ⟨2^23+(fracOf w).toNat,by omega,?_,hd.2.1,?_,?_⟩ · have:=fracOf_toNat_lt w omega · have hh:0<(z12 w).toNat:=by have h0:(z12 w).toNat≠0:=by intro hh;apply hex;exact UInt32.toNat_inj.mp hh omega rw[hd.2.2] omega · have hh:(z12 w).toNat<255:=by have hh:=expOf_toNat_lt w have h0:(z12 w).toNat≠255:=by intro hh;apply he.1;exact UInt32.toNat_inj.mp hh omega rw[hd.2.2] omega lemma fn (d:Numerics.Dyadic):|d.toReal|=(d.significand:ڰ)*(2:ڰ)^d.exponent:=by cases h:d.negative <;> simp[Numerics.Dyadic.toReal,Numerics.Dyadic.signedSignificand,h,abs_mul,abs_of_pos (zpow_pos (by norm_num: (0:ڰ)<2) _)] lemma aG (s1 s2:Float.Model.UnpackedFloat.Sign) (m1 m2:ڣ) (e1 e2:Int) (hp1:0< m1) (hp2:0< m2) (h1:∃M:ڣ,2^23≤ M ∧ M<2^24 ∧ m1=M*2^29 ∧ -178≤ e1 ∧ e1≤75) (h2:∃M:ڣ,2^23≤ M ∧ M<2^24 ∧ m2=M*2^29 ∧ -178≤ e2 ∧ e2≤75): let u:=Float.Model.UnpackedFloat.mul Float.Model.Format.binary64 (.finite s1 m1 e1 hp1) (.finite s2 m2 e2 hp2) Q4 (Model.ofModel Q0 u)=true ∧ Q3 (Model.ofModel Q0 u)= Q12 (.finite s1 m1 e1 hp1)*Q12 (.finite s2 m2 e2 hp2):=by obtain ⟨M1,hM1,hM1',hr1,he1,he1'⟩:=h1 obtain ⟨M2,hM2,hM2',hr2,he2,he2'⟩:=h2 have hm1lo:2^52≤ m1:=by calc 2^52=2^23*2^29:=by norm_num _≤ M1*2^29:=Nat.mul_le_mul_right _ hM1 _=m1:=hr1.symm have hm2lo:2^52≤ m2:=by calc 2^52=2^23*2^29:=by norm_num _≤ M2*2^29:=Nat.mul_le_mul_right _ hM2 _=m2:=hr2.symm have hm1hi:m1<2^53:=by rw[hr1];norm_num at hM1' ⊢;omega have hm2hi:m2<2^53:=by rw[hr2];norm_num at hM2' ⊢;omega have hmlo:2^104≤ m1*m2:=by calc 2^104=2^52*2^52:=by norm_num _≤ m1*m2:=Nat.mul_le_mul hm1lo hm2lo have hmhi:m1*m2<2^106:=by calc m1*m2<2^53*2^53:=Nat.mul_lt_mul_of_lt_of_le hm1hi (le_of_lt hm2hi) Q25 _=2^106:=by norm_num have hmlog:52≤ Nat.log2 (m1*m2):=(Nat.le_log2 (Nat.mul_ne_zero hp1.ne' hp2.ne')).2 (by norm_num at hmlo ⊢;omega) have hpre:e1+e2≤ Float.Model.Format.binary64.targetExponent (Float.Model.totalExponent (m1*m2) (e1+e2)):=by change e1+e2≤ max ((Nat.log2 (m1*m2):Int)+1+(e1+e2)-53) (-1074) apply le_max_of_le_left have hh:(52:Int)≤(Nat.log2 (m1*m2):Int):=by exact_mod_cast hmlog omega let d:Numerics.Dyadic:=⟨Model.modelSignBit (s1*s2),m1*m2,e1+e2⟩ have hs:Model.modelSign (Model.modelSignBit (s1*s2))=s1*s2:=by cases s1 <;> cases s2 <;> rfl have hround:Model.ofModel Q0 (Float.Model.UnpackedFloat.mul Float.Model.Format.binary64 (.finite s1 m1 e1 hp1) (.finite s2 m2 e2 hp2))= Q6 Q0 d:=by rw[Float.Model.UnpackedFloat.mul,Model.roundWithAccuracy_exact_eq_round_of_le_targetExponent _ _ _ _ hpre] simp only[Q6,show FloatFormat.binary64.isIEEE=true from rfl,ite_true,Model.ieeeRoundDyadic,d,hs] rfl have hsig:d.significand=(M1*M2)*2^58:=by dsimp only[d] rw[hr1,hr2] norm_num ring have hprec:M1*M2<2^(FloatFormat.binary64.fracWidth+1):=by have hh:M1*M2<2^24*2^24:=Nat.mul_lt_mul_of_lt_of_le hM1' (le_of_lt hM2') Q25 change M1*M2<2^53 norm_num at hh ⊢ omega have hbound:|d.toReal|≤ Q3 (Model.posMaxFinite Q0):=by rw[fn] have hmant:((m1*m2:ڣ):ڰ)≤(2:ڰ)^(106:Int):=by norm_num only[zpow_natCast] exact_mod_cast le_of_lt hmhi have hexp:(2:ڰ)^(e1+e2)≤(2:ڰ)^(150:Int):=zpow_le_zpow_right₀ Q25 Q24 calc (d.significand:ڰ)*(2:ڰ)^d.exponent ≤(2:ڰ)^(106:Int)*(2:ڰ)^(150:Int):=mul_le_mul hmant hexp (le_of_lt (zpow_pos Q25 _)) (le_of_lt (zpow_pos Q25 _)) _=(2:ڰ)^(256:Int):=by rw[←zpow_add₀ Q25];rfl _≤(2:ڰ)^(512:Int):=zpow_le_zpow_right₀ Q25 Q25 _≤ Q3 (Model.posMaxFinite Q0):=cK 512 le_rfl have hr:=Model.roundDyadic_of_representable Q0 (by rfl) d (M1*M2) 58 hsig hprec (by change -1074≤ e1+e2;omega) hbound have hreal:d.toReal=Q12 (.finite s1 m1 e1 hp1)*Q12 (.finite s2 m2 e2 hp2):=by cases s1 <;> cases s2 <;> simp only[d,Numerics.Dyadic.toReal,Numerics.Dyadic.signedSignificand,Model.unpackedToReal_finite,Model.modelSignBit] all_goals simp [Q22,Q23,FloatLib.Numerics.Radix.toReal,zpow_add₀ (by norm_num: (2:ڰ)≠0)] <;> push_cast <;> ring dsimp only rw[hround] exact ⟨hr.1,hr.2.trans hreal⟩ lemma dZ (x:ڭ):real x=Q12 x.toModel.unpack:=by rw[real,Model.toReal_eq_unpackedToReal_toModel Q26,Q8] lemma cM (x y:ڭ):Q2 (x*y).toModel= Model.ofModel Q0 (Float.Model.UnpackedFloat.mul Float.Model.Format.binary64 x.toModel.unpack y.toModel.unpack):=by change Q2 (Float.Model.mul x.toModel y.toModel)=_ rw[Float.Model.mul,Model.ofFloatModel_pack] lemma ev (x y:ڭ) (hx:fO x.toModel.unpack) (hy:fO y.toModel.unpack): finite (x*y) ∧ real (x*y)=real x*real y:=by rw[dZ x,dZ y] unfold finite real rw[cM] cases hux:x.toModel.unpack <;> cases huy:y.toModel.unpack <;> simp only[hux,huy,fO]at hx hy all_goals try contradiction case finite.finite s1 m1 e1 hp1 s2 m2 e2 hp2=> exact aG s1 s2 m1 m2 e1 e2 hp1 hp2 hx hy all_goals simp only[Float.Model.UnpackedFloat.mul,Model.isFinite_ofModel_zero Q0 (by rfl),Model.toReal_ofModel_zero Q0 (by rfl),Model.unpackedToReal_zero,zero_mul,mul_zero,and_self,eq_self,true_and] lemma eN (x w:ڎ) (hx:gk x=true) (hw:gk w=true): finite (convert x*convert w) ∧ real (convert x*convert w)=real (convert x)*real (convert w):= ev (convert x) (convert w) (b0 x hx) (b0 w hw) end d8 namespace d8 open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange lemma ap (s:ڡ) (e f:ڣ) (he:e<256) (hf:f<2^23): let w:=Model.NativeBinary32.mkBits s e f signOf w=s ∧ (z12 w).toNat=e ∧ (fracOf w).toNat=f:=by let w:=Model.NativeBinary32.mkBits s e f have hm:Model.ofUInt32 w=Model.ofFields Fmt s e f:= (Model.ofNatBits_toNatBits (Model.NativeBinary32.ofUInt32 w)).trans (Model.NativeBinary32.ofUInt32_mkBits s e f) have hs:=congrArg Model.signBit hm have hex:=congrArg Model.expField hm have hfr:=congrArg Model.fracField hm rw[ofUInt32_eq_ofFields]at hs hex hfr simp only[Model.signBit_ofFields]at hs simp only[Model.expField_ofFields,show Fmt.expWidth=8 from rfl,zz5 (show e<2^8 by exact he),zz5 (show (z12 w).toNat<2^8 by exact expOf_toNat_lt w)]at hex simp only[Model.fracField_ofFields,show Fmt.fracWidth=23 from rfl,zz5 hf,zz5 (fracOf_toNat_lt w)]at hfr simpa only[w] using And.intro hs (And.intro hex hfr) end d8 namespace d8 open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange @[inline] def bM (w:ڎ) (gl:ڣ):ڭ:= if z11 w=0 then zz0 0 else convert (Model.NativeBinary32.mkBits (signOf w) (150+zz w-gl) (fracOf w).toNat) lemma ao (w:ڎ) (gl:ڣ) (hm:z11 w≠0 → z12 w≠0 ∧ gl<150+zz w ∧ zz w norm_num[Nat.shiftLeft_eq] end d8 namespace d8 open ExactRuntime lemma ab (w:ڎ) (wm:ڜ) (hm:z11 w≠0 → z12 w≠0 ∧ wm.toNat<150+zz w ∧ zz wγ,Word->δ,mantOf->ε,oneW->ζ,signOf->η,expOf->θ,Fmt->κ,toWord->π,sqrtRational->Ac,decodeD_negative->Ad,ConvShape.ho->Es open Nat renaming mod_eq_of_lt->ν,shiftRight_eq_div_pow->ψ,mul_le_mul_right->ω,shiftLeft_eq->Α,zero_add->Β,two_pow_pos->Δ,mod_lt->Ε,pow_le_pow_right->Ι,pow_add->Κ,pos_of_ne_zero->Ο,lt_of_le_of_lt->Ρ,div_eq_of_lt->Υ,add_mul_div_right->ϔ,div_lt_of_lt_mul->ϕ,add_comm->Ϟ,and_two_pow_sub_one_eq_mod->ϡ,log2_self_le->ϰ,log2_lt->Ϻ,eq_zero_or_pos->Ae,log2_eq_iff->Af,lt_of_lt_of_le->Ag,mul_lt_mul_of_pos_right->Aj,lt_log2_self->Ak,lt_of_sub_eq_succ->Al,le_div_iff_mul_le->Am,div_lt_iff_lt_mul->An,mul_le_mul->Ar,sub_add_cancel->Aw,le_one_iff_eq_zero_or_eq_one->Ay,shiftLeft_add_eq_or_of_lt->Bq,and_two_pow_sub_one_of_lt_two_pow->Bx,one_le_two_pow->BE,testBit_eq_decide_div_mod_eq->BJ,reduceMod->BY,toUInt32_eq->Cd,mul_add_mod->Ce,mul_zero->Co,sub_right_comm->Cu,mod_mul_right_div_self->Cw,le_of_lt_succ->CI,one_le_iff_ne_zero->Dd,sub_eq_zero_iff_le->De,toUInt64_eq->Do,cast_ofNat->DF,reducePow->DU,add_sub_of_le->Ej,le_of_not_le->Ev,sub_le->EI,cast_add->ER open UInt64 renaming toNat_add->ξ,toNat_inj->σ,toNat_sub_of_le->Η,toNat_shiftRight->Ξ,toNat_sub->Τ,toNat_shiftLeft->ό,le_iff_toNat_le->ϐ,toNat_lt->Az,reduceToNat->Bc,toNat_and->BR,zero_xor->Ch,add_assoc->CY,toNat_one->Da,zero_shiftLeft->DB,toNat->Er open USize renaming le_size->τ,lt_iff_toNat_lt->υ,size->Λ,toNat_one->Φ,toNat_lt_size->ϝ open Bool renaming false_eq_true->φ,xor->Ζ,eq_iff_iff->AB open Array renaming ofFn->AF,emptyWithCapacity->Ba,getElem_push_lt->Dy open UInt32 renaming toNat_inj->ύ,toNat_shiftRight->Ϣ,toNat_toUInt64->AG,toNat_and->AH,le_iff_toNat_le->AJ,toNat_ofNat'->AL,reduceToNat->CD,toNat_sub->CX,toNat_sub_of_le->Dj,toNat_shiftLeft->Dk,lt_iff_toNat_lt->Dl,xor_zero->EE open List renaming getElem_ofFn->AN,range_eq_range'->Ca,map_map->Df,length_nil->Dr,map_add_range'->DS,length_cons->Ex open FloatFormat open Model.NativeBinary32 open Int renaming emod_eq_emod_iff_emod_sub_eq_zero->By,ofNat->BG,negSucc->CJ,ofNat_eq_natCast->DK,toNat->Fe open Int64 open FloatLib.Numerics renaming roundShiftRightEven->AQ,FixedWord.roundShiftRightEven_toNat->Bg,FixedWord.roundShiftRightEven->Bm,roundShiftRightEven_le_succ->Bn,roundShiftRightEven_mul_two_pow_of_le->Cc,roundShiftRightEven_eq_guard_sticky->Cl,div_two_pow_le_roundShiftRightEven->Cq,roundShiftRightEven_mul_two_pow->CE,Radix.toReal->Fa open Model renaming roundDyadicGeneral->AT,ofModel_finite_normalized_eq_ofFields->Bo,packRoundedSubnormal->Bv,zero->Cs,pow2->Ct,packRoundedNormal->CS,toNatBits->Dn,nativeOverflow->DE,ofFields->EH,ofBits->EQ open Or open FloatLib.Numerics.Dyadic renaming add_toRat->BF,toRat_eq_zero_iff->Di open Float.Model open Real open Float.Model.UnpackedFloat renaming roundWithAccuracy->Bp open Float.Model.Format open FloatLib.Numerics.RationalBinary renaming lessThanPowerOfTwo->Bi local notation:max x:max "˧"=>Er (x:) local notation:max x:max "؛"=>USize.toNat (x:) local notation:max x:max "؎"=>UInt32.toNat (x:) local notation:max x:max "۞"=>Nat.toUSize (x:) local notation:max x:max "܀"=>Nat.log2 (x:) local notation:max x:max "܂"=>Fin.val (x:) local notation:max x:max "܃"=>Array.size (x:) local notation:max x:max "܅"=>UInt32.toUInt64 (x:) local notation:max x:max "܉"=>Az (x:) local notation:max x:max "܊"=>ExactRuntime.ConvShape.stride (x:) local notation:max x:max "܍"=>Array.toList (x:) local notation:max x:max "߷"=>FloatLib.Floats.Formats.BinaryInterchange.FloatFormat.fracWidth (x:) local notation:max x:max "߸"=>Nat.toUInt64 (x:) local notation:max x:max "՜"=>UInt64.toUInt32 (x:) local notation:max x:max "׆"=>Fe (x:) local notation"א"=>by omega local notation"ב"=>by norm_num local notation"ג"=>by simp local notation"ד"=>by decide local notation"ה"=>by positivity local notation"ו"=>by simp;omega local notation"ז"=>by grind local notation"ח"=>by simp_all local notation"߾"=>0x80000000 local notation"߿"=>0x100000000 local notation"ק"=>0x7FFFFFFF local notation"ר"=>ite_true local notation"ש"=>ite_false local notation"ת"=>decide_eq_true_eq local notation"ؠ"=>zpow_natCast local notation"ة"=>decide_eq_true_iff local notation"ح"=>getElem!_pos local notation"ض"=>Fmt.minSubnormalExponent local notation"ػ"=>UInt64 local notation"ؼ"=>UInt32 local notation"ؽ"=>Array local notation"ؾ"=>USize local notation"ف"=>Bool local notation"ٳ"=>Nat local notation"ٴ"=>Int local postfix:max"ٽ"=>Array.size local postfix:max"پ"=>Er local postfix:max"پ"=>USize.toNat local postfix:max"پ"=>UInt32.toNat local postfix:max"پ"=>Fe local postfix:max"ٿ"=>Nat.toUSize local postfix:max"ٿ"=>UInt64.toUSize local postfix:max"ٿ"=>UInt32.toUSize local notation:max"ڀ"k:max=>AF (n:=k) local notation"ހ"=>4294967295 local notation"ށ"=>1048576 local notation"ނ"=>16777216 local notation"ރ"=>8388608 local notation"ބ"=>4611686018427387904 local notation"ޅ"=>0xFFFF section open FloatLib.Numerics end lemma Ze (n:ٳ) (f:ٳ -> ؼ) (k:ٳ) (a:kf i܂)[k]! = f k:=ח lemma Ht (s:ف) (E F:ٳ) (b:E<256) (a:F<2^23):(EH κ s E F).toNatBits=(if s then 2^31 else 0)+E*2^23+F:=by rw[Model.ofFields_eq_ofFieldsImpl];simp only[Model.ofFieldsImpl,Model.mkBitsImpl,EQ,Dn,BitVec.toNat_ofNatLT];have d:E&&&κ.expAllOnesNat=E:=Bx (n:=8) b;have e:F&&&κ.fracMaskNat=F:=Bx (n:=23) a;rw[d,e,show E.shiftLeft κ߷=E<<<23 from rfl,Nat.or_assoc,<-Bq a];have f:E<<<23+F<2^31:=א;cases s . simp[Α] . simp only[ר];rw[show Nat.shiftLeft 1 (κ.expWidth+κ߷)=1<<<31 from rfl,<-Bq f];simp;omega @[inline] def Yv (neg:ف) (E F:ؼ):ؼ:=(if neg then (߾:ؼ) else 0)+(E<<<23)+F lemma ZT (a:ف) (E F:ؼ) (b:E؎<256) (d:F؎<2^23):Yv a E F=ExactRuntime.toWord (EH κ a E؎ F؎):=by unfold ExactRuntime.toWord;rw[Ht a _ _ b d];apply ύ.1;unfold Yv;cases a<;>simp<;>omega lemma P7 (a:ف):Yv a 255 0=ExactRuntime.toWord (DE κ a):=by rw[Model.nativeOverflow_eq_signedInf_of_isIEEE Fmt ד];cases a<;>decide lemma Hu (a:ف):Yv a 0 0=ExactRuntime.toWord (Cs κ a):=by cases a<;>decide @[inline] noncomputable def Hw (w:ػ) (p:ػ×ػ):ػ×ػ:=(if p.2>>>w != 0 then p.1+w else p.1,if p.2>>>w != 0 then p.2>>>w else p.2) @[inline] noncomputable def HL (x:ػ):ػ:= let p:=Hw 2 (Hw 4 (Hw 8 (Hw 16 (Hw 32 (0,x))))) p.1+(if p.2>>>1 != 0 then 1 else 0) @[inline] def Ab (x:ػ):ػ:= let r1:ػ:=if x>>>32 != 0 then 0+32 else 0;let x1:=if x>>>32 != 0 then x>>>32 else x let r2:=if x1>>>16 != 0 then r1+16 else r1;let x2:=if x1>>>16 != 0 then x1>>>16 else x1 let r3:=if x2>>>8 != 0 then r2+8 else r2;let x3:=if x2>>>8 != 0 then x2>>>8 else x2 let r4:=if x3>>>4 != 0 then r3+4 else r3;let x4:=if x3>>>4 != 0 then x3>>>4 else x3 let r5:=if x4>>>2 != 0 then r4+2 else r4;let x5:=if x4>>>2 != 0 then x4>>>2 else x4 r5+(if x5>>>1 != 0 then 1 else 0) theorem GD (n k:ٳ) (h:2^k<=n):n.log2=k+(n/2^k).log2:=by have p:0<2^k:=Δ k have hd:n/2^k≠0:=by have:=(Am p).2 (by omega:1*2^k<=n);omega have hn:n≠0:=א rw[Af hn];have l1:=ϰ hd;have l2:=Ak (n:=n/2^k) constructor · rw[Ϟ,Κ];exact (Am p).1 l1 · rw[show k+(n/2^k).log2+1=((n/2^k).log2+1)+k by omega,Κ];exact (An p).1 l2 theorem HM (w:ػ) (p:ػ×ػ) (hw:w.toNat<64) (h2:p.2.toNat<2^(2*w.toNat)) (h1:p.1.toNat+w.toNat<2^64): p.1.toNat+p.2.toNat.log2=(Hw w p).1.toNat+(Hw w p).2.toNat.log2 /\ (Hw w p).2.toNat<2^w.toNat /\ (Hw w p).1.toNat<=p.1.toNat+w.toNat:=by have sv:(p.2>>>w).toNat=p.2.toNat/2^w.toNat:=by rw[Ξ,ν hw,ψ] have q:0<2^w.toNat:=Δ _ have h2':p.2.toNat<2^w.toNat*2^w.toNat:=by rw[←Κ,←two_mul];exact h2 unfold Hw;by_cases cc:(p.2>>>w != 0)=true · simp only[cc,if_true];have c:=cc have c0:p.2>>>w≠0:=by simpa using c have c1:(p.2>>>w).toNat≠0:=fun e=>c0 (σ.1 (by rw[e];rfl)) rw[sv] at c1 have g:2^w.toNat<=p.2.toNat:=by by_contra hc;exact c1 (Υ (א)) refine ⟨?_,?_,?_⟩ · try dsimp only rw[ξ,ν h1,sv,GD _ _ g];omega · try dsimp only rw[sv];exact (An q).2 h2' · try dsimp only rw[ξ,ν h1] · simp only[cc,φ,if_false];have c:=cc have c0:p.2>>>w=0:=by simpa using c have c1:p.2.toNat/2^w.toNat=0:=by rw[←sv,c0];rfl refine ⟨by trivial,?_,by omega⟩ by_contra hc;have:=Nat.div_pos (by omega:2^w.toNat<=p.2.toNat) q;omega theorem GB (x:ػ):(HL x).toNat=x.toNat.log2:=by unfold HL;dsimp only have hx:=x.toNat_lt obtain⟨e1,b1,c1⟩:=HM 32 (0,x) Q26 (by simpa using hx) Q29 simp only[show (32:ػ).toNat=32 from rfl] at e1 b1 c1 generalize Hw 32 (0,x)=p1 at e1 b1 c1 obtain⟨e2,b2,c2⟩:=HM 16 p1 Q26 (by simpa using b1) (by simp only[show (16:ػ).toNat=16 from rfl];simp at c1;omega) simp only[show (16:ػ).toNat=16 from rfl] at e2 b2 c2 generalize Hw 16 p1=p2 at e2 b2 c2 obtain⟨e3,b3,c3⟩:=HM 8 p2 Q26 (by simpa using b2) (by simp only[show (8:ػ).toNat=8 from rfl];simp at c1;omega) simp only[show (8:ػ).toNat=8 from rfl] at e3 b3 c3 generalize Hw 8 p2=p3 at e3 b3 c3 obtain⟨e4,b4,c4⟩:=HM 4 p3 Q26 (by simpa using b3) (by simp only[show (4:ػ).toNat=4 from rfl];simp at c1;omega) simp only[show (4:ػ).toNat=4 from rfl] at e4 b4 c4 generalize Hw 4 p3=p4 at e4 b4 c4 obtain⟨e5,b5,c5⟩:=HM 2 p4 Q26 (by simpa using b4) (by simp only[show (2:ػ).toNat=2 from rfl];simp at c1;omega) simp only[show (2:ػ).toNat=2 from rfl] at e5 b5 c5 generalize Hw 2 p4=p5 at e5 b5 c5 simp at e1 c1 have fin:p5.2.toNat.log2=if p5.2>>>1 != 0 then 1 else 0:=by have sv:(p5.2>>>1).toNat=p5.2.toNat/2:=by rw[Ξ];simp[ψ] split · rename_i c;have c0:p5.2>>>1≠0:=by simpa using c have c1:(p5.2>>>1).toNat≠0:=fun e=>c0 (σ.1 (by rw[e];rfl)) rw[sv] at c1;rw[Af (א)];omega · rename_i c;have c0:p5.2>>>1=0:=by simpa using c have c1:p5.2.toNat/2=0:=by rw[←sv,c0];rfl by_cases z:p5.2.toNat=0 · rw[z];rfl · rw[Af z];omega have hb:p5.1.toNat<=62:=א by_cases c:(p5.2>>>1 != 0)=true · rw[if_pos c] at fin;rw[if_pos c,ξ,show (1:ػ).toNat=1 from rfl,ν (א)];omega · rw[if_neg c] at fin;rw[if_neg c,ξ,show (0:ػ).toNat=0 from rfl,ν (א)];omega theorem GC (x:ػ):Ab x=HL x:=by unfold Ab HL Hw;rfl theorem GV (x:ػ):(Ab x).toNat=x.toNat.log2:=by rw[GC,GB] @[inline] def Yj (x:ػ):ػ:=Ab x lemma Zj (x:ػ) (_:x≠0):(Yj x).toNat=x.toNat.log2:=GV x @[inline] def Hy (m:ػ) (e:ٴ):ػ:= match e+149 with | .ofNat k=>m<<Bm m (k+1) @[inline] def Hz (neg:ف) (m:ػ) (e:ٴ):ؼ:= let fr:=Hy m e;if fr==0 then Yv neg 0 0 else if (0x800000:ػ)<=fr then Yv neg 1 0 else Yv neg 0 fr.toUInt32 lemma Ia (a:ف) (m:ػ) (e:ٴ) (b:m˧≠0) (h:(m˧܀:ٴ)+e < -126): Hz a m e=ExactRuntime.toWord (Bv κ a (Cs κ a) (match e-ض with | BG Ke=>m˧<<AQ m˧ (Ke+1))):=by rw[show ض= -149 from rfl,Int.sub_neg];unfold Hz Hy;generalize l:e+149=s;suffices H:∀(d:ػ) F,d˧=F→ F<=2^23→ (if d==0 then Yv a 0 0 else if 0x800000<=d then Yv a 1 0 else Yv a 0 d՜)=ExactRuntime.toWord (Bv κ a (Cs κ a) F) by rcases s with k|k ·simp at l;have o:m˧*2^k<2^23:=(Aj (Ak (n:=m˧)) (Δ k)).trans_le (by rw[<-Κ];exact Ι א א);exact H _ (m˧<<g (σ.mp h),ש];by_cases f:0x800000<=d . simp only[f,ר,show d˧>=Ct Fmt߷from f];exact ZT a 1 0 ד ד . simp only[f,ש,show¬d˧>=Ct Fmt߷from f];have j:d՜؎=d˧:=ν א;exact j▸ZT a 0 _ ד (by rw[j];exact Nat.lt_of_not_le f) @[inline] def YK (m L:ػ):ػ:= if 23<=L then Bm m (L-23).toNat else m<<<(23-L) @[inline] def Ib (neg:ف) (m L:ػ) (t:ٴ):ؼ:= let rm:=YK m L;if rm==0x1000000 then (if t+1>127 then Yv neg 255 0 else Yv neg (t+128).toNat.toUInt32 0) else Yv neg (t+127).toNat.toUInt32 (rm.toUInt32-0x800000) lemma Z7 (m:ػ) (a:m≠0):(YK m (Yj m))˧=(if κ߷<=m˧܀ then AQ m˧ (m˧܀-κ߷) else m˧<<<(κ߷-m˧܀)) /\ 2^23<=(YK m (Yj m))˧/\(YK m (Yj m))˧<=2^24:=by have k:m˧≠0:=λh=>a (σ.mp (by simpa using h));have b:=Zj m a;have f:=ϰ k;have g:m˧<2^(m˧܀+1):=Ak;rw[show κ߷=23 from rfl];unfold YK;generalize Yj m=L at b⊢;generalize q:m˧܀=N at*;by_cases h:23<=N have d:(23:ػ)<=L:=by rw[ϐ,b];exact h simp only[d,ר,h,(ח:(L-23)˧=N-23),Bg];exact⟨trivial,(by rw[Am (Δ _),<-Κ,Ej h];exact f:2^23<=m˧/2^(N-23)).trans (Cq _ _),(Bn _ _).trans (by rw[An (Δ _),<-Κ,(by clear*-h;omega:24+(N-23)=N+1)];exact g:m˧/2^(N-23)<2^24)⟩;simp only[(by rw[ϐ,b];exact h:¬(23:ػ)<=L),ש,h];have j:m˧*2^(23-N)<2^24:=(Aj g (Δ _)).trans_eq (by rw[<-Κ];congr 1;clear*-h;omega) rw[(by rw[ό,(by rw[Η _ _ (by rw[ϐ,b];exact Ev h),b];rfl:(23-L)˧=23-N),ν (Ρ (EI 23 N) ד),Α];exact ν (j.trans ד):(m<<<(23-L))˧=m˧*2^(23-N)),Α];exact⟨rfl,(by rw[<-Κ,Ej (Ev h)]:2^23=2^N*2^(23-N)).trans_le (ω _ f),j.le⟩ lemma K3 (n:ٳ) (h:n<2^32):n.toUInt32؎=n:=by rw[Cd,AL,ν h] lemma Ic (a:ف) (m:ػ) (e:ٴ) (b:m≠0) (d:¬ ((m˧܀:ٴ)+e>127)) (f:¬ ((m˧܀:ٴ)+e < -126)): Ib a m (Yj m) ((m˧܀:ٴ)+e)=ExactRuntime.toWord (CS κ a (DE κ a) (↑m˧܀+e) (if κ߷<=m˧܀ then AQ m˧ (m˧܀-κ߷) else m˧<<<(κ߷-m˧܀))):=by obtain⟨q,r,s⟩:=Z7 m b;rw[<-q];unfold Ib CS;generalize YK m (Yj m)=g at r s⊢;generalize (m˧܀:ٴ)+e=t at d f⊢;simp only[Model.pow2_eq_two_pow,show κ߷=23 from rfl,show κ.maxNormalExponent=127 from rfl,show κ.exponentBias=127 from rfl,show κ.maxFiniteExpField=254 from rfl,show κ.maxFiniteFracField=8388607 from rfl,DU,Nat.reduceAdd,DK,DF];by_cases k:g˧=ނ . have l:(g==0x1000000)=true:=beq_iff_eq.2 (σ.1 k);simp only[l,ר,k,BEq.rfl];by_cases o:t+1>127 . simp only[o];exact P7 a . simp only[o,ש];have j:((t+128)׆.toUInt32)؎=(t+1+127)׆:=by rw[K3 (t+128)׆ א];omega rw[if_neg ז];rw[ZT a _ 0 (by rw[j];omega) ד,j];rfl . have l:(g==0x1000000)=false:=beq_eq_false_iff_ne.2 λ h=>k (by rw[h];rfl) have u:(g˧==ނ)=false:=ז;simp only[l,u,φ,ש,(א:¬t>127)];have j:=K3 (t+127)׆ א;have p:(g՜-0x800000)؎=g˧-ރ:=by rw[Dj _ _ (by rw[AJ];simp;omega)];simp;omega rw[if_neg ז];rw[ZT a _ _ (by rw[j];omega) (by rw[p];omega),j,p] @[inline] def YA (neg:ف) (m:ػ) (e:ٴ):ؼ:= let L:=Yj m;let t:ٴ:=(Lپ:ٴ)+e;if t>127 then Yv neg 255 0 else if t < -126 then Hz neg m e else Ib neg m L t lemma ZU (a:ف) (m:ػ) (e:ٴ) (b:m≠0):YA a m e=ExactRuntime.toWord (AT κ ⟨a,m˧,e⟩):=by have g:m˧≠0:=λh=>b (σ.mp (by simpa using h));have j:=Zj m b;unfold YA AT;simp only[show(m˧==0)=false by simpa using g,φ,ש,j,show κ.maxNormalExponent=127 from rfl,show κ.minNormalExponent= -126 from rfl];by_cases f:(m˧܀:ٴ)+e>127;simp only[f,ר];exact P7 a;simp only[f,ש];by_cases d:(m˧܀:ٴ)+e< -126;simp only[d,ר];exact Ia a m e g d;simp only[d,ש];exact Ic a m e b f d @[noinline] def Id (neg:ف) (m:ػ) (e:ٴ):ؼ:=YA neg m e @[inline] def YY (n:ػ):ػ:= let q:=n>>>40;q+(((n&&&0xFFFFFFFFFF)+0x7FFFFFFFFF+(q&&&1))>>>40) lemma If (n:ػ):(YY n)˧=AQ n˧ 40:=by rw[Cl _ _ ד];have b:(n>>>40)˧=n˧/2^40:=by rw[Ξ,ψ];rfl have d:(n&&&0xFFFFFFFFFF)˧=n˧%2^40:=by rw[BR,show(0xFFFFFFFFFF:ػ)˧=2^40-1 from rfl,ϡ] have e:((n>>>40)&&&1)˧=n˧/2^40%2:=ח;have f:n˧/2^(40-1)%2=n˧%2^40/2^39:=by rw[(ב:(2:ٳ)^40=2^39*2),Cw] have g:n˧%2^(40-1)=n˧%2^40%2^39:=by rw[(ב:(2:ٳ)^40=2^39*2),Nat.mod_mul_right_mod] have k:=Ε n˧ (Δ 40);have l:n˧/2^40<2^24:=(An ד).2 n܉ unfold YY;simp only[ξ,Ξ,d,e,BJ,f,g];clear b d e f g;generalize n˧%2^40=R at*;simp only[Bc,ψ]at*;split<;>rename_i h<;>simp at h<;>generalize n˧/1099511627776=Q at*<;>rw[ν (a:=R+549755813887) א,ν (a:=R+549755813887+Q%2) א]<;>[rw[(א:(R+549755813887+Q%2)/1099511627776=1)];rw[(א:(R+549755813887+Q%2)/1099511627776=0)]]<;>exact ν א lemma Z8 (a:ف) (E F:ؼ) (h:E؎*2^23+F؎<2^31):(Yv a E F)؎=(if a then 2^31 else 0)+E؎*2^23+F؎:=by unfold Yv;cases a<;>simp<;>omega @[inline] def YZ (neg:ف) (u n:ػ):ؼ:= (if neg then (߾:ؼ) else 0)+((u<<<23)+YY n).toUInt32 lemma Ig (a:ف) (u n:ػ) (b:u˧<=253) (d:(YY n)˧<=2^24):(YZ a u n)؎=(if a then 2^31 else 0)+u˧*2^23+(YY n)˧:=by have e:(u<<<23)˧=u˧*2^23:=by rw[ό];simp;omega unfold YZ;cases a<;>simp<;>omega lemma P6 (a:ف) (m:ػ) (e:ٴ) (u:ػ) (b:m≠0) (d:(u˧:ٴ)=(m˧܀:ٴ)+e+126) (f:u˧<=253): YZ a u (m<<<(63-Yj m))=YA a m e:=by have k:=Zj m b;obtain⟨o,p,q⟩:=Z7 m b;have j:m˧܀<64:=(Ϻ λh=>b (σ.mp h)).mpr m܉;have l:(YY (m<<<(63-Yj m)))˧=(YK m (Yj m))˧:=by rw[If,o,(by rw[ό,(by rw[Τ,k];simp;clear*-j;omega:(63-Yj m)˧=63-m˧܀),ν (by clear*-;omega:63-m˧܀<64),Α];exact ν ((Aj Ak (Δ _)).trans_eq (by rw[<-Κ,(by clear*-j;omega:m˧܀+1+(63-m˧܀)=64)])):(m<<<(63-Yj m))˧=m˧*2^(63-m˧܀)),show κ߷=23 from rfl];split<;>rename_i g;rw[(by clear*-g j;omega:(40:ٳ)=m˧܀-23+(63-m˧܀)),CE];rw[Cc _ _ _ (by clear*-g j;omega),Α,(by clear*-;omega:63-m˧܀-40=23-m˧܀)] simp only[YA,k,show¬(m˧܀+e>127)by clear*-d f;omega,show¬(m˧܀+e< -126)by clear*-d f;omega,ש];apply ύ.mp;rw[Ig a u _ f (by clear*-l p q;omega),l];unfold Ib;generalize YK m (Yj m)=n at l p q⊢;generalize (m˧܀:ٴ)+e=t at d⊢;clear b k o j;by_cases g:n˧=ނ;simp only[show(n==0x1000000)=true by simp[<-σ,g],ר];by_cases v:t+1>127<;>simp only[v,ר,ש]<;>rw[Z8 a _ _ (by simp<;>omega)]<;>simp<;>omega;simp only[show(n==0x1000000)=false by simp[<-σ,g],φ,ש];rw[Z8 a _ _ (by simp[CX];omega)];simp[CX];omega noncomputable def Y0 (e:ٴ) (ok:ف) (B:ػ):Prop:= ∀ c:ػ,cپ<2^62 -> ok=true -> (B+c).toNat<=253 -> ((B+c).toNat:ٴ)=e+cپ @[inline] def Ii (neg:ف) (m:ػ) (e:ٴ) (ok:ف) (b:ػ):ؼ:= let L:=Yj m;let u:=b+L+126;if ok&&u<=253 then YZ neg u (m<<<(63-L)) else Id neg m e lemma P3 (a:ف) (m:ػ) (e:ٴ) (d:ف) (B:ػ) (b:m≠0) (f:Y0 e d B):Ii a m e d B=YA a m e:=by have k:m˧≠0:=λ h=>b (σ.mp (by simpa using h));have l:=Zj m b;have q:=(Ϻ k).mpr m܉;unfold Ii Id;dsimp only;split;swap;rfl rename_i h;simp at h;obtain⟨n,g⟩:=h;have o:(Yj m+126)˧=m˧܀+126:=by rw[ξ,l];simp;omega rw[CY]at g⊢;have j:(B+(Yj m+126))˧<=253:=by simpa using ϐ.mp g have p:=f _ (by rw[o];omega) n j;exact P6 a m e _ b (by rw[p];omega) j @[inline] def Yf (w:ؼ):ػ:= if θ w=0 then (fracOf w).toUInt64 else (fracOf w).toUInt64+0x800000 @[inline] def Yd (w:ؼ):ػ:= if θ w=0 then 0 else (θ w).toUInt64-1 lemma Zk (w:ؼ):(Yf w)˧=ε w:=by have:=fracOf_toNat_lt w;unfold Yf ε;split_ifs;simp;simp only[ξ];show((fracOf w)؎+ރ)%2^64=2^23+(fracOf w)؎;omega lemma Zf (w:ؼ):(Yd w)˧=γ w:=by unfold Yd γ;split_ifs with h . rfl . have b:1<=(θ w)؎:=by rcases Ae (θ w)؎with a|a . exact absurd (ύ.mp (by simpa using a)) h . exact a rw[Η _ _ (by rw[ϐ];simp;omega)];simp lemma Zc (a b:ؾ) (h:a؛+b؛<Λ):(a+b)؛=a؛+b؛:=ν h lemma A4 (A:ؽ δ) (a n k:ؾ) (b:a؛+n؛<=Aٽ) (d:a؛+n؛<Λ) (h:k>>31)܅˧=if Ζ (η a) (η b) then 1 else 0:=by have d:∀a:ؼ,η a=decide (a؎/2^31=1):=λa=>by have:=a.toNat_lt;unfold η;have j:(a؎&&&2^31)%2^31=0:=by rw[Nat.and_mod_two_pow,Nat.mod_self,Nat.and_zero] have k:(a؎&&&2^31)/2^31=a؎/2^31%2:=by rw[Nat.and_div_two_pow,Nat.div_self (Δ 31),Nat.and_one_is_mod] rw[(by rw[AB,bne_iff_ne,ة,ne_eq,ne_eq,<-ύ];simp:(a&&&߾!=0)=decide ((a&&&߾)؎≠0)),(ג:(a&&&߾)؎=a؎&&&2^31),AB,ة,ة];omega rw[AG,Ϣ,UInt32.toNat_xor,show(31:ؼ)؎%32=31 from rfl,Nat.shiftRight_xor_distrib,ψ,ψ,d,d];have:=a.toNat_lt;have:=b.toNat_lt;rcases Ay.mp (א:aپ/2^31<=1)with h|h<;>rcases Ay.mp (א:bپ/2^31<=1)with e|e<;>rw[h,e]<;>decide lemma Zg (w:ؼ):γ w<=254:=by have:=expOf_toNat_lt w;unfold γ;split_ifs<;>omega lemma B6 (a b:δ):(Yd a+Yd b)˧=γ a+γ b:=by have:=Zg a;have:=Zg b;rw[ξ,Zf,Zf,ν א] lemma Za (x:ٳ) (h:x<߿):x۞؛=x:=ν (Ag h τ) lemma B3 (A:ؽ δ) (a k:ؾ) (h:(a+k)؛>>23).toNat noncomputable def YM (a:ؼ):ٳ:=((a&&&ק)>>>23).toNat lemma W9 (a:ؼ):(a&&&ק)؎=(θ a)؎*2^23+(fracOf a)؎:=by simp only[AH,θ,fracOf,Ϣ];rw[show(ק:ؼ)؎=2^31-1 from rfl,show(0xFF:ؼ)؎=2^8-1 from rfl,show(0x7FFFFF:ؼ)؎=2^23-1 from rfl,show(23:ؼ)؎%32=23 from rfl,ϡ,ϡ,ϡ,ψ];omega lemma Zb (a:ؼ):YR a<=511/\YM a<=255/\(YM a<255 -> θ a≠255) /\ (ε a≠0 -> YR a<=γ a+1/\γ a+1<=max (YM a) 1):=by have e:=expOf_toNat_lt a;have f:=fracOf_toNat_lt a;unfold YR YM ε γ;simp only[Ϣ,CX,CD,BY,ψ,W9,ne_eq,<-ύ];rw[Ϟ _ (fracOf a)؎,ϔ _ _ (Δ _),Υ f,Β];generalize (θ a)؎=E at*;generalize (fracOf a)؎=F at*;have K:(2^32-1+(F+E*2^23))%2^32/2^23<=E∨E=0∧F=0:=א;refine⟨CI (ϕ (Ε _ ד)),CI e,Nat.ne_of_lt,λ d=>?_⟩;by_cases b:E=0 . rw[if_pos b]at d⊢;exact⟨(K.resolve_right λ h=>d h.2).trans (Nat.le_succ_of_le b.le),Nat.le_max_right _ _⟩ . rw[if_neg b]at d⊢;rw[Aw (Ο b)];exact⟨K.resolve_right λ h=>b h.1,Nat.le_max_left _ _⟩ def IE (A:ؽ δ) (Kb n:ؾ) (hA:Kbپ+nپ<=Aٽ) (hs:Kbپ+nپ<Λ) (lo hi:ؼ) (k:ؾ):ؼ:= if h:k>>23)<<<16)+(hi>>>23) termination_by nپ-kپ decreasing_by exact ZI n k h lemma W8 (A:ؽ δ) (a n:ؾ) (h:a؛+n؛<=Aٽ) (f:a؛+n؛<Λ) (b e:ؼ) (k:ؾ) (j:k؛<=n؛) (g:e؎<2^31): ∃ L H:ٳ,(IE A a n h f b e k)؎=L*2^16+H/\L<=511/\H<=255 /\ L<=b؎/2^23/\e؎/2^23<=H /\ ∀ t,k؛<=t -> t L<=YR A[a؛+t]! /\ YM A[a؛+t]! <= H:=by generalize E:n؛-k؛=d;induction d generalizing k b e with |zero=> rw[IE,dif_neg (mt υ.1 א)];have:=b.toNat_lt;refine⟨b؎/2^23,e؎/2^23,?_,א,א,le_rfl,le_rfl,λ t o p=>א⟩;simp only[UInt32.toNat_add,Dk,Ϣ,CD,BY];omega |succ d u=> have q:komega) א;have r:L<=b؎/2^23∧L<=YR w:=by split_ifs at y with l<;>rw[Dl]at l<;>omega have s:e؎/2^23<=H∧YM w<=H:=by split_ifs at z with l<;>rw[Dl]at l<;>omega refine⟨L,H,o,p,x,r.1,s.1,λ t K C=>?_⟩;obtain rfl|D:t=kپ∨(k+1)؛<=t:=א;rw[v];exact⟨r.2,s.2⟩;exact B t D C @[inline] def Yc (A:ؽ δ) (Kc i:ٳ):ؼ:= if h:i*Kc+Kc<=Aٽ/\i*Kc+Kc<=ހ then IE A (i*Kc).toUSize Kcٿ (by rw [Za _ א,Za _ א];exact h.1) (by rw [Za _ א,Za _ א];have:=τ;omega) 0xFFFFFFFF 0 0 else 0x01FF00FF @[inline] def Yk (k:ؼ):ػ:=(if k=0 then 0 else k-1).toUInt64 lemma Zq (k:ؼ):(Yk k)˧=k؎-1:=by unfold Yk;split_ifs with h;subst h;rfl;rw[AG,Dj _ _ (by rw[AJ];exact Dd.2 λ a=>h (ύ.1 a))];rfl lemma ZM (a:ؼ):(Yd ζ+Yd a)˧=γ ζ+γ a:=B6 ζ a lemma Zo (a:ؼ) (L H:ٳ) (h:a؎=L*2^16+H) (hH:H<2^16):(a>>>16)؎=L/\(a&&&ޅ)؎=H:=by constructor;rw[Ϣ,show(16:ؼ)؎%32=16 from rfl,ψ,h];omega;rw[AH,show(ޅ:ؼ)؎=2^16-1 from rfl,ϡ,h];omega lemma Zp (A:ؽ δ) (a i:ٳ) (b:i*a+a<=Aٽ) (d:i*a+a<=ހ): ∃ L H:ٳ,(Yc A a i)؎=L*2^16+H/\L<=511/\H<=255 /\ ∀ t,t < a -> L<=YR A[i*a+t]! /\ YM A[i*a+t]! <= H:=by have f:(i*a)۞؛=i*a:=Za _ א;have g:a۞؛=a:=Za _ א;unfold Yc;rw[dif_pos ⟨b,א⟩];obtain⟨L,H,e,h,c,-,-,j⟩:=W8 A (i*a)۞ a۞ (by rw[f,g];exact b) (by rw[f,g];have:=τ;omega) 0xFFFFFFFF 0 0 ג ד;refine⟨L,H,e,h,c,λt k=>?_⟩;have:=j t ג (by rw[g];exact k);rwa[f]at this section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Numerics open Model open RationalBinary (floorLog2 scaleByPowerOfTwo scaleByPowerOfTwo_snd_ne_zero) open FloatLib.Numerics (binaryRadix Radix.toReal) end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Floats.Formats.Flocq open Float.Model.UnpackedFloat open FloatLib.Numerics (binaryRadix Radix.toReal) end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open Float.Model.UnpackedFloat end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats end section end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats open Float.Model.UnpackedFloat end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Numerics open Model open RationalBinary (floorLog2 scaleByPowerOfTwo scaleByPowerOfTwo_snd_ne_zero) open FloatLib.Numerics (binaryRadix Radix.toReal) end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats FloatLib.Numerics open Model open RationalBinary (floorLog2 scaleByPowerOfTwo scaleByPowerOfTwo_snd_ne_zero) open FloatLib.Numerics (binaryRadix Radix.toReal) end section open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats end section end end Submission namespace Submission open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange @[inline] def YU (bx:ڎ):ڜ:=Yk (bx&&&0xffff)-Yk (bx>>>16) end Submission namespace d8 open FloatLib.Floats.Formats.BinaryInterchange open Float.Model Float.Model.UnpackedFloat lemma aN (spec:Format) (sg:Sign) (m:ڣ) (e:Int) (hm:m≠0) (he:spec.targetExponent (totalExponent m e)=e): round spec sg m e=.finite sg m e (Nat.pos_of_ne_zero hm):=by have hshift (em:ExtendedMantissa):em>>>0=em:=rfl simp[Float.Model.UnpackedFloat.round,decreaseExponent,he,roundWithAccuracy,shiftToTargetExponent,shiftToExponent, ExtendedMantissa.ofMantissaAndAccuracy,ExtendedMantissa.roundedMantissa,ExtendedMantissa.accuracy, Accuracy.roundToNearestEven,hshift,hm] lemma d4 (sg:Sign) (m gap:ڣ) (hm:2^23≤ m ∧ m<2^24): round Format.binary64 sg (m*2^gap) 0= .finite sg (m*2^29) ((gap:Int)-29) (by have:=hm.1;norm_num at this ⊢;omega):=by have hn:m≠0:=by have:=hm.1;norm_num at this ⊢;omega have hlog:Nat.log2 m=23:=by have hlo:23≤ Nat.log2 m:=(Nat.le_log2 hn).2 hm.1 have hhi:Nat.log2 m<24:=(Nat.log2_lt hn).2 hm.2 omega have hn29:m*2^29≠0:=by positivity have htarget:Format.binary64.targetExponent (totalExponent (m*2^29) ((gap:Int)-29))=(gap:Int)-29:=by simp only[Format.targetExponent,totalExponent] rw[←Nat.shiftLeft_eq,Nat.log2_shiftLeft_of_ne_zero _ _ hn] change max (((Nat.log2 m+29:ڣ):Int)+1+((gap:Int)-29)-53) (-1074)=(gap:Int)-29 rw[hlog] push_cast rw[max_eq_left] <;> omega have h1:=Model.round_shiftLeft Format.binary64 sg m gap (gap:Int) hn have h2:=Model.round_shiftLeft Format.binary64 sg m 29 (gap:Int) hn simp only[Nat.shiftLeft_eq,Int.sub_self]at h1 h2 rw[h1,←h2] exact aN _ _ _ _ hn29 htarget lemma dV (negative:ڡ) (m gap:ڣ) (hm:2^23≤ m ∧ m<2^24): Float.Model.UnpackedFloat.ofInt Format.binary64 (if negative then -((m*2^gap:ڣ):Int) else ((m*2^gap:ڣ):Int))= .finite (Model.modelSign negative) (m*2^29) ((gap:Int)-29) (by have:=hm.1;norm_num at this ⊢;omega):=by have hp:0<(m*2^gap:ڣ):=by have:=hm.1;positivity have hpi:0<((m*2^gap:ڣ):Int):=by exact_mod_cast hp cases negative · simp only[Bool.false_eq_true,ite_false,Float.Model.UnpackedFloat.ofInt,Float.Model.UnpackedFloat.normalize,Int.compare_eq_gt.mpr hpi,Int.toNat_natCast] exact d4 .positive m gap hm · simp only[ite_true,Float.Model.UnpackedFloat.ofInt,Float.Model.UnpackedFloat.normalize,Int.compare_eq_lt.mpr (by omega: -((m*2^gap:ڣ):Int)<0),Int.neg_neg,Int.toNat_natCast] exact d4 .negative m gap hm lemma bo (negative:ڡ) (m gap:ڣ) (hm:2^23≤ m ∧ m<2^24) (hg:gap≤39): (Float.Model.ofInt (if negative then -((m*2^gap:ڣ):Int) else ((m*2^gap:ڣ):Int))).unpack= .finite (Model.modelSign negative) (m*2^29) ((gap:Int)-29) (by have:=hm.1;norm_num at this ⊢;omega):=by unfold Float.Model.ofInt rw[dV negative m gap hm] have hn:m≠0:=by have:=hm.1;norm_num at this ⊢;omega have hm29:m*2^29≠0:=by positivity have hlog:Nat.log2 m=23:=(Nat.log2_eq_iff hn).2 hm have hbits:(m*2^29).log2+1=Format.binary64.mantissaBits:=by rw[←Nat.shiftLeft_eq,Nat.log2_shiftLeft_of_ne_zero _ _ hn,hlog] rfl change Float.Model.UnpackedFloat.unpack Format.binary64 (Float.Model.UnpackedFloat.pack Format.binary64 (.finite (Model.modelSign negative) (m*2^29) ((gap:Int)-29) (Nat.pos_of_ne_zero hm29)))=_ exact Model.unpack_pack_finite_normal Format.binary64 (Model.modelSign negative) (m*2^29) ((gap:Int)-29) hm29 hbits (by change 0≤(gap:Int)-29+1023+52;omega) (by change 0<(gap:Int)-29+1023+52;omega) (by change ((gap:Int)-29+1023+52).toNat+1<2^11 have hgi:(gap:Int)≤39:=by exact_mod_cast hg omega) lemma a8 (v:ڭ) (negative:ڡ) (m gap:ڣ) (hm:2^23≤ m ∧ m<2^24) (hg:gap≤39) (hv:v.toModel=Float.Model.ofInt (if negative then -((m*2^gap:ڣ):Int) else ((m*2^gap:ڣ):Int))): fO v.toModel.unpack ∧ finite v ∧ real v=(if negative then -((m*2^gap:ڣ):ڰ) else ((m*2^gap:ڣ):ڰ)):=by have hu:v.toModel.unpack=.finite (Model.modelSign negative) (m*2^29) ((gap:Int)-29) (by have:=hm.1;norm_num at this ⊢;omega):=by rw[hv] exact bo negative m gap hm hg have hn:fO v.toModel.unpack:=by rw[hu] exact ⟨m,hm.1,hm.2,rfl,by omega,by omega⟩ have hf:finite v:=by rw[dQ] change v.toModel.unpack.isFinite=true rw[hu] rfl have hscale:((m*2^29:ڣ):ڰ)*(2:ڰ)^((gap:Int)-29)=((m*2^gap:ڣ):ڰ):=by have hcast:((m*2^29:ڣ):ڰ)=(m:ڰ)*(2:ڰ)^(29:Int):=by norm_num only[zpow_natCast];push_cast;rfl rw[hcast,mul_assoc,←zpow_add₀ Q25] rw[show (29:Int)+((gap:Int)-29)=(gap:Int) by omega,zpow_natCast] push_cast rfl refine ⟨hn,hf,?_⟩ rw[dZ,hu,Model.unpackedToReal_finite] cases negative <;> simp only[Model.modelSignBit_modelSign,Q22,Q23,FloatLib.Numerics.Radix.toReal,ite_true,ite_false,Bool.false_eq_true,Nat.cast_ofNat,↓reduceIte] · simpa only[one_mul]using hscale · simpa only[neg_mul,one_mul]using congrArg Neg.neg hscale lemma ck (v:ڭ) (sg:Sign) (hu:v.toModel.unpack=.zero sg): fO v.toModel.unpack ∧ finite v ∧ real v=0:=by refine ⟨by rw[hu];trivial,?_,?_⟩ · rw[dQ] change v.toModel.unpack.isFinite=true rw[hu] rfl · rw[dZ,hu,Model.unpackedToReal_zero] end d8 namespace Submission open ExactRuntime lemma fX (x:ڎ):(x>>>31)=if signOf x then 1 else 0:=by apply UInt32.toNat_inj.mp have h:=D4 x 0 simp only[UInt32.xor_zero,show signOf (0:ڎ)=false by decide,Bool.xor_false,UInt32.toUInt64_toNat]at h cases hs:signOf x <;> simpa[hs]using h end Submission namespace Submission open ExactRuntime d8 lemma ec (x:ڎ) (xm:ڜ) (span:ڣ) (v:ڭ) (hr:real v=(sv x:ڰ)*2^((zz x:Int)-(xm.toNat:Int))) (hg:z11 x ≠ 0→ xm.toNat ≤ zz x ∧ zz x-xm.toNat ≤ span): |real v| ≤ (2:ڰ)^((span:Int)+24):=by rw[hr] by_cases hz:z11 x=0 · simp[sv,hz];positivity · have hm:|(sv x:ڰ)| ≤ (2:ڰ)^(24:Int):=by have h:=mantOf_lt_24 x unfold sv split <;> simp only[Int.cast_neg,Int.cast_natCast,abs_neg,abs_of_nonneg (show (0:ڰ) ≤ (z11 x:ڰ) from by positivity)] <;> exact_mod_cast h.le have he:(zz x:Int)-(xm.toNat:Int) ≤ (span:Int):=by obtain ⟨hlo,hhi⟩:=hg hz;omega rw[abs_mul,abs_of_pos (by positivity: 0<(2:ڰ)^((zz x:Int)-(xm.toNat:Int)))] calc _ ≤ (2:ڰ)^(24:Int)*2^(span:Int):=mul_le_mul hm (zpow_le_zpow_right₀ Q25 he) Q27 Q27 _ = _:=by rw[←zpow_add₀ Q25];congr 1;omega lemma bz (x w:ڎ) (xm wm:ڜ) (cx cw:ڭ) (hx:real cx=(sv x:ڰ)*2^((zz x:Int)-(xm.toNat:Int))) (hw:real cw=(sv w:ڰ)*2^((zz w:Int)-(wm.toNat:Int))) (hnx:fO cx.toModel.unpack) (hnw:fO cw.toModel.unpack) (hvx:gk x=true) (hvw:gk w=true): finite (cx*cw) ∧ real (cx*cw)*2^((xm.toNat:Int)+(wm.toNat:Int)-298)=real (convert x*convert w):=by obtain ⟨hf,hm⟩:=ev cx cw hnx hnw obtain ⟨_,hcv⟩:=eN x w hvx hvw refine ⟨hf,?_⟩ rw[hm,hcv,hx,hw,eb x hvx,eb w hvw] have hp:(2:ڰ)^((zz x:Int)-(xm.toNat:Int))*2^((zz w:Int)-(wm.toNat:Int))*2^((xm.toNat:Int)+(wm.toNat:Int)-298)= (2:ڰ)^((zz x:Int)-149)*2^((zz w:Int)-149):=by repeat rw[←zpow_add₀ (by norm_num: (2:ڰ)≠0)] congr 1 omega calc _=(sv x:ڰ)*(sv w:ڰ)*(2^((zz x:Int)-(xm.toNat:Int))*2^((zz w:Int)-(wm.toNat:Int))*2^((xm.toNat:Int)+(wm.toNat:Int)-298)):=by ring _=_:=by rw[hp];ring end Submission namespace Submission open ExactRuntime d8 @[inline] def fk (x:ڎ) (xm:ڜ):ڭ:=aI x xm lemma dd (w:ڎ) (h:2^23 ≤ z11 w):z12 w≠0:=by intro he have hf:=fracOf_toNat_lt w simp only[z11,he,if_true]at h omega lemma cC (x:ڎ) (xm:ڜ) (hm:z11 x≠0 → 2^23 ≤ z11 x ∧ z11 x<2^24 ∧ xm.toNat ≤ zz x ∧ zz x-xm.toNat ≤ 39): fO (fk x xm).toModel.unpack ∧ finite (fk x xm) ∧ real (fk x xm)=(sv x:ڰ)*2^((zz x:Int)-(xm.toNat:Int)):=by apply aa intro hn obtain ⟨a,b,c,d⟩:=hm hn exact ⟨dd x a,by omega,by omega⟩ lemma cB (w:ڎ) (wm:ڜ) (sw:ڣ) (hm:z11 w≠0 → 2^23 ≤ z11 w ∧ wm.toNat ≤ zz w ∧ zz w-wm.toNat ≤ sw) (hmax:wm.toNat+sw ≤ 172): fO (aI w 120).toModel.unpack ∧ finite (aI w 120) ∧ real (aI w 120)=(sv w:ڰ)*2^((zz w:Int)-120):=by apply aa intro hn obtain ⟨hlo,hmin,hgap⟩:=hm hn refine ⟨dd w hlo,?_,?_⟩ · change 120 < 150+zz w omega · change zz w < 120+105 omega lemma ej (w:ڎ) (gl:ڜ) (span:Int) (v:ڭ) (hr:real v=(sv w:ڰ)*2^((zz w:Int)-(gl.toNat:Int))) (hg:z11 w≠0 → (zz w:Int)-(gl.toNat:Int) ≤ span): |real v| ≤ (2:ڰ)^(span+24):=by rw[hr] by_cases hz:z11 w=0 · simp[sv,hz];positivity · have hm:|(sv w:ڰ)| ≤ (2:ڰ)^(24:Int):=by have h:=mantOf_lt_24 w unfold sv split <;> simp only[Int.cast_neg,Int.cast_natCast,abs_neg,abs_of_nonneg (show (0:ڰ) ≤ (z11 w:ڰ) from by positivity)] <;> exact_mod_cast h.le rw[abs_mul,abs_of_pos (by positivity: 0<(2:ڰ)^((zz w:Int)-(gl.toNat:Int)))] calc _ ≤ (2:ڰ)^(24:Int)*2^span:=mul_le_mul hm (zpow_le_zpow_right₀ Q25 (hg hz)) Q27 Q27 _ = _:=by rw[←zpow_add₀ Q25];congr 1;omega lemma dg (x w:ڎ) (xm wm:ڜ) (sx sw:ڣ) (cx cw:ڭ) (hx:real cx=(sv x:ڰ)*2^((zz x:Int)-(xm.toNat:Int))) (hw:real cw=(sv w:ڰ)*2^((zz w:Int)-120)) (hnx:fO cx.toModel.unpack) (hnw:fO cw.toModel.unpack) (hgx:z11 x≠0 → xm.toNat ≤ zz x ∧ zz x-xm.toNat ≤ sx) (hgw:z11 w≠0 → wm.toNat ≤ zz w ∧ zz w-wm.toNat ≤ sw): |real (cx*cw)| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250):=by rw[(ev cx cw hnx hnw).2,abs_mul] have hwa:|real cw| ≤ (2:ڰ)^((wm.toNat:Int)+(sw:Int)-120+24):=by apply ej w 120 ((wm.toNat:Int)+(sw:Int)-120) cw hw intro hn obtain ⟨a,b⟩:=hgw hn change (zz w:Int)-120 ≤ _ omega calc _ ≤ (2:ڰ)^((sx:Int)+24)*2^((wm.toNat:Int)+(sw:Int)-120+24):=mul_le_mul (ec x xm sx cx hx hgx) hwa (abs_nonneg _) Q27 _=_:=by rw[←zpow_add₀ Q25];congr 1;push_cast;omega end Submission namespace d8 open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange lemma ga (u:ڜ):(u&&&0x8000000000000000 !=0)=(u>>>63 !=0):=by apply Bool.eq_iff_iff.mpr simp only [bne_iff_ne,ne_eq,←UInt64.toNat_inj] rw [Q20,UInt64.toNat_shiftRight] change ¬u.toNat&&&2^63=0 ↔ ¬u.toNat>>>63=0 rw [Nat.and_two_pow,Nat.shiftRight_eq_div_pow,Nat.testBit_eq_decide_div_mod_eq] have hq:u.toNat/2^63<2:=by have h:=UInt64.toNat_lt u;omega rw [zz5 hq] by_cases hh:u.toNat/2^63=1 <;> simp [hh] <;> omega lemma dT (v:ڭ): Q2 v.toModel=Model.ofFields Q0 (v.toBits>>>63 !=0) (((v.toBits>>>52)&&&2047).toNat) ((v.toBits&&&0xfffffffffffff).toNat):=by have he:Model.expField (Q2 v.toModel)=((v.toBits>>>52)&&&2047).toNat:=rfl have hf:Model.fracField (Q2 v.toModel)=(v.toBits&&&0xfffffffffffff).toNat:=rfl have hs:Model.signBit (Q2 v.toModel)=(v.toBits>>>63 !=0):=by rw [←ga] apply Bool.eq_iff_iff.mpr simp only [Model.signBit,bne_iff_ne,ne_eq] rw [←UInt64.toBitVec_inj] exact Iff.rfl rw [←Model.ofFields_signBit_expField_fracField (Q2 v.toModel),he,hf,hs] @[inline] def fy (v:ڭ):ڎ:= let bits:=v.toBits;let ex:=(bits>>>52)&&&2047;let mant:=bits&&&0xfffffffffffff if ex=0 then 0 else let mant:=mant+0x10000000000000 let S:Int:=if bits>>>63 !=0 then -Int.ofNat mant.toNat else Int.ofNat mant.toNat finishWord S ((ex.toNat:Int)-1075) false lemma dq (v:ڭ):((v.toBits>>>52)&&&2047).toNat<2^11:=by have hh:(v.toBits>>>52).toNat&&&(2047:ڜ).toNat≤(2047:ڜ).toNat:=Nat.and_le_right simp only [Q20] at hh ⊢ norm_num at hh ⊢ omega lemma dr (v:ڭ):(v.toBits&&&0xfffffffffffff).toNat<2^52:=by have hh:v.toBits.toNat&&&(0xfffffffffffff:ڜ).toNat≤(0xfffffffffffff:ڜ).toNat:=Nat.and_le_right simp only [Q20] at hh ⊢ norm_num at hh ⊢ omega lemma eu (v:ڭ):((v.toBits&&&0xfffffffffffff)+0x10000000000000).toNat= (v.toBits&&&0xfffffffffffff).toNat+2^52:=by have hb:=dr v rw [UInt64.toNat_add] norm_num simp only [Q20] at hb norm_num at hb ⊢ omega lemma bY (v:ڭ) (hv:finite v) (he:((v.toBits>>>52)&&&2047)≠0): Q5 (Q2 v.toModel)=some ⟨v.toBits>>>63 !=0,(v.toBits&&&0xfffffffffffff).toNat+2^52, (((v.toBits>>>52)&&&2047).toNat:Int)-1075⟩:=by unfold finite at hv rw [dT] at hv ⊢ rw [Q17 _ _ _ _ (dq v) (dr v) hv] have he':((v.toBits>>>52)&&&2047).toNat≠0:=by intro hh apply he apply UInt64.toNat_inj.mp simpa using hh rw [if_neg he'] simp only [show FloatFormat.binary64.fracWidth=52 from rfl,show FloatFormat.binary64.exponentBias=1023 from rfl,Model.pow2_eq_two_pow] congr 2 <;> (try simp only [Q21,Nat.cast_add,Nat.cast_ofNat]) <;> ring lemma fV (z:Model Fmt):ofW (toWord z)=z:=by have h:z.toNatBits<2^32:=Model.toNatBits_lt_two_pow z simp only [ofW,toWord,Model.ofUInt32,UInt32.toNat_ofNat',zz5 h] exact Model.ofNatBits_toNatBits z lemma cq (v:ڭ) (hv:finite v) (hn:fy v&&&0x7fffffff≠0): ∃d,Q5 (Q2 v.toModel)=some d ∧ fy v=toWord (Q6 Fmt d):=by have he:((v.toBits>>>52)&&&2047)≠0:=by intro hh simp only [fy,hh,ite_true] at hn exact hn Q26 let M:ڣ:=(v.toBits&&&0xfffffffffffff).toNat+2^52 let e:Int:=(((v.toBits>>>52)&&&2047).toNat:Int)-1075 let ng:ڡ:=v.toBits>>>63 !=0 let S:Int:=if ng then -Int.ofNat M else Int.ofNat M let d:Numerics.Dyadic:=⟨ng,M,e⟩ have hd:Q5 (Q2 v.toModel)=some d:=bY v hv he have hm:0 simp only [hsg,Bool.false_eq_true,ite_false,ite_true,Q21] <;> omega have hsd:ofIntDyadic S e=d:=by cases hsg:ng <;> simp [ofIntDyadic,S,d,hsg,Q21,hmi,hm] refine ⟨d,hd,?_⟩ simp only [fy,he,ite_false,eu] change finishWord S e false=_ rw [finishWord,if_neg hs,hsd] lemma cU (v:ڭ) (hv:finite v) (hn:fy v&&&0x7fffffff≠0): ∃d,Q5 (Q2 v.toModel)=some d ∧ ofW (fy v)=Q6 Fmt d:=by obtain ⟨d,hd,hr⟩:=cq v hv hn exact ⟨d,hd,by rw [hr,fV]⟩ lemma dB (v:ڭ) (hv:finite v) (hn:fy v&&&0x7fffffff≠0) (hf:Q4 (ofW (fy v))=true): Q3 (ofW (fy v))=Q7 Fmt (real v):=by obtain ⟨d,hd,hr⟩:=cU v hv hn rw [hr] at hf ⊢ rw [Model.toReal_roundDyadic_eq_roundAt _ Q26 _ hf] congr 1 simp only [real,Model.toReal_eq,hd] end d8 namespace d8 lemma cJ (n:ڲ) (fx fw:(i:ڲ)→ i have hkn:k.toNat have he:k.toNat=n.toNat:=by have hnk:¬k.toNata | k+1=>en a t k+t k lemma bU (a:ڰ) (t:ڣ→ ڰ) (n:ڣ) (B:ڰ) (hb:0≤B) (ha:|a|≤B) (ht:∀k,kintro hk;simpa [en] using ha | succ k ih=> intro hk have hi:=ih Q24 have hc:=ht k Q24 rw [en] calc |en a t k+t k|≤|en a t k|+|t k|:=abs_add_le _ _ _≤((k:ڰ)+1)*B+B:=add_le_add hi hc _=(((k+1:ڣ):ڰ)+1)*B:=by push_cast;ring lemma bV (a:ڰ) (t A:ڣ→ ڰ) (V:ڣ→ Prop) (n:ڣ) (B E:ڰ) (hb:0≤B) (he:0≤E) (ha:|a|≤B) (ht:∀k,kintro hk;exact ⟨hv,by simp [en,hzero]⟩ | succ k ih=> intro hk have hkn:k≤n:=by omega obtain ⟨hvk,her⟩:=ih hkn have hkc:krw[hh,zpow_add₀ Q25] norm_num lemma bK (n l:ڣ) (c:Int) (hl:l≤12) (hn:n+2<2^(l+1)): let B:ڰ:=(2:ڰ)^(c-250) let e:ڰ:=(2:ڰ)^(c+(l:Int)-303) let d:ڰ:=(2:ڰ)^(c-301+2*(l:Int)) (n:ڰ)*e≤B ∧ (n:ڰ)*e≤d/2 ∧ d≤B ∧ ((n:ڰ)+2)*B<(2:ڰ)^(c+(l:Int)-249) ∧ ((n:ڰ)+3)*B<(2:ڰ)^(c+(l:Int)-248) ∧ (2:ڰ)^((c+(l:Int)-248)-53)/2≤d/2:=by dsimp only have hnp:(n:ڰ)+2<(2:ڰ)^((l:Int)+1):=by have hh:((n+2:ڣ):ڰ)<(2:ڰ)^(l+1):=by exact_mod_cast hn simpa only[Nat.cast_add,Nat.cast_ofNat,zpow_add₀ (by norm_num: (2:ڰ)≠0),zpow_natCast,zpow_one,pow_succ]using hh have hnle:(n:ڰ)≤(2:ڰ)^((l:Int)+1):=by linarith have he:0≤(2:ڰ)^(c+(l:Int)-303):=le_of_lt (zpow_pos Q25 _) have hB:0<(2:ڰ)^(c-250):=zpow_pos Q25 _ have hstep:(n:ڰ)*(2:ڰ)^(c+(l:Int)-303)≤(2:ڰ)^(c+2*(l:Int)-302):=by calc (n:ڰ)*(2:ڰ)^(c+(l:Int)-303)≤(2:ڰ)^((l:Int)+1)*(2:ڰ)^(c+(l:Int)-303):=mul_le_mul_of_nonneg_right hnle he _=(2:ڰ)^(c+2*(l:Int)-302):=by rw[←zpow_add₀ Q25];congr 1;omega have hrad:(2:ڰ)^(c-301+2*(l:Int))/2=(2:ڰ)^(c+2*(l:Int)-302):=by rw[ff];congr 1;omega have hbudget:(n:ڰ)*(2:ڰ)^(c+(l:Int)-303)≤(2:ڰ)^(c-250):=by apply hstep.trans apply zpow_le_zpow_right₀ Q25 have hli:(l:Int)≤12:=by exact_mod_cast hl omega have hd:(2:ڰ)^(c-301+2*(l:Int))≤(2:ڰ)^(c-250):=by apply zpow_le_zpow_right₀ Q25 have hli:(l:Int)≤12:=by exact_mod_cast hl omega refine ⟨hbudget,by rw[hrad];exact hstep,hd,?_,?_,?_⟩ · calc ((n:ڰ)+2)*(2:ڰ)^(c-250)<(2:ڰ)^((l:Int)+1)*(2:ڰ)^(c-250):=mul_lt_mul_of_pos_right hnp hB _=(2:ڰ)^(c+(l:Int)-249):=by rw[←zpow_add₀ Q25];congr 1;omega · have hnp2:(n:ڰ)+3<2*((2:ڰ)^((l:Int)+1)):=by have hn0:0≤(n:ڰ):=by positivity linarith calc ((n:ڰ)+3)*(2:ڰ)^(c-250)<(2*((2:ڰ)^((l:Int)+1)))*(2:ڰ)^(c-250):=mul_lt_mul_of_pos_right hnp2 hB _=(2:ڰ)^(c+(l:Int)-248):=by calc 2*(2:ڰ)^((l:Int)+1)*(2:ڰ)^(c-250)=(2:ڰ)^(1:Int)*(2:ڰ)^((l:Int)+1)*(2:ڰ)^(c-250):=by simp only[zpow_one] _=(2:ڰ)^(c+(l:Int)-248):=by rw[←zpow_add₀ Q25,←zpow_add₀ Q25] congr 1;omega · rw[ff,hrad] apply zpow_le_zpow_right₀ Q25 have hl0:0≤(l:Int):=by omega omega lemma bT (S T d lo hi:ڰ) (hs:|S-T|≤d/2) (hl:|lo-(S-d)|≤d/2) (hh:|hi-(S+d)|≤d/2): lo≤T ∧ T≤hi:=by obtain ⟨hs0,hs1⟩:=abs_le.mp hs obtain ⟨hl0,hl1⟩:=abs_le.mp hl obtain ⟨hh0,hh1⟩:=abs_le.mp hh constructor <;>linarith lemma al (l:ڣ) (c:Int) (hl:l≤12) (hc:126≤c ∧ c≤350): (-1021≤c+(l:Int)-249 ∧ c+(l:Int)-249≤512) ∧ (-1021≤c+(l:Int)-248 ∧ c+(l:Int)-248≤512):=by have hl0:0≤(l:Int):=by omega have hl12:(l:Int)≤12:=by exact_mod_cast hl omega lemma cW (c:Int) (l:ڣ): (2:ڰ)^((c+(l:Int)-249)-53)/2=(2:ڰ)^(c+(l:Int)-303):=by rw[ff] congr 1 omega lemma av (a:ڰ) (t A:ڣ→ ڰ) (V:ڣ→ Prop) (n l:ڣ) (c:Int) (hl:l≤12) (hn:n+2<2^(l+1)) (ha:|a|≤(2:ڰ)^(c-250)) (ht:∀k,kreal (t k)) n|≤(2:ڰ)^(c-301+2*(l:Int))/2 ∧ |real (A n)|≤((n:ڰ)+2)*(2:ڰ)^(c-250):=by obtain ⟨-,-,-,hinput,-,-⟩:=bK n l c hl hn obtain ⟨he,he'⟩:=(al l c hl hc).1 apply av (real a) (fun k=>real (t k)) (fun k=>real (A k)) (fun k=>finite (A k)) n l c hl hn hat (fun k hk=>(ht k hk).2) · exact congrArg real hzero · simpa only[hzero]using ha · intro k hk hv hin obtain ⟨hf,hr,herr⟩:=fz (A k) (t k) hv (ht k hk).1 (c+(l:Int)-249) he he' (hin.trans_lt hinput) rw[hsucc k hk] exact ⟨hf,by rw[←cW c l];exact herr⟩ lemma am (S gf:ڭ) (T:ڰ) (n l:ڣ) (c:Int) (hl:l≤12) (hn:n+2<2^(l+1)) (hc:126≤c ∧ c≤350) (hs:finite S) (hd:finite gf) (hdelta:real gf=(2:ڰ)^(c-301+2*(l:Int))) (herr:|real S-T|≤(2:ڰ)^(c-301+2*(l:Int))/2) (hS:|real S|≤((n:ڰ)+2)*(2:ڰ)^(c-250)): finite (S-gf) ∧ finite (S+gf) ∧ real (S-gf)≤T ∧ T≤real (S+gf):=by obtain ⟨-,-,hdB,-,hinput,hout⟩:=bK n l c hl hn obtain ⟨he,he'⟩:=(al l c hl hc).2 have hpos:0<(2:ڰ)^(c-301+2*(l:Int)):=zpow_pos Q25 _ have hsum:|real S+real gf|≤((n:ڰ)+3)*(2:ڰ)^(c-250):=by calc |real S+real gf|≤|real S|+|real gf|:=abs_add_le _ _ _≤((n:ڰ)+2)*(2:ڰ)^(c-250)+(2:ڰ)^(c-301+2*(l:Int)):=by rw[hdelta,abs_of_pos hpos];exact add_le_add hS (le_refl _) _≤((n:ڰ)+3)*(2:ڰ)^(c-250):=by nlinarith have hsub:|real S-real gf|≤((n:ڰ)+3)*(2:ڰ)^(c-250):=by calc |real S-real gf|=|real S+(-real gf)|:=by rw[sub_eq_add_neg] _≤|real S|+|-(real gf)|:=abs_add_le _ _ _≤((n:ڰ)+2)*(2:ڰ)^(c-250)+(2:ڰ)^(c-301+2*(l:Int)):=by rw[abs_neg,hdelta,abs_of_pos hpos];exact add_le_add hS (le_refl _) _≤((n:ڰ)+3)*(2:ڰ)^(c-250):=by nlinarith obtain ⟨hfl,-,hle⟩:=fT S gf hs hd (c+(l:Int)-248) he he' (hsub.trans_lt hinput) obtain ⟨hfh,-,hhe⟩:=fz S gf hs hd (c+(l:Int)-248) he he' (hsum.trans_lt hinput) have hle':|real (S-gf)-(real S-(2:ڰ)^(c-301+2*(l:Int)))|≤(2:ڰ)^(c-301+2*(l:Int))/2:=by simpa only[hdelta]using hle.trans hout have hhe':|real (S+gf)-(real S+(2:ڰ)^(c-301+2*(l:Int)))|≤(2:ڰ)^(c-301+2*(l:Int))/2:=by simpa only[hdelta]using hhe.trans hout exact ⟨hfl,hfh,bT (real S) T _ _ _ herr hle' hhe'⟩ end d8 namespace d8 def er (a:ڭ) (t:ڣ→ ڭ):ڣ→ ڭ | 0 => a | k+1 => er a t k+t k lemma dR (n:ڲ) (fx fw:(i:ڲ)→ ireal (t k)) n.toNat|≤(2:ڰ)^(c-301+2*(l:Int))/2 ∧ |real S|≤((n.toNat:ڰ)+2)*(2:ڰ)^(c-250):=by have hs:∀(i:ڲ)(h:irfl) end d8 namespace d8 open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange lemma eY (E:Int) (he:E≤127): (2:ڰ)^E≤Q3 (Model.posMaxFinite Fmt):=by have h:=Model.abs_signed_mul_bpow_le_toReal_posMaxFinite Fmt false (2^23) (E-23) (by change 8388608≤8388608+8388607;omega) (by change E-23≤104;omega) simp only [Bool.false_eq_true,ite_false,one_mul] at h change |((2^23:ڣ):ڰ)*(2:ڰ)^(E-23)|≤_ at h have heq:((2^23:ڣ):ڰ)*(2:ڰ)^(E-23)=(2:ڰ)^E:=by rw [show ((2^23:ڣ):ڰ)=(2:ڰ)^(23:Int) by norm_num,←zpow_add₀ Q25] congr 1;omega rw [heq,abs_of_pos (zpow_pos Q25 E)] at h exact h lemma cr (v:ڭ) (hv:finite v) (hn:fy v&&&0x7fffffff≠0) (hb:|real v|≤(2:ڰ)^(120:Int)): Q4 (ofW (fy v))=true:=by obtain ⟨d,hd,hr⟩:=cU v hv hn rw [hr] apply Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite Fmt Q26 have he:real v=d.toReal:=by simp only [real,Model.toReal_eq,hd] rw [←he] exact hb.trans (eY 120 Q25) lemma fW (w:ڎ) (hf:z12 w≠255): Q3 (ofW w)=(sv w:ڰ)*(2:ڰ)^((zz w:Int)-149):=by rw [ofW,Model.toReal_eq,toDyadic_ofUInt32 w hf] change (decodeD w).toReal=_ rw [←Numerics.Dyadic.cast_toRat,decodeD_toRat] push_cast rfl lemma eL (w:ڎ) (hf:Q4 (ofW w)=true) (hz:w&&&0x7fffffff≠0): Q3 (ofW w)≠0:=by have he:z12 w≠255:=by rw [ofW,isFinite_ofUInt32] at hf exact bne_iff_ne.mp hf have hm:z11 w≠0:=by intro hm by_cases he0:z12 w=0 · simp only [z11,he0,ite_true] at hm have hu:=fh w rw [he0] at hu have hh:(w&&&0x7fffffff).toNat=0:=by simpa [fracOf] using hu.trans (by simpa [UInt32.toNat_zero] using hm) exact hz (UInt32.toNat_inj.mp (by simpa using hh)) · simp [z11,he0] at hm have hs:sv w≠0:=by unfold sv;split <;> simp_all rw [fW w he] exact mul_ne_zero (by exact_mod_cast hs) (zpow_ne_zero _ Q25) lemma aO (lo hi:ڭ) (d:Numerics.Dyadic) (hlo:finite lo) (hhi:finite hi) (hn:fy lo&&&0x7fffffff≠0) (he:fy lo=fy hi) (hl:real lo≤d.toReal) (hh:d.toReal≤real hi) (hbl:|real lo|≤(2:ڰ)^(120:Int)) (hbh:|real hi|≤(2:ڰ)^(120:Int)): Q6 Fmt d=ofW (fy lo):=by have hnh:fy hi&&&0x7fffffff≠0:=by rw [←he];exact hn have hfl:=cr lo hlo hn hbl have hfh:=cr hi hhi hnh hbh have hbd:|d.toReal|≤(2:ڰ)^(120:Int):=by obtain ⟨hll,hlh⟩:=abs_le.mp hbl obtain ⟨hhl,hhh⟩:=abs_le.mp hbh exact abs_le.mpr ⟨hll.trans hl,hh.trans hhh⟩ have hfd:=Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite Fmt Q26 d (hbd.trans (eY 120 Q25)) have h0:=Model.roundAt_mono Fmt hl have h1:=Model.roundAt_mono Fmt hh rw [←dB lo hlo hn hfl,←Model.toReal_roundDyadic_eq_roundAt Fmt Q26 d hfd] at h0 rw [←dB hi hhi hnh hfh,←Model.toReal_roundDyadic_eq_roundAt Fmt Q26 d hfd,←he] at h1 have hv:Q3 (Q6 Fmt d)=Q3 (ofW (fy lo)):=le_antisymm h1 h0 exact Model.eq_of_toReal_eq_of_nonzero hfd hfl hv (by rw [hv];exact eL _ hfl hn) lemma d5 (z:ڰ) (hz:|z|<(2:ڰ)^(114:Int)): |Q7 Q0 z|≤(2:ڰ)^(120:Int):=by have he:=Submission.bn z 114 Q25 hz calc |Q7 Q0 z|=|(Q7 Q0 z-z)+z|:=by congr 1;ring _≤|Q7 Q0 z-z|+|z|:=abs_add_le _ _ _≤(2:ڰ)^(114-53:Int)/2+(2:ڰ)^(114:Int):=add_le_add he hz.le _≤(2:ڰ)^(120:Int):=by norm_num lemma aJ (S gf:ڭ) (n:ڣ) (c:Int) (hn:n<4096) (hc:c≤350) (hs:finite S) (hd:finite gf) (hS:|real S|≤((n:ڰ)+2)*(2:ڰ)^(c-250)) (hD:|real gf|≤(2:ڰ)^(c-250)): |real (S-gf)|≤(2:ڰ)^(120:Int) ∧ |real (S+gf)|≤(2:ڰ)^(120:Int):=by have hB:(2:ڰ)^(c-250)≤(2:ڰ)^(100:Int):=zpow_le_zpow_right₀ Q25 Q24 have hnn:(n:ڰ)+2≤4100:=by exact_mod_cast (show n+2≤4100 by omega) have hSB:|real S|≤4100*(2:ڰ)^(100:Int):=hS.trans (mul_le_mul hnn hB Q27 Q25) have hDB:|real gf|≤(2:ڰ)^(100:Int):=hD.trans hB have hsum:|real S+real gf|<(2:ڰ)^(114:Int):=by have hh:|real S+real gf|≤4100*(2:ڰ)^(100:Int)+(2:ڰ)^(100:Int):=(abs_add_le _ _).trans (add_le_add hSB hDB) exact hh.trans_lt Q25 have hsub:|real S-real gf|<(2:ڰ)^(114:Int):=by have hh:|real S-real gf|≤4100*(2:ڰ)^(100:Int)+(2:ڰ)^(100:Int):=(abs_sub _ _).trans (add_le_add hSB hDB) exact hh.trans_lt Q25 obtain ⟨-,hrl,-⟩:=fT S gf hs hd 114 Q25 Q25 hsub obtain ⟨-,hrh,-⟩:=fz S gf hs hd 114 Q25 Q25 hsum rw [hrl,hrh] exact ⟨d5 _ hsub,d5 _ hsum⟩ end d8 namespace d8 open FloatLib.Floats.Formats.BinaryInterchange lemma ak (a b:ڭ) (ha:finite a) (hb:finite b) (he:real a=real b) (hz:real a≠0):a=b:=by apply (show Function.Injective Float.toModel from fun ⟨a⟩ ⟨b⟩ h=>congrArg Float.ofModel h) apply Model.ofFloatModel_injective exact Model.eq_of_toReal_eq_of_nonzero ha hb he hz end d8 namespace d8 open FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange lemma eD (e:ڣ) (he:e<2047): zz6 (e.toUInt64<<<52)=Model.ofFields Q0 false e 0:=by have ht:e*2^52<2^64:=by omega have hnat:(zz6 (e.toUInt64<<<52)).toNatBits= (Model.ofFields Q0 false e 0).toNatBits:=by change (e.toUInt64<<<52).toNat=_ rw [fo _ _ _ _ (by change e<2048;omega) (by change 0<2^52;norm_num)] have heNat:e.toUInt64.toNat=e:=by change e%2^64=e exact zz5 Q24 simp only [UInt64.toNat_shiftLeft,heNat] change (e<<<52)%2^64 = (0||| (e<<<52) |||0) simp only [Nat.zero_or,Nat.or_zero,Nat.shiftLeft_eq] exact zz5 ht rw [← Model.ofNatBits_toNatBits (zz6 (e.toUInt64<<<52)),hnat,Model.ofNatBits_toNatBits] lemma e8 (E:Int) (he:-1022≤E) (he':E≤1023): let v:=zz0 ((E+1023).toNat.toUInt64<<<52) finite v ∧ real v=(2:ڰ)^E:=by dsimp only let e:ڣ:=(E+1023).toNat have hep:(e:Int)=E+1023:=Int.toNat_of_nonneg Q24 have hel:e<2047:=by omega have he0:e≠0:=by omega have hmodel:=eD e hel have hf:Q4 (zz6 (e.toUInt64<<<52))=true:=by rw [hmodel,Model.isFinite_ofFields _ _ _ _ (by change e<2048;omega) (by change 0<2^52;norm_num)] change (e != 2047)=true simp only [bne_iff_ne];omega constructor · rw [fu];exact hf · rw [f1,hmodel] rw [Model.toReal_ofFields_normal_of_isFinite _ false e 0 he0 (by change e<2048;omega) (by change 0<2^52;norm_num)] · simp only [Bool.false_eq_true,ite_false,one_mul,Nat.add_zero] change ((2^52:ڣ):ڰ)*(2:ڰ)^((e:Int)-1023-52)=(2:ڰ)^E rw [show ((2^52:ڣ):ڰ)=(2:ڰ)^(52:Int) by norm_num] rw [←zpow_add₀ Q25] congr 1;omega · rw [←hmodel];exact hf end d8 namespace d8 open FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange open Float.Model Float.Model.UnpackedFloat lemma aZ (sg:Sign) (m:ڣ) (e k:Int) (hp:0< m) (hm:m<2^53) (hlo:-1074≤ e+k) (hhi:e+k≤459): let u:=Float.Model.UnpackedFloat.mul Format.binary64 (.finite sg m e hp) (.finite .positive (2^52) (k-52) Q27) Q4 (Model.ofModel Q0 u)=true ∧ Q3 (Model.ofModel Q0 u)= Q12 (.finite sg m e hp)*(2:ڰ)^k:=by have hmlog:52≤ Nat.log2 (m*2^52):=(Nat.le_log2 Q27).2 (by nlinarith) have hpre:e+(k-52)≤ Format.binary64.targetExponent (totalExponent (m*2^52) (e+(k-52))):=by change e+(k-52)≤ max ((Nat.log2 (m*2^52):Int)+1+(e+(k-52))-53) (-1074) apply le_max_of_le_left have hh:(52:Int)≤(Nat.log2 (m*2^52):Int):=by exact_mod_cast hmlog omega have hsg:sg*.positive=sg:=by cases sg <;>rfl have hs:Model.modelSign (Model.modelSignBit sg)=sg:=by cases sg <;>rfl let d:Numerics.Dyadic:=⟨Model.modelSignBit sg,m,e+k⟩ have hshift:Float.Model.UnpackedFloat.round Format.binary64 sg (m*2^52) (e+(k-52))= Float.Model.UnpackedFloat.round Format.binary64 sg m (e+k):=by have h:=Model.round_shiftLeft Format.binary64 sg m 52 (e+k) hp.ne' simpa only[Nat.shiftLeft_eq,show e+k-(52:ڣ)=e+(k-52) by omega]using h have hround:Model.ofModel Q0 (Float.Model.UnpackedFloat.mul Format.binary64 (.finite sg m e hp) (.finite .positive (2^52) (k-52) Q27))= Q6 Q0 d:=by rw[Float.Model.UnpackedFloat.mul,hsg,Model.roundWithAccuracy_exact_eq_round_of_le_targetExponent _ _ _ _ hpre,hshift] simp only[Q6,show FloatFormat.binary64.isIEEE=true from rfl,ite_true,Model.ieeeRoundDyadic,d,hs] rfl have hbound:|d.toReal|≤ Q3 (Model.posMaxFinite Q0):=by rw[fn] have hmant:(m:ڰ)≤(2:ڰ)^(53:Int):=by norm_num only[zpow_natCast] exact_mod_cast le_of_lt hm have hexp:(2:ڰ)^(e+k)≤(2:ڰ)^(459:Int):=zpow_le_zpow_right₀ Q25 hhi calc (d.significand:ڰ)*(2:ڰ)^d.exponent≤(2:ڰ)^(53:Int)*(2:ڰ)^(459:Int):= mul_le_mul hmant hexp (le_of_lt (zpow_pos Q25 _)) (le_of_lt (zpow_pos Q25 _)) _=(2:ڰ)^(512:Int):=by rw[←zpow_add₀ Q25];rfl _≤ Q3 (Model.posMaxFinite Q0):=cK 512 le_rfl have hr:=Model.roundDyadic_of_representable Q0 (by rfl) d m 0 (by simp only[d,pow_zero,Nat.mul_one]) hm (by change -1074≤ e+k;exact hlo) hbound have hreal:d.toReal=Q12 (.finite sg m e hp)*(2:ڰ)^k:=by cases sg <;> simp [d,Numerics.Dyadic.toReal,Numerics.Dyadic.signedSignificand,Model.unpackedToReal_finite,Model.modelSignBit,Q22,Q23,FloatLib.Numerics.Radix.toReal,zpow_add₀ (by norm_num: (2:ڰ)≠0)] <;>ring dsimp only rw[hround] exact ⟨hr.1,hr.2.trans hreal⟩ lemma eE (E:Int) (he:-1022≤ E) (he':E≤1023): (zz0 ((E+1023).toNat.toUInt64<<<52)).toModel.unpack= .finite .positive (2^52) (E-52) Q27:=by let a:ڣ:=(E+1023).toNat have ha:(a:Int)=E+1023:=Int.toNat_of_nonneg Q24 have ha0:a≠0:=by omega have haBound:a<2047:=by omega have hmodel:=eD a haBound have hf:Q4 (zz6 (a.toUInt64<<<52))=true:=by rw[hmodel,Model.isFinite_ofFields _ _ _ _ (by change a<2048;omega) (by change 0<2^52;norm_num)] change (a !=2047)=true simp only[bne_iff_ne] omega have hd:Q5 (Q2 (zz0 (a.toUInt64<<<52)).toModel)= some ⟨false,2^52,E-52⟩:=by rw[eM,hmodel,Q17 _ _ _ _ (by change a<2048;omega) (by change 0<2^52;norm_num)] · simp only[ha0,ite_false,Nat.add_zero,show FloatFormat.binary64.exponentBias=1023 from rfl,show FloatFormat.binary64.fracWidth=52 from rfl] change some (⟨false,2^52,(a:Int)-1023-52⟩:Numerics.Dyadic)=some ⟨false,2^52,E-52⟩ have hh:(a:Int)-1023-52=E-52:=by omega rw[hh] · rw[←hmodel] exact hf have hdec:Model.ieeeToDyadic? (Q2 (zz0 (a.toUInt64<<<52)).toModel)=some ⟨false,2^52,E-52⟩:=by rw[Model.ieeeToDyadic?_eq_unpackedToDyadic?_toModel,Q8] rw[←dS] exact hd have hm:=Model.toModel_eq_finite_of_ieeeToDyadic?_eq_some (Q2 (zz0 (a.toUInt64<<<52)).toModel) false (2^52) (E-52) Q27 hdec simpa only[Q8,Model.modelSign,Bool.false_eq_true,ite_false,a]using hm noncomputable def eJ (v:ڭ) (k:Int):Prop:= match v.toModel.unpack with | .zero _=>True | .finite _ m e _=>m<2^53 ∧ -1074≤ e+k ∧ e+k≤459 | _=>False lemma fS (x p:ڭ) (k:Int) (hx:eJ x k) (hp:p.toModel.unpack=.finite .positive (2^52) (k-52) Q27): finite (x*p) ∧ real (x*p)=real x*(2:ڰ)^k:=by rw[dZ x] unfold finite real rw[cM,hp] cases hux:x.toModel.unpack <;> simp only[hux,eJ]at hx all_goals try contradiction case finite sg m e hm=> exact aZ sg m e k hm hx.1 hx.2.1 hx.2.2 all_goals simp only[Float.Model.UnpackedFloat.mul,Model.isFinite_ofModel_zero Q0 (by rfl),Model.toReal_ofModel_zero Q0 (by rfl),Model.unpackedToReal_zero,zero_mul,eq_self,and_self] lemma dw (x:ڭ) (k:Int) (hx:eJ x k) (hk:-1022≤ k ∧ k≤1023): let p:=zz0 ((k+1023).toNat.toUInt64<<<52) finite (x*p) ∧ real (x*p)=real x*(2:ڰ)^k:= fS x _ k hx (eE k hk.1 hk.2) end d8 namespace Submission open ExactRuntime d8 open FloatLib.Floats.Formats.BinaryInterchange open Float.Model Float.Model.UnpackedFloat @[inline] def fZ (w:ڎ):ڎ:=(w&&&0x7fffff)|||0x800000 @[inline] def fG (w:ڎ):ڎ:=(w>>>23)&&&511 lemma eW (w:ڎ):(fZ w).toNat=(fracOf w).toNat+2^23:=by unfold fZ rw[UInt32.toNat_or] change (fracOf w).toNat ||| 2^23=_ exact Nat.or_two_pow_eq_add_of_lt (fracOf_toNat_lt w) lemma dj (w:ڎ): (fG w).toNat<512 ∧ (fG w).toNat%256=(z12 w).toNat ∧ ((fG w).toNat<256 ↔ signOf w=false):=by have hw:=w.toNat_lt have hd:(w>>>23).toNat=w.toNat/2^23:=by simp only[UInt32.toNat_shiftRight,Nat.shiftRight_eq_div_pow];rfl have hb:(w>>>23).toNat<512:=by rw[hd];norm_num at hw ⊢;omega have hi:(fG w).toNat=(w>>>23).toNat:=by simp only[fG,UInt32.toNat_and,show (511:ڎ).toNat=2^9-1 from rfl,Nat.and_two_pow_sub_one_eq_mod] exact zz5 hb have he:(z12 w).toNat=(w>>>23).toNat%256:=by simp only[z12,UInt32.toNat_and,show (0xff:ڎ).toNat=2^8-1 from rfl,Nat.and_two_pow_sub_one_eq_mod] have hs:(w>>>23).toNat/256=(if signOf w then (1:ڣ) else 0):=by have h:=congrArg UInt32.toNat (fX w) have hh:(w>>>31).toNat=(w>>>23).toNat/256:=by rw[hd] simp only[UInt32.toNat_shiftRight,Nat.shiftRight_eq_div_pow] norm_num rw[Nat.div_div_eq_div_mul] rw[hh]at h cases hc:signOf w <;> simpa[hc] using h rw[hi] refine ⟨hb,he.symm,?_⟩ cases hc:signOf w <;> simp[hc]at hs ⊢ <;> omega lemma aE (w:ڎ): fO (fZ w).toFloat.toModel.unpack ∧ finite (fZ w).toFloat ∧ real (fZ w).toFloat=((fZ w).toNat:ڰ):=by have hm:2^23 ≤ (fZ w).toNat ∧ (fZ w).toNat<2^24:=by rw[eW] have:=fracOf_toNat_lt w omega have hv:(fZ w).toFloat.toModel=Float.Model.ofInt ((fZ w).toNat:Int):=by change Float.Model.ofUInt32 _=Float.Model.ofInt _ unfold Float.Model.ofUInt32 Float.Model.ofInt Float.Model.UnpackedFloat.ofUInt32 Float.Model.UnpackedFloat.ofNat rfl simpa using a8 (fZ w).toFloat false (fZ w).toNat 0 hm Q24 (by simpa using hv) lemma aD (s:ڡ) (k:Int) (hk:-120 ≤ k ∧ k ≤ 52): (if s then -(zz0 ((k+1023).toNat.toUInt64<<<52)) else zz0 ((k+1023).toNat.toUInt64<<<52)).toModel.unpack= .finite (Model.modelSign s) (2^52) (k-52) Q27:=by have hp:=eE k Q24 Q24 cases s · exact hp · change (Float.Model.neg _).unpack=_ rw[Float.Model.neg,hp] change Float.Model.UnpackedFloat.unpack Format.binary64 (Float.Model.UnpackedFloat.pack Format.binary64 (.finite .negative (2^52) (k-52) Q27))=_ apply Model.unpack_pack_finite_normal · positivity · change Nat.log2 (2^52)+1=53 rw[Nat.log2_two_pow] · change 0 ≤ k-52+1023+52;omega · change 0 < k-52+1023+52;omega · change (k-52+1023+52).toNat+1<2^11;omega lemma aY (s:ڡ) (k:Int) (hk:-120 ≤ k ∧ k ≤ 52): let p:=if s then -(zz0 ((k+1023).toNat.toUInt64<<<52)) else zz0 ((k+1023).toNat.toUInt64<<<52) fO p.toModel.unpack ∧ finite p ∧ real p=(if s then -(2:ڰ)^k else (2:ڰ)^k):=by dsimp only have hp:=aD s k hk refine ⟨?_,?_,?_⟩ · rw[hp] exact ⟨2^23,by omega,by omega,by norm_num,by omega,by omega⟩ · rw[dQ] change (if s then -(zz0 ((k+1023).toNat.toUInt64<<<52)) else zz0 ((k+1023).toNat.toUInt64<<<52)).toModel.unpack.isFinite=true rw[hp];rfl · rw[dZ,hp,Model.unpackedToReal_finite] have he:(2:ڰ)^(52:ڣ)*(2:ڰ)^(k-52)=(2:ڰ)^k:=by rw[←zpow_natCast,←zpow_add₀ Q25] congr 1 omega have hh:(if s then -((2:ڰ)^52*(2:ڰ)^(k-52)) else (2:ڰ)^52*(2:ڰ)^(k-52))=(if s then -(2:ڰ)^k else (2:ڰ)^k):=by rw[he] norm_num only[show (2:ڰ)^52=4503599627370496 by norm_num] at hh cases s <;> simpa [Model.modelSign,Model.modelSignBit,Q22,Q23,FloatLib.Numerics.Radix.toReal]using hh @[inline] def cG (SF:fI) (w:ڎ):ڭ:= (fZ w).toFloat*SF.data.uget (fG w).toUSize (by rw[SF.size,UInt32.toNat_toUSize];exact (dj w).1) end Submission namespace Submission open ExactRuntime lemma aq (w:ڎ) (L H:ڣ) (hL:1 ≤ L) (hH:H<255) (hr:L ≤ YR w ∧ YM w ≤ H): d8.gk w=true ∧ (z11 w ≠ 0 → 2^23 ≤ z11 w ∧ z11 w<2^24 ∧ L-1 ≤ zz w ∧ zz w ≤ H-1):=by have hf:z12 w ≠ 255:=(Zb w).2.2.1 Q24 have hn (hm:z11 w ≠ 0):z12 w ≠ 0:=by intro he have hmf:z11 w=(fracOf w).toNat:=by simp only[z11,he,ite_true] have hp:0<(fracOf w).toNat:=by omega have hbase:(w&&&0x7fffffff).toNat=(fracOf w).toNat:=by rw[W9,he];simp have hsub:((w&&&0x7fffffff)-1).toNat=(fracOf w).toNat-1:=by rw[UInt32.toNat_sub_of_le _ _ (by rw[UInt32.le_iff_toNat_le,hbase];exact hp),hbase] rfl have hyr:YR w=0:=by unfold YR rw[UInt32.toNat_shiftRight,hsub] have hfrac:=fracOf_toNat_lt w norm_num only[UInt32.reduceToNat,Nat.reduceMod,Nat.shiftRight_eq_div_pow] change ((fracOf w).toNat-1)/2^23=0 exact Nat.div_eq_of_lt Q24 rw[hyr]at hr omega constructor · change (z12 w != 255 && (z12 w != 0 || fracOf w == 0))=true by_cases he:z12 w=0 · have hm:z11 w=0:=by by_contra hm;exact hn hm he have hm':(fracOf w).toNat=0:=by simpa only[z11,he,ite_true]using hm have hfr:fracOf w=0:=UInt32.toNat_inj.mp hm' simp[hf,he,hfr] · simp[hf,he] · intro hm have hnormal:=hn hm have hmant:z11 w=2^23+(fracOf w).toNat:=by simp only[z11,hnormal,ite_false] have hfrac:=fracOf_toNat_lt w have hh:YR w ≤ zz w+1 ∧ zz w+1 ≤ max (YM w) 1:=(Zb w).2.2.2 hm have hg:YM w=(z12 w).toNat:=by unfold YM rw[UInt32.toNat_shiftRight,W9] norm_num only[UInt32.reduceToNat,Nat.reduceMod,Nat.shiftRight_eq_div_pow] change ((z12 w).toNat*2^23+(fracOf w).toNat)/2^23=(z12 w).toNat omega have he:(z12 w).toNat ≠ 0:=by intro h;apply hnormal;exact UInt32.toNat_inj.mp h rw[hg,max_eq_left Q24]at hh refine ⟨by omega,by omega,by omega,?_⟩ rw[hg]at hr omega lemma ef (A:ڟ ڎ) (n i t s:ڣ) (ha:i*n+n ≤ A.size) (hb:i*n+n<4294967296) (ht:t>>16)) (hl:Yk (Yc A n i>>>16) ≤ Yk (Yc A n i&&&0xffff)) (hs:(YU (Yc A n i)).toNat ≤ s): d8.gk A[i*n+t]! = true ∧ (z11 A[i*n+t]! ≠ 0 → 2^23 ≤ z11 A[i*n+t]! ∧ z11 A[i*n+t]!<2^24 ∧ (Yk (Yc A n i>>>16)).toNat ≤ zz A[i*n+t]! ∧ zz A[i*n+t]!-(Yk (Yc A n i>>>16)).toNat ≤ s):=by obtain ⟨L,H,he,hL,hH,hrows⟩:=Zp A n i ha Q24 obtain ⟨hmin,hmax⟩:=Zo _ L H he Q24 have hLpos:1 ≤ L:=by have hh:=UInt32.le_iff_toNat_le.mp hlo norm_num only[UInt32.toNat_one]at hh rw[hmin]at hh exact hh have hHne:H ≠ 255:=by intro h;apply hf;apply UInt32.toNat_inj.mp;rw[hmax,h];rfl have hrow:=aq A[i*n+t]! L H hLpos Q24 (hrows t ht) have hmin':(Yk (Yc A n i>>>16)).toNat=L-1:=by rw[Zq,hmin] have hmax':(Yk (Yc A n i&&&0xffff)).toNat=H-1:=by rw[Zq,hmax] have hspan:(YU (Yc A n i)).toNat=(H-1)-(L-1):=by unfold YU;rw[UInt64.toNat_sub_of_le _ _ hl,hmin',hmax'] refine ⟨hrow.1,?_⟩ intro hm obtain ⟨ha,hb,hc,hd⟩:=hrow.2 hm rw[hspan]at hs rw[hmin'] exact ⟨ha,hb,hc,by omega⟩ end Submission namespace Submission open ExactRuntime lemma dJ (bx:ڎ) (s:ڣ) (hs:s ≤ 39) (hspan:(YU bx).toNat ≤ s): Yk (bx>>>16) ≤ Yk (bx&&&0xffff):=by have hm:(Yk (bx>>>16)).toNat<2^32:=by rw[Zq];have:=UInt32.toNat_lt (bx>>>16);omega have hh:(Yk (bx&&&0xffff)).toNat<2^32:=by rw[Zq];have:=UInt32.toNat_lt (bx&&&0xffff);omega rw[UInt64.le_iff_toNat_le] unfold YU at hspan rw[UInt64.toNat_sub]at hspan omega lemma eP (A:ڟ ڎ) (n i:ڣ) (ha:i*n+n ≤ A.size) (hb:i*n+n<4294967296) (hf:(Yc A n i&&&0xffff) ≠ 255): (Yk (Yc A n i&&&0xffff)).toNat ≤ 253:=by obtain ⟨L,H,he,hL,hH,hrows⟩:=Zp A n i ha Q24 have hparts:((Yc A n i)&&&0xffff).toNat=H:=(Zo _ L H he Q24).2 have hn:H ≠ 255:=by intro h;apply hf;apply UInt32.toNat_inj.mp;rw[hparts,h];rfl rw[Zq,hparts] omega lemma eR (bx bv:ڎ) (hx:Yk (bx>>>16) ≤ Yk (bx&&&0xffff)) (hw:Yk (bv>>>16) ≤ Yk (bv&&&0xffff)): (Yk (bx>>>16)).toNat+(Yk (bv>>>16)).toNat+(YU bx).toNat+(YU bv).toNat= (Yk (bx&&&0xffff)).toNat+(Yk (bv&&&0xffff)).toNat:=by simp only[YU,UInt64.toNat_sub_of_le _ _ hx,UInt64.toNat_sub_of_le _ _ hw] have hx':(Yk (bx>>>16)).toNat ≤ (Yk (bx&&&0xffff)).toNat:=UInt64.le_iff_toNat_le.mp hx have hw':(Yk (bv>>>16)).toNat ≤ (Yk (bv&&&0xffff)).toNat:=UInt64.le_iff_toNat_le.mp hw omega lemma fj (a b:ڜ) (w:ڎ) (ha:a.toNat ≤ 253) (hb:b.toNat ≤ 253): (max (a+b) (Yd oneW+Yd w)).toNat=max (a.toNat+b.toNat) (126+zz w):=by have hab:(a+b).toNat=a.toNat+b.toNat:=by rw[UInt64.toNat_add];exact zz5 Q24 have hw:(Yd oneW+Yd w).toNat=126+zz w:=by rw[ZM];rfl rw[UInt64.toNat_max,hab,hw] lemma fB (n gs:ڣ) (hn:n<4096) (hc:126 ≤ gs ∧ gs ≤ 349): let E:=(gs:Int)-298+2*((n+2).log2:Int)-2 let gf:=zz0 ((E+1023).toNat.toUInt64<<<52) d8.finite gf ∧ d8.real gf=(2:ڰ)^((gs:Int)-300+2*((n+2).log2:Int)):=by obtain ⟨hl,hlog⟩:=d8.bL n hn have he: -1022 ≤ (gs:Int)-298+2*((n+2).log2:Int)-2:=by omega have he':(gs:Int)-298+2*((n+2).log2:Int)-2 ≤ 1023:=by omega have hh:=d8.e8 ((gs:Int)-298+2*((n+2).log2:Int)-2) he he' dsimp only at hh ⊢ refine ⟨hh.1,?_⟩ rw[hh.2] congr 1 omega end Submission namespace d8 open FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange lemma cL (v:ڭ):Model.expField (Q2 v.toModel)=((v.toBits>>>52)&&&2047).toNat:=by rfl lemma cj (v:ڭ):Model.fracField (Q2 v.toModel)=(v.toBits&&&0xfffffffffffff).toNat:=by rfl lemma ci (v:ڭ): (v.toBits&&&0x7fffffffffffffff).toNat= Model.expField (Q2 v.toModel)*2^52+Model.fracField (Q2 v.toModel):=by rw[cL,cj] simp only[Q20,UInt64.toNat_shiftRight] rw[show (0x7fffffffffffffff:ڜ).toNat=2^63-1 from rfl, show (0xfffffffffffff:ڜ).toNat=2^52-1 from rfl, show (2047:ڜ).toNat=2^11-1 from rfl, show (52:ڜ).toNat%64=52 from rfl] simp only[Nat.and_two_pow_sub_one_eq_mod,Nat.shiftRight_eq_div_pow] omega lemma bt (v:ڭ) (k:Int) (hk:-298≤ k ∧ k≤208) (hf:finite v) (hg:(v.toBits&&&0x7fffffffffffffff)=0 ∨ (299≤((v.toBits>>>52)&&&2047).toNat ∧ ((v.toBits>>>52)&&&2047).toNat≤1326)): eJ v k:=by let a:=Q2 v.toModel have hfinite:Q4 a=true:=hf have hExp:=cL v have hFrac:Model.fracField a<2^52:=by simpa only[show FloatFormat.binary64.fracWidth=52 from rfl]using Model.fracField_lt_pow2 a have hExpMax:Model.expField a<2^11:=by simpa only[show FloatFormat.binary64.expWidth=11 from rfl]using Model.expField_lt_pow2 a have hfields:Model.ofFields Q0 (Model.signBit a) (Model.expField a) (Model.fracField a)=a:=Model.ofFields_signBit_expField_fracField a have hdecode:=Q17 Q0 (Model.signBit a) (Model.expField a) (Model.fracField a) hExpMax hFrac (by rw[hfields];exact hfinite) rw[hfields]at hdecode rcases hg with hz|hE · have hzNat:(v.toBits&&&0x7fffffffffffffff).toNat=0:=by rw[hz];rfl have hvals:=ci v have he0:Model.expField a=0:=by dsimp only[a]at*;omega have hf0:Model.fracField a=0:=by dsimp only[a]at*;omega rw[he0,hf0]at hdecode simp only[ite_true]at hdecode rw[dS]at hdecode cases hu:v.toModel.unpack <;> simp only[hu,Q13]at hdecode · cases hdecode · cases hdecode · simp only[eJ,hu] · rename_i sg m e hm simp only[Option.some.injEq,Numerics.Dyadic.mk.injEq]at hdecode have hh:m=0:=hdecode.2.1 omega · have he:299≤ Model.expField a ∧ Model.expField a≤1326:=by rw[hExp];exact hE have he0:Model.expField a≠0:=by omega simp only[he0,ite_false]at hdecode rw[dS]at hdecode cases hu:v.toModel.unpack <;> simp only[hu,Q13]at hdecode · cases hdecode · cases hdecode · simp only[eJ,hu] · rename_i sg m e hm simp only[Option.some.injEq,Numerics.Dyadic.mk.injEq]at hdecode simp only[eJ,hu] change m<2^53 ∧ -1074≤ e+k ∧ e+k≤459 have hmVal:m=2^52+Model.fracField a:=by simpa only[Model.pow2_eq_two_pow,show FloatFormat.binary64.fracWidth=52 from rfl]using hdecode.2.1 have heVal:e=(Model.expField a:Int)-1075:=by have hh:e=(Model.expField a:Int)-1023-52:=by simpa only[show FloatFormat.binary64.exponentBias=1023 from rfl,show FloatFormat.binary64.fracWidth=52 from rfl,Q21,Nat.cast_ofNat]using hdecode.2.2 omega rw[hmVal,heVal] omega lemma aH (v:ڭ) (k:Int) (hk:-298≤k ∧ k≤208) (hf:finite v) (hg:(v.toBits&&&0x7fffffffffffffff)=0 ∨ (299≤((v.toBits>>>52)&&&2047).toNat ∧ ((v.toBits>>>52)&&&2047).toNat≤1326)): let p:=zz0 ((k+1023).toNat.toUInt64<<<52) finite (v*p) ∧ real (v*p)=real v*(2:ڰ)^k:= dw v k (bt v k hk hf hg) ⟨by omega,by omega⟩ end d8 namespace d8 lemma fg (e:Int):(2:ڰ)^(e+1)=2*(2:ڰ)^e:=by rw[zpow_add₀ Q25] norm_num ring lemma aP (S T:ڰ) (n l:ڣ) (c0 gs g:Int) (hcut:c0+g≤ gs) (herr:|S-T|≤(2:ڰ)^(c0-301+2*(l:Int))/2) (hmag:|S|≤((n:ڰ)+2)*(2:ڰ)^(c0-250)): |S*(2:ڰ)^g-T*(2:ڰ)^g|≤(2:ڰ)^(gs-301+2*(l:Int))/2 ∧ |S*(2:ڰ)^g|≤((n:ڰ)+2)*(2:ڰ)^(gs-250):=by have hs:0≤(2:ڰ)^g:=le_of_lt (zpow_pos Q25 _) have hp1:(2:ڰ)^(c0-301+2*(l:Int))*(2:ڰ)^g≤(2:ڰ)^(gs-301+2*(l:Int)):=by rw[←zpow_add₀ Q25] apply zpow_le_zpow_right₀ Q25 omega have hp2:(2:ڰ)^(c0-250)*(2:ڰ)^g≤(2:ڰ)^(gs-250):=by rw[←zpow_add₀ Q25] apply zpow_le_zpow_right₀ Q25 omega constructor · rw[←sub_mul,abs_mul,abs_of_nonneg hs] calc |S-T| *(2:ڰ)^g≤((2:ڰ)^(c0-301+2*(l:Int))/2)*(2:ڰ)^g:=mul_le_mul_of_nonneg_right herr hs _=((2:ڰ)^(c0-301+2*(l:Int))*(2:ڰ)^g)/2:=by ring _≤(2:ڰ)^(gs-301+2*(l:Int))/2:=div_le_div_of_nonneg_right hp1 Q25 · rw[abs_mul,abs_of_nonneg hs] calc |S| *(2:ڰ)^g≤(((n:ڰ)+2)*(2:ڰ)^(c0-250))*(2:ڰ)^g:=mul_le_mul_of_nonneg_right hmag hs _=((n:ڰ)+2)*((2:ڰ)^(c0-250)*(2:ڰ)^g):=by ring _≤((n:ڰ)+2)*(2:ڰ)^(gs-250):=mul_le_mul_of_nonneg_left hp2 Q27 lemma ah (q b:ڭ) (T:ڰ) (n l:ڣ) (c0 gs g:Int) (hl:l≤12) (hn:n+2<2^(l+1)) (hc:126≤ gs ∧ gs≤349) (hcut:c0+g≤ gs) (hq:finite q) (hg:-298≤ g ∧ g≤208) (hguard:(q.toBits&&&0x7fffffffffffffff)=0 ∨ (299≤((q.toBits>>>52)&&&2047).toNat ∧ ((q.toBits>>>52)&&&2047).toNat≤1326)) (herr:|real q-T|≤(2:ڰ)^(c0-301+2*(l:Int))/2) (hmag:|real q|≤((n:ڰ)+2)*(2:ڰ)^(c0-250)) (hb:finite b) (hbmag:|real b|≤(2:ڰ)^(gs-250)): let p:=zz0 ((g+1023).toNat.toUInt64<<<52) let S:=q*p+b finite S ∧ |real S-(T*(2:ڰ)^g+real b)|≤(2:ڰ)^(gs-300+2*(l:Int))/2 ∧ |real S|≤((n:ڰ)+2)*(2:ڰ)^((gs+1)-250):=by let p:=zz0 ((g+1023).toNat.toUInt64<<<52) let Q:=q*p obtain ⟨hQf,hQr⟩:=aH q g hg hq hguard obtain ⟨hQerr,hQmag⟩:=aP (real q) T n l c0 gs g hcut herr hmag have hQerr':|real Q-T*(2:ڰ)^g|≤(2:ڰ)^(gs-301+2*(l:Int))/2:=by simpa only[Q,p,hQr]using hQerr have hQmag':|real Q|≤((n:ڰ)+2)*(2:ڰ)^(gs-250):=by simpa only[Q,p,hQr]using hQmag have hQfin:finite Q:=hQf obtain ⟨-,-,hDB,-,hinput,herror⟩:=bK n l gs hl hn have hc':126≤ gs ∧ gs≤350:=by omega obtain ⟨he,he'⟩:=(al l gs hl hc').2 have hsum:|real Q+real b|≤((n:ڰ)+3)*(2:ڰ)^(gs-250):=by calc |real Q+real b|≤|real Q|+|real b|:=abs_add_le _ _ _≤((n:ڰ)+2)*(2:ڰ)^(gs-250)+(2:ڰ)^(gs-250):=add_le_add hQmag' hbmag _=((n:ڰ)+3)*(2:ڰ)^(gs-250):=by ring obtain ⟨hSf,-,hSerr⟩:=fz Q b hQfin hb (gs+(l:Int)-248) he he' (hsum.trans_lt hinput) have hSerr':|real (Q+b)-(real Q+real b)|≤(2:ڰ)^(gs-301+2*(l:Int))/2:=hSerr.trans herror have hdelta:(2:ڰ)^(gs-300+2*(l:Int))=2*(2:ڰ)^(gs-301+2*(l:Int)):=by have hh:=fg (gs-301+2*(l:Int)) convert hh using 1 <;>congr 1 <;>omega have hB:(2:ڰ)^((gs+1)-250)=2*(2:ڰ)^(gs-250):=by have hh:=fg (gs-250) convert hh using 1 <;>congr 1 <;>omega have hBpos:0<(2:ڰ)^(gs-250):=zpow_pos Q25 _ have hn0:0≤(n:ڰ):=by positivity change finite (Q+b) ∧ _ ∧ _ refine ⟨hSf,?_,?_⟩ · have hh:|real (Q+b)-(T*(2:ڰ)^g+real b)|≤|real (Q+b)-(real Q+real b)|+|real Q-T*(2:ڰ)^g|:=by calc |real (Q+b)-(T*(2:ڰ)^g+real b)|=|(real (Q+b)-(real Q+real b))+(real Q-T*(2:ڰ)^g)|:=by congr 1;ring _≤|real (Q+b)-(real Q+real b)|+|real Q-T*(2:ڰ)^g|:=abs_add_le _ _ rw[hdelta] linarith · have hh:|real (Q+b)|≤|real (Q+b)-(real Q+real b)|+|real Q+real b|:=by calc |real (Q+b)|=|(real (Q+b)-(real Q+real b))+(real Q+real b)|:=by congr 1;ring _≤|real (Q+b)-(real Q+real b)|+|real Q+real b|:=abs_add_le _ _ rw[hB] nlinarith lemma ag (S gf:ڭ) (T:ڰ) (n l:ڣ) (gs:Int) (hl:l≤12) (hn:n+2<2^(l+1)) (hc:126≤ gs ∧ gs≤349) (hs:finite S) (hd:finite gf) (hdr:real gf=(2:ڰ)^(gs-300+2*(l:Int))) (herr:|real S-T|≤(2:ڰ)^(gs-300+2*(l:Int))/2) (hmag:|real S|≤((n:ڰ)+2)*(2:ڰ)^((gs+1)-250)): finite (S-gf) ∧ finite (S+gf) ∧ real (S-gf)≤ T ∧ T≤ real (S+gf):=by have hpow:(2:ڰ)^((gs+1)-301+2*(l:Int))=(2:ڰ)^(gs-300+2*(l:Int)):=by congr 1;omega apply am S gf T n l (gs+1) hl hn Q24 hs hd · rwa[hpow] · rwa[hpow] · exact hmag end d8 namespace d8.DotMath open ExactRuntime FloatLib.Floats.Formats.BinaryInterchange FloatLib.Floats theorem fP (n: ڣ) (f: Fin n → Word) (i: ڣ) (hi: i < n): (zz2 f)[i]! = f ⟨i,hi⟩:= by rw [getElem!_pos _ _ (by simpa using hi),Array.getElem_ofFn] theorem cV (a b: Word): ((sv a: ℚ)*sv b*(2: ℚ)^(zz a+zz b))*2^(-298: Int) = z9 a*z9 b:= by simp only [z9,decodeD_toRat] rw [show (-298: Int) = -149+-149 by norm_num,zpow_add₀ two_ne_zero] rw [zpow_sub₀ two_ne_zero,zpow_sub₀ two_ne_zero,zpow_natCast,zpow_natCast,pow_add] norm_num [zpow_neg,zpow_natCast] ring theorem fm (a b: ڟ Word) (gj n: ڣ): (dsum a b gj n: ℚ)*2^(-298: Int) = ∑ j ∈ Finset.range n,z9 a[gj+j]!*z9 b[gj+j]!:= by induction n generalizing gj with | zero => simp [dsum] | succ n ih => rw [dsum] push_cast rw [add_mul,ih] conv_rhs => rw [Finset.sum_range_succ'] simp only [Nat.add_zero] rw [cV] have ht: (∑ j ∈ Finset.range n, z9 a[gj+1+j]!*z9 b[gj+1+j]!) = ∑ j ∈ Finset.range n, z9 a[gj+(j+1)]!*z9 b[gj+(j+1)]!:= by apply Finset.sum_congr rfl intro j _ simp [Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] rw [ht] ring def fJ (a b: ڟ Word): ℚ:= ∑ j ∈ Finset.range a.size,z9 a[j]!*z9 b[j]! theorem cI (a b: ڟ Word) (hs: a.size = b.size) (hf: ∀ j,j < a.size → z12 a[j]! ≠ 255 ∧ z12 b[j]! ≠ 255): Model.Reduction.Semantics.finiteDotSlice (a.map (Model.ofUInt32 (fmt:= Fmt))) (b.map (Model.ofUInt32 (fmt:= Fmt))) 0 a.size Q29 (by simp [hs]) = fJ a b:= by rw [finiteDotSlice_eq a b 0 a.size Q29 (by simp [hs]) (by intro j _ hj; exact hf j Q24),fm] simp [fJ] theorem aF (a b: ڟ Word) (hs: a.size = b.size) (hf: ∀ j,j < a.size → z12 a[j]! ≠ 255 ∧ z12 b[j]! ≠ 255) (hn: fJ a b ≠ 0): ∃ d: FloatLib.Numerics.Dyadic, d.toRat = fJ a b ∧ dotSpec a b = toWord (Q6 Fmt d):= by let L:= a.map (Model.ofUInt32 (fmt:= Fmt)) let R:= b.map (Model.ofUInt32 (fmt:= Fmt)) have hLR: L.size = R.size:= by simp [L,R,hs] have hLf: ∀ j (hj: j < L.size),Q4 L[j] = true:= by intro j hj have hj': j < a.size:= by simpa [L] using hj have he:= (hf j hj').1 rw [getElem!_pos a j hj'] at he simp [L,isFinite_ofUInt32,he] have hRf: ∀ j (hj: j < R.size),Q4 R[j] = true:= by intro j hj have hj': j < b.size:= by simpa [R] using hj have he:= (hf j Q24).2 rw [getElem!_pos b j hj'] at he simp [R,isFinite_ofUInt32,he] have hex:= Model.Reduction.Internal.dotState_exact_toRat (destination:= Fmt) L R hLR hLf hRf have hmath: Model.Reduction.Semantics.finiteDotSlice L R 0 L.size Q29 (by simp [hLR]) = fJ a b:= by simpa [L,R] using cI a b hs hf have hn': Model.Reduction.Semantics.finiteDot L.toList R.toList ≠ .ok 0:= by rw [Model.Reduction.Semantics.finiteDot_toList_eq_slice L R hLR,hmath] simpa using hn refine ⟨(Model.Reduction.Internal.dotState L R hLR: Model.Reduction.Internal.State Fmt).exact,hex.trans hmath,?_⟩ unfold dotSpec Model.dot rw [Model.Reduction.dotWithStatus_eq_round_of_finite_nonzero Fmt L R .nearestEven hLR hLf hRf hn'] rfl theorem dp (n: ڣ) (fa fb: ڣ → Word): fJ (zz2 (n:= n) fun i => fa i.val) (zz2 (n:= n) fun i => fb i.val) = ∑ j ∈ Finset.range n,z9 (fa j)*z9 (fb j):= by unfold fJ simp only [Array.size_ofFn] apply Finset.sum_congr rfl intro j hj rw [fP _ _ _ (Finset.mem_range.mp hj),fP _ _ _ (Finset.mem_range.mp hj)] theorem bm (n: ڣ) (fa fb: ڣ → Word) (hf: ∀ j,j < n → z12 (fa j) ≠ 255 ∧ z12 (fb j) ≠ 255) (hn: (∑ j ∈ Finset.range n,z9 (fa j)*z9 (fb j)) ≠ 0): ∃ d: FloatLib.Numerics.Dyadic, d.toRat = (∑ j ∈ Finset.range n,z9 (fa j)*z9 (fb j)) ∧ dotOf n fa fb = toWord (Q6 Fmt d):= by let a:= zz2 (n:= n) fun i => fa i.val let b:= zz2 (n:= n) fun i => fb i.val have hmath: fJ a b = _:= dp n fa fb have hf': ∀ j,j < a.size → z12 a[j]! ≠ 255 ∧ z12 b[j]! ≠ 255:= by intro j hj have hj': j < n:= by simpa [a] using hj simpa only [a,b,fP _ _ _ hj'] using hf j hj' obtain ⟨d,hd,hw⟩:= aF a b (by simp [a,b]) hf' (by rwa [hmath]) exact ⟨d,hd.trans hmath,hw⟩ theorem dY: z9 oneW = 1:= by have he: z12 oneW = 127:= by apply UInt32.toNat_inj.mp norm_num [z12,oneW,UInt32.toNat_and,UInt32.toNat_shiftRight] have hf: fracOf oneW = 0:= by apply UInt32.toNat_inj.mp norm_num [fracOf,oneW,UInt32.toNat_and] have hs: signOf oneW = false:= by have hz: oneW &&& 0x80000000 = 0:= by apply UInt32.toNat_inj.mp norm_num [oneW,UInt32.toNat_and] simp [signOf,hz] norm_num [z9,decodeD,he,hf,hs,FloatLib.Numerics.Dyadic.toRat, FloatLib.Numerics.Dyadic.signedSignificand] theorem bJ (a b: ڟ Word) (hs: a.size = b.size) (hf: ∀ j,j < a.size → z12 a[j]! ≠ 255 ∧ z12 b[j]! ≠ 255) (hz: fJ a b = 0): dotSpec a b = toWord (Model.zero Fmt (decide (a.size ≠ 0) && dallNZ a b 0 a.size)):= by let L:= a.map (Model.ofUInt32 (fmt:= Fmt)) let R:= b.map (Model.ofUInt32 (fmt:= Fmt)) have hLR: L.size = R.size:= by simp [L,R,hs] have hLf: ∀ j (hj: j < L.size),Q4 L[j] = true:= by intro j hj have hj': j < a.size:= by simpa [L] using hj have he:= (hf j hj').1 rw [getElem!_pos a j hj'] at he simp [L,isFinite_ofUInt32,he] have hRf: ∀ j (hj: j < R.size),Q4 R[j] = true:= by intro j hj have hj': j < b.size:= by simpa [R] using hj have he:= (hf j Q24).2 rw [getElem!_pos b j hj'] at he simp [R,isFinite_ofUInt32,he] let state: Model.Reduction.Internal.State Fmt:= Model.Reduction.Internal.dotState L R hLR have hex:= Model.Reduction.Internal.dotState_exact_toRat (destination:= Fmt) L R hLR hLf hRf have hmath: Model.Reduction.Semantics.finiteDotSlice L R 0 L.size Q29 (by simp [hLR]) = fJ a b:= by simpa [L,R] using cI a b hs hf have hzero: state.exact.significand = 0:= by rw [← FloatLib.Numerics.Dyadic.toRat_eq_zero_iff] exact (hex.trans hmath).trans hz have flags:= dotStateLoop_flags a b {} 0 a.size Q29 (by simp [hs]) (by intro j _ hj; exact hf j Q24) have hflags: state.sawFiniteTerm = decide (a.size ≠ 0) ∧ state.allTermsNegativeZero = dallNZ a b 0 a.size:= by simpa [state,Model.Reduction.Internal.dotState,L,R] using flags unfold dotSpec Model.dot rw [Model.Reduction.dotWithStatus_eq_zero_of_finite Fmt L R .nearestEven hLR hLf hRf hzero] simp only [Except.map] change toWord (Model.zero Fmt (state.sawFiniteTerm && (state.allTermsNegativeZero || !state.allTermsPositiveZero && (Model.IEEERoundingMode.nearestEven == Model.IEEERoundingMode.towardNegativeInfinity)))) = _ simp [hflags.1,hflags.2] end d8.DotMath namespace d8 open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange lemma b6 (w:ڎ) (hv:gk w=true): real (convert w)=(z9 w:ڰ):=by rw [eb w hv,z9,decodeD_toRat] push_cast rfl lemma ft (a:ڰ) (t:ڣ→ ڰ) (n:ڣ): en a t n=a+∑k∈Finset.range n,t k:=by induction n with | zero=>simp [en] | succ n ih=>rw [en,ih,Finset.sum_range_succ];ring lemma cP (n:ڣ) (fa fb:ڣ→ ڎ) (gm:ڎ) (hb:gk gm=true) (hv:∀k,kreal (convert (fa k)*convert (fb k))) n= ((∑k∈Finset.range n,z9 (fa k)*z9 (fb k))+z9 gm:ڰ):=by rw [ft,b6 gm hb] push_cast rw [add_comm] congr 1 apply Finset.sum_congr rfl intro k hk obtain ⟨hx,hw⟩:=hv k (Finset.mem_range.mp hk) rw [(eN _ _ hx hw).2,b6 _ hx,b6 _ hw] lemma bS (lo hi:ڭ) (T:ڰ) (hlo:finite lo) (hhi:finite hi) (hn:fy lo&&&0x7fffffff≠0) (he:fy lo=fy hi) (hl:real lo≤T) (hh:T≤real hi) (hbl:|real lo|≤(2:ڰ)^(120:Int)) (hbh:|real hi|≤(2:ڰ)^(120:Int)): T≠0:=by intro hz subst T have hnh:fy hi&&&0x7fffffff≠0:=by rw [←he];exact hn have hfl:=cr lo hlo hn hbl have hfh:=cr hi hhi hnh hbh have h0:=Model.roundAt_mono Fmt hl have h1:=Model.roundAt_mono Fmt hh rw [←dB lo hlo hn hfl,Model.roundAt_zero] at h0 rw [←dB hi hhi hnh hfh,Model.roundAt_zero,←he] at h1 exact eL _ hfl hn (le_antisymm h0 h1) lemma fU (w:ڎ) (hv:gk w=true):z12 w≠255:=by simp only [gk,Bool.and_eq_true,bne_iff_ne] at hv exact hv.1 lemma d9 (n:ڣ) (fa fb:ڣ→ ڎ) (gm:ڎ): (∑k∈Finset.range (n+1),z9 (if kreal (convert (fa k)*convert (fb k))) n≠0): ∃d:Numerics.Dyadic, d.toReal=en (real (convert gm)) (fun k=>real (convert (fa k)*convert (fb k))) n ∧ dotOf (n+1) (fun k=>if kif kif kif ksimp[en] | succ n ih=> rw[en,en,add_mul] rw[show t n*s=u n from ht n Q24] rw[←ih (fun k hk=>ht k Q24)] ring lemma az (n N gs:ڣ) (fa fb ta tb:ڣ→ ڎ) (gm:ڎ) (q S gf:ڭ) (tc:ڣ→ ڰ) (c0 g:Int) (hn:n<4096) (hc:126≤ gs ∧ gs≤349) (hcut:c0+g≤(gs:Int)) (hv:∀k,k< n→ gk (fa k)=true ∧ gk (fb k)=true) (hvT:∀k,k< N→ gk (ta k)=true ∧ gk (tb k)=true) (hb:gk gm=true) (hbiased:126+zz gm≤ gs) (hq:finite q) (hg:-298≤ g ∧ g≤208) (hguard:(q.toBits&&&0x7fffffffffffffff)=0 ∨ (299≤((q.toBits>>>52)&&&2047).toNat ∧ ((q.toBits>>>52)&&&2047).toNat≤1326)) (hqerr:|real q-en 0 tc n|≤(2:ڰ)^(c0-301+2*((n+2).log2:Int))/2) (hqmag:|real q|≤((n:ڰ)+2)*(2:ڰ)^(c0-250)) (ht:∀k,k< n→ tc k*(2:ڰ)^g=real (convert (fa k)*convert (fb k))) (hEq:en (real (convert gm)) (fun k=>real (convert (fa k)*convert (fb k))) n= en (real (convert gm)) (fun k=>real (convert (ta k)*convert (tb k))) N) (hS:S=q*zz0 ((g+1023).toNat.toUInt64<<<52)+convert gm) (hd:finite gf) (hdr:real gf=(2:ڰ)^((gs:Int)-300+2*((n+2).log2:Int))) (he:fy (S-gf)=fy (S+gf)) (hz:fy (S-gf)&&&0x7fffffff≠0): dotOf (N+1) (fun k=>if k< N then ta k else oneW) (fun k=>if k< N then tb k else gm)=fy (S-gf):=by let l:ڣ:=(n+2).log2 let T:=en (real (convert gm)) (fun k=>real (convert (ta k)*convert (tb k))) N have hTscale:en 0 tc n*(2:ڰ)^g+real (convert gm)=T:= (aQ tc _ n _ _ ht).trans hEq obtain ⟨hl,hnl⟩:=bL n hn have hc':126≤(gs:Int) ∧ (gs:Int)≤349:=by exact_mod_cast hc have hsummary:finite S ∧ |real S-T|≤(2:ڰ)^((gs:Int)-300+2*(l:Int))/2 ∧ |real S|≤((n:ڰ)+2)*(2:ڰ)^(((gs:Int)+1)-250):=by rw[hS] have hh:=ah q (convert gm) (en 0 tc n) n l c0 gs g hl hnl hc' hcut hq hg hguard hqerr hqmag (cZ gm) (dE gm hb gs hbiased) simpa only[hTscale]using hh obtain ⟨hSf,hSerr,hSmag⟩:=hsummary obtain ⟨hlo,hhi,hle,hge⟩:=ag S gf T n l gs hl hnl hc' hSf hd hdr hSerr hSmag have hpow:(2:ڰ)^(((gs:Int)+1)-301+2*(l:Int))=(2:ڰ)^((gs:Int)-300+2*(l:Int)):=by congr 1;omega obtain ⟨-,-,hdB,-,-,-⟩:=bK n l ((gs:Int)+1) hl hnl have hdeltaAbs:|real gf|≤(2:ڰ)^(((gs:Int)+1)-250):=by rw[hdr,abs_of_pos (zpow_pos (by norm_num: (0:ڰ)<2) _)] rw[hpow]at hdB exact hdB obtain ⟨hls,hhs⟩:=aJ S gf n ((gs:Int)+1) hn Q24 hSf hd hSmag hdeltaAbs have hT:T≠0:=bS _ _ T hlo hhi hz he hle hge hls hhs obtain ⟨d,hdrT,hdot⟩:=cX N ta tb gm hb hvT hT have hcert:=aO (S-gf) (S+gf) d hlo hhi hz he (by rw[hdrT];exact hle) (by rw[hdrT];exact hge) hls hhs rw[hdot,hcert] change toWord (ofW (fy (S-gf)))=fy (S-gf) unfold toWord ofW Model.ofUInt32 rw[Model.toNatBits_ofNatBits_of_lt _ (by change _<2^32;exact UInt32.toNat_lt _)] exact UInt32.ofNat_toNat end d8 namespace d8 open ExactRuntime @[specialize] def fq (gp:ڣ) (f:ڣ→ ڎ) (j:ڣ) (O:ڟ ڎ):ڟ ڎ:= if jintro j O h;rw[fq,if_neg Q24];simp | succ d ih=> intro j O h rw[fq,if_pos Q24,ih (j+1) _ Q24] simp only[Array.toList_push,List.range'_succ,List.map_cons,List.append_assoc,List.cons_append,List.nil_append] lemma cO (gr gp:ڣ) (f:ڣ→ ڣ→ ڎ) (ch:ڣ) (O:ڟ ڎ) (h:ch(tile j).1))++(O1.toList++(List.range' j d).map (fun j=>(tile j).2.1))++(O2.toList++(List.range' j d).map (fun j=>(tile j).2.2.1))++(O3.toList++(List.range' j d).map (fun j=>(tile j).2.2.2)):=by intro d induction d with | zero=>intro j O0 O1 O2 O3 h;rw[ey,if_neg Q24];simp | succ d ih=> intro j O0 O1 O2 O3 h rw[ey,if_pos Q24] dsimp only rw[ih (j+1) _ _ _ _ Q24] simp only[Array.toList_push,List.range'_succ,List.map_cons,List.append_assoc,List.cons_append,List.nil_append] @[specialize] def ez (gp:ڣ) (tile:ڣ→ ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ) (j:ڣ) (O0 O1 O2 O3 O4 O5 O6 O7:ڟ ڎ):ڟ ڎ:= if j(tile j).1))++(O1.toList++(List.range' j d).map (fun j=>(tile j).2.1))++(O2.toList++(List.range' j d).map (fun j=>(tile j).2.2.1))++(O3.toList++(List.range' j d).map (fun j=>(tile j).2.2.2.1))++(O4.toList++(List.range' j d).map (fun j=>(tile j).2.2.2.2.1))++(O5.toList++(List.range' j d).map (fun j=>(tile j).2.2.2.2.2.1))++(O6.toList++(List.range' j d).map (fun j=>(tile j).2.2.2.2.2.2.1))++(O7.toList++(List.range' j d).map (fun j=>(tile j).2.2.2.2.2.2.2)):=by intro d induction d with | zero=>intro j O0 O1 O2 O3 O4 O5 O6 O7 h;rw[ez,if_neg Q24];simp | succ d ih=> intro j O0 O1 O2 O3 O4 O5 O6 O7 h rw[ez,if_pos Q24] dsimp only rw[ih (j+1) _ _ _ _ _ _ _ _ Q24] simp only[Array.toList_push,List.range'_succ,List.map_cons,List.append_assoc,List.cons_append,List.nil_append] lemma bp (gp:ڣ) (tile:ڣ→ ڎ×ڎ×ڎ×ڎ) (f:ڣ→ ڣ→ ڎ) (ht:∀j,j(tile j).1)=(List.range' 0 gp).map (f 0):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.1)=(List.range' 0 gp).map (f 1):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.1)=(List.range' 0 gp).map (f 2):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.2)=(List.range' 0 gp).map (f 3):=by apply List.map_congr_left intro j hj have hj':j(tile j).1)=(List.range' 0 gp).map (f 0):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.1)=(List.range' 0 gp).map (f 1):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.1)=(List.range' 0 gp).map (f 2):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.2.1)=(List.range' 0 gp).map (f 3):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.2.2.1)=(List.range' 0 gp).map (f 4):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.2.2.2.1)=(List.range' 0 gp).map (f 5):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.2.2.2.2.1)=(List.range' 0 gp).map (f 6):=by apply List.map_congr_left intro j hj have hj':j(tile j).2.2.2.2.2.2.2)=(List.range' 0 gp).map (f 7):=by apply List.map_congr_left intro j hj have hj':j intro ch O hd rw[eA] split · rename_i hc rw[ih (gr-(ch+4)) Q24 (ch+4) _ rfl] rw[bp gp (tile ch) (fun r=>f (ch+r)) (fun j hj=>ht ch j hc hj)] rw[cO gr gp f ch _ Q24] rw[cO gr gp f (ch+1) _ Q24] rw[cO gr gp f (ch+2) _ Q24] rw[cO gr gp f (ch+3) _ Q24] simp only[Nat.add_zero] · rfl @[specialize] def eB (gr gp:ڣ) (f:ڣ→ ڣ→ ڎ) (tile:ڣ→ ڣ→ ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ) (tile4:ڣ→ ڣ→ ڎ×ڎ×ڎ×ڎ) (ch:ڣ) (O:ڟ ڎ):ڟ ڎ:= if ch+7 intro ch O hd rw[eB] split · rename_i hc rw[ih (gr-(ch+8)) Q24 (ch+8) _ rfl] rw[bq gp (tile ch) (fun r=>f (ch+r)) (fun j hj=>ht ch j hc hj)] rw[cO gr gp f ch _ Q24] rw[cO gr gp f (ch+1) _ Q24] rw[cO gr gp f (ch+2) _ Q24] rw[cO gr gp f (ch+3) _ Q24] rw[cO gr gp f (ch+4) _ Q24] rw[cO gr gp f (ch+5) _ Q24] rw[cO gr gp f (ch+6) _ Q24] rw[cO gr gp f (ch+7) _ Q24] simp only[Nat.add_zero] · exact br gr gp f tile4 h4 _ ch O rfl end d8 namespace Submission open ExactRuntime d8 lemma c8 (a n k:ڲ) (size:ڣ) (ha:a.toNat+n.toNat ≤ size) (hg:a.toNat+n.toNat ≤ zz3) (hk:kbx&&&0xffff!=255 && (1:ڎ) ≤ (bx>>>16) && YU bx ≤ 39)=true hw:BV.all (fun bv=>bv&&&0xffff!=255 && (1:ڎ) ≤ (bv>>>16) && YU bv ≤ 7)=true hb:b.all d8.gk=true lemma bA (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (i:ڣ) (hi:i>>16) ∧ (YU BX[i]!).toNat ≤ 39 ∧ Yk (BX[i]!>>>16) ≤ Yk (BX[i]!&&&0xffff) ∧ (Yk (BX[i]!&&&0xffff)).toNat ≤ 253:=by have hh:=Array.all_eq_true.mp h.hx i Q24 rw[←getElem!_pos BX i Q24]at hh simp only[Bool.and_eq_true,bne_iff_ne,decide_eq_true_eq]at hh have hs:(YU BX[i]!).toNat ≤ 39:=UInt64.le_iff_toNat_le.mp hh.2 have ho:=dJ BX[i]! 39 Q24 hs refine ⟨hh.1.1,hh.1.2,hs,ho,?_⟩ rw[hBX i hi] have hsize:=bA gr n gp X W b BX BV h i hi exact eP X n i hsize.1 hsize.2 (by rw[←hBX i hi];exact hh.1.1) lemma c9 (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (gn:BV.size=gp) (hBV:∀j,j>>16) ∧ (YU BV[j]!).toNat ≤ 7 ∧ Yk (BV[j]!>>>16) ≤ Yk (BV[j]!&&&0xffff) ∧ (Yk (BV[j]!&&&0xffff)).toNat ≤ 253:=by have hh:=Array.all_eq_true.mp h.hw j Q24 rw[←getElem!_pos BV j Q24]at hh simp only[Bool.and_eq_true,bne_iff_ne,decide_eq_true_eq]at hh have hs:(YU BV[j]!).toNat ≤ 7:=UInt64.le_iff_toNat_le.mp hh.2 have ho:=dJ BV[j]! 7 Q24 hs refine ⟨hh.1.1,hh.1.2,hs,ho,?_⟩ rw[hBV j hj] have hsize:=bh gr n gp X W b BX BV h j hj exact eP W n j hsize.1 hsize.2 (by rw[←hBV j hj];exact hh.1.1) lemma cz (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat ≤ zz X[i*n+k]! ∧ zz X[i*n+k]!-(Yk (BX[i]!>>>16)).toNat ≤ (YU BX[i]!).toNat):=by have hm:=da gr n gp X W b BX BV h go hBX i hi have hs:=bA gr n gp X W b BX BV h i hi rw[hBX i hi]at hm ⊢ exact ef X n i k (YU (Yc X n i)).toNat hs.1 hs.2 hk hm.1 hm.2.1 hm.2.2.2.1 Q24 lemma cy (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (gn:BV.size=gp) (hBV:∀j,j>>16)).toNat ≤ zz W[j*n+k]! ∧ zz W[j*n+k]!-(Yk (BV[j]!>>>16)).toNat ≤ (YU BV[j]!).toNat):=by have hm:=c9 gr n gp X W b BX BV h gn hBV j hj have hs:=bh gr n gp X W b BX BV h j hj rw[hBV j hj]at hm ⊢ exact ef W n j k (YU (Yc W n j)).toNat hs.1 hs.2 hk hm.1 hm.2.1 hm.2.2.2.1 Q24 lemma dG (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (j:ڣ) (hj:j>>16) ≤ Yk (bx&&&0xffff)) (hw:Yk (bv>>>16) ≤ Yk (bv&&&0xffff)) (hxm:(Yk (bx&&&0xffff)).toNat ≤ 253) (hwm:(Yk (bv&&&0xffff)).toNat ≤ 253): let gs:=(max (Yk (bx&&&0xffff)+Yk (bv&&&0xffff)) (Yd oneW+Yd gm)).toNat 126 ≤ gs ∧ (Yk (bx>>>16)).toNat+(Yk (bv>>>16)).toNat ≤ 506 ∧ (Yk (bx>>>16)).toNat+(Yk (bv>>>16)).toNat+(YU bx).toNat+(YU bv).toNat ≤ gs ∧ 126+zz gm ≤ gs:=by dsimp rw[fj _ _ gm hxm hwm] have hxo:=UInt64.le_iff_toNat_le.mp hx have hwo:=UInt64.le_iff_toNat_le.mp hw have hsum:=eR bx bv hx hw refine ⟨?_,by omega,?_,Nat.le_max_right _ _⟩ · exact le_trans Q24 (Nat.le_max_right _ _) · rw[hsum];exact Nat.le_max_left _ _ end Submission open ExactRuntime FloatLib FloatLib.Floats.Formats.BinaryInterchange namespace Submission lemma be (ex:ڜ) (he:ex.toNat<2048): Y0 ((ex.toNat:Int)-1075) true (ex-1075):=by intro c hc _ hb simp only[UInt64.toNat_add,UInt64.toNat_sub,UInt64.reduceToNat]at hb ⊢ omega lemma ei (a:ڡ) (m:ڜ) (e:Int) (hm:m≠0): YA a m e=finishWord (if a then -Int.ofNat m.toNat else Int.ofNat m.toNat) e false:=by have hn:m.toNat≠0:=by intro h apply hm exact UInt64.toNat_inj.mp (by simpa using h) rw[ZU a m e hm,Model.roundDyadicGeneral_eq_roundDyadic] symm apply finishWord_of_ne ⟨a,m.toNat,e⟩ · cases a <;> simp[hn] · cases a <;> simp[FloatLib.Numerics.Dyadic.toRat,FloatLib.Numerics.Dyadic.signedSignificand] @[inline] def fD (v:ڭ):ڎ:= let bits:=v.toBits let ex:=(bits>>>52)&&&2047 let mant:=bits&&&0xfffffffffffff if ex=0 then 0 else let mant:=mant+0x10000000000000 let e:=(ex.toNat:Int)-1075 Ii (bits>>>63!=0) mant e true (ex-1075) lemma eQ (v:ڭ):fD v=d8.fy v:=by unfold fD d8.fy dsimp only split · rfl · have hm:((v.toBits&&&0xfffffffffffff)+0x10000000000000)≠0:=by intro hh have h:=d8.eu v rw[hh]at h have hz:(0:ڜ).toNat=0:=rfl rw[hz]at h omega rw[P3 _ _ _ true _ hm (be _ (by exact d8.dq v))] exact ei _ _ _ hm end Submission namespace d8 open ExactRuntime FloatLib FloatLib.Floats FloatLib.Floats.Formats.BinaryInterchange @[inline] def f5 (v:ڭ):ڡ:=Float.le v (zz0 0) lemma dU (v:ڭ) (h:f5 v=true):real v≤0:=by have hr:real v=Q12 v.toModel.unpack:=by rw [real,Model.toReal_eq_unpackedToReal_toModel Q26,Q8] rw [hr] unfold f5 Float.le at h simp only [decide_eq_true_eq] at h change v.toModel.unpack.le (zz0 0).toModel.unpack=true at h have hz:(zz0 0).toModel.unpack=Float.Model.UnpackedFloat.zero .positive:=rfl rw [hz] at h cases hv:v.toModel.unpack with | notANumber=>simp [hv,Float.Model.UnpackedFloat.le,Float.Model.UnpackedFloat.compare] at h | infinity sg=>simp [Q12,Q13] | zero sg=>simp | finite sg m e hm=> cases sg with | positive => simp [hv,Float.Model.UnpackedFloat.le,Float.Model.UnpackedFloat.compare] at h | negative => simp only [Model.unpackedToReal_finite,Model.modelSignBit] simp only [Bool.true_eq,ite_true] have hp:(0:ڰ)fa i.val) let b:=zz2 (n:=n) (fun i=>fb i.val) have hs:a.size=b.size:=by simp [a,b] have hfa:∀k,k rfl · obtain ⟨d,hd,hw⟩:=DotMath.bm n fa fb hf hz have hdr:d.toReal=(Q:ڰ):=by rw [←Numerics.Dyadic.cast_toRat,hd] have hfinite:=Model.isFinite_roundDyadic_of_isIEEE_of_abs_toReal_le_posMaxFinite Fmt Q26 d (by rw [hdr];exact hB.trans (eY 120 Q25)) have hr:Q3 (Q6 Fmt d)≤0:=by rw [Model.toReal_roundDyadic_eq_roundAt Fmt Q26 d hfinite] exact (Model.roundAt_mono Fmt (by rw [hdr];exact hT)).trans_eq (Model.roundAt_zero Fmt) rw [hw] change reluW (toWord (Q6 Fmt d))=0 apply cT · have hh:Q4 (ofW (toWord (Q6 Fmt d)))=true:=by rw [fV];exact hfinite rw [ofW,isFinite_ofUInt32] at hh exact bne_iff_ne.mp hh · rw [fV] exact hr lemma bZ (n:ڣ) (fa fb:ڣ→ ڎ) (gm:ڎ) (hb:gk gm=true) (hv:∀k,kreal (convert (fa k)*convert (fb k))) n≤0) (hB:|en (real (convert gm)) (fun k=>real (convert (fa k)*convert (fb k))) n|≤(2:ڰ)^(120:Int)): act true (dotOf (n+1) (fun k=>if kif k>>52)&&&2047 qb&&&0x7fffffffffffffff==0 || ((299:ڜ) ≤ ex && ex ≤ 1326) lemma bB (q:ڭ) (h:dI q=true): (q.toBits&&&0x7fffffffffffffff)=0 ∨ (299 ≤ ((q.toBits>>>52)&&&2047).toNat ∧ ((q.toBits>>>52)&&&2047).toNat ≤ 1326):=by simp only[dI,Bool.or_eq_true,Bool.and_eq_true,beq_iff_eq,decide_eq_true_eq]at h rcases h with hz|⟨hl,hh⟩ · exact Or.inl hz · exact Or.inr ⟨UInt64.le_iff_toNat_le.mp hl,UInt64.le_iff_toNat_le.mp hh⟩ @[noinline] def c6 (n gs gl:ڣ) (gq:ڡ) (bw:ڎ) (gm q:ڭ) (fK:Unit → ڎ):ڎ:= let gh:=zz0 ((gl+725).toUInt64<<<52) let de:=(gs:Int)-298+2*((n+2).log2:Int)-2 let gf:=zz0 ((de+1023).toNat.toUInt64<<<52) let v:=q*gh+gm if dI q && gs ≤ 349 then let H:=v+gf if gq && d8.f5 H then 0 else let lo:=fD (v-gf);let hi:=fD H if lo==hi && lo&&&0x7fffffff!=0 then act gq lo else act gq (fK ()) else act gq (fK ()) lemma aA (n N gs gl:ڣ) (gq:ڡ) (fa fb ta tb:ڣ → ڎ) (bw:ڎ) (gm q:ڭ) (tc:ڣ → ڰ) (c0:Int) (fK:Unit → ڎ) (hn:n<4096) (hc:126 ≤ gs) (hbase:gl ≤ 506) (hcut:c0+((gl:Int)-298) ≤ (gs:Int)) (hb:gk bw=true) (hbias:gm=convert bw) (hbiased:126+zz bw ≤ gs) (hv:∀k,kreal (convert (fa k)*convert (fb k))) n= en (real (convert bw)) (fun k=>real (convert (ta k)*convert (tb k))) N) (hfb:fK ()=dotOf (N+1) (fun k=>if kif kif kif kreal (convert (ta k)*convert (tb k))) N obtain ⟨hl,hnl⟩:=bL n hn have hcg:(126:Int) ≤ gs ∧ (gs:Int) ≤ 349:=by omega have hg:-298 ≤ (gl:Int)-298 ∧ (gl:Int)-298 ≤ 208:=by omega have hpow:(((gl:Int)-298)+1023).toNat=gl+725:=by omega have hscale:en 0 tc n*(2:ڰ)^((gl:Int)-298)+real (convert bw)=T:=(aQ tc _ n _ _ ht).trans hEq obtain ⟨hSf,hSerr,hSmag⟩:=ah q (convert bw) (en 0 tc n) n l c0 gs ((gl:Int)-298) hl hnl hcg hcut hq hg hguard hqerr hqmag (cZ bw) (dE bw hb gs hbiased) rw[hpow]at hSf hSerr hSmag rw[hscale]at hSerr obtain ⟨hDf,hDr⟩:=fB n gs hn ⟨hc,hcond'.2⟩ have hDreal:real D=(2:ڰ)^((gs:Int)-300+2*(l:Int)):=hDr have hDfin:finite D:=hDf obtain ⟨hlof,hhif,hle,hge⟩:=ag S D T n l gs hl hnl hcg hSf hDfin hDreal hSerr hSmag split · rename_i hre have hre':gq=true ∧ f5 (S+D)=true:=by simpa only[Bool.and_eq_true]using hre have hT:T ≤ 0:=hge.trans (dU (S+D) hre'.2) have hpowD:(2:ڰ)^(((gs:Int)+1)-301+2*(l:Int))=(2:ڰ)^((gs:Int)-300+2*(l:Int)):=by congr 1;omega obtain ⟨_,_,hDB,_,_,_⟩:=bK n l ((gs:Int)+1) hl hnl have hDabs:|real D| ≤ (2:ڰ)^(((gs:Int)+1)-250):=by rw[hDreal,abs_of_pos (zpow_pos Q25 _)] rw[hpowD]at hDB exact hDB obtain ⟨hls,hhs⟩:=aJ S D n ((gs:Int)+1) hn Q24 hSf hDfin hSmag hDabs have hTabs:|T| ≤ (2:ڰ)^(120:Int):=by rw[abs_le]at hls hhs ⊢ exact ⟨hls.1.trans hle,hge.trans hhs.2⟩ rw[hre'.1] symm exact bZ N ta tb bw hb hvT hT hTabs · split · rename_i heq have heq':fD (S-D)=fD (S+D) ∧ fD (S-D)&&&0x7fffffff ≠ 0:=by simpa only[Bool.and_eq_true,beq_iff_eq,bne_iff_ne]using heq have hcert:=az n N gs fa fb ta tb bw q S D tc c0 ((gl:Int)-298) hn ⟨hc,hcond'.2⟩ hcut hv hvT hb hbiased hq hg hguard hqerr hqmag ht hEq (by simp only[S,hpow]) hDfin hDreal have hcert':dotOf (N+1) (fun k=>if kif kfa i.val)) (zz2 (n:=n) (fun i=>fb i.val)) lemma cf (n:ڣ) (fa fb:ڣ→ ڎ) (hf:∀j,j intro k S nz hr rw[cS,if_neg Q24,show n-k=0 by omega] simp[dsum,dallNZ] | succ r ih=> intro k S nz hr have hk:k < n:=by omega rw[cS,if_pos hk] obtain ⟨hS,hN⟩:=ih (k+1) (S+eI (fa k) (fb k) c) (nz&&fv (fa k) (fb k)) Q24 constructor · rw[hS,show n-k=(n-(k+1))+1 by omega,dsum,add_mul] rw[bX _ _ c (hc k hk),hfa k hk,hfb k hk] ring · rw[hN,show n-k=(n-(k+1))+1 by omega,dallNZ,hfa k hk,hfb k hk] simp only[fv,Bool.and_assoc] lemma dD (x:ڎ) (hx:sv x ≠ 0):z11 x ≠ 0:=by intro hz apply hx simp[sv,hz] end d8 namespace d8 open ExactRuntime @[inline] def dz (h l:ڜ):ڣ:=h.toNat*2^64+l.toNat @[inline] def dy (h l hi lo:ڜ):ڜ×ڜ:= let l':=l+lo (h+hi+(if l'>>(64-gap),m<< cases hw:signOf w <;> simp[hx,hw] <;> ring @[specialize] def cQ (n:ڣ) (fa fb:ڣ→ ڎ) (gl k:ڣ) (ph pl nh nl:ڜ) (nz:ڡ):ڜ×ڜ×ڜ×ڜ×ڡ:= if k intro k ph pl nh nl nz hr hk hb rw[cQ,if_neg Q24,cS,if_neg Q24] exact ⟨rfl,rfl⟩ | succ r ih=> intro k ph pl nh nl nz hr hk hb have hkn:ksimp[dsum] | succ n ih=> rw[show dsum a b gj (n+1+1)=sv a[gj]!*sv b[gj]!*2^(zz a[gj]!+zz b[gj]!)+dsum a b (gj+1) (n+1) from rfl,show dsum a b gj (n+1)=sv a[gj]!*sv b[gj]!*2^(zz a[gj]!+zz b[gj]!)+dsum a b (gj+1) n from rfl,ih] simp only[Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] ring lemma dA (a b:ڟ ڎ) (gj n:ڣ): dallNZ a b gj (n+1)=(dallNZ a b gj n&&fv a[gj+n]! b[gj+n]!):=by induction n generalizing gj with | zero=>simp[dallNZ,fv] | succ n ih=> change (fv a[gj]! b[gj]! && dallNZ a b (gj+1) (n+1)) = ((fv a[gj]! b[gj]! && dallNZ a b (gj+1) n) && fv a[gj+(n+1)]! b[gj+(n+1)]!) rw[ih] simp only[fv,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm,Bool.and_assoc] @[inline] def bb (n:ڣ) (gm:ڎ) (gl:ڣ) (sum:Int) (nz:ڡ):ڎ:= let c:=min gl (126+zz gm) finishWord ((sum<<<(gl-c))+eI oneW gm c) ((c:Int)-298) (nz&&fv oneW gm) lemma ad (n:ڣ) (fa fb:ڣ → ڎ) (gm:ڎ) (gl:ڣ) (hf:∀ k,k < n → z12 (fa k)≠255∧z12 (fb k)≠255) (hb:z12 gm≠255) (hc:∀ k,k < n → z11 (fa k)≠0 → z11 (fb k)≠0 → gl ≤ zz (fa k)+zz (fb k)): bb n gm gl (cS n fa fb gl 0 0 true).1 (cS n fa fb gl 0 0 true).2= dotOf (n+1) (fun k=>if k < n then fa k else oneW) (fun k=>if k < n then fb k else gm):=by let A:ڟ ڎ:=zz2 (n:=n+1) (fun i=>if i.val < n then fa i.val else oneW) let B:ڟ ڎ:=zz2 (n:=n+1) (fun i=>if i.val < n then fb i.val else gm) have ha:∀ k,k < n → A[k]! = fa k:=by intro k hk;rw[DotMath.fP (n+1) _ k Q24];simp[hk] have hbw:∀ k,k < n → B[k]! = fb k:=by intro k hk;rw[DotMath.fP (n+1) _ k Q24];simp[hk] have hlastA:A[n]! = oneW:=by rw[DotMath.fP (n+1) _ n Q24];simp have hlastB:B[n]! = gm:=by rw[DotMath.fP (n+1) _ n Q24];simp have hcb:∀ k,k < n → sv (fa k)*sv (fb k)≠0 → gl ≤ zz (fa k)+zz (fb k):=by intro k hk h;have hz:=mul_ne_zero_iff.mp h;exact hc k hk (dD _ hz.1) (dD _ hz.2) obtain ⟨hS,hN⟩:=ay A B n fa fb gl ha hbw hcb n 0 0 true Q24 simp only[Int.zero_mul,zero_add,Bool.true_and,Nat.sub_zero]at hS hN let c:=min gl (126+zz gm) have hcle:c ≤ gl:=Nat.min_le_left _ _ have hbias:c ≤ zz oneW+zz gm:=by exact Nat.min_le_right _ _ have hscale:(((cS n fa fb gl 0 0 true).1<<<(gl-c))+eI oneW gm c)*2^c=dsum A B 0 (n+1):=by rw[add_mul,Int.shiftLeft_eq,mul_assoc,←pow_add,Nat.sub_add_cancel hcle,hS,bX oneW gm c (by intro _;exact hbias),cp] simp only[Nat.zero_add,hlastA,hlastB] have hnz:((cS n fa fb gl 0 0 true).2&&fv oneW gm)=dallNZ A B 0 (n+1):=by rw[dA,hN];simp only[Nat.zero_add,hlastA,hlastB] unfold bb change finishWord _ ((c:Int)-298) _ = _ have hexp:(c:Int)-298=(-298:Int)+(c:Int):=by omega rw[hexp,finishWord_scale,hscale,hnz] have ht:=cf (n+1) (fun k=>if k < n then fa k else oneW) (fun k=>if k < n then fb k else gm) (by intro k hk;by_cases h:k < n;simpa[h]using hf k h;simp only[if_neg h];exact ⟨by decide,hb⟩) simpa only[fL,f4,A,B,Array.size_ofFn,Nat.sub_zero,show decide (n+1≠0)=true from by simp,Bool.true_and]using ht @[inline] def bW (n:ڣ) (fa fb:ڣ → ڎ) (gm:ڎ) (gl:ڣ):ڎ:= let z:=cQ n fa fb gl 0 0 0 0 0 true bb n gm gl ((dz z.1 z.2.1:Int)-(dz z.2.2.1 z.2.2.2.1:Int)) z.2.2.2.2 lemma ai (n:ڣ) (fa fb:ڣ → ڎ) (gm:ڎ) (gl:ڣ) (hn:n < 4096) (hf:∀ k,k < n → z12 (fa k)≠255∧z12 (fb k)≠255) (hb:z12 gm≠255) (hc:∀ k,k < n → z11 (fa k)≠0 → z11 (fb k)≠0 → gl ≤ zz (fa k)+zz (fb k) ∧ zz (fa k)+zz (fb k)-gl ≤ 46): bW n fa fb gm gl=dotOf (n+1) (fun k=>if k < n then fa k else oneW) (fun k=>if k < n then fb k else gm):=by have hh:=aw n fa fb gl hn (fun k hk hx hw=>(hc k hk hx hw).2) n 0 0 0 0 0 true Q24 Q24 (by simp[dz]) simp only[show dz 0 0=0 from rfl,Int.natCast_zero,sub_self]at hh unfold bW dsimp only rw[hh.1,hh.2] exact ad n fa fb gm gl hf hb (fun k hk hx hw=>(hc k hk hx hw).1) end d8 namespace Submission open ExactRuntime d8 @[inline] def eh (X W b:ڟ ڎ) (n i j:ڣ):ڎ:= dotOf (n+1) (fun k=>if kif kX[xi+k]!) (fun k=>W[wj+k]!) b[j]! gl end Submission namespace d8 lemma fQ (A:ڟ ڎ) (i:ڣ) (P:ڨ): (pack A i P).data=P.data++((A.toList.drop i).map convert).toArray:=by rw[pack] split · rename_i h rw[fQ A (i+1)] cases P simp only[FloatArray.push] have hh:A.toList.drop i=A[i]::A.toList.drop (i+1):=by rw[List.drop_eq_getElem_cons h] simp rw[hh] simp [getElem!_pos A i h] · rename_i h have hi:A.size<=i:=by omega have hh:A.toList.length<=i:=by simpa only[Array.length_toList]using hi rw[List.drop_eq_nil_of_le hh] simp termination_by A.size-i end d8 namespace d8 @[inline] def f8 (A:ڟ ڎ):ڨ:=pack A 0 (zz1 A.size) lemma e6 (A:ڟ ڎ):(f8 A).data=A.map convert:=by rw[f8,fQ] simp only[zz1,List.drop_zero,Array.empty_append] rw[←Array.toList_map,Array.toArray_toList] lemma e7 (A:ڟ ڎ):(f8 A).size=A.size:=by change (f8 A).data.size=A.size rw[e6,Array.size_map] lemma fs (A:ڟ ڎ) (i:ڲ) (hi:i.toNat intro k sum hr have hk:¬k intro k sum hr have hk:kb7 X W b n i j ibase):=by rfl end Submission namespace Submission open ExactRuntime d8 @[noinline] def dM (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (i j:ڣ) (gq:ڡ):ڎ:= if hi:i>>16) let q:=ek SF XF W xa wa nu wm hpX hgX hpW hgW 0 (zz0 0) let gl:=(Yk (BX[i]!>>>16)+wm).toNat let gs:=(max (Yk (BX[i]!&&&0xffff)+Yk (BV[j]!&&&0xffff)) (Yd oneW+Yd b[j]!)).toNat b9 X W b i j n gs ((Yk (BX[i]!>>>16)).toNat+120) gl gq b[j]! (BF.uget j.toUSize hbJ) q else act gq (eh X W b n i j) else act gq (eh X W b n i j) end Submission namespace Submission open ExactRuntime d8 @[specialize] def dN (SF:fI) {β:Type} (kont:ڭ → ڭ → ڭ → ڭ → ڭ → ڭ → ڭ → ڭ → β) (XF:ڨ) (W:ڟ ڎ) (xa0 xa1 xa2 xa3 xa4 xa5 xa6 xa7 wa n:ڲ) (wm:ڜ) (hX0:xa0.toNat+n.toNat ≤ XF.size) (gX0:xa0.toNat+n.toNat ≤ zz3) (hX1:xa1.toNat+n.toNat ≤ XF.size) (gX1:xa1.toNat+n.toNat ≤ zz3) (hX2:xa2.toNat+n.toNat ≤ XF.size) (gX2:xa2.toNat+n.toNat ≤ zz3) (hX3:xa3.toNat+n.toNat ≤ XF.size) (gX3:xa3.toNat+n.toNat ≤ zz3) (hX4:xa4.toNat+n.toNat ≤ XF.size) (gX4:xa4.toNat+n.toNat ≤ zz3) (hX5:xa5.toNat+n.toNat ≤ XF.size) (gX5:xa5.toNat+n.toNat ≤ zz3) (hX6:xa6.toNat+n.toNat ≤ XF.size) (gX6:xa6.toNat+n.toNat ≤ zz3) (hX7:xa7.toNat+n.toNat ≤ XF.size) (gX7:xa7.toNat+n.toNat ≤ zz3) (hW:wa.toNat+n.toNat ≤ W.size) (gW:wa.toNat+n.toNat ≤ zz3) (k:ڲ) (s0 s1 s2 s3 s4 s5 s6 s7:ڭ):β:= if h:k real (t k)) n| ≤ (2 : ڰ) ^ (c - 301 + 2 * (l : Int)) / 2 ∧ |real (A n)| ≤ ((n : ڰ) + 2) * (2 : ڰ) ^ (c - 250) := by obtain ⟨-, -, -, hinput, -, -⟩ := bK n l c hl hn obtain ⟨he, he'⟩ := (al l c hl hc).1 apply av (real a) (fun k => real (t k)) (fun k => real (A k)) (fun k => finite (A k)) n l c hl hn hat (fun k hk => (ht k hk).2) · exact congrArg real hzero · simpa only [hzero] using ha · intro k hk hv hin cases hact : active k with | false => have hreal : real (t k) = 0 := hskip k hk hact rw [hsucc k hk, hact] simp only [Bool.false_eq_true, ite_false] simp only [hreal, add_zero, sub_self, abs_zero] exact ⟨hv, le_of_lt (zpow_pos Q25 _)⟩ | true => obtain ⟨hf, -, herr⟩ := fz (A k) (t k) hv (ht k hk).1 (c + (l : Int) - 249) he he' (hin.trans_lt hinput) rw [hsucc k hk, hact] simp only [eq_self, ite_true] exact ⟨hf, by rw [← cW c l]; exact herr⟩ end Submission namespace Submission def z7 (a : ڭ) (t : ڣ → ڭ) (active : ڣ → ڡ) : ڣ → ڭ | 0 => a | k + 1 => if active k then z7 a t active k + t k else z7 a t active k end Submission namespace Submission open d8 @[specialize] def z2 (n : ڲ) (fx fw : (i : ڲ) → i < n → ڭ) (active : (i : ڲ) → i < n → ڡ) (k : ڲ) (sum : ڭ) : ڭ := if h : k < n then z2 n fx fw active (k + 1) (if active k h then sum + fx k h * fw k h else sum) else sum termination_by n.toNat - k.toNat decreasing_by have hk := USize.lt_iff_toNat_lt.mp h have hnext : (k + 1).toNat = k.toNat + 1 := by rw [USize.toNat_add, USize.toNat_one, zz5] have hn := n.toNat_lt_size simp only [zz3] at hn omega rw [hnext] omega lemma z4 (n : ڲ) (fx fw : (i : ڲ) → i < n → ڭ) (active : (i : ڲ) → i < n → ڡ) (A : ڣ → ڭ) (hs : ∀ (i : ڲ) (h : i < n), A (i.toNat + 1) = if active i h then A i.toNat + fx i h * fw i h else A i.toNat) (k : ڲ) (hk : k.toNat ≤ n.toNat) : z2 n fx fw active k (A k.toNat) = A n.toNat := by rw [z2] split next h => have hkn := USize.lt_iff_toNat_lt.mp h have hnext : (k + 1).toNat = k.toNat + 1 := by rw [USize.toNat_add, USize.toNat_one, zz5] have hn := n.toNat_lt_size simp only [zz3] at hn omega rw [← hs k h, ← hnext] exact z4 n fx fw active A hs (k + 1) (by rw [hnext]; omega) next h => have hnk : ¬ k.toNat < n.toNat := by simpa only [USize.lt_iff_toNat_lt] using h have he : k.toNat = n.toNat := by omega rw [he] termination_by n.toNat - k.toNat decreasing_by simp_wf have hn := n.toNat_lt_size simp only [zz3] at hn have hmod : (k.toNat + 1) % 2 ^ System.Platform.numBits = k.toNat + 1 := zz5 Q24 rw [hmod] omega end Submission namespace Submission open d8 lemma z3 (n : ڲ) (fx fw : (i : ڲ) → i < n → ڭ) (active : (i : ڲ) → i < n → ڡ) (a : ڭ) (t A : ڣ → ڭ) (activeNat : ڣ → ڡ) (l : ڣ) (c : Int) (hl : l ≤ 12) (hn : n.toNat + 2 < 2 ^ (l + 1)) (hc : 126 ≤ c ∧ c ≤ 350) (ha : finite a) (hat : |real a| ≤ (2 : ڰ) ^ (c - 250)) (ht : ∀ k, k < n.toNat → finite (t k) ∧ |real (t k)| ≤ (2 : ڰ) ^ (c - 250)) (hA0 : A 0 = a) (hstep : ∀ (i : ڲ) (h : i < n), A (i.toNat + 1) = if active i h then A i.toNat + fx i h * fw i h else A i.toNat) (hact : ∀ (i : ڲ) (h : i < n), activeNat i.toNat = active i h) (htEq : ∀ (i : ڲ) (h : i < n), t i.toNat = fx i h * fw i h) (hskip : ∀ k, k < n.toNat → activeNat k = false → real (t k) = 0) : let q := z2 n fx fw active 0 a finite q ∧ |real q - en (real a) (fun k => real (t k)) n.toNat| ≤ (2 : ڰ) ^ (c - 301 + 2 * (l : Int)) / 2 ∧ |real q| ≤ ((n.toNat : ڰ) + 2) * (2 : ڰ) ^ (c - 250) := by dsimp only have hloop := z4 n fx fw active A hstep 0 Q29 simp only [USize.toNat_zero] at hloop rw [hA0] at hloop simpa only [USize.toNat_zero, hloop] using (show finite (A n.toNat) ∧ |real (A n.toNat) - en (real a) (fun k => real (t k)) n.toNat| ≤ (2 : ڰ) ^ (c - 301 + 2 * (l : Int)) / 2 ∧ |real (A n.toNat)| ≤ ((n.toNat : ڰ) + 2) * (2 : ڰ) ^ (c - 250) from by apply z8 a t A activeNat n.toNat l c hl hn hc ha hat ht hA0 · intro k hk let i : ڲ := k.toUSize have hi : i.toNat = k := by dsimp [i] change k % zz3 = k exact zz5 (by have hnsize := n.toNat_lt_size omega) have hik : i < n := USize.lt_iff_toNat_lt.mpr (by rw [hi]; exact hk) rw [← hi, hact i hik, hstep i hik, htEq i hik] · exact hskip) end Submission namespace Submission lemma z6 (n : ڲ) (fx fw : (i : ڲ) → i < n → ڭ) (active : (i : ڲ) → i < n → ڡ) (k : ڲ) (sum : ڭ) (hk : ¬ k < n) : z2 n fx fw active k sum = sum := by rw [z2, dif_neg hk] lemma z5 (n : ڲ) (fx fw : (i : ڲ) → i < n → ڭ) (active : (i : ڲ) → i < n → ڡ) (k : ڲ) (sum : ڭ) (hk : k < n) : z2 n fx fw active k sum = z2 n fx fw active (k + 1) (if active k hk then sum + fx k hk * fw k hk else sum) := by rw [z2, dif_pos hk] end Submission namespace Submission open d8 lemma z1 (SF:fI) {β:Type} (kont:ڭ → ڭ → ڭ → ڭ → ڭ → ڭ → ڭ → ڭ → β) (XF:ڨ) (W:ڟ ڎ) (xa0 xa1 xa2 xa3 xa4 xa5 xa6 xa7 wa n:ڲ) (wm:ڜ) (hX0:xa0.toNat+n.toNat ≤ XF.size) (gX0:xa0.toNat+n.toNat ≤ zz3) (hX1:xa1.toNat+n.toNat ≤ XF.size) (gX1:xa1.toNat+n.toNat ≤ zz3) (hX2:xa2.toNat+n.toNat ≤ XF.size) (gX2:xa2.toNat+n.toNat ≤ zz3) (hX3:xa3.toNat+n.toNat ≤ XF.size) (gX3:xa3.toNat+n.toNat ≤ zz3) (hX4:xa4.toNat+n.toNat ≤ XF.size) (gX4:xa4.toNat+n.toNat ≤ zz3) (hX5:xa5.toNat+n.toNat ≤ XF.size) (gX5:xa5.toNat+n.toNat ≤ zz3) (hX6:xa6.toNat+n.toNat ≤ XF.size) (gX6:xa6.toNat+n.toNat ≤ zz3) (hX7:xa7.toNat+n.toNat ≤ XF.size) (gX7:xa7.toNat+n.toNat ≤ zz3) (hW:wa.toNat+n.toNat ≤ W.size) (gW:wa.toNat+n.toNat ≤ zz3): ∀r k s0 s1 s2 s3 s4 s5 s6 s7,n.toNat-k.toNat=r → dN SF kont XF W xa0 xa1 xa2 xa3 xa4 xa5 xa6 xa7 wa n wm hX0 gX0 hX1 gX1 hX2 gX2 hX3 gX3 hX4 gX4 hX5 gX5 hX6 gX6 hX7 gX7 hW gW k s0 s1 s2 s3 s4 s5 s6 s7= kont (z2 n (fY XF xa0 n hX0 gX0) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s0) (z2 n (fY XF xa1 n hX1 gX1) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s1) (z2 n (fY XF xa2 n hX2 gX2) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s2) (z2 n (fY XF xa3 n hX3 gX3) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s3) (z2 n (fY XF xa4 n hX4 gX4) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s4) (z2 n (fY XF xa5 n hX5 gX5) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s5) (z2 n (fY XF xa6 n hX6 gX6) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s6) (z2 n (fY XF xa7 n hX7 gX7) (f0 SF W wa n wm hW gW) (fun (i : ڲ) (hi : i < n) => !(W.uget (wa+i) (c8 wa n i W.size hW gW hi) == 0)) k s7) := by intro r induction r with | zero => intro k s0 s1 s2 s3 s4 s5 s6 s7 hr have hk : ¬ k < n := by rw [USize.lt_iff_toNat_lt]; omega rw [dN, dif_neg hk] simp only [z6 _ _ _ _ _ _ hk] | succ r ih => intro k s0 s1 s2 s3 s4 s5 s6 s7 hr have hk : k < n := by rw [USize.lt_iff_toNat_lt]; omega have hnext : (k+1).toNat=k.toNat+1 := by rw [USize.toNat_add,USize.toNat_one,zz5] have hn := n.toNat_lt_size simp only [zz3] at hn have hki := USize.lt_iff_toNat_lt.mp hk omega rw [dN, dif_pos hk] simp only [z5 _ _ _ _ _ _ hk] let raw := W.uget (wa+k) (c8 wa n k W.size hW gW hk) by_cases hraw : raw == 0 · simp only [raw, hraw, Bool.not_true, Bool.not_false, Bool.false_eq_true, eq_self, ite_true, ite_false] exact ih (k+1) s0 s1 s2 s3 s4 s5 s6 s7 (by rw [hnext]; omega) · simp only [raw, hraw, Bool.not_true, Bool.not_false, Bool.false_eq_true, eq_self, ite_true, ite_false] let w := f0 SF W wa n wm hW gW k hk exact ih (k+1) (s0+fY XF xa0 n hX0 gX0 k hk*w) (s1+fY XF xa1 n hX1 gX1 k hk*w) (s2+fY XF xa2 n hX2 gX2 k hk*w) (s3+fY XF xa3 n hX3 gX3 k hk*w) (s4+fY XF xa4 n hX4 gX4 k hk*w) (s5+fY XF xa5 n hX5 gX5 k hk*w) (s6+fY XF xa6 n hX6 gX6 k hk*w) (s7+fY XF xa7 n hX7 gX7 k hk*w) (by rw [hnext]; omega) end Submission namespace Submission open d8 lemma z3' (n : ڲ) (fx fw : (i : ڲ) → i < n → ڭ) (active : (i : ڲ) → i < n → ڡ) (a : ڭ) (t : ڣ → ڭ) (activeNat : ڣ → ڡ) (l : ڣ) (c : Int) (hl : l ≤ 12) (hn : n.toNat + 2 < 2 ^ (l + 1)) (hc : 126 ≤ c ∧ c ≤ 350) (ha : finite a) (hat : |real a| ≤ (2 : ڰ) ^ (c - 250)) (ht : ∀ k, k < n.toNat → finite (t k) ∧ |real (t k)| ≤ (2 : ڰ) ^ (c - 250)) (hact : ∀ (i : ڲ) (h : i < n), activeNat i.toNat = active i h) (htEq : ∀ (i : ڲ) (h : i < n), t i.toNat = fx i h * fw i h) (hskip : ∀ k, k < n.toNat → activeNat k = false → real (t k) = 0) : let q := z2 n fx fw active 0 a finite q ∧ |real q - en (real a) (fun k => real (t k)) n.toNat| ≤ (2 : ڰ) ^ (c - 301 + 2 * (l : Int)) / 2 ∧ |real q| ≤ ((n.toNat : ڰ) + 2) * (2 : ڰ) ^ (c - 250) := by exact z3 n fx fw active a t (z7 a t activeNat) activeNat l c hl hn hc ha hat ht rfl (fun i hi => by simp only [z7, hact i hi, htEq i hi]) hact htEq hskip end Submission namespace Submission open ExactRuntime d8 @[inline] def cb (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (XF:ڨ) (hXF:XF.size=X.size) (i j:ڣ) (hi:i>>16)) (eT gr n gp X W b BX BV h XF hXF i hi).1 (eT gr n gp X W b BX BV h XF hXF i hi).2 (eS gr n gp X W b BX BV h j hj).1 (eS gr n gp X W b BX BV h j hj).2 0 (zz0 0) @[noinline] def cD (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (BF:ڨ) (hBF:BF.size=b.size) (i j:ڣ) (hj:j>>16) let gl:=(Yk (BX[i]!>>>16)+wm).toNat let gs:=(max (Yk (BX[i]!&&&0xffff)+Yk (BV[j]!&&&0xffff)) (Yd oneW+Yd b[j]!)).toNat b9 X W b i j n gs ((Yk (BX[i]!>>>16)).toNat+120) gl gq b[j]! (BF.uget j.toUSize hbJ) q ne lemma bj (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (i j:ڣ) (hi:i(cD SF gr n gp X W b BX BV h BF hBF (ch+0) j hj gq s0,cD SF gr n gp X W b BX BV h BF hBF (ch+1) j hj gq s1,cD SF gr n gp X W b BX BV h BF hBF (ch+2) j hj gq s2,cD SF gr n gp X W b BX BV h BF hBF (ch+3) j hj gq s3,cD SF gr n gp X W b BX BV h BF hBF (ch+4) j hj gq s4,cD SF gr n gp X W b BX BV h BF hBF (ch+5) j hj gq s5,cD SF gr n gp X W b BX BV h BF hBF (ch+6) j hj gq s6,cD SF gr n gp X W b BX BV h BF hBF (ch+7) j hj gq s7)) XF W ((ch+0)*n).toUSize ((ch+1)*n).toUSize ((ch+2)*n).toUSize ((ch+3)*n).toUSize ((ch+4)*n).toUSize ((ch+5)*n).toUSize ((ch+6)*n).toUSize ((ch+7)*n).toUSize (j*n).toUSize n.toUSize (Yk (BV[j]!>>>16)) (eT gr n gp X W b BX BV h XF hXF (ch+0) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+0) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+1) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+1) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+2) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+2) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+3) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+3) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+4) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+4) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+5) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+5) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+6) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+6) Q24).2 (eT gr n gp X W b BX BV h XF hXF (ch+7) Q24).1 (eT gr n gp X W b BX BV h XF hXF (ch+7) Q24).2 (eS gr n gp X W b BX BV h j hj).1 (eS gr n gp X W b BX BV h j hj).2 0 (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) end Submission namespace d8 lemma cN (gr gp:ڣ) (f:ڣ → ڣ → ڎ):∀d ch (O:ڟ ڎ),gr-ch=d → (eZ gr gp f ch O).toList=O.toList++(List.range' (ch*gp) ((gr-ch)*gp)).map (fun i=>f (i/gp) (i%gp)):=by intro d induction d with | zero=>intro ch O h;unfold eZ;rw[if_neg Q24];simp[h] | succ d ih=> intro ch O h unfold eZ rw[if_pos Q24,ih (ch+1) _ Q24,dv gp (f ch) gp 0 _ Q24] have hn:(gr-ch)*gp=gp+(gr-(ch+1))*gp:=by rw[show gr-ch=(gr-(ch+1))+1 by omega,Nat.add_mul,Nat.one_mul,Nat.add_comm] rw[hn,←List.range'_append,List.map_append] simp only[List.append_assoc,Nat.sub_zero,Nat.zero_add,Nat.add_mul,Nat.one_mul] congr 2 · rw[show List.range' (ch*gp) gp=(List.range' 0 gp).map (ch*gp+·) by rw[List.map_add_range'];simp] rw[List.map_map] apply List.map_congr_left intro j hj have hj':jf (i.val/gp) (i.val%gp)):=by apply Array.toList_inj.mp rw[cN gr gp f gr 0 _ Q24] apply List.ext_getElem <;>simp end d8 namespace Submission open ExactRuntime d8 @[noinline] def ge (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (ch j:ڣ) (gq:ڡ):ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ:= if hc:ch+7t L[k]!) n=((L.take n).map t).sum:=by induction n with | zero=>simp[en] | succ n ih=> rw[en,ih Q24,List.take_succ_eq_append_getElem Q24] simp only[List.map_append,List.map_cons,List.map_nil,List.sum_append,List.sum_cons,List.sum_nil,add_zero] rw[getElem!_pos L n Q24] lemma dx (L:List ڣ) (t:ڣ→ ڰ): en 0 (fun k=>t L[k]!) L.length=(L.map t).sum:=by rw[e9 L t L.length Q24,List.take_length] lemma dC (L:List ڣ) (p:ڣ→ ڡ) (t:ڣ→ ڰ) (hz:∀k,k∈L→ p k=false→ t k=0): ((L.filter p).map t).sum=(L.map t).sum:=by induction L with | nil=>simp | cons a L ih=> have hi:=ih (fun k hk=>hz k (by simp[hk])) cases hp:p a · have ha:t a=0:=hz a Q29 hp simpa[hp,ha]using hi · simpa[hp]using congrArg (fun q=>t a+q) hi lemma eG (n:ڣ) (t:ڣ→ ڰ): en 0 t n=((zz4 n).map t).sum:=by induction n with | zero=>simp[en] | succ n ih=>simp[en,ih,List.range_succ] lemma d7 (n:ڣ) (p:ڣ→ ڡ) (t:ڣ→ ڰ) (hz:∀k,kt I[k]!) I.length=en 0 t n:=by dsimp rw[dx,dC _ p t (fun k hk=>hz k (List.mem_range.mp hk)),eG] lemma eF (n:ڣ) (a:ڰ) (t u:ڣ→ ڰ) (h:∀k,krfl | succ n ih=>rw[en,en,ih (fun k hk=>h k Q24),h n Q24] lemma cH (I:ڟ ڎ) (L:List ڣ) (hI:I.toList=L.map Nat.toUInt32) (hL:∀k,k∈L→ k<2^32) (k:ڣ) (hk:kt I[k]!.toNat) I.size=en 0 t n:=by have hlen:I.size=((zz4 n).filter p).length:=by have h:=congrArg List.length hI simpa using h have hget (k:ڣ) (hk:kt (((zz4 n).filter p)[k]!)) (fun k hk=>congrArg t (hget k hk)),hlen] exact d7 n p t hz end d8 namespace Submission open ExactRuntime d8 @[specialize] def db (n:ڣ) (f:ڣ→ ڎ) (t:ڣ) (I:ڟ ڎ):ڟ ڎ:= if tYf (f u)≠0)).map Nat.toUInt32:=by intro k induction k with | zero=>intro t I h;unfold db;rw[if_neg Q24];simp[h] | succ k ih=> intro t I h unfold db rw[if_pos Q24,ih (t+1) _ Q24,show n-t=(n-(t+1))+1 by omega,List.range'_succ] split <;> simp[*] lemma bi (n:ڣ) (f:ڣ→ ڎ): (db n f 0 (Array.emptyWithCapacity n)).toList= ((zz4 n).filter (fun k=>decide (z11 (f k)≠0))).map Nat.toUInt32:=by rw[bC n f n 0 _ Q24] simp only[Array.emptyWithCapacity_eq,Array.toList_empty,List.nil_append,Nat.sub_zero,←List.range_eq_range'] congr 2 funext k have hzero:Yf (f k)=0 ↔ z11 (f k)=0:=by constructor · intro h;rw[←Zk,h];rfl · intro h;apply UInt64.toNat_inj.mp;rw[Zk,h];rfl simp only[ne_eq,hzero] lemma aT (n:ڣ) (f:ڣ→ ڎ) (hn:n≤2^32) (k:ڣ) (hk:k<(db n f 0 (Array.emptyWithCapacity n)).size): ((db n f 0 (Array.emptyWithCapacity n))[k]!).toNatdecide (z11 (f k)≠0))).map Nat.toUInt32:=bi n f have hlen:I.size=((zz4 n).filter (fun k=>decide (z11 (f k)≠0))).length:=by have h:=congrArg List.length hI simpa using h have hkl:k<((zz4 n).filter (fun k=>decide (z11 (f k)≠0))).length:=by change kdecide (z11 (f k)≠0)))[k]lt_of_lt_of_le (List.mem_range.mp (List.mem_of_mem_filter hj)) hn) k hk rw[hg,getElem!_pos _ k hkl] exact hlt lemma b8 (n:ڣ) (f:ڣ→ ڎ): (db n f 0 (Array.emptyWithCapacity n)).size ≤ n:=by have h:=congrArg List.length (bi n f) simp only[Array.length_toList,List.length_map]at h rw[h] exact (List.length_filter_le _ _).trans Q29 lemma bg (x:ڎ) (xm:ڜ) (cx cw:ڭ) (hr:real cx=(sv x:ڰ)*2^((zz x:Int)-(xm.toNat:Int))) (hnx:fO cx.toModel.unpack) (hnw:fO cw.toModel.unpack) (hz:z11 x=0): real (cx*cw)=0:=by rw[(ev cx cw hnx hnw).2,hr] simp[sv,hz] end Submission namespace Submission open ExactRuntime d8 @[inline] def cv (I:ڟ ڎ) (m:ڲ) (hm:m.toNat=I.size) (k:ڲ) (hk:k < m):ڲ:= (I.uget k (by rw[←hm];exact USize.lt_iff_toNat_lt.mp hk)).toUSize lemma bu (I:ڟ ڎ) (m:ڲ) (hm:m.toNat=I.size) (k:ڲ) (hk:k < m): (cv I m hm k hk).toNat=I[k.toNat]!.toNat:=by unfold cv rw[UInt32.toNat_toUSize] congr 1 change I[k.toNat]'(by rw[←hm];exact USize.lt_iff_toNat_lt.mp hk)=I[k.toNat]! rw[getElem!_pos I _ (by rw[←hm];exact USize.lt_iff_toNat_lt.mp hk)] lemma c7 (n:ڣ) (m:ڣ) (hn:n < 4096) (hm:m ≤ n):m.toUSize.toNat=m:=Za _ Q24 end Submission namespace Submission open ExactRuntime d8 lemma aR (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,k < I.size → I[k]!.toNat < n): ∀(k:ڲ)(hk:k < I.size.toUSize),cv I I.size.toUSize (c7 n I.size h.hk hIs) k hk < n.toUSize:=by intro k hk rw[USize.lt_iff_toNat_lt,bu,Za _ (by have:=h.hk;omega)] apply hIb rw[←c7 n I.size h.hk hIs] exact USize.lt_iff_toNat_lt.mp hk lemma bN (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (XF:ڨ) (hXF:XF.size=X.size): (0:ڲ).toNat+n.toUSize.toNat ≤ XF.size ∧ (0:ڲ).toNat+n.toUSize.toNat ≤ zz3:=by simpa using eT 1 n gp X W b BX BV h XF hXF 0 Q24 end Submission namespace Submission open ExactRuntime d8 @[specialize] def bG (SF:fI) (XF:ڨ) (W:ڟ ڎ) (xa wa nu m:ڲ) (wm:ڜ) (idx:(k:ڲ) → k < m → ڲ) (hidx:∀(k:ڲ)(hk:k < m),idx k hk < nu) (ha:xa.toNat+nu.toNat ≤ XF.size) (hg:xa.toNat+nu.toNat ≤ zz3) (hb:wa.toNat+nu.toNat ≤ W.size) (hh:wa.toNat+nu.toNat ≤ zz3) (k:ڲ) (sum:ڭ):ڭ:= if h:k < m then let ix:=idx k h let x:=fY XF xa nu ha hg ix (hidx k h) let w:=f0 SF W wa nu wm hb hh ix (hidx k h) bG SF XF W xa wa nu m wm idx hidx ha hg hb hh (k+1) (sum+x*w) else sum termination_by m.toNat-k.toNat decreasing_by have hn:=USize.lt_iff_toNat_lt.mp h have hnum:(k+1).toNat=k.toNat+1:=by rw[USize.toNat_add,USize.toNat_one,zz5] have hb:=m.toNat_lt_size exact (show k.toNat+1 < zz3 by omega) rw[hnum] omega lemma aX (SF:fI) (XF:ڨ) (W:ڟ ڎ) (xa wa nu m:ڲ) (wm:ڜ) (idx:(k:ڲ) → k < m → ڲ) (hidx:∀(k:ڲ)(hk:k < m),idx k hk < nu) (ha:xa.toNat+nu.toNat ≤ XF.size) (hg:xa.toNat+nu.toNat ≤ zz3) (hb:wa.toNat+nu.toNat ≤ W.size) (hh:wa.toNat+nu.toNat ≤ zz3): ∀r k sum,m.toNat-k.toNat=r → bG SF XF W xa wa nu m wm idx hidx ha hg hb hh k sum= loop m (fun k hk=>fY XF xa nu ha hg (idx k hk) (hidx k hk)) (fun k hk=>f0 SF W wa nu wm hb hh (idx k hk) (hidx k hk)) k sum:=by intro r induction r with | zero=> intro k sum hr have hk:¬k < m:=by rw[USize.lt_iff_toNat_lt];omega rw[bG,dif_neg hk,loop,dif_neg hk] | succ r ih=> intro k sum hr have hk:k < m:=by rw[USize.lt_iff_toNat_lt];omega have hnum:(k+1).toNat=k.toNat+1:=by rw[USize.toNat_add,USize.toNat_one,zz5] have hn:=m.toNat_lt_size have hh:=USize.lt_iff_toNat_lt.mp hk exact (show k.toNat+1 < zz3 by omega) rw[bG,dif_pos hk,loop,dif_pos hk] exact ih (k+1) _ (by rw[hnum];omega) end Submission namespace Submission open ExactRuntime d8 @[noinline] def bk (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,k < I.size → I[k]!.toNat < n) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (j:ڣ) (gq:ڡ):ڎ:= if hj:j < gp then let nu:=n.toUSize let m:=I.size.toUSize have hnu:nu.toNat=n:=(dF 1 n gp X W b BX BV h 0 Q24).2 have hm:m.toNat=I.size:=c7 n I.size h.hk hIs let idx:=cv I m hm have hidx:∀(k:ڲ)(hk:k < m),idx k hk < nu:=by intro k hk rw[USize.lt_iff_toNat_lt,bu,hnu] apply hIb rw[←hm];exact USize.lt_iff_toNat_lt.mp hk let wa:=(j*n).toUSize have hwa:wa.toNat=j*n:=(dc 1 n gp X W b BX BV h j hj).1 have hsX:=bA 1 n gp X W b BX BV h 0 Q24 have hsW:=bh 1 n gp X W b BX BV h j hj have hpX:(0:ڲ).toNat+nu.toNat ≤ XF.size:=by rw[hnu,hXF];simpa using hsX.1 have hpW:wa.toNat+nu.toNat ≤ W.size:=by rw[hwa,hnu];exact hsW.1 have hgX:(0:ڲ).toNat+nu.toNat ≤ zz3:=by rw[hnu,USize.toNat_zero];have:=USize.le_size;have:=h.hk;omega have hgW:wa.toNat+nu.toNat ≤ zz3:=by rw[hwa,hnu];have:=USize.le_size;omega have hbJ:j.toUSize.toNat < BF.size:=by rw[(dc 1 n gp X W b BX BV h j hj).2,hBF];have:=h.hB;omega let wm:=Yk (BV[j]!>>>16) let q:=bG SF XF W 0 wa nu m wm idx hidx hpX hgX hpW hgW 0 (zz0 0) let gl:=(Yk (BX[0]!>>>16)+wm).toNat let gs:=(max (Yk (BX[0]!&&&0xffff)+Yk (BV[j]!&&&0xffff)) (Yd oneW+Yd b[j]!)).toNat b9 X W b 0 j n gs ((Yk (BX[0]!>>>16)).toNat+120) gl gq b[j]! (BF.uget j.toUSize hbJ) q I.size else act gq (dotOf (n+1) (fun k=>if kif k intro k s0 s1 s2 s3 s4 s5 s6 s7 hr have hk:¬k < m:=by rw[USize.lt_iff_toNat_lt];omega rw[cE,dif_neg hk] rw[bG,dif_neg hk];rw[bG,dif_neg hk];rw[bG,dif_neg hk];rw[bG,dif_neg hk];rw[bG,dif_neg hk];rw[bG,dif_neg hk];rw[bG,dif_neg hk];rw[bG,dif_neg hk] | succ r ih=> intro k s0 s1 s2 s3 s4 s5 s6 s7 hr have hk:k < m:=by rw[USize.lt_iff_toNat_lt];omega have hnum:(k+1).toNat=k.toNat+1:=by rw[USize.toNat_add,USize.toNat_one,zz5] have hn:=m.toNat_lt_size have hh:=USize.lt_iff_toNat_lt.mp hk exact (show k.toNat+1 < zz3 by omega) rw[cE,dif_pos hk] rw[bH SF XF W xa wa0 nu m wm0 idx hidx hX gX hW0 gW0 k s0 hk,bH SF XF W xa wa1 nu m wm1 idx hidx hX gX hW1 gW1 k s1 hk,bH SF XF W xa wa2 nu m wm2 idx hidx hX gX hW2 gW2 k s2 hk,bH SF XF W xa wa3 nu m wm3 idx hidx hX gX hW3 gW3 k s3 hk,bH SF XF W xa wa4 nu m wm4 idx hidx hX gX hW4 gW4 k s4 hk,bH SF XF W xa wa5 nu m wm5 idx hidx hX gX hW5 gW5 k s5 hk,bH SF XF W xa wa6 nu m wm6 idx hidx hX gX hW6 gW6 k s6 hk,bH SF XF W xa wa7 nu m wm7 idx hidx hX gX hW7 gW7 k s7 hk] exact ih (k+1) _ _ _ _ _ _ _ _ (by rw[hnum];omega) end Submission namespace Submission open ExactRuntime d8 @[inline] def ca (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,k < I.size → I[k]!.toNat < n) (XF:ڨ) (hXF:XF.size=X.size) (j:ڣ) (hj:j < gp):ڭ:= bG SF XF W 0 (j*n).toUSize n.toUSize I.size.toUSize (Yk (BV[j]!>>>16)) (cv I I.size.toUSize (c7 n I.size h.hk hIs)) (aR n gp X W b BX BV h I hIs hIb) (bN n gp X W b BX BV h XF hXF).1 (bN n gp X W b BX BV h XF hXF).2 (eS 1 n gp X W b BX BV h j hj).1 (eS 1 n gp X W b BX BV h j hj).2 0 (zz0 0) lemma af (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,k < I.size → I[k]!.toNat < n) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (j:ڣ) (hj:j < gp) (gq:ڡ): bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF j gq= cD SF 1 n gp X W b BX BV h BF hBF 0 j hj gq (ca SF n gp X W b BX BV h I hIs hIb XF hXF j hj) I.size:=by unfold bk rw[dif_pos hj] rfl @[inline] def aW (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,k < I.size → I[k]!.toNat < n) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (j:ڣ) (hj:j+7 < gp) (gq:ڡ):ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ:= cE SF (fun s0 s1 s2 s3 s4 s5 s6 s7=>(cD SF 1 n gp X W b BX BV h BF hBF 0 (j+0) Q24 gq s0 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+1) Q24 gq s1 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+2) Q24 gq s2 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+3) Q24 gq s3 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+4) Q24 gq s4 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+5) Q24 gq s5 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+6) Q24 gq s6 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+7) Q24 gq s7 I.size)) XF W 0 ((j+0)*n).toUSize ((j+1)*n).toUSize ((j+2)*n).toUSize ((j+3)*n).toUSize ((j+4)*n).toUSize ((j+5)*n).toUSize ((j+6)*n).toUSize ((j+7)*n).toUSize n.toUSize I.size.toUSize (Yk (BV[j+0]!>>>16)) (Yk (BV[j+1]!>>>16)) (Yk (BV[j+2]!>>>16)) (Yk (BV[j+3]!>>>16)) (Yk (BV[j+4]!>>>16)) (Yk (BV[j+5]!>>>16)) (Yk (BV[j+6]!>>>16)) (Yk (BV[j+7]!>>>16)) (cv I I.size.toUSize (c7 n I.size h.hk hIs)) (aR n gp X W b BX BV h I hIs hIb) (bN n gp X W b BX BV h XF hXF).1 (bN n gp X W b BX BV h XF hXF).2 (eS 1 n gp X W b BX BV h (j+0) Q24).1 (eS 1 n gp X W b BX BV h (j+0) Q24).2 (eS 1 n gp X W b BX BV h (j+1) Q24).1 (eS 1 n gp X W b BX BV h (j+1) Q24).2 (eS 1 n gp X W b BX BV h (j+2) Q24).1 (eS 1 n gp X W b BX BV h (j+2) Q24).2 (eS 1 n gp X W b BX BV h (j+3) Q24).1 (eS 1 n gp X W b BX BV h (j+3) Q24).2 (eS 1 n gp X W b BX BV h (j+4) Q24).1 (eS 1 n gp X W b BX BV h (j+4) Q24).2 (eS 1 n gp X W b BX BV h (j+5) Q24).1 (eS 1 n gp X W b BX BV h (j+5) Q24).2 (eS 1 n gp X W b BX BV h (j+6) Q24).1 (eS 1 n gp X W b BX BV h (j+6) Q24).2 (eS 1 n gp X W b BX BV h (j+7) Q24).1 (eS 1 n gp X W b BX BV h (j+7) Q24).2 0 (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) lemma ar (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,k < I.size → I[k]!.toNat < n) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (j:ڣ) (hj:j+7 < gp) (gq:ڡ): aW SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF j hj gq= (bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+0) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+1) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+2) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+3) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+4) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+5) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+6) gq,bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+7) gq):=by unfold aW rw[bP SF (fun s0 s1 s2 s3 s4 s5 s6 s7=>(cD SF 1 n gp X W b BX BV h BF hBF 0 (j+0) Q24 gq s0 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+1) Q24 gq s1 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+2) Q24 gq s2 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+3) Q24 gq s3 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+4) Q24 gq s4 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+5) Q24 gq s5 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+6) Q24 gq s6 I.size,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+7) Q24 gq s7 I.size)) XF W 0 ((j+0)*n).toUSize ((j+1)*n).toUSize ((j+2)*n).toUSize ((j+3)*n).toUSize ((j+4)*n).toUSize ((j+5)*n).toUSize ((j+6)*n).toUSize ((j+7)*n).toUSize n.toUSize I.size.toUSize (Yk (BV[j+0]!>>>16)) (Yk (BV[j+1]!>>>16)) (Yk (BV[j+2]!>>>16)) (Yk (BV[j+3]!>>>16)) (Yk (BV[j+4]!>>>16)) (Yk (BV[j+5]!>>>16)) (Yk (BV[j+6]!>>>16)) (Yk (BV[j+7]!>>>16)) (cv I I.size.toUSize (c7 n I.size h.hk hIs)) (aR n gp X W b BX BV h I hIs hIb) (bN n gp X W b BX BV h XF hXF).1 (bN n gp X W b BX BV h XF hXF).2 (eS 1 n gp X W b BX BV h (j+0) Q24).1 (eS 1 n gp X W b BX BV h (j+0) Q24).2 (eS 1 n gp X W b BX BV h (j+1) Q24).1 (eS 1 n gp X W b BX BV h (j+1) Q24).2 (eS 1 n gp X W b BX BV h (j+2) Q24).1 (eS 1 n gp X W b BX BV h (j+2) Q24).2 (eS 1 n gp X W b BX BV h (j+3) Q24).1 (eS 1 n gp X W b BX BV h (j+3) Q24).2 (eS 1 n gp X W b BX BV h (j+4) Q24).1 (eS 1 n gp X W b BX BV h (j+4) Q24).2 (eS 1 n gp X W b BX BV h (j+5) Q24).1 (eS 1 n gp X W b BX BV h (j+5) Q24).2 (eS 1 n gp X W b BX BV h (j+6) Q24).1 (eS 1 n gp X W b BX BV h (j+6) Q24).2 (eS 1 n gp X W b BX BV h (j+7) Q24).1 (eS 1 n gp X W b BX BV h (j+7) Q24).2 I.size.toUSize.toNat 0 (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) rfl] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+0) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+1) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+2) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+3) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+4) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+5) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+6) Q24] rw[af SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF (j+7) Q24] rfl end Submission namespace Submission open ExactRuntime d8 lemma ac (SF:fI) (XF:ڨ) (W:ڟ ڎ) (xa wa nu:ڲ) (wm:ڜ) (hX:xa.toNat+nu.toNat ≤ XF.size) (gX:xa.toNat+nu.toNat ≤ zz3) (hW:wa.toNat+nu.toNat ≤ W.size) (gW:wa.toNat+nu.toNat ≤ zz3): bG SF XF W xa wa nu nu wm (fun k _=>k) (fun _ hk=>hk) hX gX hW gW 0 (zz0 0)= ek SF XF W xa wa nu wm hX gX hW gW 0 (zz0 0):=by rw[aX SF XF W xa wa nu nu wm (fun k _=>k) (fun _ hk=>hk) hX gX hW gW nu.toNat 0 (zz0 0) rfl, dl SF XF W xa wa nu wm hX gX hW gW nu.toNat 0 (zz0 0) rfl] @[noinline] def bF (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (j:ڣ) (hj:j+7 < gp) (gq:ڡ):ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ:= cE SF (fun s0 s1 s2 s3 s4 s5 s6 s7=>(cD SF 1 n gp X W b BX BV h BF hBF 0 (j+0) Q24 gq s0,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+1) Q24 gq s1,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+2) Q24 gq s2,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+3) Q24 gq s3,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+4) Q24 gq s4,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+5) Q24 gq s5,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+6) Q24 gq s6,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+7) Q24 gq s7)) XF W 0 ((j+0)*n).toUSize ((j+1)*n).toUSize ((j+2)*n).toUSize ((j+3)*n).toUSize ((j+4)*n).toUSize ((j+5)*n).toUSize ((j+6)*n).toUSize ((j+7)*n).toUSize n.toUSize n.toUSize (Yk (BV[j+0]!>>>16)) (Yk (BV[j+1]!>>>16)) (Yk (BV[j+2]!>>>16)) (Yk (BV[j+3]!>>>16)) (Yk (BV[j+4]!>>>16)) (Yk (BV[j+5]!>>>16)) (Yk (BV[j+6]!>>>16)) (Yk (BV[j+7]!>>>16)) (fun k _=>k) (fun _ hk=>hk) (bN n gp X W b BX BV h XF hXF).1 (bN n gp X W b BX BV h XF hXF).2 (eS 1 n gp X W b BX BV h (j+0) Q24).1 (eS 1 n gp X W b BX BV h (j+0) Q24).2 (eS 1 n gp X W b BX BV h (j+1) Q24).1 (eS 1 n gp X W b BX BV h (j+1) Q24).2 (eS 1 n gp X W b BX BV h (j+2) Q24).1 (eS 1 n gp X W b BX BV h (j+2) Q24).2 (eS 1 n gp X W b BX BV h (j+3) Q24).1 (eS 1 n gp X W b BX BV h (j+3) Q24).2 (eS 1 n gp X W b BX BV h (j+4) Q24).1 (eS 1 n gp X W b BX BV h (j+4) Q24).2 (eS 1 n gp X W b BX BV h (j+5) Q24).1 (eS 1 n gp X W b BX BV h (j+5) Q24).2 (eS 1 n gp X W b BX BV h (j+6) Q24).1 (eS 1 n gp X W b BX BV h (j+6) Q24).2 (eS 1 n gp X W b BX BV h (j+7) Q24).1 (eS 1 n gp X W b BX BV h (j+7) Q24).2 0 (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) lemma aV (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (j:ڣ) (hj:j+7 < gp) (gq:ڡ): bF SF n gp X W b BX BV h XF BF hXF hBF j hj gq= (dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+0) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+1) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+2) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+3) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+4) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+5) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+6) gq,dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+7) gq):=by unfold bF rw[bP SF (fun s0 s1 s2 s3 s4 s5 s6 s7=>(cD SF 1 n gp X W b BX BV h BF hBF 0 (j+0) Q24 gq s0,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+1) Q24 gq s1,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+2) Q24 gq s2,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+3) Q24 gq s3,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+4) Q24 gq s4,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+5) Q24 gq s5,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+6) Q24 gq s6,cD SF 1 n gp X W b BX BV h BF hBF 0 (j+7) Q24 gq s7)) XF W 0 ((j+0)*n).toUSize ((j+1)*n).toUSize ((j+2)*n).toUSize ((j+3)*n).toUSize ((j+4)*n).toUSize ((j+5)*n).toUSize ((j+6)*n).toUSize ((j+7)*n).toUSize n.toUSize n.toUSize (Yk (BV[j+0]!>>>16)) (Yk (BV[j+1]!>>>16)) (Yk (BV[j+2]!>>>16)) (Yk (BV[j+3]!>>>16)) (Yk (BV[j+4]!>>>16)) (Yk (BV[j+5]!>>>16)) (Yk (BV[j+6]!>>>16)) (Yk (BV[j+7]!>>>16)) (fun k _=>k) (fun _ hk=>hk) (bN n gp X W b BX BV h XF hXF).1 (bN n gp X W b BX BV h XF hXF).2 (eS 1 n gp X W b BX BV h (j+0) Q24).1 (eS 1 n gp X W b BX BV h (j+0) Q24).2 (eS 1 n gp X W b BX BV h (j+1) Q24).1 (eS 1 n gp X W b BX BV h (j+1) Q24).2 (eS 1 n gp X W b BX BV h (j+2) Q24).1 (eS 1 n gp X W b BX BV h (j+2) Q24).2 (eS 1 n gp X W b BX BV h (j+3) Q24).1 (eS 1 n gp X W b BX BV h (j+3) Q24).2 (eS 1 n gp X W b BX BV h (j+4) Q24).1 (eS 1 n gp X W b BX BV h (j+4) Q24).2 (eS 1 n gp X W b BX BV h (j+5) Q24).1 (eS 1 n gp X W b BX BV h (j+5) Q24).2 (eS 1 n gp X W b BX BV h (j+6) Q24).1 (eS 1 n gp X W b BX BV h (j+6) Q24).2 (eS 1 n gp X W b BX BV h (j+7) Q24).1 (eS 1 n gp X W b BX BV h (j+7) Q24).2 n.toUSize.toNat 0 (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) (zz0 0) rfl] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+0) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+1) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+2) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+3) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+4) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+5) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+6) Q24 Q24] rw[bj SF 1 n gp X W b BX BV h XF BF hXF hBF 0 (j+7) Q24 Q24] simp only[ac SF,cb,Nat.zero_mul,show (0:ڣ).toUSize=(0:ڲ) from rfl] end Submission namespace d8 @[specialize] def du (gp:ڣ) (f:ڣ → ڎ) (tile:ڣ → ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ×ڎ) (j:ڣ) (O:ڟ ڎ):ڟ ڎ:= if j+7 intro j O hd rw[du] split · rename_i hj rw[ih (gp-(j+8)) Q24 (j+8) _ rfl,ht j hj] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] conv_rhs=>rw[fq,if_pos Q24] · rfl end d8 namespace Submission open ExactRuntime d8 open FloatLib.Floats.Formats.BinaryInterchange open Float.Model Float.Model.UnpackedFloat lemma au (w:ڎ): (fZ w).toFloat.toModel.unpack=.finite .positive ((fZ w).toNat*2^29) (-29) (by rw[eW];positivity):=by have hm:2^23 ≤ (fZ w).toNat ∧ (fZ w).toNat<2^24:=by rw[eW];have:=fracOf_toNat_lt w;omega have hv:(fZ w).toFloat.toModel=Float.Model.ofInt ((fZ w).toNat:Int):=by change Float.Model.ofUInt32 _=Float.Model.ofInt _ unfold Float.Model.ofUInt32 Float.Model.ofInt Float.Model.UnpackedFloat.ofUInt32 Float.Model.UnpackedFloat.ofNat rfl rw[hv] simpa using bo false (fZ w).toNat 0 hm Q24 lemma bl (SF:fI) (w:ڎ) (he:z12 w=0): cG SF w=zz0 0:=by unfold cG rw[SF.get _ (by rw[UInt32.toNat_toUSize];exact (dj w).1),UInt32.toNat_toUSize] unfold fH rw[(dj w).2.1,he] simp only[UInt32.toNat_zero,ite_true] apply (show Function.Injective Float.toModel from fun ⟨a⟩ ⟨b⟩ h=>congrArg Float.ofModel h) apply Model.ofFloatModel_injective rw[cM,au,show (zz0 0).toModel.unpack=.zero .positive from rfl] rfl lemma cd (SF:fI) (w:ڎ) (he:z12 w≠0): SF.data.uget (fG w).toUSize (by rw[SF.size,UInt32.toNat_toUSize];exact (dj w).1)= if signOf w then -(zz0 ((((zz w:Int)-120+1023).toNat.toUInt64)<<<52)) else zz0 ((((zz w:Int)-120+1023).toNat.toUInt64)<<<52):=by rw[SF.get _ (by rw[UInt32.toNat_toUSize];exact (dj w).1),UInt32.toNat_toUSize] unfold fH rw[(dj w).2.1] have hen:(z12 w).toNat≠0:=by intro hh;apply he;exact UInt32.toNat_inj.mp hh rw[if_neg hen] have hp:(z12 w).toNat+902=((zz w:Int)-120+1023).toNat:=by simp only[zz,if_neg he] omega rw[hp] cases hs:signOf w · rw[if_pos ((dj w).2.2.mpr hs)] rfl · rw[if_neg (by intro hi;have hh:=(dj w).2.2.mp hi;rw[hs]at hh;cases hh)] rfl lemma bR (SF:fI) (w:ڎ) (hm:z11 w≠0 → 2^23 ≤ z11 w ∧ zz w ≤ 172): cG SF w=aI w 120:=by by_cases he:z12 w=0 · have hz:z11 w=0:=by by_contra hn have hh:=(hm hn).1 simp only[z11,he,ite_true]at hh have:=fracOf_toNat_lt w omega rw[bl SF w he,ab w 120 (by intro hn;exact (hn hz).elim)] simp only[bM,hz,ite_true] · have hn:z11 w≠0:=by simp only[z11,if_neg he];omega have hr:=aE w have hp:=aY (signOf w) ((zz w:Int)-120) (by have:=(hm hn).2;omega) have hsf:=cd SF w he have hprod:=ev (fZ w).toFloat (SF.data.uget (fG w).toUSize (by rw[SF.size,UInt32.toNat_toUSize];exact (dj w).1)) hr.1 (by rw[hsf];exact hp.1) change finite (cG SF w) ∧ real (cG SF w)=_ at hprod have hvalue:real (cG SF w)=(sv w:ڰ)*(2:ڰ)^((zz w:Int)-120):=by rw[hprod.2,hr.2.2,hsf,hp.2.2] have hmant:(fZ w).toNat=z11 w:=by rw[eW];simp only[z11,if_neg he];omega rw[hmant] cases hs:signOf w <;> simp[sv,hs] have hb:=aa w 120 (by intro hh;exact ⟨he,by change 120<150+zz w;omega,by change zz w<120+105;have:=(hm hn).2;omega⟩) apply ak _ _ hprod.1 hb.2.1 · exact hvalue.trans hb.2.2.symm · rw[hvalue] apply mul_ne_zero · have hsv:sv w≠0:=by unfold sv;split <;> simpa using hn exact_mod_cast hsv · exact ne_of_gt (zpow_pos Q25 _) end Submission namespace Submission open ExactRuntime d8 lemma aB (fullN:ڣ) (n:ڲ) (fx fw:(i:ڲ) → i < n → ڭ) (fa fb:ڣ → ڎ) (xm wm:ڜ) (sx sw:ڣ) (hn:fullN < 4096) (hm:n.toNat ≤ fullN) (hsx:sx ≤ 39) (hsw:sw ≤ 7) (hC:sx+wm.toNat+sw ≤ 172) (hx:∀k,k < n.toNat → gk (fa k)=true ∧ (z11 (fa k)≠0 → 2^23 ≤ z11 (fa k) ∧ z11 (fa k) < 2^24 ∧ xm.toNat ≤ zz (fa k) ∧ zz (fa k)-xm.toNat ≤ sx)) (hw:∀k,k < n.toNat → gk (fb k)=true ∧ (z11 (fb k)≠0 → 2^23 ≤ z11 (fb k) ∧ z11 (fb k) < 2^24 ∧ wm.toNat ≤ zz (fb k) ∧ zz (fb k)-wm.toNat ≤ sw)) (hfx:∀(i:ڲ)(h:i < n),fx i h=fk (fa i.toNat) xm) (hfw:∀(i:ڲ)(h:i < n),fw i h=aI (fb i.toNat) 120): let q:=loop n fx fw 0 (zz0 0) let tc:ڣ → ڰ:=fun k=>real (fk (fa k) xm*aI (fb k) 120) finite q ∧ |real q-en 0 tc n.toNat| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-301+2*((fullN+2).log2:Int))/2 ∧ |real q| ≤ ((fullN:ڰ)+2)*(2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250):=by let t:ڣ → ڭ:=fun k=>fk (fa k) xm*aI (fb k) 120 have hxf (k:ڣ) (hk:k < n.toNat):fO (fk (fa k) xm).toModel.unpack ∧ finite (fk (fa k) xm) ∧ real (fk (fa k) xm)=(sv (fa k):ڰ)*2^((zz (fa k):Int)-(xm.toNat:Int)):=by apply cC intro hh obtain ⟨a,b,c,d⟩:=(hx k hk).2 hh exact ⟨a,b,c,by omega⟩ have hwf (k:ڣ) (hk:k < n.toNat):fO (aI (fb k) 120).toModel.unpack ∧ finite (aI (fb k) 120) ∧ real (aI (fb k) 120)=(sv (fb k):ڰ)*2^((zz (fb k):Int)-120):=by apply cB (fb k) wm sw · intro hh obtain ⟨a,b,c,d⟩:=(hw k hk).2 hh exact ⟨a,c,d⟩ · omega have ht:∀k,k < n.toNat → finite (t k) ∧ |real (t k)| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250):=by intro k hk obtain ⟨a,b,c⟩:=hxf k hk obtain ⟨d,e,f⟩:=hwf k hk refine ⟨(ev _ _ a d).1,?_⟩ exact dg _ _ xm wm sx sw _ _ c f a d (fun hh=>⟨((hx k hk).2 hh).2.2.1,((hx k hk).2 hh).2.2.2⟩) (fun hh=>⟨((hw k hk).2 hh).2.2.1,((hw k hk).2 hh).2.2.2⟩) have htEq:∀(i:ڲ)(h:i < n),t i.toNat=fx i h*fw i h:=by intro i h;rw[hfx i h,hfw i h] have hzfin:finite (zz0 0):=(ck (zz0 0) .positive rfl).2.1 have hzreal:real (zz0 0)=0:=(ck (zz0 0) .positive rfl).2.2 obtain ⟨hl,hnl⟩:=bL fullN hn have hnl':n.toNat+2 < 2^((fullN+2).log2+1):=by omega have hcc:(126:Int) ≤ ((178+sx+wm.toNat+sw:ڣ):Int) ∧ ((178+sx+wm.toNat+sw:ڣ):Int) ≤ 350:=by omega obtain ⟨hq,he,hmag⟩:=dR n fx fw (zz0 0) t (fullN+2).log2 ((178+sx+wm.toNat+sw:ڣ):Int) hl hnl' hcc hzfin (by rw[hzreal,abs_zero];positivity) ht htEq rw[hzreal]at he refine ⟨hq,he,?_⟩ exact hmag.trans (mul_le_mul_of_nonneg_right (by exact_mod_cast (show n.toNat+2 ≤ fullN+2 by omega)) Q27) lemma aj (n:ڲ) (fx fw:(i:ڲ) → i < n → ڭ) (fa fb:ڣ → ڎ) (xm wm:ڜ) (sx sw:ڣ) (hn:n.toNat < 4096) (hsx:sx ≤ 39) (hsw:sw ≤ 7) (hC:sx+wm.toNat+sw ≤ 172) (hx:∀k,k < n.toNat → gk (fa k)=true ∧ (z11 (fa k)≠0 → 2^23 ≤ z11 (fa k) ∧ z11 (fa k) < 2^24 ∧ xm.toNat ≤ zz (fa k) ∧ zz (fa k)-xm.toNat ≤ sx)) (hw:∀k,k < n.toNat → gk (fb k)=true ∧ (z11 (fb k)≠0 → 2^23 ≤ z11 (fb k) ∧ z11 (fb k) < 2^24 ∧ wm.toNat ≤ zz (fb k) ∧ zz (fb k)-wm.toNat ≤ sw)) (hfx:∀(i:ڲ)(h:i < n),fx i h=fk (fa i.toNat) xm) (hfw:∀(i:ڲ)(h:i < n),fw i h=aI (fb i.toNat) 120): let q:=loop n fx fw 0 (zz0 0) let tc:ڣ → ڰ:=fun k=>real (fk (fa k) xm*aI (fb k) 120) finite q ∧ |real q-en 0 tc n.toNat| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-301+2*((n.toNat+2).log2:Int))/2 ∧ |real q| ≤ ((n.toNat:ڰ)+2)*(2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250):= aB n.toNat n fx fw fa fb xm wm sx sw hn (Nat.le_refl _) hsx hsw hC hx hw hfx hfw end Submission namespace Submission open ExactRuntime d8 def fE (X:ڟ ڎ) (BX:ڟ ڎ) (n t:ڣ) (P:ڨ):ڨ:= if t>>16) let c:=fk x xm fE X BX n (t+1) (P.push c) else P termination_by X.size-t lemma eU (X BX:ڟ ڎ) (n t:ڣ) (P:ڨ): fE X BX n t P=d8.f7 X.size (fun k=>fk X[k]! (Yk (BX[k/n]!>>>16))) t P:=by rw[fE,d8.f7] split · exact eU X BX n (t+1) _ · rfl termination_by X.size-t lemma cA (X BX:ڟ ڎ) (n:ڣ): (fE X BX n 0 (zz1 X.size)).size=X.size:=by rw[eU] exact d8.dX _ _ lemma df (X BX:ڟ ڎ) (n:ڣ) (k:ڲ) (hk:k.toNat>>16)):=by simpa only[d8.fR,←eU]using d8.eC X.size (fun k=>fk X[k]! (Yk (BX[k/n]!>>>16))) k hk lemma di (X BX:ڟ ڎ) (n i:ڣ) (k nu:ڲ) (hn:0>>16)):=by change _ ≤ 2^System.Platform.numBits at hg have hkn:k.toNatintro i h;rw[f2,dif_neg Q24];simp;intro j hj hjs;omega | succ d ih=> intro i h rw[f2,dif_pos Q24,Bool.and_eq_true,ih (i+1) Q24] rw[←getElem!_pos A i Q24] constructor · rintro ⟨hpi,hs⟩ j hij hj by_cases he:j=i · subst j;exact hpi · exact hs j Q24 hj · intro hh exact ⟨hh i le_rfl Q24,fun j hji hj=>hh j Q24 hj⟩ lemma fA (A:ڟ ڎ) (p:ڎ → ڡ):f2 A p 0=A.all p:=by apply Bool.eq_iff_iff.mpr rw[eO A p A.size 0 Q24,Array.all_eq_true] constructor · intro h i hi;simpa only[getElem!_pos A i hi]using h i Q24 hi · intro h i hi his;simpa only[getElem!_pos A i his]using h i his @[inline] def dH (gr n gp:ڣ) (X W b BX BV:ڟ ڎ):ڡ:= 0bx&&&0xffff!=255 && (1:ڎ) ≤ (bx>>>16) && YU bx ≤ 39) 0 && f2 BV (fun bv=>bv&&&0xffff!=255 && (1:ڎ) ≤ (bv>>>16) && YU bv ≤ 7) 0 && f2 b d8.gk 0 lemma aS (gr n gp:ڣ) (X W b BX BV:ڟ ڎ): dH gr n gp X W b BX BV=true ↔ fC gr n gp X W b BX BV:=by unfold dH simp only[Bool.and_eq_true,decide_eq_true_eq,beq_iff_eq,fA] constructor · rintro ⟨⟨⟨⟨⟨⟨⟨⟨⟨a,b⟩,c⟩,d⟩,e⟩,f⟩,g⟩,h⟩,i⟩,j⟩ exact ⟨a,b,c,d,e,f,g,h,i,j⟩ · intro h exact ⟨⟨⟨⟨⟨⟨⟨⟨⟨h.hn,h.hk⟩,h.hX⟩,h.hW⟩,h.hB⟩,h.hXS⟩,h.hWS⟩,h.hx⟩,h.hw⟩,h.hb⟩ def bf (gr n gp:ڣ) (X W b BX BV:ڟ ڎ):Decidable (fC gr n gp X W b BX BV):= decidable_of_iff (dH gr n gp X W b BX BV=true) (aS gr n gp X W b BX BV) end Submission namespace Submission open ExactRuntime @[specialize] def f3 (A:ڟ ڎ) (f:ڎ → ڣ) (i a:ڣ):ڣ:= if h:i intro i a hd rw[f3,dif_neg Q24] exact ⟨le_rfl,by intro j hj hk;omega⟩ | succ d ih=> intro i a hd rw[f3,dif_pos Q24] obtain ⟨ha,hf⟩:=ih (i+1) (max a (f (A[i]'Q24))) Q24 refine ⟨(le_max_left _ _).trans ha,?_⟩ intro j hij hj by_cases he:j=i · subst j rw[getElem!_pos A i Q24] exact (le_max_right _ _).trans ha · exact hf j Q24 hj @[inline] def fF (BX BV:ڟ ڎ):ڡ:= decide (f3 BX (fun v=>(YU v).toNat) 0 0+f3 BV (fun v=>(Yk (v>>>16)).toNat+(YU v).toNat) 0 0 ≤ 172) lemma dh (gr gp:ڣ) (BX BV:ڟ ڎ) (hxs:BX.size=gr) (hws:BV.size=gp) (h:fF BX BV=true): ∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172:=by unfold fF at h rw[decide_eq_true_eq]at h intro i hi j hj have hx:=(dK BX (fun v=>(YU v).toNat) BX.size 0 0 Q24).2 i Q24 Q24 have hw:=(dK BV (fun v=>(Yk (v>>>16)).toNat+(YU v).toNat) BV.size 0 0 Q24).2 j Q24 Q24 omega end Submission namespace Submission open ExactRuntime d8 lemma z0 (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (i j:ڣ) (hi:i>>16); let wm:=Yk (BV[j]!>>>16) let sx:ڣ:=(YU BX[i]!).toNat; let sw:ڣ:=(YU BV[j]!).toNat finite q ∧ |real q-en 0 (fun k=>real (fk X[i*n+k]! xm*aI W[j*n+k]! 120)) n| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-301+2*((n+2).log2:Int))/2 ∧ |real q| ≤ ((n:ڰ)+2)*(2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250)): cD SF gr n gp X W b BX BV h (f8 b) (e7 b) i j hj gq q= act gq (dotOf (n+1) (fun k=>if kif k>>16) let wm:=Yk (BV[j]!>>>16) let sx:ڣ:=(YU BX[i]!).toNat let sw:ڣ:=(YU BV[j]!).toNat have hbase:(xm+wm).toNat=xm.toNat+wm.toNat:=by rw[UInt64.toNat_add,zz5] have hh:=hcf.2.1 change xm.toNat+wm.toNat ≤ 506 at hh omega have hxrow:=cz gr n gp X W b BX BV h go hBX i have hwrow:=cy gr n gp X W b BX BV h gn hBV j have hC0:sx+wm.toNat+sw ≤ 172:=hC i hi j hj have hsummary:=hq rw[bD] apply aA (fa:=fun k=>X[i*n+k]!) (fb:=fun k=>W[j*n+k]!) (ta:=fun k=>X[i*n+k]!) (tb:=fun k=>W[j*n+k]!) (tc:=fun k=>real (fk X[i*n+k]! xm*aI W[j*n+k]! 120)) (c0:=((178+sx+wm.toNat+sw:ڣ):Int)) · exact h.hk · exact hcf.1 · have ho:=UInt64.le_iff_toNat_le.mp hxm.2.2.2.1 have hm:=hxm.2.2.2.2 change xm.toNat ≤ _ at ho dsimp only[xm] at ho omega · push_cast;have hh:=hcf.2.2.1;change xm.toNat+wm.toNat+sx+sw ≤ _ at hh dsimp only[xm,wm] at hh ⊢ omega · exact dG gr n gp X W b BX BV h j hj · rw[fs b j.toUSize (by rw[(dc gr n gp X W b BX BV h j hj).2];have:=h.hB;omega)] congr 1 change b[j.toUSize.toNat]'(by rw[(dc gr n gp X W b BX BV h j hj).2];have:=h.hB;omega) =b[j]! simp only[(dc gr n gp X W b BX BV h j hj).2,getElem!_pos b j (by have:=h.hB;omega)] · exact hcf.2.2.2 · intro k hk;exact ⟨(hxrow k hi hk).1,(hwrow k hj hk).1⟩ · intro k hk;exact ⟨(hxrow k hi hk).1,(hwrow k hj hk).1⟩ · exact hsummary.1 · exact hsummary.2.1 · exact hsummary.2.2 · intro k hk obtain ⟨hxn,hxf,hxr⟩:=cC X[i*n+k]! xm (by intro hm;obtain ⟨a,b,c,d⟩:=(hxrow k hi hk).2 hm;exact ⟨a,b,c,by have:=hxm.2.2.1;change sx ≤ 39 at this;change zz X[i*n+k]!-xm.toNat ≤ sx at d;omega⟩) obtain ⟨hwn,hwf,hwr⟩:=cB W[j*n+k]! wm sw (by intro hm;obtain ⟨a,b,c,d⟩:=(hwrow k hj hk).2 hm;exact ⟨a,c,d⟩) Q24 exact (bz _ _ xm 120 _ _ hxr hwr hxn hwn (hxrow k hi hk).1 (hwrow k hj hk).1).2 · rfl · unfold b7 apply ai · exact h.hk · intro k hk exact ⟨fU _ (hxrow k hi hk).1,fU _ (hwrow k hj hk).1⟩ · exact fU _ (dG gr n gp X W b BX BV h j hj) · intro k hk hmx hmw rw[hbase] have hx0:=((hxrow k hi hk).2 hmx).2.2.1 have hw0:=((hwrow k hj hk).2 hmw).2.2.1 change xm.toNat ≤ zz X[i*n+k]! at hx0 change wm.toNat ≤ zz W[j*n+k]! at hw0 have hx1:=((hxrow k hi hk).2 hmx).2.2.2 have hw1:=((hwrow k hj hk).2 hmw).2.2.2 change zz X[i*n+k]!-xm.toNat ≤ sx at hx1 change zz W[j*n+k]!-wm.toNat ≤ sw at hw1 have hsx:sx ≤ 39:=hxm.2.2.1 have hsw:sw ≤ 7:=hwm.2.2.1 constructor <;> omega lemma aU (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (i j:ڣ) (gq:ڡ): dM SF gr n gp X W b BX BV h (fE X BX n 0 (zz1 X.size)) (f8 b) (cA X BX n) (e7 b) i j gq= act gq (dotOf (n+1) (fun k=>if kif k>>16) let wm:=Yk (BV[j]!>>>16) let sx:ڣ:=(YU BX[i]!).toNat let sw:ڣ:=(YU BV[j]!).toNat have hbase:(xm+wm).toNat=xm.toNat+wm.toNat:=by rw[UInt64.toNat_add,zz5] have hh:=hcf.2.1 change xm.toNat+wm.toNat ≤ 506 at hh omega have hnu:n.toUSize.toNat=n:=(dF gr n gp X W b BX BV h i hi).2 have hxa:(i*n).toUSize.toNat=i*n:=(dF gr n gp X W b BX BV h i hi).1 have hwa:(j*n).toUSize.toNat=j*n:=(dc gr n gp X W b BX BV h j hj).1 have hsX:=bA gr n gp X W b BX BV h i hi have hsW:=bh gr n gp X W b BX BV h j hj have haX:(i*n).toUSize.toNat+n.toUSize.toNat ≤ (fE X BX n 0 (zz1 X.size)).size:=by rw[hxa,hnu,cA];exact hsX.1 have haW:(j*n).toUSize.toNat+n.toUSize.toNat ≤ W.size:=by rw[hwa,hnu];exact hsW.1 have hgX:(i*n).toUSize.toNat+n.toUSize.toNat ≤ zz3:=by rw[hxa,hnu];have:=USize.le_size;omega have hgW:(j*n).toUSize.toNat+n.toUSize.toNat ≤ zz3:=by rw[hwa,hnu];have:=USize.le_size;omega let fx:=fY (fE X BX n 0 (zz1 X.size)) (i*n).toUSize n.toUSize haX hgX let fw:=f0 SF W (j*n).toUSize n.toUSize wm haW hgW have hfx:∀(k:ڲ)(hk:k>>16)).toNat ≤ _ at hc;change zz W[j*n+k.toNat]!-(Yk (BV[j]!>>>16)).toNat ≤ (YU BV[j]!).toNat at hd;omega⟩ have hxrow:=cz gr n gp X W b BX BV h go hBX i have hwrow:=cy gr n gp X W b BX BV h gn hBV j have hC0:sx+wm.toNat+sw ≤ 172:=hC i hi j hj have hsummary:=aj n.toUSize fx fw (fun k=>X[i*n+k]!) (fun k=>W[j*n+k]!) xm wm sx sw (by rw[hnu];exact h.hk) hxm.2.2.1 hwm.2.2.1 hC0 (by intro k hk;rw[hnu]at hk;exact hxrow k hi hk) (by intro k hk;rw[hnu]at hk;exact hwrow k hj hk) hfx hfw rw[hnu]at hsummary have hloop:=dl SF (fE X BX n 0 (zz1 X.size)) W (i*n).toUSize (j*n).toUSize n.toUSize wm haX hgX haW hgW n 0 (zz0 0) (by rw[hnu];rfl) rw[hloop] exact z0 SF gr n gp X W b BX BV h go hBX gn hBV hC i j hi hj gq _ hsummary · rfl · rfl end Submission namespace Submission open ExactRuntime d8 lemma aBSkip (fullN:ڣ) (n:ڲ) (fx fw:(i:ڲ) → i < n → ڭ) (active:(i:ڲ)→ireal (fk (fa k) xm*aI (fb k) 120) finite q ∧ |real q-en 0 tc n.toNat| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-301+2*((fullN+2).log2:Int))/2 ∧ |real q| ≤ ((fullN:ڰ)+2)*(2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250):=by let t:ڣ → ڭ:=fun k=>fk (fa k) xm*aI (fb k) 120 have hxf (k:ڣ) (hk:k < n.toNat):fO (fk (fa k) xm).toModel.unpack ∧ finite (fk (fa k) xm) ∧ real (fk (fa k) xm)=(sv (fa k):ڰ)*2^((zz (fa k):Int)-(xm.toNat:Int)):=by apply cC intro hh obtain ⟨a,b,c,d⟩:=(hx k hk).2 hh exact ⟨a,b,c,by omega⟩ have hwf (k:ڣ) (hk:k < n.toNat):fO (aI (fb k) 120).toModel.unpack ∧ finite (aI (fb k) 120) ∧ real (aI (fb k) 120)=(sv (fb k):ڰ)*2^((zz (fb k):Int)-120):=by apply cB (fb k) wm sw · intro hh obtain ⟨a,b,c,d⟩:=(hw k hk).2 hh exact ⟨a,c,d⟩ · omega have ht:∀k,k < n.toNat → finite (t k) ∧ |real (t k)| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250):=by intro k hk obtain ⟨a,b,c⟩:=hxf k hk obtain ⟨d,e,f⟩:=hwf k hk refine ⟨(ev _ _ a d).1,?_⟩ exact dg _ _ xm wm sx sw _ _ c f a d (fun hh=>⟨((hx k hk).2 hh).2.2.1,((hx k hk).2 hh).2.2.2⟩) (fun hh=>⟨((hw k hk).2 hh).2.2.1,((hw k hk).2 hh).2.2.2⟩) have htEq:∀(i:ڲ)(h:i < n),t i.toNat=fx i h*fw i h:=by intro i h;rw[hfx i h,hfw i h] have hzfin:finite (zz0 0):=(ck (zz0 0) .positive rfl).2.1 have hzreal:real (zz0 0)=0:=(ck (zz0 0) .positive rfl).2.2 obtain ⟨hl,hnl⟩:=bL fullN hn have hnl':n.toNat+2 < 2^((fullN+2).log2+1):=by omega have hcc:(126:Int) ≤ ((178+sx+wm.toNat+sw:ڣ):Int) ∧ ((178+sx+wm.toNat+sw:ڣ):Int) ≤ 350:=by omega have hact:∀(i:ڲ)(hi:i !(fb k == 0)) (fullN+2).log2 ((178+sx+wm.toNat+sw:ڣ):Int) hl hnl' hcc hzfin (by rw[hzreal,abs_zero];positivity) ht hact htEq hskip rw[hzreal]at he refine ⟨hq,he,?_⟩ exact hmag.trans (mul_le_mul_of_nonneg_right (by exact_mod_cast (show n.toNat+2 ≤ fullN+2 by omega)) Q27) end Submission namespace Submission open ExactRuntime d8 lemma aUSkip (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (i j:ڣ) (hi:i>>16)) (eS gr n gp X W b BX BV h j hj).1 (eS gr n gp X W b BX BV h j hj).2) (fun k hk => !(W.uget ((j*n).toUSize+k) (c8 ((j*n).toUSize) n.toUSize k W.size (eS gr n gp X W b BX BV h j hj).1 (eS gr n gp X W b BX BV h j hj).2 hk) == 0)) 0 (zz0 0))= act gq (dotOf (n+1) (fun k=>if kif k>>16) let wm:=Yk (BV[j]!>>>16) let sx:ڣ:=(YU BX[i]!).toNat let sw:ڣ:=(YU BV[j]!).toNat have hbase:(xm+wm).toNat=xm.toNat+wm.toNat:=by rw[UInt64.toNat_add,zz5] have hh:=hcf.2.1 change xm.toNat+wm.toNat ≤ 506 at hh omega have hnu:n.toUSize.toNat=n:=(dF gr n gp X W b BX BV h i hi).2 have hxa:(i*n).toUSize.toNat=i*n:=(dF gr n gp X W b BX BV h i hi).1 have hwa:(j*n).toUSize.toNat=j*n:=(dc gr n gp X W b BX BV h j hj).1 have hsX:=bA gr n gp X W b BX BV h i hi have hsW:=bh gr n gp X W b BX BV h j hj have haX:(i*n).toUSize.toNat+n.toUSize.toNat ≤ (fE X BX n 0 (zz1 X.size)).size:=by rw[hxa,hnu,cA];exact hsX.1 have haW:(j*n).toUSize.toNat+n.toUSize.toNat ≤ W.size:=by rw[hwa,hnu];exact hsW.1 have hgX:(i*n).toUSize.toNat+n.toUSize.toNat ≤ zz3:=by rw[hxa,hnu];have:=USize.le_size;omega have hgW:(j*n).toUSize.toNat+n.toUSize.toNat ≤ zz3:=by rw[hwa,hnu];have:=USize.le_size;omega let fx:=fY (fE X BX n 0 (zz1 X.size)) (i*n).toUSize n.toUSize haX hgX let fw:=f0 SF W (j*n).toUSize n.toUSize wm haW hgW have hfx:∀(k:ڲ)(hk:k>>16)).toNat ≤ _ at hc;change zz W[j*n+k.toNat]!-(Yk (BV[j]!>>>16)).toNat ≤ (YU BV[j]!).toNat at hd;omega⟩ have hxrow:=cz gr n gp X W b BX BV h go hBX i have hwrow:=cy gr n gp X W b BX BV h gn hBV j have hC0:sx+wm.toNat+sw ≤ 172:=hC i hi j hj let active:(k:ڲ)→k !(W.uget ((j*n).toUSize+k) (c8 ((j*n).toUSize) n.toUSize k W.size haW hgW hk) == 0) have hactive:∀(k:ڲ)(hk:kX[i*n+k]!) (fun k=>W[j*n+k]!) xm wm sx sw h.hk (by rw[hnu]) hxm.2.2.1 hwm.2.2.1 hC0 (by intro k hk;rw[hnu] at hk;exact (hxrow k hi hk)) (by intro k hk;rw[hnu] at hk;exact (hwrow k hj hk)) hfx hfw hactive rw[hnu] at hsummary exact z0 SF gr n gp X W b BX BV h go hBX gn hBV hC i j hi hj gq _ hsummary end Submission namespace Submission open ExactRuntime d8 lemma dnSpec (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (ch j:ڣ) (hch:ch+7if kif kif kif kif kif kif kif kif kif kif kif kif kif kif kif k try rfl rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+0) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+1) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+2) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+3) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+4) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+5) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+6) j Q24 hj gq] rw[aUSkip SF gr n gp X W b BX BV h go hBX gn hBV hC (ch+7) j Q24 hj gq] end Submission namespace Submission open ExactRuntime d8 lemma dmSkip (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (ch j:ڣ) (hch:ch+7>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (I:ڟ ڎ) (hIs:I.size ≤ n) (hIb:∀k,kdecide (z11 X[k]!≠0))).map Nat.toUInt32) (j:ڣ) (gq:ڡ): bk SF n gp X W b BX BV h I hIs hIb (fE X BX n 0 (zz1 X.size)) (f8 b) (cA X BX n) (e7 b) j gq= act gq (dotOf (n+1) (fun k=>if kif k>>16) let wm:=Yk (BV[j]!>>>16) let sx:ڣ:=(YU BX[0]!).toNat let sw:ڣ:=(YU BV[j]!).toNat have hbase:(xm+wm).toNat=xm.toNat+wm.toNat:=by rw[UInt64.toNat_add,zz5] have hh:=hcf.2.1 change xm.toNat+wm.toNat ≤ 506 at hh omega have hnu:n.toUSize.toNat=n:=(dF 1 n gp X W b BX BV h 0 Q24).2 have hm:I.size.toUSize.toNat=I.size:=c7 n I.size h.hk hIs let idx:=cv I I.size.toUSize hm have hidx:∀(k:ڲ)(hk:kfY (fE X BX n 0 (zz1 X.size)) 0 n.toUSize haX hgX (idx k hk) (hidx k hk) let fw:=fun (k:ڲ)(hk:kf0 SF W (j*n).toUSize n.toUSize wm haW hgW (idx k hk) (hidx k hk) have hxrow (k:ڣ) (hk:kfk X[k]! xm*aI W[j*n+k]! 120 let tcomp:ڣ → ڭ:=fun k=>term I[k]!.toNat let tc:ڣ → ڰ:=fun k=>real (term k) have hfx:∀(k:ڲ)(hk:kX[I[k]!.toNat]!) (fun k=>W[j*n+I[k]!.toNat]!) xm wm sx sw (by have hnFull:n<4096:=h.hk;omega) (by rw[hm]) hxm.2.2.1 hwm.2.2.1 hC0 (by intro k hk;rw[hm]at hk;exact hxrow _ (hIb k hk)) (by intro k hk;rw[hm]at hk;exact hwrow _ hj (hIb k hk)) hfx hfw have hprefix:en 0 (fun k=>real (tcomp k)) I.size.toUSize.toNat=en 0 tc n:=by rw[hm] apply bc n (fun k=>decide (z11 X[k]!≠0)) tc I (by have:=h.hk;omega) hI intro k hk hp have hz:z11 X[k]! = 0:=by simpa only[decide_eq_false_iff_not,not_not]using hp exact bg _ xm _ _ (hxc k hk).2.2 (hxc k hk).1 (hwc k hk).1 hz have hloop:=aX SF (fE X BX n 0 (zz1 X.size)) W 0 (j*n).toUSize n.toUSize I.size.toUSize wm idx hidx haX hgX haW hgW I.size 0 (zz0 0) (by rw[hm];rfl) rw[hloop,bD (ne:=I.size)] change finite (loop I.size.toUSize fx fw 0 (zz0 0)) ∧ |real (loop I.size.toUSize fx fw 0 (zz0 0))-en 0 (fun k=>real (tcomp k)) I.size.toUSize.toNat| ≤ (2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-301+2*((I.size+2).log2:Int))/2 ∧ |real (loop I.size.toUSize fx fw 0 (zz0 0))| ≤ ((I.size:ڰ)+2)*(2:ڰ)^(((178+sx+wm.toNat+sw:ڣ):Int)-250) at hsummary rw[hm] at hsummary apply aA (n:=I.size) (N:=n) (fa:=fun k=>X[I[k]!.toNat]!) (fb:=fun k=>W[j*n+I[k]!.toNat]!) (ta:=fun k=>X[k]!) (tb:=fun k=>W[j*n+k]!) (tc:=fun k=>real (tcomp k)) (c0:=((178+sx+wm.toNat+sw:ڣ):Int)) · have hnFull:n<4096:=h.hk;omega · exact hcf.1 · have ho:=UInt64.le_iff_toNat_le.mp hxm.2.2.2.1 have hm:=hxm.2.2.2.2 change xm.toNat ≤ _ at ho dsimp only[xm] at ho omega · push_cast;have hh:=hcf.2.2.1;change xm.toNat+wm.toNat+sx+sw ≤ _ at hh dsimp only[xm,wm] at hh ⊢ omega · exact dG 1 n gp X W b BX BV h j hj · rw[fs b j.toUSize (by rw[(dc 1 n gp X W b BX BV h j hj).2];have:=h.hB;omega)] congr 1 change b[j.toUSize.toNat]'(by rw[(dc 1 n gp X W b BX BV h j hj).2];have:=h.hB;omega)=b[j]! simp only[(dc 1 n gp X W b BX BV h j hj).2,getElem!_pos b j (by have:=h.hB;omega)] · exact hcf.2.2.2 · intro k hk have hk0:I[k]!.toNatreal (tcomp k)) I.size=en 0 tc n:=by simpa only[hm] using hprefix have hsc:∀k,kreal (convert X[I[k]!.toNat]!*convert W[j*n+I[k]!.toNat]!)) I.size = en 0 (fun k=>real (tcomp k)) I.size*(2:ڰ)^((xm.toNat+120:Int)-298)+real (convert b[j]!) := (aQ _ _ _ _ _ hsc).symm _ = en 0 tc n*(2:ڰ)^((xm.toNat+120:Int)-298)+real (convert b[j]!) := by rw[hcEq] _ = en (real (convert b[j]!)) (fun k=>real (convert X[k]!*convert W[j*n+k]!)) n := aQ _ _ _ _ _ hsf · unfold b7 simp only[Nat.zero_mul,Nat.zero_add] apply ai · exact h.hk · intro k hk exact ⟨fU _ (hxrow k hk).1,fU _ (hwrow k hj hk).1⟩ · exact fU _ (dG 1 n gp X W b BX BV h j hj) · intro k hk hmx hmw rw[hbase] have hx0:=((hxrow k hk).2 hmx).2.2.1 have hw0:=((hwrow k hj hk).2 hmw).2.2.1 change xm.toNat ≤ zz X[k]! at hx0 change wm.toNat ≤ zz W[j*n+k]! at hw0 have hx1:=((hxrow k hk).2 hmx).2.2.2 have hw1:=((hwrow k hj hk).2 hmw).2.2.2 change zz X[k]!-xm.toNat ≤ sx at hx1 change zz W[j*n+k]!-wm.toNat ≤ sw at hw1 have hsx:sx ≤ 39:=hxm.2.2.1 have hsw:sw ≤ 7:=hwm.2.2.1 constructor <;> omega · rfl end Submission namespace Submission open ExactRuntime d8 @[noinline] def eV (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (gq:ڡ):ڟ ڎ:= let I:=db n (fun k=>X[k]!) 0 (Array.emptyWithCapacity n) have hIs:I.size ≤ n:=b8 n (fun k=>X[k]!) have hIb:∀k,k < I.size → I[k]!.toNat < n:=aT n (fun k=>X[k]!) (by have:=h.hk;omega) if 4*I.size ≤ 3*n then let F:=bk SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF let F:=fun j=>F j gq du gp F (fun j=>if hj:j+7 < gp then aW SF n gp X W b BX BV h I hIs hIb XF BF hXF hBF j hj gq else ((F (j+0)),(F (j+1)),(F (j+2)),(F (j+3)),(F (j+4)),(F (j+5)),(F (j+6)),(F (j+7)))) 0 #[] else let F:=fun j=>dM SF 1 n gp X W b BX BV h XF BF hXF hBF 0 j gq du gp F (fun j=>if hj:j+7 < gp then bF SF n gp X W b BX BV h XF BF hXF hBF j hj gq else ((F (j+0)),(F (j+1)),(F (j+2)),(F (j+3)),(F (j+4)),(F (j+5)),(F (j+6)),(F (j+7)))) 0 #[] lemma bE (SF:fI) (n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC 1 n gp X W b BX BV) (go:BX.size=1) (hBX:∀i,i < 1 → BX[i]! = Yc X n i) (gn:BV.size=gp) (hBV:∀j,j < gp → BV[j]! = Yc W n j) (hC:∀i,i<1 → ∀j,j>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (gq:ڡ): eV SF n gp X W b BX BV h (fE X BX n 0 (zz1 X.size)) (f8 b) (cA X BX n) (e7 b) gq= fq gp (fun j=>act gq (dotOf (n+1) (fun k=>if k < n then X[k]! else oneW) (fun k=>if k < n then W[j*n+k]! else b[j]!))) 0 #[]:=by unfold eV dsimp only split · rw[aK _ _ _ (by intro j hj rw[dif_pos hj,ar SF] simp only[Nat.add_zero]) gp 0 #[] Q24] congr 1 funext j apply ae SF n gp X W b BX BV h go hBX gn hBV hC exact bi n (fun k=>X[k]!) · rw[aK _ _ _ (by intro j hj rw[dif_pos hj,aV SF] simp only[Nat.add_zero]) gp 0 #[] Q24] congr 1 funext j simpa only[Nat.zero_mul,Nat.zero_add]using aU SF 1 n gp X W b BX BV h go hBX gn hBV hC 0 j gq end Submission namespace Submission open ExactRuntime d8 @[noinline] def dk (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (XF BF:ڨ) (hXF:XF.size=X.size) (hBF:BF.size=b.size) (gq:ڡ):ڟ ڎ:= let F:=fun i j=>dM SF gr n gp X W b BX BV h XF BF hXF hBF i j gq let T4:=fun ch j=>(F ch j,F (ch+1) j,F (ch+2) j,F (ch+3) j) let T8:=fun ch j=>ge SF gr n gp X W b BX BV h XF BF hXF hBF ch j gq eB gr gp F T8 T4 0 #[] lemma aCSkip (SF:fI) (gr n gp:ڣ) (X W b BX BV:ڟ ڎ) (h:fC gr n gp X W b BX BV) (go:BX.size=gr) (hBX:∀i,i>>16)).toNat+(YU BV[j]!).toNat ≤ 172) (gq:ڡ): dk SF gr n gp X W b BX BV h (fE X BX n 0 (zz1 X.size)) (f8 b) (cA X BX n) (e7 b) gq=linearSpec gr n gp gq X W b:=by unfold dk dsimp only rw[bs gr gp _ _ _ ?_ ?_ gr 0 #[] rfl] · rw[cn] unfold linearSpec linearWith congr 1 funext q exact aU SF gr n gp X W b BX BV h go hBX gn hBV hC _ _ gq · intro ch j hc hj unfold ge rw[dif_pos hc,dif_pos hj,dmSkip SF gr n gp X W b BX BV h go hBX gn hBV hC ch j hc hj gq] · intro ch j hc hj;rfl lemma dL (SF:fI) (n gp:ڣ) (X W b:ڟ ڎ) (gq:ڡ): fq gp (fun j=>act gq (dotOf (n+1) (fun k=>if kif k simp intro i hi simp[Nat.div_eq_of_lt hi,zz5 hi] local instance d66RuntimeReady (gr n gp:ڣ) (X W b BX BV:ڟ ڎ): Decidable (fC gr n gp X W b BX BV):= bf gr n gp X W b BX BV @[noinline] def fl (gr n gp:ڣ) (gq:ڡ) (X W b:ڟ ڎ):ڟ ڎ:= let SF:=dO let BX:=zz2 (n:=gr) (fun i=>Yc X n i.val) let BV:=zz2 (n:=gp) (fun j=>Yc W n j.val) if h:fC gr n gp X W b BX BV then if hR:fF BX BV then let XF:=fE X BX n 0 (zz1 X.size) let BF:=f8 b if hr:gr=1 then eV SF n gp X W b BX BV (by rw[←hr];exact h) XF BF (cA X BX n) (e7 b) gq else dk SF gr n gp X W b BX BV h XF BF (cA X BX n) (e7 b) gq else linearSpec gr n gp gq X W b else linearSpec gr n gp gq X W b lemma bQ:fl=linearSpec:=by funext gr n gp gq X W b let SF:=dO unfold fl dsimp only split · rename_i h split · rename_i hR have hC:=dh gr gp _ _ Q29 Q29 hR split · rename_i hr subst gr rw[bE SF n gp X W b _ _ _ Q29 (fun i hi=>Ze 1 (Yc X n) i hi) Q29 (fun j hj=>by simp[hj]) hC gq] exact dL SF n gp X W b gq · exact aCSkip SF gr n gp X W b _ _ h Q29 (fun i hi=>by simp[hi]) Q29 (fun j hj=>by simp[hj]) hC gq · rfl · rfl end Submission namespace Submission def kernels:Kernels where core:=specKernels.core dense:=⟨fl,specKernels.dense.gemm⟩ conv:=specKernels.conv elem:=specKernels.elem norm:=specKernels.norm theorem correct:Obligation kernels:=by simp only[Obligation,kernels,specKernels,specDense,specConv,specElem,specNorm,bQ] end Submission