| import Mathlib |
| import OAI.Computability.MinUncut.Search.UniformFiniteSum |
| import OAI.Computability.MinUncut.Estimates.SamplerAssembly |
| import OAI.Computability.MinUncut.Search.ParameterFields |
| import OAI.Computability.MinUncut.Encoding.DerivedResolver |
|
|
| namespace OAI |
|
|
| section |
| syntax "comp_arith" : tactic |
| open Lean Elab Tactic Meta in |
| elab_rules : tactic |
| | `(tactic| comp_arith) => do |
| let target ← getMainTarget |
| let fn := target.getAppArgs.back! |
| let head ← lambdaTelescope fn fun args body => do |
| let body ← instantiateMVars body |
| if !args.isEmpty && !(args.any fun a => body.containsFVar a.fvarId!) then return `constant |
| let name := body.getAppFn.constName? |
| let ty ← inferType body |
| let rat := (← whnf ty).isConstOf ``Rat |
| let n ← match name with |
| | some ``HAdd.hAdd => pure (if rat then ``MinUncut.Preprocess.ca_ratAdd else ``MinUncut.Preprocess.ca_add) |
| | some ``HMul.hMul => pure (if rat then ``MinUncut.Preprocess.ca_ratMul else ``MinUncut.Preprocess.ca_mul) |
| | some ``HSub.hSub => pure (if rat then ``MinUncut.Preprocess.ca_ratSub else ``MinUncut.Preprocess.ca_sub) |
| | some ``HDiv.hDiv => pure (if rat then ``MinUncut.Preprocess.ca_ratDiv else ``MinUncut.Preprocess.ca_div) |
| | some ``HMod.hMod => pure ``MinUncut.Preprocess.ca_mod |
| | some ``HPow.hPow => pure (if rat then ``MinUncut.Preprocess.ca_ratPow else ``MinUncut.Preprocess.ca_pow) |
| | some ``Inv.inv => pure ``MinUncut.Preprocess.ca_ratInv |
| | some ``Nat.choose => pure ``MinUncut.Preprocess.ca_choose |
| | some ``Nat.factorial => pure ``MinUncut.Preprocess.ca_factorial |
| | some ``Nat.cast => pure ``MinUncut.Preprocess.ca_ratCast |
| | some ``Nat.ceil => pure ``MinUncut.Preprocess.ca_ratCeil |
| | some ``And => pure ``MinUncut.Preprocess.ca_and |
| | some ``LE.le => pure (if body.getAppArgs[0]!.isConstOf ``Rat then ``MinUncut.Preprocess.ca_ratLe else ``MinUncut.Preprocess.ca_natLe) |
| | some ``LT.lt => pure (if body.getAppArgs[0]!.isConstOf ``Rat then ``MinUncut.Preprocess.ca_ratLt else ``MinUncut.Preprocess.ca_natLt) |
| | _ => pure `fallback |
| return n |
| if head == `constant then evalTactic (← `(tactic| exact MinUncut.Preprocess.ca_const _)) |
| else if head == `fallback then evalTactic (← `(tactic| fun_prop)) |
| else |
| evalTactic (← `(tactic| apply $(mkIdent head))) |
| evalTactic (← `(tactic| all_goals comp_arith)) |
|
|
| end |
| section |
| namespace MinUncut.Preprocess |
| open MinUncut.Inner MinUncut.Outer MinUncut.FiniteGaussian |
| @[fun_prop] lemma c_epsilon : Computable (fun p : ℕ × ℕ=>InnerData.epsilon p.1 p.2) := by |
| unfold InnerData.epsilon |
| exact ca_ratDiv (ca_const 1) (ca_ratMul |
| (ca_ratMul (ca_const 40) (ca_ratCast (c_T.comp Computable.fst))) |
| (ca_ratAdd (ca_ratCast (ca_pow Computable.snd (ca_const 2))) (ca_const 1))) |
| @[fun_prop] lemma c_atomConstant : Computable (fun p : ℕ × ℕ × ℕ=>InnerData.atomConstant p.1 p.2.1 p.2.2) := by |
| unfold InnerData.atomConstant |
| apply ca_mul |
| · apply ca_pow <;> fun_prop |
| · apply ca_choose |
| · apply ca_add |
| · apply ca_pow <;> fun_prop |
| · fun_prop |
| · fun_prop |
|
|
| lemma inner_check_0 : ComputablePred (fun p : ℕ × InnerData => |
| 2 ≤ p.2.m) := by comp_arith |
|
|
| lemma inner_check_1 : ComputablePred (fun p : ℕ × InnerData => |
| p.2.k+2 ≤ p.2.n) := by comp_arith |
|
|
| lemma inner_check_2 : ComputablePred (fun p : ℕ × InnerData => |
| 1 ≤ p.2.k) := by comp_arith |
|
|
| lemma inner_check_3 : ComputablePred (fun p : ℕ × InnerData => |
| 0 < p.2.H) := by comp_arith |
|
|
| lemma inner_check_4 : ComputablePred (fun p : ℕ × InnerData => |
| 0 < p.2.A) := by comp_arith |
|
|
| lemma inner_check_5 : ComputablePred (fun p : ℕ × InnerData => |
| 0 < p.2.γ) := by comp_arith |
|
|
| lemma inner_check_6 : ComputablePred (fun p : ℕ × InnerData => |
| 0 < p.2.p) := by comp_arith |
|
|
| lemma inner_check_7 : ComputablePred (fun p : ℕ × InnerData => |
| p.2.p < 1) := by comp_arith |
|
|
| lemma inner_check_8 : ComputablePred (fun p : ℕ × InnerData => |
| 0 < p.2.θ) := by comp_arith |
|
|
| lemma inner_check_9 : ComputablePred (fun p : ℕ × InnerData => |
| p.2.θ < 1) := by comp_arith |
|
|
| lemma inner_check_10 : ComputablePred (fun p : ℕ × InnerData => |
| ((p.2.s:ℚ)+3)*(1+rationalSigma p.1^2)⁻¹ ≤ (p.2.s:ℚ)+2) := by comp_arith |
|
|
| lemma inner_check_11 : ComputablePred (fun p : ℕ × InnerData => |
| ((p.2.s:ℚ)+2)*((1+rationalSigma p.1^2)⁻¹)^(p.2.s+2) ≤ 1/16) := by comp_arith |
|
|
| lemma inner_check_12 : ComputablePred (fun p : ℕ × InnerData => |
| rationalR p.1*p.2.m < (p.2.m-p.2.s).choose 2) := by comp_arith |
|
|
| lemma inner_check_13 : ComputablePred (fun p : ℕ × InnerData => |
| ((p.2.s+rationalR p.1*p.2.m:ℕ):ℚ)*(p.2.k:ℚ)/((p.2.n:ℚ)-1) < (InnerData.epsilon p.1 p.2.m*rationalSigma p.1)^2) := by comp_arith |
|
|
| lemma inner_check_14 : ComputablePred (fun p : ℕ × InnerData => |
| (rationalSigma p.1)⁻¹^2/(p.2.H:ℚ) < InnerData.epsilon p.1 p.2.m) := by comp_arith |
|
|
| lemma inner_check_15 : ComputablePred (fun p : ℕ × InnerData => |
| 2*(rationalSigma p.1)⁻¹^2/(p.2.A:ℚ) < InnerData.epsilon p.1 p.2.m) := by comp_arith |
|
|
| lemma inner_check_16 : ComputablePred (fun p : ℕ × InnerData => |
| (p.2.m:ℚ)/((p.2.k:ℚ)+1) < (InnerData.epsilon p.1 p.2.m/(2*(p.2.A:ℚ)))^(2^p.2.m)) := by comp_arith |
|
|
| lemma inner_check_17 : ComputablePred (fun p : ℕ × InnerData => |
| (p.2.H:ℚ)*(p.2.γ+(p.2.H:ℚ)^2/(p.2.A:ℚ)) < InnerData.epsilon p.1 p.2.m^2) := by comp_arith |
|
|
| lemma inner_check_18 : ComputablePred (fun p : ℕ × InnerData => |
| p.2.θ^2+(p.2.m:ℚ)*p.2.p*(p.2.n^p.2.m:ℕ)/(rationalSigma p.1)^2 < |
| (InnerData.epsilon p.1 p.2.m^2*(rationalSigma p.1)^2*p.2.γ/(InnerData.atomConstant p.2.s p.2.m p.2.n:ℚ))^2) := by comp_arith |
|
|
| lemma inner_check_computable : ComputablePred (fun p : ℕ × InnerData=>p.2.Check p.1) := |
| ca_and inner_check_0 (ca_and inner_check_1 (ca_and inner_check_2 (ca_and inner_check_3 (ca_and inner_check_4 (ca_and inner_check_5 (ca_and inner_check_6 (ca_and inner_check_7 (ca_and inner_check_8 (ca_and inner_check_9 (ca_and inner_check_10 (ca_and inner_check_11 (ca_and inner_check_12 (ca_and inner_check_13 (ca_and inner_check_14 (ca_and inner_check_15 (ca_and inner_check_16 (ca_and inner_check_17 (inner_check_18)))))))))))))))))) |
|
|
| @[fun_prop] lemma c_amplitude : Computable (fun p : ℕ × InnerData=>OuterData.amplitude p.1 p.2) := by |
| unfold OuterData.amplitude; comp_arith |
| @[fun_prop] lemma c_hints : Computable OuterData.hints := by |
| unfold OuterData.hints |
| apply ca_sub |
| · apply ca_mul |
| · exact c_innerData_m |
| · apply ca_pow |
| · exact c_innerData_n |
| · apply ca_sub |
| · exact c_innerData_m |
| · exact ca_const 1 |
| · exact ca_const 1 |
| @[fun_prop] lemma c_rate : Computable OuterData.rate := by unfold OuterData.rate; fun_prop |
| lemma c_listBound : Computable (fun p : ℕ × InnerData × OuterData=>OuterData.listBound p.1 p.2.1 p.2.2) := by |
| unfold OuterData.listBound; comp_arith |
| lemma c_radicand : Computable (fun p : InnerData × ℕ × ℕ=>OuterData.radicand p.1 p.2.1 p.2.2) := by |
| unfold OuterData.radicand; comp_arith |
| attribute [fun_prop] c_listBound c_radicand |
| @[fun_prop] lemma c_oTheta : Computable (fun p : ℕ × InnerData × OuterData=>p.2.1.θ) := |
| c_innerData_θ.comp (Computable.fst.comp Computable.snd) |
| @[fun_prop] lemma c_oP : Computable (fun p : ℕ × InnerData × OuterData=>p.2.1.p) := |
| c_innerData_p.comp (Computable.fst.comp Computable.snd) |
| @[fun_prop] lemma c_oB4 : Computable (fun p : ℕ × InnerData × OuterData=>p.2.2.b4) := |
| c_outerData_b4.comp (Computable.snd.comp Computable.snd) |
| lemma outer_check_0 : ComputablePred (fun p : ℕ × InnerData × OuterData=>0 < p.2.2.u) := by comp_arith |
| lemma outer_check_1 : ComputablePred (fun p : ℕ × InnerData × OuterData=>0 < p.2.2.b4) := by comp_arith |
| lemma outer_check_2 : ComputablePred (fun p : ℕ × InnerData × OuterData=>0 < p.2.2.v) := by comp_arith |
| lemma outer_check_3 : ComputablePred (fun p : ℕ × InnerData × OuterData=>1 ≤ p.2.2.t) := by comp_arith |
| lemma outer_check_4 : ComputablePred (fun p : ℕ × InnerData × OuterData=>p.2.2.k ≤ p.2.2.t) := by comp_arith |
| lemma outer_check_5 : ComputablePred (fun p : ℕ × InnerData × OuterData=>OuterData.listBound p.1 p.2.1 p.2.2 < p.2.1.p/4) := by comp_arith |
| lemma outer_check_6 : ComputablePred (fun p : ℕ × InnerData × OuterData=>(64/(p.2.1.θ^2*rationalSigma p.1^2))*(p.1:ℚ)*p.2.2.b4 < p.2.1.p/4) := by comp_arith |
| lemma outer_check_7 : ComputablePred (fun p : ℕ × InnerData × OuterData=>OuterData.radicand p.2.1 p.2.2.k p.2.2.t < p.2.2.v^2) := by comp_arith |
| lemma outer_check_8 : ComputablePred (fun p : ℕ × InnerData × OuterData=>(256/p.2.1.θ^4)*(p.2.2.u^2*OuterData.amplitude p.1 p.2.1^2+p.2.2.v*(OuterData.amplitude p.1 p.2.1+OuterData.amplitude p.1 p.2.1^2/p.2.2.u)^4) < p.2.1.p/2) := by comp_arith |
| lemma outer_check_computable : ComputablePred (fun p : ℕ × InnerData × OuterData=>p.2.2.Check p.1 p.2.1) := |
| ca_and outer_check_0 (ca_and outer_check_1 (ca_and outer_check_2 (ca_and outer_check_3 (ca_and outer_check_4 (ca_and outer_check_5 (ca_and outer_check_6 (ca_and outer_check_7 (outer_check_8)))))))) |
| lemma c_qError : Computable (fun p : ℕ × ℚ=>qError p.1 p.2) := by unfold qError; comp_arith |
| attribute [fun_prop] c_qError |
| @[fun_prop] lemma c_gT : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>p.2.2.2.2.T) := |
| c_gridData_T.comp (Computable.snd.comp (Computable.snd.comp (Computable.snd.comp Computable.snd))) |
| @[fun_prop] lemma c_gL : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>p.2.2.2.2.L) := |
| c_gridData_L.comp (Computable.snd.comp (Computable.snd.comp (Computable.snd.comp Computable.snd))) |
| @[fun_prop] lemma c_gr : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>p.2.2.2.2.r) := |
| c_gridData_r.comp (Computable.snd.comp (Computable.snd.comp (Computable.snd.comp Computable.snd))) |
| @[fun_prop] lemma c_gE : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>p.2.2.2.1) := |
| Computable.fst.comp (Computable.snd.comp (Computable.snd.comp Computable.snd)) |
| lemma grid_check_0 : ComputablePred (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>1 ≤ p.2.2.2.2.T) := by comp_arith |
| lemma grid_check_1 : ComputablePred (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>1 ≤ p.2.2.2.2.L) := by comp_arith |
| lemma grid_check_2 : ComputablePred (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>(p.1:ℚ)/(p.2.2.2.2.T:ℚ)^2 < p.2.2.2.1/4) := |
| ca_ratLt (ca_ratDiv (ca_ratCast Computable.fst) (ca_ratPow (ca_ratCast c_gT) (ca_const 2))) |
| (ca_ratDiv c_gE (ca_const 4)) |
| lemma grid_check_3 : ComputablePred (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>2*(p.2.1:ℚ)*p.2.2.1*p.2.2.2.2.T/p.2.2.2.2.L < p.2.2.2.1/4) := |
| ca_ratLt (ca_ratDiv (ca_ratMul (ca_ratMul |
| (ca_ratMul (ca_const 2) (ca_ratCast (Computable.fst.comp Computable.snd))) |
| (Computable.fst.comp (Computable.snd.comp Computable.snd))) (ca_ratCast c_gT)) (ca_ratCast c_gL)) |
| (ca_ratDiv c_gE (ca_const 4)) |
| lemma c_gErrorArg : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>((p.2.2.2.2.T:ℚ)^2/2)) := |
| ca_ratDiv (ca_ratPow (ca_ratCast c_gT) (ca_const 2)) (ca_const 2) |
| lemma c_gError : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>qError p.2.2.2.2.r ((p.2.2.2.2.T:ℚ)^2/2)) := |
| (c_qError.comp (c_gr.pair c_gErrorArg)).of_eq (by intro p; rfl) |
| lemma c_gCoef : Computable (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>2*(p.1:ℚ)*p.2.2.2.2.T) := |
| ca_ratMul (ca_ratMul (ca_const 2) (ca_ratCast Computable.fst)) (ca_ratCast c_gT) |
| lemma grid_check_4 : ComputablePred (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>2*(p.1:ℚ)*p.2.2.2.2.T*qError p.2.2.2.2.r ((p.2.2.2.2.T:ℚ)^2/2) < p.2.2.2.1/4) := |
| ca_ratLt (ca_ratMul c_gCoef c_gError) (ca_ratDiv c_gE (ca_const 4)) |
| lemma grid_check_computable : ComputablePred (fun p : ℕ × ℕ × ℚ × ℚ × GridData=>p.2.2.2.2.Check p.1 p.2.1 p.2.2.1 p.2.2.2.1) := |
| ca_and grid_check_0 (ca_and grid_check_1 (ca_and grid_check_2 (ca_and grid_check_3 (grid_check_4)))) |
| end MinUncut.Preprocess |
|
|
| end |
| section |
| namespace MinUncut.Preprocess |
| open MinUncut.FiniteGaussian |
|
|
| def gridTail (n : ℕ) : ℕ := n.unpair.2 |
| def gridField (n : ℕ) : ℕ := (n.unpair.1-1).unpair.2 |
| def gridExtract (n : ℕ) : GridData := |
| ⟨gridField (gridTail n),gridField (gridTail (gridTail n)), |
| gridField (gridTail (gridTail (gridTail n)))⟩ |
| lemma gridExtract_encode (g : GridData) : gridExtract (oldGridEncode g)=g := by |
| simp only [oldGridEncode_eq,gridExtract,gridTail,gridField,Nat.unpair_pair,Nat.add_sub_cancel_right] |
| lemma gridDecode_eq (n : ℕ) : oldGridDecode n = |
| if oldGridEncode (gridExtract n)=n then some (gridExtract n) else none := by |
| cases h : oldGridDecode n with |
| | none => |
| split |
| · next he => |
| have hk := @Encodable.encodek GridData instEncodableGridData (gridExtract n) |
| change oldGridDecode (oldGridEncode (gridExtract n))=some (gridExtract n) at hk |
| rw [he,h] at hk |
| cases hk |
| · rfl |
| | some g => |
| have he := oldGridDecode_canonical n g h |
| have hx : gridExtract n=g := by rw [←he,gridExtract_encode] |
| simp only [hx,he,ite_true] |
|
|
| @[fun_prop] lemma c_gridTail : Computable gridTail := Computable.snd.comp Computable.unpair |
| @[fun_prop] lemma c_gridField : Computable gridField := |
| Computable.snd.comp (Computable.unpair.comp |
| (ca_sub (Computable.fst.comp Computable.unpair) (ca_const 1))) |
| lemma c_gridMk : Computable gridDataEquiv.symm := |
| (Primrec.of_equiv_symm (e:=gridDataEquiv)).to_comp |
| lemma gridExtract_eq : gridExtract = fun n => gridDataEquiv.symm |
| (gridField (gridTail n),gridField (gridTail (gridTail n)), |
| gridField (gridTail (gridTail (gridTail n)))) := by |
| funext n |
| simp only [gridExtract,gridDataEquiv,Equiv.coe_fn_symm_mk] |
| lemma c_gridExtract₁ : Computable (fun n=>gridField (gridTail n)) := |
| c_gridField.comp c_gridTail |
| lemma c_gridExtract₂ : Computable (fun n=>gridField (gridTail (gridTail n))) := |
| c_gridExtract₁.comp c_gridTail |
| lemma c_gridExtract₃ : Computable (fun n=>gridField (gridTail (gridTail (gridTail n)))) := |
| c_gridExtract₂.comp c_gridTail |
| lemma c_gridExtractPair : Computable (fun n=>(gridField (gridTail n), |
| gridField (gridTail (gridTail n)),gridField (gridTail (gridTail (gridTail n))))) := |
| c_gridExtract₁.pair (c_gridExtract₂.pair c_gridExtract₃) |
| lemma c_gridExtract : Computable gridExtract := by |
| rw [gridExtract_eq] |
| exact c_gridMk.comp c_gridExtractPair |
| lemma c_oldGridEncode : Computable oldGridEncode := by |
| have hp : Computable₂ Nat.pair := Primrec₂.natPair.to_comp |
| rw [show oldGridEncode=(fun g : GridData=>Nat.pair (Nat.pair 0 0+1) |
| (Nat.pair (Nat.pair 0 g.T+1) (Nat.pair (Nat.pair 0 g.L+1) |
| (Nat.pair (Nat.pair 0 g.r+1) (Nat.pair 0 0))))) from funext oldGridEncode_eq] |
| exact hp.comp (ca_const _) (hp.comp (ca_add (hp.comp (ca_const 0) c_gridData_T) (ca_const 1)) |
| (hp.comp (ca_add (hp.comp (ca_const 0) c_gridData_L) (ca_const 1)) |
| (hp.comp (ca_add (hp.comp (ca_const 0) c_gridData_r) (ca_const 1)) (ca_const _)))) |
| lemma c_oldGridDecode : Computable oldGridDecode := by |
| have he : ComputablePred (fun n=>oldGridEncode (gridExtract n)=n) := |
| (Primrec.eq.computablePred.decide.comp ((c_oldGridEncode.comp c_gridExtract).pair Computable.id)).computablePred |
| exact (Computable.cond he.decide (Computable.option_some.comp c_gridExtract) (ca_const none)).of_eq |
| (by intro n; simp only [Bool.cond_decide]; exact (gridDecode_eq n).symm) |
| end MinUncut.Preprocess |
|
|
| end |
| section |
| namespace MinUncut.Preprocess |
| open MinUncut.Inner MinUncut.Outer MinUncut.FiniteGaussian |
|
|
| def parameterJ (K : ℕ) : ℕ := 10*(max K 2) |
| lemma parameterJ_pos (K : ℕ) : 1≤parameterJ K := by unfold parameterJ; omega |
| lemma parameterJ_eq (K : ℕ) (hK : 2≤K) : parameterJ K=10*K := by |
| unfold parameterJ |
| rw [max_eq_left hK] |
| @[fun_prop] lemma c_parameterJ : Computable parameterJ := by |
| have h : Computable (fun K : ℕ=>10*(K+(2-K))) := by fun_prop |
| exact h.of_eq (by intro K; unfold parameterJ; congr 1; omega) |
| lemma inner_exists (K : ℕ) : ∃d : InnerData,d.Check (parameterJ K) := |
| InnerData.check_exists (parameterJ_pos K) |
| noncomputable def selectedInner (K : ℕ) : InnerData := search inner_exists K |
| lemma selectedInner_check (K : ℕ) : (selectedInner K).Check (parameterJ K) := |
| search_spec inner_exists K |
| lemma c_inner_pred : ComputablePred (fun p : ℕ × InnerData=>p.2.Check (parameterJ p.1)) := |
| (inner_check_computable.decide.comp ((c_parameterJ.comp Computable.fst).pair Computable.snd)).computablePred |
| @[fun_prop] lemma c_selectedInner : Computable selectedInner := |
| computable_search c_inner_pred inner_exists ⟨0,0,0,0,0,0,0,0,0⟩ |
|
|
| attribute [local irreducible] selectedInner |
|
|
| lemma outer_exists (K : ℕ) : ∃o : OuterData,o.Check (parameterJ K) (selectedInner K) := |
| OuterData.check_exists (parameterJ_pos K) _ (selectedInner_check K) |
| noncomputable def selectedOuter (K : ℕ) : OuterData := search outer_exists K |
| lemma selectedOuter_check (K : ℕ) : (selectedOuter K).Check (parameterJ K) (selectedInner K) := |
| search_spec outer_exists K |
| lemma c_outer_arguments : Computable (fun p : ℕ × OuterData => |
| (parameterJ p.1,selectedInner p.1,p.2)) := by |
| exact (c_parameterJ.comp Computable.fst).pair |
| ((c_selectedInner.comp Computable.fst).pair Computable.snd) |
| lemma c_outer_decide : Computable (fun p : ℕ × OuterData => |
| decide (p.2.Check (parameterJ p.1) (selectedInner p.1))) := by |
| have hh : Computable (fun p : ℕ × InnerData × OuterData=>decide (p.2.2.Check p.1 p.2.1)) := |
| outer_check_computable.decide |
| exact @Computable.comp (ℕ × OuterData) (ℕ × InnerData × OuterData) Bool _ _ _ |
| (fun p=>decide (p.2.2.Check p.1 p.2.1)) (fun p=>(parameterJ p.1,selectedInner p.1,p.2)) hh c_outer_arguments |
| lemma c_outer_pred : ComputablePred (fun p : ℕ × OuterData=>p.2.Check (parameterJ p.1) (selectedInner p.1)) := |
| c_outer_decide.computablePred |
| @[fun_prop] lemma c_selectedOuter : Computable selectedOuter := |
| computable_search c_outer_pred outer_exists ⟨0,0,0,0,0⟩ |
| noncomputable def selectedParameters (K : ℕ) : Parameters (parameterJ K) := |
| ⟨parameterJ_pos K,selectedInner K,selectedInner_check K,selectedOuter K,selectedOuter_check K⟩ |
|
|
| def gridPredicate (x : ℕ × ℕ × ℚ × ℚ) (g : GridData) : Prop := |
| if 0≤x.2.2.1 ∧ 0<x.2.2.2 then g.Check x.1 x.2.1 x.2.2.1 x.2.2.2 else g=⟨0,0,0⟩ |
| instance : DecidableRel gridPredicate := fun _ _=>by unfold gridPredicate; infer_instance |
| lemma grid_exists (x : ℕ × ℕ × ℚ × ℚ) : ∃g,gridPredicate x g := by |
| unfold gridPredicate |
| split_ifs with h |
| · exact GridData.exists_check x.1 x.2.1 h.1 h.2 |
| · exact ⟨_,rfl⟩ |
| noncomputable def selectedGrid (x : ℕ × ℕ × ℚ × ℚ) : GridData := |
| searchWith instEncodableGridData grid_exists x |
| lemma selectedGrid_eq (d S : ℕ) (A ε : ℚ) (hA : 0≤A) (hε : 0<ε) : |
| selectedGrid (d,S,A,ε)=GridData.select d S A ε hA hε := by |
| unfold selectedGrid searchWith GridData.select |
| congr 1 |
| funext g |
| simp only [gridPredicate,hA,hε,and_self,ite_true] |
| lemma c_grid_valid : ComputablePred (fun x : ℕ × ℕ × ℚ × ℚ=>0≤x.2.2.1 ∧ 0<x.2.2.2) := |
| ca_and (ca_ratLe (ca_const 0) (Computable.fst.comp (Computable.snd.comp Computable.snd))) |
| (ca_ratLt (ca_const 0) (Computable.snd.comp (Computable.snd.comp Computable.snd))) |
| lemma c_grid_pred : ComputablePred (fun p : (ℕ × ℕ × ℚ × ℚ) × GridData=>gridPredicate p.1 p.2) := by |
| have hc := grid_check_computable.decide.comp (Computable.fst.comp Computable.fst |>.pair |
| ((Computable.fst.comp (Computable.snd.comp Computable.fst)).pair |
| ((Computable.fst.comp (Computable.snd.comp (Computable.snd.comp Computable.fst))).pair |
| ((Computable.snd.comp (Computable.snd.comp (Computable.snd.comp Computable.fst))).pair Computable.snd)))) |
| have he : Computable (fun p : (ℕ × ℕ × ℚ × ℚ) × GridData=>decide (p.2=⟨0,0,0⟩)) := |
| ComputablePred.decide ((Primrec.eq.computablePred.decide.comp |
| (Computable.snd.pair (ca_const (⟨0,0,0⟩ : GridData)))).computablePred) |
| have hh := Computable.cond (c_grid_valid.decide.comp Computable.fst) hc he |
| exact ⟨inferInstance,hh.of_eq (by |
| intro p |
| simp only [gridPredicate,Bool.cond_decide] |
| split_ifs <;> rfl)⟩ |
| lemma c_selectedGrid : Computable selectedGrid := |
| computable_searchWith instEncodableGridData c_oldGridDecode c_grid_pred grid_exists ⟨0,0,0⟩ |
| end MinUncut.Preprocess |
|
|
| end |
|
|
| end OAI |
|
|
