Datasets:

roseking
/

openAI-math-dataset

import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.NormalizedBranchTrace
import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.PlanarClockMargins

namespace OAI

/-! Clock and observation margins for the entire filled branch trajectory. -/

noncomputable section
namespace ForcedComputation.Recorder.Planar
open ShearFlows PlanarHamiltonian PlanarRouting Set

/-- The parking rectangles have room for the rational initial translation. -/
theorem shifted_parking_bounds {n : ℕ} {κ : ℚ} (hκ : 0 ≤ κ) (hκ' : κ ≤ 1 / 64)
    (i : Fin n) (δ : Fin 2 → ℚ)
    (hδ₀ : |(δ 0 : ℝ)| ≤ 1 / 512) (hδ₁ : |(δ 1 : ℝ)| ≤ 3 / 1024)
    {x : Plane} (hx : x ∈ (parkingBox n κ i).carrier) :
    translatedPoint δ x ∈ clockRectangle.carrier ∧ 3 / 16 ≤ translatedPoint δ x 1 := by
  have hb := parkingBox_bounds hκ hκ' i hx
  have hs : (parkingScale n : ℝ) ≤ 1 / 64 := by
    have hh := (Rat.cast_le (K := ℝ)).mpr (parkingScale_le n)
    norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] at hh
    exact hh
  have hk : (0 : ℝ) ≤ κ := by exact_mod_cast hκ
  have hk' : (κ : ℝ) ≤ 1 / 64 := by
    have hh := (Rat.cast_le (K := ℝ)).mpr hκ'
    norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] at hh
    exact hh
  have hc : (parkingCenter n i 0 : ℝ) < 3 / 4 := by
    have hh := (Rat.cast_lt (K := ℝ)).mpr (parkingCenter_bounds n i).2
    norm_num only [Rat.cast_div, Rat.cast_ofNat] at hh
    exact hh
  have hxu := (hx 0).2
  change x 0 ≤ ((parkingCenter n i 0 + parkingScale n * κ : ℚ) : ℝ) at hxu
  push_cast at hxu
  have hm := mul_le_mul hs hk' hk (by norm_num : (0 : ℝ) ≤ 1 / 64)
  obtain ⟨hd₀, hd₀'⟩ := abs_le.mp hδ₀
  obtain ⟨hd₁, hd₁'⟩ := abs_le.mp hδ₁
  constructor
  · intro j
    fin_cases j
    · change ((1 / 8 : ℚ) : ℝ) ≤ x 0 + (δ 0 : ℝ) ∧
        x 0 + (δ 0 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
      norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
      constructor <;> linarith [hb.1]
    · change ((1 / 32 : ℚ) : ℝ) ≤ x 1 + (δ 1 : ℝ) ∧
        x 1 + (δ 1 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
      norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
      constructor <;> linarith [hb.2.2.1, hb.2.2.2]
  · change 3 / 16 ≤ x 1 + (δ 1 : ℝ)
    linarith [hb.2.2.1]

theorem horizontalPoint_vertical (R : RationalBox 2) (p : Fin 2 → ℚ) (x : Plane) :
    horizontalPoint R p x 1 = x 1 := by
  simp [horizontalPoint, horizontalCenter]

theorem shifted_horizontalPoint_clock (M : Alternating.Machine) (hM : M.WellFormed)
    (b : Branch (finiteMachine M hM)) (R : RationalBox 2)
    (hwidth : R.halfWidth 0 ≤ 1 / 128)
    (δ : Fin 2 → ℚ) (hδ₀ : |(δ 0 : ℝ)| ≤ 1 / 512)
    (hδ₁ : |(δ 1 : ℝ)| ≤ 3 / 1024)
    {x : Plane} (hx : x ∈ R.carrier)
    (hy : (5 / 128 : ℝ) ≤ x 1 ∧ x 1 ≤ 19 / 64) :
    translatedPoint δ (horizontalPoint R (parkingFor M hM b) x) ∈ clockRectangle.carrier := by
  have hc := parkingCenter_bounds (geometricBranches M hM).length (branchIndex M hM b)
  have hcl : (1 / 2 : ℝ) < (parkingFor M hM b 0 : ℝ) := by
    have hh := (Rat.cast_lt (K := ℝ)).mpr hc.1
    norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] at hh
    exact hh
  have hcu : (parkingFor M hM b 0 : ℝ) < 3 / 4 := by
    have hh := (Rat.cast_lt (K := ℝ)).mpr hc.2
    norm_num only [Rat.cast_div, Rat.cast_ofNat] at hh
    exact hh
  have hw := RationalBox.mem_carrier_iff.mp hx 0
  obtain ⟨hwl, hwu⟩ := abs_le.mp hw
  obtain ⟨hd₀, hd₀'⟩ := abs_le.mp hδ₀
  obtain ⟨hd₁, hd₁'⟩ := abs_le.mp hδ₁
  intro j
  fin_cases j
  · change ((1 / 8 : ℚ) : ℝ) ≤
        horizontalPoint R (parkingFor M hM b) x 0 + (δ 0 : ℝ) ∧
      horizontalPoint R (parkingFor M hM b) x 0 + (δ 0 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
    have he : horizontalPoint R (parkingFor M hM b) x 0 =
        x 0 + (parkingFor M hM b 0 : ℝ) - R.center 0 := by
      simp [horizontalPoint, horizontalCenter]
      ring
    rw [he]
    norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
    constructor <;> linarith
  · change ((1 / 32 : ℚ) : ℝ) ≤
        horizontalPoint R (parkingFor M hM b) x 1 + (δ 1 : ℝ) ∧
      horizontalPoint R (parkingFor M hM b) x 1 + (δ 1 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
    rw [horizontalPoint_vertical]
    norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
    constructor <;> linarith [hy.1, hy.2]

theorem branch_scaledStage_mem (M : Alternating.Machine) (hM : M.WellFormed)
    (b : Branch (finiteMachine M hM)) {x : Plane}
    (hx : x ∈ (instruction M hM b).source.carrier) (k : Fin 5) :
    scaledStage (instruction M hM b) (parkingScale (geometricBranches M hM).length)
      (3 / 8) (parkingFor M hM b) x k ∈
        (parkingBox (geometricBranches M hM).length (bandScale M) (branchIndex M hM b)).carrier := by
  have hw := instruction_halfWidths M hM b
  exact scaledStage_mem_parking (bandScale_pos M).le (branchIndex M hM b) _
    (instruction_factor_pos M hM b) (instruction_image M hM b)
    hw.1 hw.2.1 hw.2.2.1 hw.2.2.2 hx k

theorem shifted_branchAnchors_clock (M : Alternating.Machine) (hM : M.WellFormed)
    (b : Branch (finiteMachine M hM)) (δ : Fin 2 → ℚ)
    (hδ₀ : |(δ 0 : ℝ)| ≤ 1 / 512) (hδ₁ : |(δ 1 : ℝ)| ≤ 3 / 1024)
    {x : Plane} (hx : x ∈ (instruction M hM b).source.carrier) (k : Fin 9) :
    translatedPoint δ (branchAnchors M hM b x k) ∈ clockRectangle.carrier := by
  have ht : (instruction M hM b).affine x ∈ (instruction M hM b).target.carrier := by
    rw [← instruction_image M hM b]
    exact mem_image_of_mem _ hx
  have hs := instruction_source_bounds M hM b hx
  have ht' := instruction_target_bounds M hM b ht
  have hw := instruction_halfWidthQ_bound M hM b
  have hws : (instruction M hM b).source.halfWidth 0 ≤ 1 / 128 := by
    have hh := (Rat.cast_le (K := ℝ)).mpr (hw.1 0)
    simpa only [halfWidthQ_cast, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hh
  have hwt : (instruction M hM b).target.halfWidth 0 ≤ 1 / 128 := by
    have hh := (Rat.cast_le (K := ℝ)).mpr (hw.2 0)
    simpa only [halfWidthQ_cast, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hh
  have hp (j : Fin 5) := (shifted_parking_bounds (bandScale_pos M).le (bandScale_le M)
    (branchIndex M hM b) δ hδ₀ hδ₁ (branch_scaledStage_mem M hM b hx j)).1
  fin_cases k
  · exact shifted_coding_rectangle_clock M hM δ hδ₀ hδ₁ hs
  · exact shifted_horizontalPoint_clock M hM b _ hws δ hδ₀ hδ₁ hx hs.2
  · exact hp 0
  · exact hp 1
  · exact hp 2
  · exact hp 3
  · exact hp 4
  · exact shifted_horizontalPoint_clock M hM b _ hwt δ hδ₀ hδ₁ ht ht'.2
  · exact shifted_coding_rectangle_clock M hM δ hδ₀ hδ₁ ht'

theorem shifted_branchAnchors_safe (M : Alternating.Machine) (hM : M.WellFormed)
    (b : Branch (finiteMachine M hM)) (hn : recorderHalting M b.target = false)
    (δ : Fin 2 → ℚ) (hδ₀ : |(δ 0 : ℝ)| ≤ 1 / 512) (hδ₁ : |(δ 1 : ℝ)| ≤ 3 / 1024)
    {x : Plane} (hx : x ∈ (instruction M hM b).source.carrier) (k : Fin 9) :
    3 / 16 ≤ translatedPoint δ (branchAnchors M hM b x k) 1 := by
  have ht : (instruction M hM b).affine x ∈ (instruction M hM b).target.carrier := by
    rw [← instruction_image M hM b]
    exact mem_image_of_mem _ hx
  have hs := (shifted_instruction_source_height M hM b δ hδ₁ hx).1
  have ht' := (shifted_instruction_target_nonterminal_height M hM b hn δ hδ₁ ht).1
  have hp (j : Fin 5) := (shifted_parking_bounds (bandScale_pos M).le (bandScale_le M)
    (branchIndex M hM b) δ hδ₀ hδ₁ (branch_scaledStage_mem M hM b hx j)).2
  fin_cases k
  · exact hs
  · change 3 / 16 ≤ horizontalPoint _ _ x 1 + (δ 1 : ℝ)
    rw [horizontalPoint_vertical]
    exact hs
  · exact hp 0
  · exact hp 1
  · exact hp 2
  · exact hp 3
  · exact hp 4
  · change 3 / 16 ≤ horizontalPoint _ _ ((instruction M hM b).affine x) 1 + (δ 1 : ℝ)
    rw [horizontalPoint_vertical]
    exact ht'
  · exact ht'

theorem normalizedAnchors_clock (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
    (b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
    {x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
    (k : Fin 9) : normalizedAnchors I hI b x k ∈ clockRectangle.carrier := by
  have hδ := initialShift_small (freshInput I) (freshInput_valid hI) (fresh_initial_nonhalting I hI)
  exact shifted_branchAnchors_clock _ _ b _ hδ.1 hδ.2 hx k

theorem normalizedAnchors_safe (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
    (b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
    (hn : recorderHalting (freshMachine I.1) b.target = false)
    {x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
    (k : Fin 9) : 3 / 16 ≤ normalizedAnchors I hI b x k 1 := by
  have hδ := initialShift_small (freshInput I) (freshInput_valid hI) (fresh_initial_nonhalting I hI)
  exact shifted_branchAnchors_safe _ _ b hn _ hδ.1 hδ.2 hx k

theorem normalizedCurve_segment (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
    (b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
    (x : Plane) (k : Fin 8) (t : ℝ) :
    normalizedCurve I hI b x k t = normalizedAnchors I hI b x k.castSucc +
      smoothRamp (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
        (branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).start
        (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
        (branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).finish t •
      (normalizedAnchors I hI b x k.succ - normalizedAnchors I hI b x k.castSucc) := by
  unfold normalizedCurve branchCurve
  rw [Pulse.curve, Primitive.path_segment, branchCurve_endpoint]
  ext j
  simp only [translatedPoint, normalizedAnchors, Pi.add_apply, Pi.sub_apply, Pi.smul_apply,
    smul_eq_mul]
  ring

theorem normalizedCurve_clock (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
    (b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
    {x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
    (k : Fin 8) (t : ℝ) : normalizedCurve I hI b x k t ∈ clockRectangle.carrier := by
  have h₀ := normalizedAnchors_clock I hI b hx k.castSucc
  have h₁ := normalizedAnchors_clock I hI b hx k.succ
  have hθ := smoothRamp_range
    (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
      (branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).start
    (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
      (branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).finish t
  rw [normalizedCurve_segment]
  intro j
  have hj₀ := h₀ j
  have hj₁ := h₁ j
  simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, Pi.sub_apply]
  constructor <;> nlinarith [hθ.1, hθ.2]

theorem normalizedCurve_safe (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
    (b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
    (hn : recorderHalting (freshMachine I.1) b.target = false)
    {x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
    (k : Fin 8) (t : ℝ) : 3 / 16 ≤ normalizedCurve I hI b x k t 1 := by
  have h₀ := normalizedAnchors_safe I hI b hn hx k.castSucc
  have h₁ := normalizedAnchors_safe I hI b hn hx k.succ
  have hθ := smoothRamp_range
    (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
      (branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).start
    (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
      (branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).finish t
  rw [normalizedCurve_segment]
  simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, Pi.sub_apply]
  nlinarith [hθ.1, hθ.2]

end ForcedComputation.Recorder.Planar

end

end OAI

	import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.NormalizedBranchTrace
	import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.PlanarClockMargins

	namespace OAI

	/-! Clock and observation margins for the entire filled branch trajectory. -/

	noncomputable section
	namespace ForcedComputation.Recorder.Planar
	open ShearFlows PlanarHamiltonian PlanarRouting Set

	/-- The parking rectangles have room for the rational initial translation. -/
	theorem shifted_parking_bounds {n : ℕ} {κ : ℚ} (hκ : 0 ≤ κ) (hκ' : κ ≤ 1 / 64)
	(i : Fin n) (δ : Fin 2 → ℚ)
	(hδ₀ : \|(δ 0 : ℝ)\| ≤ 1 / 512) (hδ₁ : \|(δ 1 : ℝ)\| ≤ 3 / 1024)
	{x : Plane} (hx : x ∈ (parkingBox n κ i).carrier) :
	translatedPoint δ x ∈ clockRectangle.carrier ∧ 3 / 16 ≤ translatedPoint δ x 1 := by
	have hb := parkingBox_bounds hκ hκ' i hx
	have hs : (parkingScale n : ℝ) ≤ 1 / 64 := by
	have hh := (Rat.cast_le (K := ℝ)).mpr (parkingScale_le n)
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] at hh
	exact hh
	have hk : (0 : ℝ) ≤ κ := by exact_mod_cast hκ
	have hk' : (κ : ℝ) ≤ 1 / 64 := by
	have hh := (Rat.cast_le (K := ℝ)).mpr hκ'
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] at hh
	exact hh
	have hc : (parkingCenter n i 0 : ℝ) < 3 / 4 := by
	have hh := (Rat.cast_lt (K := ℝ)).mpr (parkingCenter_bounds n i).2
	norm_num only [Rat.cast_div, Rat.cast_ofNat] at hh
	exact hh
	have hxu := (hx 0).2
	change x 0 ≤ ((parkingCenter n i 0 + parkingScale n * κ : ℚ) : ℝ) at hxu
	push_cast at hxu
	have hm := mul_le_mul hs hk' hk (by norm_num : (0 : ℝ) ≤ 1 / 64)
	obtain ⟨hd₀, hd₀'⟩ := abs_le.mp hδ₀
	obtain ⟨hd₁, hd₁'⟩ := abs_le.mp hδ₁
	constructor
	· intro j
	fin_cases j
	· change ((1 / 8 : ℚ) : ℝ) ≤ x 0 + (δ 0 : ℝ) ∧
	x 0 + (δ 0 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
	constructor <;> linarith [hb.1]
	· change ((1 / 32 : ℚ) : ℝ) ≤ x 1 + (δ 1 : ℝ) ∧
	x 1 + (δ 1 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
	constructor <;> linarith [hb.2.2.1, hb.2.2.2]
	· change 3 / 16 ≤ x 1 + (δ 1 : ℝ)
	linarith [hb.2.2.1]

	theorem horizontalPoint_vertical (R : RationalBox 2) (p : Fin 2 → ℚ) (x : Plane) :
	horizontalPoint R p x 1 = x 1 := by
	simp [horizontalPoint, horizontalCenter]

	theorem shifted_horizontalPoint_clock (M : Alternating.Machine) (hM : M.WellFormed)
	(b : Branch (finiteMachine M hM)) (R : RationalBox 2)
	(hwidth : R.halfWidth 0 ≤ 1 / 128)
	(δ : Fin 2 → ℚ) (hδ₀ : \|(δ 0 : ℝ)\| ≤ 1 / 512)
	(hδ₁ : \|(δ 1 : ℝ)\| ≤ 3 / 1024)
	{x : Plane} (hx : x ∈ R.carrier)
	(hy : (5 / 128 : ℝ) ≤ x 1 ∧ x 1 ≤ 19 / 64) :
	translatedPoint δ (horizontalPoint R (parkingFor M hM b) x) ∈ clockRectangle.carrier := by
	have hc := parkingCenter_bounds (geometricBranches M hM).length (branchIndex M hM b)
	have hcl : (1 / 2 : ℝ) < (parkingFor M hM b 0 : ℝ) := by
	have hh := (Rat.cast_lt (K := ℝ)).mpr hc.1
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] at hh
	exact hh
	have hcu : (parkingFor M hM b 0 : ℝ) < 3 / 4 := by
	have hh := (Rat.cast_lt (K := ℝ)).mpr hc.2
	norm_num only [Rat.cast_div, Rat.cast_ofNat] at hh
	exact hh
	have hw := RationalBox.mem_carrier_iff.mp hx 0
	obtain ⟨hwl, hwu⟩ := abs_le.mp hw
	obtain ⟨hd₀, hd₀'⟩ := abs_le.mp hδ₀
	obtain ⟨hd₁, hd₁'⟩ := abs_le.mp hδ₁
	intro j
	fin_cases j
	· change ((1 / 8 : ℚ) : ℝ) ≤
	horizontalPoint R (parkingFor M hM b) x 0 + (δ 0 : ℝ) ∧
	horizontalPoint R (parkingFor M hM b) x 0 + (δ 0 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
	have he : horizontalPoint R (parkingFor M hM b) x 0 =
	x 0 + (parkingFor M hM b 0 : ℝ) - R.center 0 := by
	simp [horizontalPoint, horizontalCenter]
	ring
	rw [he]
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
	constructor <;> linarith
	· change ((1 / 32 : ℚ) : ℝ) ≤
	horizontalPoint R (parkingFor M hM b) x 1 + (δ 1 : ℝ) ∧
	horizontalPoint R (parkingFor M hM b) x 1 + (δ 1 : ℝ) ≤ ((7 / 8 : ℚ) : ℝ)
	rw [horizontalPoint_vertical]
	norm_num only [Rat.cast_div, Rat.cast_one, Rat.cast_ofNat]
	constructor <;> linarith [hy.1, hy.2]

	theorem branch_scaledStage_mem (M : Alternating.Machine) (hM : M.WellFormed)
	(b : Branch (finiteMachine M hM)) {x : Plane}
	(hx : x ∈ (instruction M hM b).source.carrier) (k : Fin 5) :
	scaledStage (instruction M hM b) (parkingScale (geometricBranches M hM).length)
	(3 / 8) (parkingFor M hM b) x k ∈
	(parkingBox (geometricBranches M hM).length (bandScale M) (branchIndex M hM b)).carrier := by
	have hw := instruction_halfWidths M hM b
	exact scaledStage_mem_parking (bandScale_pos M).le (branchIndex M hM b) _
	(instruction_factor_pos M hM b) (instruction_image M hM b)
	hw.1 hw.2.1 hw.2.2.1 hw.2.2.2 hx k

	theorem shifted_branchAnchors_clock (M : Alternating.Machine) (hM : M.WellFormed)
	(b : Branch (finiteMachine M hM)) (δ : Fin 2 → ℚ)
	(hδ₀ : \|(δ 0 : ℝ)\| ≤ 1 / 512) (hδ₁ : \|(δ 1 : ℝ)\| ≤ 3 / 1024)
	{x : Plane} (hx : x ∈ (instruction M hM b).source.carrier) (k : Fin 9) :
	translatedPoint δ (branchAnchors M hM b x k) ∈ clockRectangle.carrier := by
	have ht : (instruction M hM b).affine x ∈ (instruction M hM b).target.carrier := by
	rw [← instruction_image M hM b]
	exact mem_image_of_mem _ hx
	have hs := instruction_source_bounds M hM b hx
	have ht' := instruction_target_bounds M hM b ht
	have hw := instruction_halfWidthQ_bound M hM b
	have hws : (instruction M hM b).source.halfWidth 0 ≤ 1 / 128 := by
	have hh := (Rat.cast_le (K := ℝ)).mpr (hw.1 0)
	simpa only [halfWidthQ_cast, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hh
	have hwt : (instruction M hM b).target.halfWidth 0 ≤ 1 / 128 := by
	have hh := (Rat.cast_le (K := ℝ)).mpr (hw.2 0)
	simpa only [halfWidthQ_cast, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hh
	have hp (j : Fin 5) := (shifted_parking_bounds (bandScale_pos M).le (bandScale_le M)
	(branchIndex M hM b) δ hδ₀ hδ₁ (branch_scaledStage_mem M hM b hx j)).1
	fin_cases k
	· exact shifted_coding_rectangle_clock M hM δ hδ₀ hδ₁ hs
	· exact shifted_horizontalPoint_clock M hM b _ hws δ hδ₀ hδ₁ hx hs.2
	· exact hp 0
	· exact hp 1
	· exact hp 2
	· exact hp 3
	· exact hp 4
	· exact shifted_horizontalPoint_clock M hM b _ hwt δ hδ₀ hδ₁ ht ht'.2
	· exact shifted_coding_rectangle_clock M hM δ hδ₀ hδ₁ ht'

	theorem shifted_branchAnchors_safe (M : Alternating.Machine) (hM : M.WellFormed)
	(b : Branch (finiteMachine M hM)) (hn : recorderHalting M b.target = false)
	(δ : Fin 2 → ℚ) (hδ₀ : \|(δ 0 : ℝ)\| ≤ 1 / 512) (hδ₁ : \|(δ 1 : ℝ)\| ≤ 3 / 1024)
	{x : Plane} (hx : x ∈ (instruction M hM b).source.carrier) (k : Fin 9) :
	3 / 16 ≤ translatedPoint δ (branchAnchors M hM b x k) 1 := by
	have ht : (instruction M hM b).affine x ∈ (instruction M hM b).target.carrier := by
	rw [← instruction_image M hM b]
	exact mem_image_of_mem _ hx
	have hs := (shifted_instruction_source_height M hM b δ hδ₁ hx).1
	have ht' := (shifted_instruction_target_nonterminal_height M hM b hn δ hδ₁ ht).1
	have hp (j : Fin 5) := (shifted_parking_bounds (bandScale_pos M).le (bandScale_le M)
	(branchIndex M hM b) δ hδ₀ hδ₁ (branch_scaledStage_mem M hM b hx j)).2
	fin_cases k
	· exact hs
	· change 3 / 16 ≤ horizontalPoint _ _ x 1 + (δ 1 : ℝ)
	rw [horizontalPoint_vertical]
	exact hs
	· exact hp 0
	· exact hp 1
	· exact hp 2
	· exact hp 3
	· exact hp 4
	· change 3 / 16 ≤ horizontalPoint _ _ ((instruction M hM b).affine x) 1 + (δ 1 : ℝ)
	rw [horizontalPoint_vertical]
	exact ht'
	· exact ht'

	theorem normalizedAnchors_clock (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
	(b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
	{x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
	(k : Fin 9) : normalizedAnchors I hI b x k ∈ clockRectangle.carrier := by
	have hδ := initialShift_small (freshInput I) (freshInput_valid hI) (fresh_initial_nonhalting I hI)
	exact shifted_branchAnchors_clock _ _ b _ hδ.1 hδ.2 hx k

	theorem normalizedAnchors_safe (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
	(b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
	(hn : recorderHalting (freshMachine I.1) b.target = false)
	{x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
	(k : Fin 9) : 3 / 16 ≤ normalizedAnchors I hI b x k 1 := by
	have hδ := initialShift_small (freshInput I) (freshInput_valid hI) (fresh_initial_nonhalting I hI)
	exact shifted_branchAnchors_safe _ _ b hn _ hδ.1 hδ.2 hx k

	theorem normalizedCurve_segment (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
	(b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
	(x : Plane) (k : Fin 8) (t : ℝ) :
	normalizedCurve I hI b x k t = normalizedAnchors I hI b x k.castSucc +
	smoothRamp (compiledPulse (freshMachine I.1) (freshInput_valid hI).1
	(branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).start
	(compiledPulse (freshMachine I.1) (freshInput_valid hI).1
	(branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).finish t •
	(normalizedAnchors I hI b x k.succ - normalizedAnchors I hI b x k.castSucc) := by
	unfold normalizedCurve branchCurve
	rw [Pulse.curve, Primitive.path_segment, branchCurve_endpoint]
	ext j
	simp only [translatedPoint, normalizedAnchors, Pi.add_apply, Pi.sub_apply, Pi.smul_apply,
	smul_eq_mul]
	ring

	theorem normalizedCurve_clock (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
	(b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
	{x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
	(k : Fin 8) (t : ℝ) : normalizedCurve I hI b x k t ∈ clockRectangle.carrier := by
	have h₀ := normalizedAnchors_clock I hI b hx k.castSucc
	have h₁ := normalizedAnchors_clock I hI b hx k.succ
	have hθ := smoothRamp_range
	(compiledPulse (freshMachine I.1) (freshInput_valid hI).1
	(branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).start
	(compiledPulse (freshMachine I.1) (freshInput_valid hI).1
	(branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).finish t
	rw [normalizedCurve_segment]
	intro j
	have hj₀ := h₀ j
	have hj₁ := h₁ j
	simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, Pi.sub_apply]
	constructor <;> nlinarith [hθ.1, hθ.2]

	theorem normalizedCurve_safe (I : Alternating.MachineInput) (hI : Alternating.ValidInput I)
	(b : Branch (finiteMachine (freshMachine I.1) (freshInput_valid hI).1))
	(hn : recorderHalting (freshMachine I.1) b.target = false)
	{x : Plane} (hx : x ∈ (instruction (freshMachine I.1) (freshInput_valid hI).1 b).source.carrier)
	(k : Fin 8) (t : ℝ) : 3 / 16 ≤ normalizedCurve I hI b x k t 1 := by
	have h₀ := normalizedAnchors_safe I hI b hn hx k.castSucc
	have h₁ := normalizedAnchors_safe I hI b hn hx k.succ
	have hθ := smoothRamp_range
	(compiledPulse (freshMachine I.1) (freshInput_valid hI).1
	(branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).start
	(compiledPulse (freshMachine I.1) (freshInput_valid hI).1
	(branchIndices (freshMachine I.1) (freshInput_valid hI).1 b k)).finish t
	rw [normalizedCurve_segment]
	simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, Pi.sub_apply]
	nlinarith [hθ.1, hθ.2]

	end ForcedComputation.Recorder.Planar

	end

	end OAI