introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
9.71 kB
import OAI.MathematicalPhysics.AlternatingFlow.Detector
import OAI.MathematicalPhysics.AlternatingFlow.MachineProfiles
namespace OAI
open scoped BigOperators ENNReal NNReal Topology ContDiff
open MeasureTheory
namespace AlternatingNS
namespace LocalRule
noncomputable def readC (M : Machine) (N n : β„•) (D : ℝ) : ℝ :=
Profiles.decoder M.base ((M.base : ℝ) ^ Scales.s N n * D)
noncomputable def readB (M : Machine) (N n : β„•) (D : ℝ) : ℝ :=
Profiles.decoder M.base ((M.base : ℝ) ^ (Scales.s N n + 1 + Scales.K N n) * D)
noncomputable def readA (M : Machine) (N n : β„•) (D : ℝ) : ℝ :=
Profiles.decoder M.base ((M.base : ℝ) ^ (Scales.s N n + 1) * D) -
((M.base : ℝ) ^ Scales.K N n)⁻¹ * readB M N n D
noncomputable def updateLeft (b _a l : β„•) (r : Rule) (A _B : ℝ) : ℝ :=
letI := neZeroThree
letI := twoAtLeastTwo
if r.2.2 = 0 then (b : ℝ) * A - 2 * l
else if r.2.2 = 1 then A else ((2 * r.2.1 : β„•) + A) / b
noncomputable def updateRight (b a l : β„•) (r : Rule) (_A B : ℝ) : ℝ :=
letI := neZeroThree
letI := twoAtLeastTwo
let R := (b : ℝ) * B - 2 * a
if r.2.2 = 0 then ((2 * l : β„•) + ((2 * r.2.1 : β„•) + R) / b) / b
else if r.2.2 = 1 then ((2 * r.2.1 : β„•) + R) / b else R
noncomputable def branchNumerator (b K a l : β„•) (r : Rule) (A B : ℝ) : ℝ :=
(2 * r.1 : β„•) + updateLeft b a l r A B +
((b : ℝ) ^ K)⁻¹ * updateRight b a l r A B
noncomputable def branch (M : Machine) (N n q a : β„•) (A B : ℝ) : ℝ :=
letI := neZeroThree
let r := M.command q a
if r.2.2 = 0 then βˆ‘ l ∈ Finset.range M.alphabet,
Profiles.selector M.base l A * branchNumerator M.base (Scales.K N (n + 1)) a l r A B
else branchNumerator M.base (Scales.K N (n + 1)) a 0 r A B
noncomputable def write (M : Machine) (N n : β„•) (D : ℝ) : ℝ :=
Scales.Ξ΅ M.base N (n + 1) / M.base *
βˆ‘ q ∈ Finset.range (M.states + 1), βˆ‘ a ∈ Finset.range M.alphabet,
Profiles.selector M.base q (readC M N n D) *
Profiles.selector M.base a (readB M N n D) *
branch M N n q a (readA M N n D) (readB M N n D)
noncomputable def haltWeight (M : Machine) (N n : β„•) (D : ℝ) : ℝ :=
βˆ‘ q ∈ Finset.range (M.states + 1),
if q = M.states ∨ q ∈ M.haltingStates then Profiles.selector M.base q (readC M N n D) else 0
noncomputable def signal (M : Machine) (N n : β„•) (D : ℝ) : ℝ :=
letI := twoAtLeastTwo
Scales.Ξ΅ M.base N n - Scales.Ξ΅ M.base N (n + 1) +
2 * Scales.Ξ΅ M.base N (n + 1) * haltWeight M N n D
lemma readC_smooth (M : Machine) (N n : β„•) : ContDiff ℝ ∞ (readC M N n) := by
exact (Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega)).comp
(contDiff_const.mul contDiff_id)
lemma readB_smooth (M : Machine) (N n : β„•) : ContDiff ℝ ∞ (readB M N n) := by
exact (Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega)).comp
(contDiff_const.mul contDiff_id)
lemma readA_smooth (M : Machine) (N n : β„•) : ContDiff ℝ ∞ (readA M N n) := by
exact ((Profiles.decoder_smooth M.base (by have := M.base_ge_four; omega)).comp
(contDiff_const.mul contDiff_id)).sub (contDiff_const.mul (readB_smooth M N n))
lemma branchNumerator_smooth (b K a l : β„•) (r : Rule) (A B : ℝ β†’ ℝ)
(hA : ContDiff ℝ ∞ A) (hB : ContDiff ℝ ∞ B) :
ContDiff ℝ ∞ (fun D => branchNumerator b K a l r (A D) (B D)) := by
unfold branchNumerator updateLeft updateRight
split_ifs <;> fun_prop
lemma branch_smooth (M : Machine) (N n q a : β„•) (A B : ℝ β†’ ℝ)
(hA : ContDiff ℝ ∞ A) (hB : ContDiff ℝ ∞ B) :
ContDiff ℝ ∞ (fun D => branch M N n q a (A D) (B D)) := by
unfold branch
dsimp only
split_ifs
Β· apply ContDiff.sum
intro l _
exact ((Profiles.selector_smooth M.base l).comp hA).mul
(branchNumerator_smooth _ _ _ _ _ _ _ hA hB)
Β· exact branchNumerator_smooth _ _ _ _ _ _ _ hA hB
lemma write_smooth (M : Machine) (N n : β„•) : ContDiff ℝ ∞ (write M N n) := by
unfold write
apply ContDiff.mul contDiff_const
apply ContDiff.sum
intro q _
apply ContDiff.sum
intro a _
exact (((Profiles.selector_smooth M.base q).comp (readC_smooth M N n)).mul
((Profiles.selector_smooth M.base a).comp (readB_smooth M N n))).mul
(branch_smooth M N n q a _ _ (readA_smooth M N n) (readB_smooth M N n))
lemma haltWeight_smooth (M : Machine) (N n : β„•) : ContDiff ℝ ∞ (haltWeight M N n) := by
unfold haltWeight
apply ContDiff.sum
intro q _
split_ifs
Β· exact (Profiles.selector_smooth M.base q).comp (readC_smooth M N n)
Β· exact contDiff_const
lemma signal_smooth (M : Machine) (N n : β„•) : ContDiff ℝ ∞ (signal M N n) := by
exact contDiff_const.add (contDiff_const.mul (haltWeight_smooth M N n))
lemma readC_run (M : Machine) (hM : M.WellFormed) (w : List β„•) (hw : M.ValidInput w) (n : β„•) :
readC M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
M.recordedBlock w n := (M.read_run hM w hw n).1
lemma readB_run (M : Machine) (hM : M.WellFormed) (w : List β„•) (hw : M.ValidInput w) (n : β„•) :
readB M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
Machine.rightCode M.base w.length n (M.run w n) := (M.read_run hM w hw n).2.1
lemma readA_run (M : Machine) (hM : M.WellFormed) (w : List β„•) (hw : M.ValidInput w) (n : β„•) :
readA M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
Machine.leftCode M.base w.length n (M.run w n) := (M.read_run hM w hw n).2.2
end LocalRule
end AlternatingNS
namespace AlternatingNS
namespace LocalRule
lemma branchNumerator_execute (b N n : β„•) (hb : 0 < b) (c : Machine.Configuration)
(hc : Machine.Window N n c) (r : Rule) :
branchNumerator b (Scales.K N (n + 1)) (c.tape c.head) (c.tape (c.head - 1)) r
(Machine.leftCode b N n c) (Machine.rightCode b N n c) =
(2 * r.1 : β„•) + Machine.leftCode b N (n + 1) (Machine.execute c r) +
((b : ℝ) ^ Scales.K N (n + 1))⁻¹ * Machine.rightCode b N (n + 1) (Machine.execute c r) := by
by_cases hβ‚€ : r.2.2 = 0
Β· obtain ⟨hL, hR⟩ := Machine.code_execute_left b N n hb c hc r hβ‚€
rw [hL, hR]
simp [branchNumerator, updateLeft, updateRight, hβ‚€, Machine.leftDigits, Machine.rightDigits]
Β· by_cases h₁ : r.2.2 = 1
Β· obtain ⟨hL, hR⟩ := Machine.code_execute_stay b N n hb c hc r h₁
rw [hL, hR]
simp [branchNumerator, updateLeft, updateRight, h₁, Machine.rightDigits]
Β· have hβ‚‚ : r.2.2 = 2 := by omega
obtain ⟨hL, hR⟩ := Machine.code_execute_right b N n hb c hc r hβ‚‚
rw [hL, hR]
simp [branchNumerator, updateLeft, updateRight, hβ‚€, h₁, Machine.rightDigits]
lemma branch_on_configuration (M : Machine) (N n : β„•) (c : Machine.Configuration)
(ha : M.Admissible c) (hw : Machine.Window N n c) :
branch M N n c.state (c.tape c.head)
(Machine.leftCode M.base N n c) (Machine.rightCode M.base N n c) =
(2 * (M.step c).state : β„•) + Machine.leftCode M.base N (n + 1) (M.step c) +
((M.base : ℝ) ^ Scales.K N (n + 1))⁻¹ * Machine.rightCode M.base N (n + 1) (M.step c) := by
have hb : 0 < M.base := by have := M.base_ge_four; omega
have hnum := branchNumerator_execute M.base N n hb c hw (M.command c.state (c.tape c.head))
rw [Machine.step_execute]
unfold branch
dsimp only
split_ifs with hβ‚€
Β· rw [Finset.sum_eq_single_of_mem (c.tape (c.head - 1)) (Finset.mem_range.2 (ha.2 _))]
Β· rw [Machine.selector_leftCode M c ha N n, ite_eq_left rfl, one_mul]
exact hnum
Β· intro l _ hl
simp [Machine.selector_leftCode M c ha N n l, hl]
Β· simpa only [branchNumerator, updateLeft, updateRight, hβ‚€, ite_false, Machine.execute] using hnum
lemma write_run (M : Machine) (hM : M.WellFormed) (w : List β„•) (hw : M.ValidInput w) (n : β„•) :
write M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
Scales.Ξ΅ M.base w.length (n + 1) * M.recordedBlock w (n + 1) := by
have hc := M.run_admissible hM w hw n
have hq : (M.run w n).state ∈ Finset.range (M.states + 1) :=
Finset.mem_range.2 (Nat.lt_succ_of_le hc.1)
have ha : (M.run w n).tape (M.run w n).head ∈ Finset.range M.alphabet :=
Finset.mem_range.2 (hc.2 _)
unfold write
rw [readC_run M hM w hw n, readB_run M hM w hw n, readA_run M hM w hw n]
simp only [Machine.selector_recordedBlock M hM w hw n,
Machine.selector_rightCode M (M.run w n) hc w.length n,
ite_mul, one_mul, zero_mul, Finset.sum_ite_irrel, Finset.sum_const_zero,
Finset.sum_ite_eq', ite_eq_left hq, ite_eq_left ha]
rw [branch_on_configuration M w.length n (M.run w n) hc (M.run_window w n)]
rw [Machine.recordedBlock_formula, Machine.run_succ]
ring
lemma haltWeight_run (M : Machine) (hM : M.WellFormed) (w : List β„•) (hw : M.ValidInput w) (n : β„•) :
haltWeight M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
if M.isHalting (M.run w n) then 1 else 0 := by
have hc := (M.run_admissible hM w hw n).1
unfold haltWeight
rw [readC_run M hM w hw n,
Finset.sum_eq_single_of_mem (M.run w n).state (Finset.mem_range.2 (by omega))]
Β· simp [Machine.selector_recordedBlock M hM w hw n, Machine.isHalting]
Β· intro q _ hq
simp [Machine.selector_recordedBlock M hM w hw n q, hq]
lemma signal_run (M : Machine) (hM : M.WellFormed) (w : List β„•) (hw : M.ValidInput w) (n : β„•) :
signal M w.length n (Encoding.donor M.base w.length (M.recordedBlock w) n) =
Detector.increment M.base w.length (fun j => M.isHalting (M.run w j)) n := by
rw [signal, haltWeight_run M hM w hw n]
simp only [Detector.increment, mul_ite, mul_one, mul_zero]
end LocalRule
end AlternatingNS
end OAI