openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Programs /FiniteGeometry.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.FiniteLabels | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.RecorderCoordinates | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.BoxBounds | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Programs.RectangleSeparation | |
| namespace OAI | |
| /-! The actual finite list of rational affine instructions and the fixed | |
| unit-torus geometric data for the initialized computation construction. -/ | |
| namespace ForcedComputation.Recorder | |
| open Radix ShearFlows | |
| def geometricBranches (M : Alternating.Machine) (hM : M.WellFormed) : | |
| List (Branch (finiteMachine M hM)) := (compileBranches M hM).dedup | |
| def geometricInstruction (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : Instruction := | |
| branchInstruction (bandScale M) (radixBase M) (radixDigit M) (stateOffset M) b | |
| def compiledInput (M : Alternating.Machine) (hM : M.WellFormed) : Input where | |
| period := 1 | |
| chart := ⟨![1 / 32, 1 / 32, 1 / 8], ![31 / 32, 31 / 32, 7 / 8]⟩ | |
| h := bandScale M / 2 | |
| codingHeight := 1 / 2 | |
| centers := ⟨![1 / 8, 1 / 4], ![13 / 16, 1 / 2]⟩ | |
| instructions := (geometricBranches M hM).map (geometricInstruction M hM) | |
| theorem geometricInstruction_mem (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : | |
| geometricInstruction M hM b ∈ (compiledInput M hM).instructions := by | |
| apply List.mem_map.mpr | |
| refine ⟨b, ?_, rfl⟩ | |
| simpa only [geometricBranches, List.mem_dedup] using mem_compileBranches M hM b | |
| theorem geometricInstruction_factor_pos (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : 0 < (geometricInstruction M hM b).factor := | |
| headFactor_pos (lt_trans (by norm_num) (radixBase_gt_one M)) _ | |
| theorem geometricInstruction_source_positive (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : (geometricInstruction M hM b).source.positive := | |
| scaledBox_positive (bandScale_pos M) _ | |
| (sourceBox_positive (lt_trans (by norm_num) (radixBase_gt_one M)) _ _) | |
| theorem geometricInstruction_target_positive (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : (geometricInstruction M hM b).target.positive := | |
| scaledBox_positive (bandScale_pos M) _ | |
| (targetBox_positive (lt_trans (by norm_num) (radixBase_gt_one M)) _ _ _) | |
| theorem radixDigit_bounds_rat (M : Alternating.Machine) (a : Symbol (State M) (Alphabet M)) : | |
| 0 ≤ radixDigit M a ∧ radixDigit M a + 1 ≤ radixBase M := by | |
| constructor | |
| · exact_mod_cast (radixDigit_bounds M a).1 | |
| · exact_mod_cast (radixDigit_bounds M a).2 | |
| theorem geometricInstruction_source_unit (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : | |
| InUnit (sourceBox (radixBase M) (radixDigit M b.left) (radixDigit M b.read)) := | |
| sourceBox_inUnit (lt_trans (by norm_num) (radixBase_gt_one M)) | |
| (radixDigit_bounds_rat M _) (radixDigit_bounds_rat M _) | |
| theorem geometricInstruction_target_unit (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : | |
| InUnit (targetBox (radixBase M) (radixDigit M b.left) (radixDigit M b.write) | |
| (headMoveOfInt b.displacement)) := | |
| targetBox_inUnit (lt_trans (by norm_num) (radixBase_gt_one M)) | |
| (radixDigit_bounds_rat M _) (radixDigit_bounds_rat M _) _ | |
| theorem geometricInstruction_halfWidths (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) (j : Fin 2) : | |
| (geometricInstruction M hM b).source.halfWidth j ≤ (bandScale M : ℝ) / 2 ∧ | |
| (geometricInstruction M hM b).target.halfWidth j ≤ (bandScale M : ℝ) / 2 := by | |
| have hp : (0 : ℝ) ≤ bandScale M := by exact_mod_cast (bandScale_pos M).le | |
| constructor | |
| · change (scaledBox (bandScale M) (stateOffset M b.source) | |
| (sourceBox (radixBase M) (radixDigit M b.left) (radixDigit M b.read))).halfWidth j ≤ _ | |
| rw [scaledBox_halfWidth] | |
| nlinarith [halfWidth_le_half (geometricInstruction_source_unit M hM b) j] | |
| · change (scaledBox (bandScale M) (stateOffset M b.target) | |
| (targetBox (radixBase M) (radixDigit M b.left) (radixDigit M b.write) | |
| (headMoveOfInt b.displacement))).halfWidth j ≤ _ | |
| rw [scaledBox_halfWidth] | |
| nlinarith [halfWidth_le_half (geometricInstruction_target_unit M hM b) j] | |
| theorem stateBox_bounds (M : Alternating.Machine) (q : Control (State M) (Alphabet M)) | |
| {R : RationalBox 2} (hR : InUnit R) {x : Plane} | |
| (hx : x ∈ (scaledBox (bandScale M) (stateOffset M q) R).carrier) : | |
| (1 / 8 : ℝ) ≤ x 0 ∧ x 0 ≤ 13 / 16 ∧ (1 / 4 : ℝ) ≤ x 1 ∧ x 1 ≤ 1 / 2 := by | |
| have h₀ := scaledBox_between (bandScale_pos M).le (stateOffset M q) hR hx 0 | |
| have h₁ := scaledBox_between (bandScale_pos M).le (stateOffset M q) hR hx 1 | |
| have hk : (bandScale M : ℝ) ≤ 1 / 64 := by | |
| have h := (Rat.cast_le (K := ℝ)).mpr (bandScale_le M) | |
| norm_num at h | |
| exact h | |
| have hy : (3 / 8 : ℝ) < centerY M q ∧ (centerY M q : ℝ) < 7 / 16 := by | |
| constructor | |
| · have h := (Rat.cast_lt (K := ℝ)).mpr (centerY_bounds M q).1 | |
| norm_num at h | |
| exact h | |
| · have h := (Rat.cast_lt (K := ℝ)).mpr (centerY_bounds M q).2 | |
| norm_num at h | |
| exact h | |
| simp only [stateOffset, Matrix.cons_val_zero, Matrix.cons_val_one, | |
| Rat.cast_sub, Rat.cast_div, Rat.cast_ofNat] at h₀ h₁ | |
| cases ht : recorderHalting M q <;> simp only [ht, Bool.false_eq_true, ite_false, ite_true] at h₀ <;> | |
| norm_num at h₀ | |
| all_goals exact ⟨by linarith [h₀.1, h₀.2], by linarith [h₀.1, h₀.2], | |
| by linarith [h₁.1, h₁.2], by linarith [h₁.1, h₁.2]⟩ | |
| theorem stateBox_nonterminal_x (M : Alternating.Machine) (q : Control (State M) (Alphabet M)) | |
| (hq : recorderHalting M q = false) {R : RationalBox 2} (hR : InUnit R) {x : Plane} | |
| (hx : x ∈ (scaledBox (bandScale M) (stateOffset M q) R).carrier) : | |
| 1 / 4 - (bandScale M : ℝ) / 2 ≤ x 0 ∧ | |
| x 0 ≤ 1 / 4 + (bandScale M : ℝ) / 2 := by | |
| have h := scaledBox_between (bandScale_pos M).le (stateOffset M q) hR hx 0 | |
| norm_num [stateOffset, hq] at h | |
| constructor <;> linarith [h.1, h.2] | |
| theorem stateBox_terminal_x (M : Alternating.Machine) (q : Control (State M) (Alphabet M)) | |
| (hq : recorderHalting M q = true) {R : RationalBox 2} (hR : InUnit R) {x : Plane} | |
| (hx : x ∈ (scaledBox (bandScale M) (stateOffset M q) R).carrier) : | |
| 3 / 4 - (bandScale M : ℝ) / 2 ≤ x 0 ∧ | |
| x 0 ≤ 3 / 4 + (bandScale M : ℝ) / 2 := by | |
| have h := scaledBox_between (bandScale_pos M).le (stateOffset M q) hR hx 0 | |
| norm_num [stateOffset, hq] at h | |
| constructor <;> linarith [h.1, h.2] | |
| theorem geometricInstruction_source_bounds (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) {x : Plane} | |
| (hx : x ∈ (geometricInstruction M hM b).source.carrier) : | |
| (1 / 8 : ℝ) ≤ x 0 ∧ x 0 ≤ 13 / 16 ∧ (1 / 4 : ℝ) ≤ x 1 ∧ x 1 ≤ 1 / 2 := | |
| stateBox_bounds M b.source (geometricInstruction_source_unit M hM b) hx | |
| theorem geometricInstruction_target_bounds (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) {x : Plane} | |
| (hx : x ∈ (geometricInstruction M hM b).target.carrier) : | |
| (1 / 8 : ℝ) ≤ x 0 ∧ x 0 ≤ 13 / 16 ∧ (1 / 4 : ℝ) ≤ x 1 ∧ x 1 ≤ 1 / 2 := | |
| stateBox_bounds M b.target (geometricInstruction_target_unit M hM b) hx | |
| theorem geometricInstruction_image (M : Alternating.Machine) (hM : M.WellFormed) | |
| (b : Branch (finiteMachine M hM)) : | |
| (geometricInstruction M hM b).affine '' (geometricInstruction M hM b).source.carrier = | |
| (geometricInstruction M hM b).target.carrier := by | |
| let r := radixInstruction (radixBase M) (radixDigit M b.left) (radixDigit M b.read) | |
| (radixDigit M b.write) (headMoveOfInt b.displacement) | |
| change (scaledInstruction (bandScale M) (stateOffset M b.source) (stateOffset M b.target) r).affine '' | |
| (scaledBox (bandScale M) (stateOffset M b.source) r.source).carrier = | |
| (scaledBox (bandScale M) (stateOffset M b.target) r.target).carrier | |
| rw [← scaledBox_image (bandScale_pos M), ← scaledBox_image (bandScale_pos M), Set.image_image] | |
| have he : (scaledInstruction (bandScale M) (stateOffset M b.source) (stateOffset M b.target) r).affine ∘ | |
| embedPlane (bandScale M) (stateOffset M b.source) = | |
| embedPlane (bandScale M) (stateOffset M b.target) ∘ r.affine := by | |
| funext x | |
| exact scaledInstruction_action _ _ _ _ _ | |
| simp only [Function.comp_def] at he | |
| have hr : r.affine '' r.source.carrier = r.target.carrier := | |
| radixInstruction_image (lt_trans (by norm_num) (radixBase_gt_one M)) _ _ _ _ | |
| rw [he, ← Set.image_image, hr] | |
| theorem compiledInput_basic (M : Alternating.Machine) (hM : M.WellFormed) : | |
| 0 < (compiledInput M hM).period ∧ (compiledInput M hM).chart.positive ∧ | |
| (∀ j, (compiledInput M hM).chart.upper j - (compiledInput M hM).chart.lower j < | |
| (compiledInput M hM).period) ∧ | |
| 0 < (compiledInput M hM).h ∧ (compiledInput M hM).centers.nonemptyBox ∧ | |
| ((compiledInput M hM).chart.lower 2 : ℝ) < (compiledInput M hM).codingHeight ∧ | |
| ((compiledInput M hM).codingHeight : ℝ) < (compiledInput M hM).chart.upper 2 := by | |
| refine ⟨by norm_num [compiledInput], ?_, ?_, ?_, ?_, ?_, ?_⟩ | |
| · intro j | |
| fin_cases j <;> norm_num [compiledInput] | |
| · intro j | |
| fin_cases j <;> norm_num [compiledInput] | |
| · exact div_pos (bandScale_pos M) (by norm_num) | |
| · intro j | |
| fin_cases j <;> norm_num [compiledInput] | |
| · norm_num [compiledInput] | |
| · norm_num [compiledInput] | |
| theorem compiledInput_chartMargin (M : Alternating.Machine) (hM : M.WellFormed) : | |
| ∀ j : Fin 2, | |
| ((compiledInput M hM).chart.lower j.castSucc : ℝ) < | |
| ((compiledInput M hM).centers.lower j : ℝ) - 2 * ((compiledInput M hM).h : ℝ) ∧ | |
| ((compiledInput M hM).centers.upper j : ℝ) + 2 * ((compiledInput M hM).h : ℝ) < | |
| ((compiledInput M hM).chart.upper j.castSucc : ℝ) := by | |
| have hs : (bandScale M : ℝ) ≤ 1 / 64 := by | |
| have h := (Rat.cast_le (K := ℝ)).mpr (bandScale_le M) | |
| norm_num at h | |
| exact h | |
| intro j | |
| fin_cases j <;> norm_num [compiledInput] <;> constructor <;> linarith | |
| theorem stateBox_separation (M : Alternating.Machine) | |
| {q r : Control (State M) (Alphabet M)} (hqr : q ≠ r) | |
| {R S : RationalBox 2} (hR : InUnit R) (hS : InUnit S) : | |
| PositivelySeparated (scaledBox (bandScale M) (stateOffset M q) R).carrier | |
| (scaledBox (bandScale M) (stateOffset M r) S).carrier := by | |
| have hp : (0 : ℝ) < bandScale M := by exact_mod_cast bandScale_pos M | |
| refine ⟨3 * (bandScale M : ℝ), by positivity, ?_⟩ | |
| intro x hx y hy | |
| have hgap := centerY_gap M hqr | |
| have hxb := scaledBox_between (bandScale_pos M).le (stateOffset M q) hR hx 1 | |
| have hyb := scaledBox_between (bandScale_pos M).le (stateOffset M r) hS hy 1 | |
| dsimp [stateOffset] at hxb hyb | |
| push_cast at hxb hyb | |
| have hab : 3 * (bandScale M : ℝ) ≤ |x 1 - y 1| := by | |
| rcases le_total (centerY M q : ℝ) (centerY M r : ℝ) with h | h | |
| · rw [abs_of_nonpos (sub_nonpos.mpr h)] at hgap | |
| calc | |
| 3 * (bandScale M : ℝ) ≤ y 1 - x 1 := by linarith [hxb.2, hyb.1] | |
| _ ≤ |y 1 - x 1| := le_abs_self _ | |
| _ = |x 1 - y 1| := abs_sub_comm _ _ | |
| · rw [abs_of_nonneg (sub_nonneg.mpr h)] at hgap | |
| exact (show 3 * (bandScale M : ℝ) ≤ x 1 - y 1 by linarith [hxb.1, hyb.2]).trans | |
| (le_abs_self _) | |
| exact hab.trans (by simpa only [Pi.sub_apply, Real.norm_eq_abs] using norm_le_pi_norm (x - y) 1) | |
| theorem geometricInstruction_source_separation (M : Alternating.Machine) (hM : M.WellFormed) | |
| {b c : Branch (finiteMachine M hM)} (hne : b ≠ c) : | |
| PositivelySeparated (geometricInstruction M hM b).source.carrier | |
| (geometricInstruction M hM c).source.carrier := by | |
| by_cases hs : b.source = c.source | |
| · have hpair : (symbolLabel M b.left, symbolLabel M b.read) ≠ | |
| (symbolLabel M c.left, symbolLabel M c.read) := by | |
| intro h | |
| have hl := (symbolLabel M).injective (congrArg Prod.fst h) | |
| have hr := (symbolLabel M).injective (congrArg Prod.snd h) | |
| rcases Branch.source_symbols_differ hne hs with hn | hn | |
| · exact hn hr | |
| · exact hn hl | |
| have hgap := (sourceBox_gap (symbolLabel M b.left) (symbolLabel M b.read) | |
| (symbolLabel M c.left) (symbolLabel M c.read) hpair).scaled (bandScale_pos M) | |
| (stateOffset M b.source) | |
| have hp : 0 < (bandScale M : ℝ) * (1 / (radixBase M : ℝ)) := by | |
| have hk : (0 : ℝ) < bandScale M := by exact_mod_cast bandScale_pos M | |
| have hB : (0 : ℝ) < radixBase M := by exact_mod_cast lt_trans (by norm_num) (radixBase_gt_one M) | |
| positivity | |
| simpa only [geometricInstruction, branchInstruction, scaledInstruction, radixInstruction, | |
| radixBase, radixDigit, hs] using hgap.positiveSeparated hp | |
| · exact stateBox_separation M hs (geometricInstruction_source_unit M hM b) | |
| (geometricInstruction_source_unit M hM c) | |
| theorem geometricInstruction_target_separation (M : Alternating.Machine) (hM : M.WellFormed) | |
| {b c : Branch (finiteMachine M hM)} (hne : b ≠ c) : | |
| PositivelySeparated (geometricInstruction M hM b).target.carrier | |
| (geometricInstruction M hM c).target.carrier := by | |
| by_cases ht : b.target = c.target | |
| · have hpair : (symbolLabel M b.left, symbolLabel M b.write) ≠ | |
| (symbolLabel M c.left, symbolLabel M c.write) := by | |
| intro h | |
| have hl := (symbolLabel M).injective (congrArg Prod.fst h) | |
| have hw := (symbolLabel M).injective (congrArg Prod.snd h) | |
| rcases Branch.target_symbols_differ hne ht with hn | hn | |
| · exact hn hw | |
| · exact hn hl | |
| have hd := Branch.same_target_displacement ht | |
| have hgap := (targetBox_gap (symbolLabel M b.left) (symbolLabel M b.write) | |
| (symbolLabel M c.left) (symbolLabel M c.write) (headMoveOfInt b.displacement) hpair).scaled | |
| (bandScale_pos M) (stateOffset M b.target) | |
| have hp : 0 < (bandScale M : ℝ) * (1 / (radixBase M : ℝ) ^ 2) := by | |
| have hk : (0 : ℝ) < bandScale M := by exact_mod_cast bandScale_pos M | |
| have hB : (0 : ℝ) < radixBase M := by exact_mod_cast lt_trans (by norm_num) (radixBase_gt_one M) | |
| positivity | |
| simpa only [geometricInstruction, branchInstruction, scaledInstruction, radixInstruction, | |
| radixBase, radixDigit, ht, hd] using hgap.positiveSeparated hp | |
| · exact stateBox_separation M ht (geometricInstruction_target_unit M hM b) | |
| (geometricInstruction_target_unit M hM c) | |
| /-- Transfer a separation relation through a duplicate-free finite map. -/ | |
| theorem indexed_map_separation {A B : Type*} (l : List A) (F : A → B) | |
| (hl : l.Nodup) (P : B → B → Prop) | |
| (hP : ∀ a b, a ≠ b → P (F a) (F b)) | |
| (i j : Fin (l.map F).length) (hij : i ≠ j) : P ((l.map F)[i]) ((l.map F)[j]) := by | |
| let i' : Fin l.length := ⟨i.val, by simpa only [List.length_map] using i.isLt⟩ | |
| let j' : Fin l.length := ⟨j.val, by simpa only [List.length_map] using j.isLt⟩ | |
| have hne : l.get i' ≠ l.get j' := by | |
| intro he | |
| have heq := hl.get_inj_iff.mp he | |
| have hv : i.val = j.val := congrArg (fun k : Fin l.length => k.val) heq | |
| exact hij (Fin.ext hv) | |
| have hp := hP (l.get i') (l.get j') hne | |
| simpa only [List.get_eq_getElem, Fin.getElem_fin, List.getElem_map, i', j'] using hp | |
| theorem compiledInput_source_separation (M : Alternating.Machine) (hM : M.WellFormed) | |
| (i j : Fin (compiledInput M hM).instructions.length) (hij : i ≠ j) : | |
| PositivelySeparated ((compiledInput M hM).instructions[i].source.carrier) | |
| ((compiledInput M hM).instructions[j].source.carrier) := by | |
| apply indexed_map_separation (geometricBranches M hM) (geometricInstruction M hM) | |
| (List.nodup_dedup _) (fun b c => PositivelySeparated b.source.carrier c.source.carrier) | |
| (fun _ _ hn => geometricInstruction_source_separation M hM hn) i j hij | |
| theorem compiledInput_target_separation (M : Alternating.Machine) (hM : M.WellFormed) | |
| (i j : Fin (compiledInput M hM).instructions.length) (hij : i ≠ j) : | |
| PositivelySeparated ((compiledInput M hM).instructions[i].target.carrier) | |
| ((compiledInput M hM).instructions[j].target.carrier) := by | |
| apply indexed_map_separation (geometricBranches M hM) (geometricInstruction M hM) | |
| (List.nodup_dedup _) (fun b c => PositivelySeparated b.target.carrier c.target.carrier) | |
| (fun _ _ hn => geometricInstruction_target_separation M hM hn) i j hij | |
| /-- The finite machine compiler supplies every hypothesis of the full-rectangle | |
| solenoidal-shear realization theorem. -/ | |
| theorem compiledInput_valid (M : Alternating.Machine) (hM : M.WellFormed) : | |
| ValidInput (compiledInput M hM) := by | |
| obtain ⟨hp, hc, hcl, hh, hn, hz₀, hz₁⟩ := compiledInput_basic M hM | |
| refine ⟨hp, hc, hcl, hh, hn, compiledInput_chartMargin M hM, ⟨hz₀, hz₁⟩, | |
| ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ | |
| · intro b hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| exact geometricInstruction_source_positive M hM c | |
| · intro b hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| exact geometricInstruction_target_positive M hM c | |
| · intro b hb x hx | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| obtain ⟨h₀, h₁, h₂, h₃⟩ := geometricInstruction_source_bounds M hM c hx | |
| intro j | |
| fin_cases j <;> norm_num [compiledInput, Input.inPlanarChart] <;> constructor <;> linarith | |
| · intro b hb x hx | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| obtain ⟨h₀, h₁, h₂, h₃⟩ := geometricInstruction_target_bounds M hM c hx | |
| intro j | |
| fin_cases j <;> norm_num [compiledInput, Input.inPlanarChart] <;> constructor <;> linarith | |
| · intro b hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| exact geometricInstruction_factor_pos M hM c | |
| · intro b hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| exact geometricInstruction_image M hM c | |
| · exact compiledInput_source_separation M hM | |
| · exact compiledInput_target_separation M hM | |
| · intro b hb j | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| simpa only [compiledInput, Rat.cast_div, Rat.cast_ofNat] using | |
| geometricInstruction_halfWidths M hM c j | |
| · intro b hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| have hx := geometricInstruction_source_bounds M hM c | |
| (center_mem (geometricInstruction_source_positive M hM c)) | |
| intro j | |
| fin_cases j | |
| · simpa [compiledInput] using And.intro hx.1 hx.2.1 | |
| · simpa [compiledInput] using And.intro hx.2.2.1 hx.2.2.2 | |
| · intro b hb | |
| obtain ⟨c, _, rfl⟩ := List.mem_map.mp hb | |
| have hx := geometricInstruction_target_bounds M hM c | |
| (center_mem (geometricInstruction_target_positive M hM c)) | |
| intro j | |
| fin_cases j | |
| · simpa [compiledInput] using And.intro hx.1 hx.2.1 | |
| · simpa [compiledInput] using And.intro hx.2.2.1 hx.2.2.2 | |
| end ForcedComputation.Recorder | |
| end OAI | |