| import OAI.MathematicalPhysics.AlternatingFlow.ProfileNames |
| import OAI.MathematicalPhysics.AlternatingFlow.DecoderBounds |
|
|
| namespace OAI |
|
|
| section DecoderNamesDevelopment |
|
|
| open scoped BigOperators Topology ContDiff |
| open Filter |
|
|
| namespace AlternatingNS.Effective |
| attribute [local instance] Arithmetic.rationalCoding |
|
|
| lemma decoderBound : Primrec₂ Quantitative.decoderBound := |
| Primrec.nat_add.comp (Primrec.const 1) |
| (Primrec.nat_mul.comp |
| (nat_pow.comp (Primrec.nat_mul.comp (Primrec.const 3) |
| (Primrec.nat_sub.comp Primrec.fst (Primrec.const 1))) Primrec.snd) |
| (transitionBound.comp Primrec.snd)) |
|
|
| lemma rat_fract : Primrec (fun q : ℚ => Int.fract q) := |
| Arithmetic.rat_sub.comp Primrec.id (Arithmetic.rat_intCast.comp Arithmetic.rat_floor) |
|
|
| lemma frac_cast (q : ℚ) : ((Int.fract q : ℚ) : ℝ) = Int.fract (q : ℝ) := by |
| simp only [Int.fract, Rat.cast_sub, Rat.cast_intCast, Rat.floor_cast] |
|
|
| lemma periodizer_named : Named (fun z : (ℚ × ℚ) × ℚ => Profiles.periodizer z.1.1 z.1.2 z.2) := by |
| have hv : Computable (fun z : (ℚ × ℚ) × ℚ => Int.fract z.2) := rat_fract.to_comp.comp Computable.snd |
| have hA : Computable (fun z : (ℚ × ℚ) × ℚ => (Int.fract z.2 - z.1.1)/(z.1.2-z.1.1)) := |
| Arithmetic.rat_div.to_comp.comp |
| (Arithmetic.rat_sub.to_comp.comp hv (Computable.fst.comp Computable.fst)) |
| (Arithmetic.rat_sub.to_comp.comp (Computable.snd.comp Computable.fst) |
| (Computable.fst.comp Computable.fst)) |
| exact ((Named.rational hv).sub (transition_named.comp hA)).congr (by |
| intro z |
| simp only [Function.comp_def, Profiles.periodizer, Rat.cast_div, Rat.cast_sub] |
| rw [frac_cast]) |
|
|
| lemma decoder_named : Named (fun z : ℕ × ℚ => Profiles.decoder z.1 (z.2 : ℝ)) := by |
| let m (b : ℕ) : ℚ := ((b : ℚ)-2)/((b : ℚ)-1) |
| have hm : Computable m := Arithmetic.rat_div.to_comp.comp |
| (Arithmetic.rat_sub.to_comp.comp Arithmetic.rat_natCast.to_comp (Computable.const 2)) |
| (Arithmetic.rat_sub.to_comp.comp Arithmetic.rat_natCast.to_comp (Computable.const 1)) |
| have ha : Computable (fun z : ℕ × ℚ => (2*m z.1+1)/3) := Arithmetic.rat_div.to_comp.comp |
| (Arithmetic.rat_add.to_comp.comp |
| (Arithmetic.rat_mul.to_comp.comp (Computable.const 2) (hm.comp Computable.fst)) |
| (Computable.const 1)) (Computable.const 3) |
| have hc : Computable (fun z : ℕ × ℚ => (m z.1+2)/3) := Arithmetic.rat_div.to_comp.comp |
| (Arithmetic.rat_add.to_comp.comp (hm.comp Computable.fst) (Computable.const 2)) (Computable.const 3) |
| exact (periodizer_named.comp ((ha.pair hc).pair Computable.snd)).congr (by |
| intro z; simp [Profiles.decoder, Encoding.tailMax, m]) |
|
|
| lemma Named.decoder {A : Type*} [Primcodable A] (b : A → ℕ) (hb : Computable b) |
| (hbase : ∀ x, 2 ≤ b x) {f : A → ℝ} (hf : Named f) : |
| Named (fun x => Profiles.decoder (b x) (f x)) := by |
| let L (x : A) : ℚ := Quantitative.decoderBound (b x) 1 |
| have hL : Computable L := Arithmetic.rat_natCast.to_comp.comp |
| (decoderBound.to_comp.comp hb (Computable.const 1)) |
| have hg : Named (fun z : A × ℚ => Profiles.decoder (b z.1) (z.2 : ℝ)) := |
| Named.comp (g := fun z : A × ℚ => (b z.1, z.2)) decoder_named |
| ((hb.comp Computable.fst).pair Computable.snd) |
| have hlip (a : A) (x y : ℝ) : |Profiles.decoder (b a) x - Profiles.decoder (b a) y| ≤ |
| (L a : ℝ) * |x-y| := by |
| simpa only [L, Rat.cast_natCast] using jet_one_lipschitz (Profiles.decoder_smooth _ (hbase a)) |
| (Quantitative.decoderBound (b a) 1) (Quantitative.decoder_jet_bound (b a) (hbase a) 1) x y |
| exact Named.apply_lipschitz (fun x => Profiles.decoder (b x)) L hL |
| (fun _ => Nat.cast_nonneg _) hlip hg hf |
|
|
| end AlternatingNS.Effective |
|
|
| end DecoderNamesDevelopment |
|
|
| end OAI |
|
|
