| import OAI.Computability.WLIdentification.MachinePresentation |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
| namespace FinitePresentation.MachineRealizer |
| open WordExpressions Machine |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| /-- Factor the finite enumerations through the compiled type names so instance |
| search does not repeatedly expand the entire cellular compiler. -/ |
| noncomputable instance compiledRealTypeFintype (M : Machine) (d : ℕ) (w : Word) : |
| Fintype (M.compiledCircuit d w).RealType := by infer_instance |
|
|
| noncomputable instance compiledComparisonFintype (M : Machine) (d : ℕ) (w : Word) : |
| Fintype (M.compiledCircuit d w).Comparison := by infer_instance |
|
|
| theorem width_poly (C e : ℕ) : NatPoly (fun X : Fin 1 → Word => addressWidth C e (X 0).length) := |
| NatPoly.add (NatPoly.add (NatPoly.add |
| (NatPoly.mul (NatPoly.const C) (NatPoly.pow_const (NatPoly.succ (NatPoly.var 0)) e)) (NatPoly.var 0)) |
| (NatPoly.const 32)) (NatPoly.const 2) |
|
|
| theorem inputSpan_lt_width (C e : ℕ) (w : Word) : inputSpan w<2^addressWidth C e w.length := by |
| have hs : inputSpan w≤w.length+1 := max_le (by omega) (by omega) |
| have hd : w.length+1≤addressWidth C e w.length := by unfold addressWidth paddedExponent; omega |
| exact hs.trans_lt ((Nat.lt_two_pow_self (n := w.length+1)).trans_le |
| (Nat.pow_le_pow_right (by decide) hd)) |
|
|
| theorem dimension_poly (C e : ℕ) : NatPoly (fun X : Fin 1 → Word => reductionDimension C e (X 0).length) := |
| NatPoly.add (width_poly C e) (width_poly C e) |
|
|
| noncomputable def compiled (M : Machine) (C e : ℕ) := |
| circuit M (fun w => addressWidth C e w.length) (width_poly C e) (inputSpan_lt_width C e) |
|
|
| theorem wire_poly (C e : ℕ) : NatPoly (fun X : Fin 1 → Word => 4*(reductionDimension C e (X 0).length+1)-1) := |
| NatPoly.sub (NatPoly.mul (NatPoly.const 4) (NatPoly.succ (dimension_poly C e))) (NatPoly.const 1) |
|
|
| noncomputable def ring (M : Machine) (C e : ℕ) := (compiled M C e).schemas.ring |
| (fun w => 4*(reductionDimension C e w.length+1)-1) (wire_poly C e) |
|
|
| noncomputable def affine (M : Machine) (C e : ℕ) := (ring M C e).affine |
| (fun w => by have := reductionDimension_ge C e w.length; change 2≤reductionDimension C e w.length; omega) |
|
|
| noncomputable def uncolored (M : Machine) (C e : ℕ) := (affine M C e).uncolored |
|
|
| theorem graph_isomorphic (M : Machine) (C e : ℕ) (w : Word) : |
| Isomorphic ((uncolored M C e).graph w) (M.reductionGraph C e w) := |
| (affine M C e).uncolored_isomorphic w |
|
|
| theorem graph_nonempty (M : Machine) (C e : ℕ) (w : Word) : |
| 0<((uncolored M C e).graph w).order := by |
| obtain ⟨f,_⟩ := graph_isomorphic M C e w |
| have he : ((uncolored M C e).graph w).order=(M.reductionGraph C e w).order := by |
| simpa only [Fintype.card_fin] using Fintype.card_congr f |
| rw [he] |
| exact M.reductionGraph_nonempty C e w |
|
|
| noncomputable def output (M : Machine) (C e : ℕ) : Word → Word := |
| (uncolored M C e).output (fun w => reductionDimension C e w.length) |
|
|
| theorem output_poly (M : Machine) (C e : ℕ) : Poly (fun X : Fin 1 → Word => output M C e (X 0)) := |
| (uncolored M C e).output_poly (dimension_poly C e) |
|
|
| theorem output_correct {L : BinaryLanguage} {M : Machine} {C e : ℕ} |
| (h : DecidesWithin M L (fun m => 2^(C*(m+1)^e))) (w : Word) : |
| w∈L ↔ output M C e w∈dimensionLanguage := by |
| rw [output,PresentedGraph.output_eq,inputWord_mem_iff _ (graph_nonempty M C e w) _ |
| (by have := reductionDimension_ge C e w.length; omega), |
| WLdim_isomorphic (graph_isomorphic M C e w),M.reductionGraph_correct h w] |
| end FinitePresentation.MachineRealizer |
|
|
| /-- The reduction is an actual polynomial-time tape transducer. Relabeling is |
| by effective rank/select on polynomial finite coding families, not by an |
| arbitrary Fintype enumeration. Its semantic conclusion retains all graph mates. -/ |
| theorem dimensionLanguage_hard : ∀ L : BinaryLanguage, InEXPTIME L → PolytimeManyOne L dimensionLanguage := by |
| intro L ⟨M,C,e,h⟩ |
| obtain ⟨N,c,d,hN⟩ := (FinitePresentation.MachineRealizer.output_poly M C e).computes |
| exact ⟨FinitePresentation.MachineRealizer.output M C e,N,c,d,hN, |
| FinitePresentation.MachineRealizer.output_correct h⟩ |
|
|
| end WLIdentification |
|
|
| end OAI |
|
|
