File size: 4,220 Bytes
92416a2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 | 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
|