File size: 6,487 Bytes
d5b7741 | 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 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | import OAI.Combinatorics.ContingencyTables.Machines.NatListEquality
import OAI.Combinatorics.ContingencyTables.Dense.DenseAxisWordProgram
namespace OAI
/-! # Testing dense adjacency by the polynomial list of signed directions -/
namespace ContingencyTables.DensePrograms
open MatchingFPRAS MatchingFPRAS.TreeTyped GridBoundary
abbrev AxisNumberData := (ℕ×List ℕ)×ℕ
def axisNumberStep (z : AxisNumberData) : Option (List ℕ) :=
axisListStep ((z.1,z.2/2),decide (z.2%2=1))
def axisNumberStepRealizer : Realizer axisNumberStep :=
composition (pair (pair first (composition (pair second (constant 2)) quotient))
(composition (pair (composition (pair second (constant 2)) remainder) (constant 1)) natEqual))
axisListStepRealizer
theorem polynomial_axisNumberStep : PolynomialTime axisNumberStepRealizer :=
polynomial_composition (polynomial_pair
(polynomial_pair polynomial_first
(polynomial_composition (polynomial_pair polynomial_second (polynomial_constant 2))
polynomial_quotient))
(polynomial_composition (polynomial_pair
(polynomial_composition (polynomial_pair polynomial_second (polynomial_constant 2))
polynomial_remainder) (polynomial_constant 1)) polynomial_natEqual)) polynomial_axisListStep
theorem axisNumberStep_eq {q K M : ℕ} (a : Grid (I := Fin q) K) (v : Fin M) :
axisNumberStep ((K,gridNatCode a),v.val)=(axisCodeStep a v).map gridNatCode := by
change axisListStep (((K,gridNatCode a),v.val/2),decide (v.val%2=1))=_
by_cases hv : v.val<q*2
· let u : Fin (q*2) := ⟨v.val,hv⟩
let dir := (directionCodeEquiv q).symm u
have hfirst : dir.1.val=v.val/2 := directionCode_first u
have hsecond : dir.2=decide (v.val%2=1) := directionCode_second u
rw [←hfirst,←hsecond,axisListStep_eq]
simp only [axisCodeStep,dite_eq_left hv]
rfl
· have hi : ¬v.val/2<q := by omega
have hlen : (gridNatCode a).length=q := by simp only [gridNatCode,List.length_ofFn]
simp only [axisListStep,hlen,ite_eq_right hi,axisCodeStep,dite_eq_right hv,Option.map_none]
abbrev ProposalTestData := (ℕ×List ℕ)×List ℕ
def proposalMatches (z : ProposalTestData×ℕ) : Bool :=
(axisNumberStep (z.1.1,z.2)).elim false (fun xs => NatListEquality.listEqual (xs,z.1.2))
def proposalMatchesRealizer : Realizer proposalMatches :=
composition (pair identity
(composition (pair (composition first first) second) axisNumberStepRealizer))
(optionCases (constant false)
(composition (pair second (composition (composition first first) second))
NatListEquality.listEqualRealizer))
lemma polynomial_proposalMatches : PolynomialTime proposalMatchesRealizer :=
polynomial_composition (polynomial_pair polynomial_identity
(polynomial_composition (polynomial_pair (polynomial_composition polynomial_first polynomial_first)
polynomial_second) polynomial_axisNumberStep))
(polynomial_optionCases (polynomial_constant false)
(polynomial_composition (polynomial_pair polynomial_second
(polynomial_composition (polynomial_composition polynomial_first polynomial_first)
polynomial_second)) NatListEquality.polynomial_listEqual))
def proposalIndices (z : ProposalTestData) : List ℕ := List.range (2*z.1.2.length)
def proposalIndicesRealizer : Realizer proposalIndices := by
let L : Realizer (fun z : ProposalTestData => z.1.2.length) :=
composition (composition first second) listLength
let M := composition (pair (constant 2) L) multiply
exact composition M range
lemma polynomial_proposalIndices : PolynomialTime proposalIndicesRealizer := by
unfold proposalIndicesRealizer
apply polynomial_boundedRange (polynomial_composition (polynomial_pair (polynomial_constant 2)
(polynomial_composition (polynomial_composition polynomial_first polynomial_second)
polynomial_listLength)) polynomial_multiply) (2*Polynomial.X)
intro z
have hl: z.1.2.length ≤ weight z:=
(list_length_le_weight z.1.2).trans ((weight_snd z.1).trans (weight_fst z))
simpa only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,Function.comp_apply] using
Nat.mul_le_mul_left 2 hl
def hasProposal (z : ProposalTestData) : Bool :=
(proposalIndices z).any (fun i => proposalMatches (z,i))
def hasProposalRealizer : Realizer hasProposal :=
(composition (composition (pair identity proposalIndicesRealizer)
(mapWith proposalMatchesRealizer)) any).congr (by
intro z
simp only [Function.comp_apply,List.any_map,id_eq,Function.comp_def,hasProposal])
theorem polynomial_hasProposal : PolynomialTime hasProposalRealizer := by
unfold hasProposalRealizer
apply polynomial_congr
exact polynomial_composition (polynomial_composition
(polynomial_pair polynomial_identity polynomial_proposalIndices)
(polynomial_mapWith polynomial_proposalMatches)) polynomial_any
lemma gridNatCode_injective {q K : ℕ} : Function.Injective (gridNatCode (q := q) (K := K)) := by
intro a b h
have hv:=List.ofFn_injective h
funext i
apply Subtype.ext
have hi:=congrFun hv i
change (corner a i).toNat=(corner b i).toNat at hi
have ha: 0≤corner a i := (a i).property.1
have hb: 0≤corner b i := (b i).property.1
change corner a i=corner b i
have hv:=congrArg (fun n : ℕ => (n:ℤ)) hi
simpa only [Int.toNat_of_nonneg ha,Int.toNat_of_nonneg hb] using hv
theorem hasProposal_code {q K : ℕ} (a b : Grid (I := Fin q) K) :
hasProposal ((K,gridNatCode a),gridNatCode b)=true ↔ Neighbor a b := by
simp only [hasProposal,List.any_eq_true]
constructor
· rintro ⟨v,hv,h⟩
have hlen : v<2*q := by simpa [proposalIndices,gridNatCode] using hv
rw [proposalMatches,axisNumberStep_eq a (⟨v,by omega⟩ : Fin (2*q))] at h
cases he:axisCodeStep a (⟨v,by omega⟩ : Fin (2*q)) with
| none => simp [he] at h
| some c =>
have hc : gridNatCode c=gridNatCode b :=
(NatListEquality.listEqual_true _ _).mp (by simpa [he] using h)
have hcb:=gridNatCode_injective hc
subst c
exact axisCodeStep_sound a b _ he
· intro h
obtain ⟨v,hv⟩:=axisCodeStep_exists (le_refl (q*2)) a b h
refine ⟨v.val,?_,?_⟩
· simpa only [proposalIndices,List.mem_range,gridNatCode,List.length_ofFn,Nat.mul_comm] using v.isLt
· rw [proposalMatches,axisNumberStep_eq a v,hv]
simpa only [Option.map_some,Option.elim_some] using
(NatListEquality.listEqual_true _ _).mpr rfl
end ContingencyTables.DensePrograms
end OAI
|