File size: 5,186 Bytes
ea76aac | 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 | import Mathlib
import OAI.Computability.MaxCut.Analysis.CubeEquiv
import OAI.Computability.MaxCut.Estimates.ListSum
namespace OAI
noncomputable section
namespace OptimalMaxCut.RawGrid
open scoped BigOperators
open Finset MaxCutGames.Foundations.Target MaxCutGames.Foundations.Hastad
open LongCode LongCode.InstanceAdapter CounterMachine.Expr
attribute [local instance] Classical.propDecidable
@[simp] theorem vertices_bits {q : ℕ} (g : Instance q) : vertices (bits g) = g.vertices := (word_header g).1
@[simp] theorem edges_bits {q : ℕ} (g : Instance q) : edges (bits g) = g.constraints.length := (word_header g).2.2
@[simp] theorem row_source {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) :
row q (bits g) e 0 = g.constraints[e].source.val := by
simpa [row] using InstanceAdapter.row_source g e
@[simp] theorem row_target {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) :
row q (bits g) e 1 = g.constraints[e].target.val := InstanceAdapter.row_target g e
@[simp] theorem row_image {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) (i : Fin q) :
row q (bits g) e (2+i.val) = g.constraints[e].permutation.images[i].val := InstanceAdapter.row_image g e i
@[simp] theorem degree_bits {q : ℕ} (g : Instance q) (y : Fin g.vertices) :
degree q (bits g) y = InstanceAdapter.degree g y := by
rw [degree, edges_bits, ← Fin.sum_univ_eq_sum_range]
unfold InstanceAdapter.degree
apply sum_congr rfl
intro e he
rw [row_target]
simp only [Fin.val_inj]
@[simp] theorem lookup_fin {q : ℕ} (x : Cube (Fin q)) (i : Fin q) :
lookup x i.val = (finTwoEquiv.symm (x i)).val := by
simp [lookup, Fin.val_inj]
@[simp] theorem permCode_bits {q : ℕ} (g : Instance q) (e : Fin g.constraints.length)
(x : Cube (Fin q)) :
permCode (bits g) e x = (cubeEquiv q (cubePerm (MaxCutGames.Explicit.MachineOutputContract.permutationEquiv g.constraints[e].permutation) x)).val := by
simp only [permCode, row_image, lookup_fin, cubeEquiv, Equiv.trans_apply, finFunctionFinEquiv_apply]
rfl
@[simp] theorem query_bits {q : ℕ} (g : Instance q) (e : Fin g.constraints.length)
(x : Cube (Fin q)) :
query (bits g) e x = (vertexEquiv g.vertices q
(g.constraints[e].source,cubePerm (MaxCutGames.Explicit.MachineOutputContract.permutationEquiv g.constraints[e].permutation) x)).val := by
simp only [query, permCode_bits, row_source]
rfl
@[simp] theorem gridSize_bits {q : ℕ} (g : Instance q) (K : ℕ) :
gridSize q K (bits g) = Game.gridSize (Fin g.vertices) (Fin g.constraints.length) q K := by
simp [gridSize, Game.gridSize, Game.Sample, vertices_bits, edges_bits]
theorem rational_floor (c : ℚ) (hc : 0 ≤ c) (P d m : ℕ) :
⌊(P:ℚ)*((d:ℚ)*c/((m:ℚ)*(d:ℚ)^2))⌋₊ =
P*d*c.num.toNat/(c.den*m*d^2) := by
have hn : ((c.num.toNat:ℕ):ℚ) = (c.num:ℚ) := by
exact_mod_cast Int.toNat_of_nonneg (Rat.num_nonneg.mpr hc)
have hc' : c = ((c.num.toNat:ℕ):ℚ)/c.den := by rw [hn, Rat.num_div_den]
conv_lhs => rw [hc']
have he : (P:ℚ)*((d:ℚ)*(((c.num.toNat:ℕ):ℚ)/c.den)/((m:ℚ)*(d:ℚ)^2)) =
((P*d*c.num.toNat:ℕ):ℚ)/((c.den*m*d^2:ℕ):ℚ) := by
push_cast
simp only [div_eq_mul_inv, mul_inv_rev]
ring
rw [he, Nat.floor_div_natCast, Nat.floor_natCast]
@[simp] theorem atom_bits {q : ℕ} (g : Instance q) (t : ℚ)
(ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) (y : Fin g.vertices)
(e f : Fin g.constraints.length) (x z : Cube (Fin q)) :
atom t ht K (bits g) y e f x z =
⌊(Game.gridSize (Fin g.vertices) (Fin g.constraints.length) q K:ℚ)*
((ofInstance g).sampleLaw t ht).weight (y,e,f,x,z)⌋₊ := by
rw [InstanceAdapter.sampleLaw_weight]
simp only [atom, row_target, Fin.val_inj, gridSize_bits, degree_bits, edges_bits]
split_ifs
· exact (rational_floor _ ((jointLaw t ht q).nonneg _) _ _ _).symm
· simp
/-- Byte-oriented integer aggregation is exactly the rational rounded law.
This identity is independent of computational complexity assumptions. -/
theorem weights_bits {q : ℕ} (g : Instance q) (t : ℚ)
(ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ)
(anchor : Fin (g.vertices*2^q)) (u v : Fin (g.vertices*2^q)) :
(ofInstance g).gridWeights t ht (vertexEquiv g.vertices q) anchor K u v =
(weights q t ht K (bits g) u.val v.val : ℚ) / gridSize q K (bits g) := by
rw [Game.gridWeights, roundedWeights_integer, gridSize_bits]
by_cases huv : u=v
· subst v; simp [weights]
· have hval : u.val ≠ v.val := fun h => huv (Fin.ext h)
simp only [huv, ↓reduceIte, weights, hval, vertices_bits, edges_bits]
congr 2
rw [Fintype.sum_prod_type]
rw [← Fin.sum_univ_eq_sum_range]
apply sum_congr rfl
intro y hy
rw [Fintype.sum_prod_type, ← Fin.sum_univ_eq_sum_range]
apply sum_congr rfl
intro e he
rw [Fintype.sum_prod_type, ← Fin.sum_univ_eq_sum_range]
apply sum_congr rfl
intro f hf
rw [Fintype.sum_prod_type]
apply sum_congr rfl
intro x hx
apply sum_congr rfl
intro z hz
simp only [query_bits, atom_bits, Game.queries, ofInstance, Prod.mk.injEq, ← Fin.val_inj]
end OptimalMaxCut.RawGrid
end
end OAI
|