| import Mathlib |
| import OAI.Computability.MinUncut.Estimates.UniformRestrict |
| import OAI.Computability.MinUncut.Encoding.DerivedResolver |
| import OAI.Computability.MinUncut.Estimates.ExpressionEffectivity |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace MinUncut.Preprocess.Syntax |
| open MinUncutGames.Foundations.Hastad.SourceOccurrences |
| open MinUncut.Costed MinUncut.CodeEffective Turing.ToPartrec UEncoding |
| variable {P : Type} [Primcodable P] {A B : P → Type} |
| def O (c : UEncoding P A) (f : ∀p,A p → AExpr) : Prop := c.Out (fun p x=>(f p x).program.code) |
| variable {c : UEncoding P A} |
| lemma O.fixed (e : AExpr) : O c (fun _ _=>e) := out_const c (Computable.const _) |
| lemma O.const {f : ∀p,A p → ℕ} (hf : c.Out f) : O c (fun p x=>.const (f p x)) := hf.map p_constCode.to_comp |
| lemma O.reg {f : ∀p,A p → ℕ} (hf : c.Out f) : O c (fun p x=>.reg (f p x)) := hf.map p_atCode.to_comp |
| lemma O.add {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.add (a p x) (b p x)) := |
| ha.map₂ hb (p_bin PolyProgram.add.code).to_comp |
| lemma O.sub {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.sub (a p x) (b p x)) := |
| ha.map₂ hb (p_bin PolyProgram.sub.code).to_comp |
| lemma O.mul {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.mul (a p x) (b p x)) := |
| ha.map₂ hb (p_bin PolyProgram.mul.code).to_comp |
| lemma O.div {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.div (a p x) (b p x)) := |
| ha.map₂ hb (p_bin Division.quotient.code).to_comp |
| lemma O.mod {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.mod (a p x) (b p x)) := |
| ha.map₂ hb (p_bin Division.remainder.code).to_comp |
| lemma O.cond {e a b : ∀p,A p → AExpr} (he : O c e) (ha : O c a) (hb : O c b) : |
| O c (fun p x=>.cond (e p x) (a p x) (b p x)) := by |
| have hh := (he.pair (ha.pair hb)).map p_branch.to_comp |
| exact hh.ofEq (fun p x=>(cond_code (e p x) (a p x) (b p x)).symm) |
| lemma O.eq {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.eq (a p x) (b p x)) := by |
| have hh := ((ha.sub hb).add (hb.sub ha)).cond (O.fixed (.const 1)) (O.fixed (.const 0)) |
| exact hh.ofEq (fun p x=>(eq_code (a p x) (b p x)).symm) |
| lemma O.le {a b : ∀p,A p → AExpr} (ha : O c a) (hb : O c b) : O c (fun p x=>.le (a p x) (b p x)) := by |
| have hh := (ha.sub hb).cond (O.fixed (.const 1)) (O.fixed (.const 0)) |
| exact hh.ofEq (fun p x=>(le_code (a p x) (b p x)).symm) |
| lemma O.at {a : ∀p,A p → AExpr} (ha : O c a) : O c (fun p x=>.at (a p x)) := by |
| have hh := ha.map (computable_comp.comp (Computable.const PolyProgram.dynamic.code) |
| (computable_cons.comp Computable.id (Computable.const Code.id))) |
| exact hh.ofEq (fun p x=>(at_code (a p x)).symm) |
| lemma O.choose {q : ∀p,A p → Bool} {a b : ∀p,A p → AExpr} |
| (hq : c.Map bool q) (ha : O c a) (hb : O c b) : O c (fun p x=>if q p x then a p x else b p x) := by |
| apply (Out.cond hq ha hb).ofEq |
| intro p x |
| change (if q p x = true then (a p x).program.code else (b p x).program.code) = |
| (if q p x = true then a p x else b p x).program.code |
| by_cases h : q p x = true |
| · rw [ite_eq_left h] |
| exact (congrArg (fun e : AExpr=>e.program.code) (ite_eq_left h : (if q p x = true then a p x else b p x)=a p x)).symm |
| · rw [ite_eq_right h] |
| exact (congrArg (fun e : AExpr=>e.program.code) (ite_eq_right h : (if q p x = true then a p x else b p x)=b p x)).symm |
|
|
| def powCode (a : Code) (n : ℕ) : Code := Nat.rec (AExpr.const 1).program.code (fun _ ih=>bin PolyProgram.mul.code ih a) n |
| lemma c_powCode : Computable₂ powCode := by |
| exact Computable.nat_rec Computable.snd (Computable.const _) |
| ((p_bin PolyProgram.mul.code).to_comp.comp (Computable.snd.comp Computable.snd) |
| (Computable.fst.comp Computable.fst)).to₂ |
| lemma O.pow {a : ∀p,A p → AExpr} {n : ∀p,A p → ℕ} (ha : O c a) (hn : c.Out n) : |
| O c (fun p x=>(a p x).pow (n p x)) := |
| (ha.map₂ hn c_powCode).ofEq (fun p x=>powCode_eq (a p x) (n p x)) |
| lemma O.sum {as : ∀p,A p → List AExpr} (hs : c.Out (fun p x=>(as p x).map (fun a=>a.program.code))) : |
| O c (fun p x=>AExpr.sum (as p x)) := |
| (hs.map p_sumCode.to_comp).ofEq (fun p x=>sumCode_eq (as p x)) |
| lemma O.first {a : ∀p,A p → AExpr} {b : UEncoding P B} (ha : O c a) : |
| O (c.prod b) (fun p x=>a p x.1) := Out.first ha |
| lemma O.second {a : ∀p,A p → AExpr} {b : UEncoding P B} (ha : O c a) : |
| O (b.prod c) (fun p x=>a p x.2) := Out.second ha |
| lemma O.comp {a : ∀p,B p → AExpr} {b : UEncoding P B} {f : ∀p,A p → B p} |
| (ha : O b a) (hf : c.Map b f) : O c (fun p x=>a p (f p x)) := Out.comp ha hf |
| lemma O.fromC {a : P → AExpr} (ha : C a) : O c (fun p _=>a p) := out_const c ha |
| lemma O.toC {a : P → AExpr} (ha : O (UEncoding.fixed (P:=P) Encoding.unit) (fun p _=>a p)) : C a := by |
| obtain ⟨f,hf,he⟩:=ha |
| exact (hf.comp (Computable.id.pair (Computable.const 0))).of_eq (fun p=>he p ()) |
|
|
| end MinUncut.Preprocess.Syntax |
|
|
| end |
| namespace MinUncut.SourceTemplate |
| open MinUncutGames.Foundations MinUncutGames.Foundations.Target |
| open PCP Hastad Hastad.SourceContexts Hastad.SourceOccurrences |
| open MinUncutGames.Reduction.CloneGap |
|
|
| structure Signature (u : ℕ) where |
| positive : Fin u → Slot → Bool |
| same : (Fin u × Slot) → (Fin u × Slot) → Bool |
|
|
| def positiveAt {n : ℕ} (c : Clause n) : Slot → Bool |
| | .first => (c)[0].positive |
| | .second => (c)[1].positive |
| | .third => (c)[2].positive |
|
|
| def signature (F : Formula) {u : ℕ} (c : ClauseContext F u) : Signature u where |
| positive t := positiveAt (clauseAt F (c t)) |
| same a b := decide (nameAt (clauseAt F (c a.1)) a.2 = nameAt (clauseAt F (c b.1)) b.2) |
|
|
| def Signature.satisfies {u : ℕ} (S : Signature u) (j : J u) (t : Fin u) : Bool := |
| (literalValue (S.positive t .first) (j t).first || |
| literalValue (S.positive t .second) (j t).second) || |
| literalValue (S.positive t .third) (j t).third |
|
|
| def Signature.valid {u : ℕ} (S : Signature u) (j : J u) : Bool := |
| decide ((∀ t, S.satisfies j t = true) ∧ ∀ t t' s s', |
| S.same (t,s) (t',s') = true → answerAt (j t) s = answerAt (j t') s') |
|
|
| def Signature.slot {u : ℕ} (S : Signature u) (s : SlotContext u) (t : Fin u) : Slot := |
| if S.same (t,.first) (t,s t) then .first |
| else if S.same (t,.second) (t,s t) then .second else .third |
|
|
| def Signature.project {u : ℕ} (S : Signature u) (s : SlotContext u) (j : J u) : I u := |
| fun t => answerAt (j t) (S.slot s t) |
|
|
| @[simp] lemma signature_valid (F : Formula) {u : ℕ} (c : ClauseContext F u) : |
| (signature F c).valid = validJ F c := by |
| funext j |
| simp only [Signature.valid, signature, Signature.satisfies, positiveAt, |
| validJ, localSatisfies, decide_eq_true_eq] |
| rfl |
|
|
| @[simp] lemma signature_project (F : Formula) {u : ℕ} (c : ClauseContext F u) |
| (s : SlotContext u) : |
| (signature F c).project s = pi F c (sampledVariables F c s) := by |
| funext j t |
| simp only [Signature.project, Signature.slot, signature, decide_eq_true_eq, |
| pi, canonicalSlot, sampledVariables] |
| rfl |
|
|
| abbrev LocalKey (u : ℕ) := Cube (I u) ⊕ (Cube (J u) ⊕ Unit) |
|
|
| def keyAddress (F : Formula) {u : ℕ} (c : ClauseContext F u) |
| (v : VariableContext F u) : LocalKey u → Fin (nBits F u) |
| | .inl f => (proofEncoding F u).code (.inl (v,f)) |
| | .inr (.inl g) => (proofEncoding F u).code (.inr (.inl (c,g))) |
| | .inr (.inr _) => dummyIndex F u |
|
|
| def emptyLocal {u : ℕ} : EmptyContext.Address (leftAnchor u) → LocalKey u |
| | .inl f => .inl f.val |
| | .inr _ => .inr (.inr ()) |
|
|
| def foldedLocal {u : ℕ} (valid : J u → Bool) |
| (j₀ : {j : J u |
| FoldedEquation.Address (leftAnchor u) j₀ → LocalKey u |
| | .inl f => .inl f.val |
| | .inr g => .inr (.inl (extendRestricted valid g.val)) |
|
|
| def localEquation {u D : ℕ} (valid : J u → Bool) (π : J u → I u) |
| (t : SourceTape.TestTape (I u) (J u) D) : Equation (LocalKey u) := |
| match firstValid (jEncoding u) valid with |
| | none => mapEquation emptyLocal (EmptyContext.equation (leftAnchor u) t.1) |
| | some j₀ => mapEquation (foldedLocal valid j₀) |
| (FoldedEquation.conditionedEquation valid π (leftAnchor u) j₀ t.1 t.2.2 |
| (MinUncutGames.Reduction.FiniteNoise.realizedNoise t.2.1)) |
|
|
| def Signature.equation {u D : ℕ} (S : Signature u) (s : SlotContext u) |
| (t : SourceTape.TestTape (I u) (J u) D) : Equation (LocalKey u) := |
| localEquation S.valid (S.project s) t |
|
|
| lemma mapEquation_comp {A B C : Type} (f : A → B) (g : B → C) (e : Equation A) : |
| mapEquation g (mapEquation f e) = mapEquation (g ∘ f) e := by |
| cases e |
| rfl |
|
|
| lemma localEquation_spec (F : Formula) {u D : ℕ} (c : ClauseContext F u) |
| (v : VariableContext F u) (t : SourceTape.TestTape (I u) (J u) D) : |
| mapEquation (keyAddress F c v) (localEquation (validJ F c) (pi F c v) t) = |
| contextEquation F u D c v t := by |
| unfold localEquation contextEquation rightAnchor |
| cases h : firstValid (jEncoding u) (validJ F c) with |
| | none => |
| simp only |
| rw [mapEquation_comp] |
| congr 1 |
| funext a |
| cases a <;> rfl |
| | some j₀ => |
| simp only |
| rw [mapEquation_comp] |
| unfold conditionedOccurrence |
| congr 1 |
| funext a |
| cases a <;> rfl |
|
|
| lemma signature_equation (F : Formula) {u D : ℕ} (c : ClauseContext F u) |
| (s : SlotContext u) (t : SourceTape.TestTape (I u) (J u) D) : |
| mapEquation (keyAddress F c (sampledVariables F c s)) |
| ((signature F c).equation s t) = sourceEquation F u D ((c,s),t) := by |
| unfold Signature.equation |
| rw [signature_valid, signature_project] |
| exact localEquation_spec F c _ t |
|
|
| end MinUncut.SourceTemplate |
|
|
| end OAI |
|
|
