Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentBoundary.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 32.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentBoundary.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentBoundary.lean
-
curl -L -o FactorAssignmentBoundary.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentBoundary.lean
32.2 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentCallbackNative | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.QueryTupleState | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.DensePolynomialProgramZero | |
| /-! The real initializer and paid cache setup establish the physical boundary | |
| for the actual stored-ID fold. Bounds are fixed before that fold; the current | |
| Good-empty-support seed is serialized on151, the unread suffix on150 and the | |
| reversed original ID on149. No execution service is a field below. -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentBoundary | |
| open OAI BitProgram StructuredCalls SubexpSetupStorage | |
| open OAI.Algorithms.SubexponentialSAT.SqrtLog OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgram HashCircuitProgram HashCircuitProgram.Native | |
| open IdempotentApplyProgram.Steps MomentsProgram NativeSemantics | |
| open OAI.Algorithms.SubexponentialSAT.SubexpLiftRing OAI.Algorithms.SubexponentialSAT.SubexpQuarticRing | |
| open FactorAssignmentProgram | |
| noncomputable section | |
| attribute [local simp] Fin.coe_ofNat_eq_mod | |
| /-- The fixed source masters read by the actual scalar table producer. -/ | |
| def scalarPorts : List (Fin 768) := | |
| [194,202,203,201,204,145,280,207,78,128,243,138,703] | |
| /-- The fixed layout/source masters read by the actual source-row producer. -/ | |
| def sourcePorts : List (Fin 768) := | |
| [130,131,132,710,711,140,712,138,139,135,136,713,714,715,717,716,280,207,211,728] | |
| /-- All retained words used at a factor boundary, including the original175 | |
| ID stream and actual857 correction word. -/ | |
| def retainedPorts : List (Fin 896) := | |
| (scalarPorts ++ sourcePorts).map FactorTableProgram.basePort ++ | |
| [175,212,281,700,701,702,704,705,706,707,708,857] | |
| theorem table_entry_written (i : Fin 896) (hi : i ∈ FactorTableProgram.entryPorts) : | |
| i ∈ FactorTableSpace.writtenPorts := by | |
| rcases List.mem_append.mp hi with hi | hi | |
| · obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi | |
| exact List.mem_append_left _ (List.mem_map.mpr ⟨j,(List.mem_filter.mp hj).1,rfl⟩) | |
| · exact List.mem_append_right _ hi | |
| /-- Numeric support of the actual relocated source writes. -/ | |
| theorem written_bounds (i : Fin 896) (hi : i ∈ FactorTableSpace.writtenPorts) : | |
| i.val = 62 ∨ (340 ≤ i.val ∧ i.val ≤ 684) ∨ | |
| i.val = 881 ∨ i.val = 882 ∨ (885 ≤ i.val ∧ i.val ≤ 892) := by | |
| rcases List.mem_append.mp hi with hi | hi | |
| · obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi | |
| have hjb := Incidence.mem_workerPorts j |>.mp hj | |
| unfold FactorTableProgram.basePort | |
| split_ifs | |
| all_goals simp only [Fin.coe_ofNat_eq_mod, Fin.val_castAdd] | |
| all_goals omega | |
| · simp only [List.mem_cons,List.mem_nil_iff,or_false] at hi | |
| rcases hi with rfl|rfl|rfl|rfl|rfl|rfl|rfl|rfl <;> norm_num [Fin.coe_ofNat_eq_mod] | |
| theorem retained_not_entry (i : Fin 896) (hi : i ∈ retainedPorts) : | |
| i ∉ entryScratch := by | |
| have small : ∀ i ∈ retainedPorts, | |
| i ∉ ([149,150,151,159,854] ++ callbackScratch.map lowStack : List (Fin 896)) := | |
| List.forall_iff_forall_mem.mp (by decide) | |
| have outside : ∀ i ∈ retainedPorts, | |
| i.val ≠ 62 ∧ (i.val < 340 ∨ 684 < i.val) ∧ i.val ≠ 881 ∧ i.val ≠ 882 ∧ | |
| (i.val < 885 ∨ 892 < i.val) := List.forall_iff_forall_mem.mp (by decide) | |
| intro hm | |
| rcases List.mem_append.mp hm with hm | hm | |
| · exact small i hi hm | |
| · have hw := written_bounds i (table_entry_written i hm) | |
| have ho := outside i hi | |
| omega | |
| theorem retained_not_cache (i : Fin 896) (hi : i ∈ retainedPorts) : | |
| i ∉ cachePorts.map lowStack := | |
| (List.forall_iff_forall_mem.mp (by decide) : ∀ i ∈ retainedPorts, | |
| i ∉ cachePorts.map lowStack) i hi | |
| theorem entry_not_cache (i : Fin 896) (hi : i ∈ entryScratch) : | |
| i ∉ LeafNodeCacheProgram.cachePorts.map lowStack := by | |
| have small : ∀ i ∈ ([149,150,151,159,854] ++ callbackScratch.map lowStack : List (Fin 896)), | |
| i ∉ LeafNodeCacheProgram.cachePorts.map lowStack := List.forall_iff_forall_mem.mp (by decide) | |
| rcases List.mem_append.mp hi with hi | hi | |
| · exact small i hi | |
| · intro hm | |
| have hw := written_bounds i (table_entry_written i hi) | |
| have hc : i.val < 340 ∧ i.val ≠ 62 := | |
| (List.forall_iff_forall_mem.mp (by decide) : ∀ i ∈ LeafNodeCacheProgram.cachePorts.map lowStack, | |
| i.val < 340 ∧ i.val ≠ 62) i hm | |
| omega | |
| theorem table_written_entry (i : Fin 896) (hi : i ∈ FactorTableSpace.writtenPorts) | |
| (h556 : i ≠ 556) : i ∈ entryScratch := by | |
| apply List.mem_append_right | |
| rcases List.mem_append.mp hi with hi | hi | |
| · obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi | |
| apply List.mem_append_left | |
| apply List.mem_map.mpr | |
| refine ⟨j,List.mem_filter.mpr ⟨hj,?_⟩,rfl⟩ | |
| have hn : j ≠ 556 := by intro he; subst j; exact h556 rfl | |
| simpa only [decide_eq_true_eq] using hn | |
| · exact List.mem_append_right _ hi | |
| theorem scalar_frame {t d J R n : ℕ} {model : RingModel.Data d} | |
| {M : SubexpPreparedQuartic.Modulus 3 t} {cache : RingProgram.ScalarCache 3 t} | |
| {theta : DensePolynomialProgram.Coeff (baseWidth 3 t) d} | |
| {a b : State 16 768} | |
| (h : FactorTableNative.ScalarMasters t model M cache J R theta a n) | |
| (hf : ∀ i ∈ scalarPorts, b.stacks i = a.stacks i) : | |
| FactorTableNative.ScalarMasters t model M cache J R theta b n := by | |
| refine ⟨h.widthPositive,h.zeroCanonical,h.zeroBits,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_⟩ | |
| · rw [hf 194 (by decide)]; exact h.modulus | |
| · rw [hf 202 (by decide)]; exact h.width | |
| · rw [hf 203 (by decide)]; exact h.zero | |
| · rw [hf 201 (by decide)]; exact h.table | |
| · rw [hf 204 (by decide)]; exact h.degree | |
| · rw [hf 145 (by decide)]; exact h.choicesLength | |
| · rw [hf 280 (by decide)]; exact h.zeroWord | |
| · rw [hf 207 (by decide)]; exact h.oneWord | |
| · rw [hf 78 (by decide)]; exact h.thetaWord | |
| · rw [hf 128 (by decide)]; exact h.ambientCount | |
| · rw [hf 243 (by decide)]; exact h.targetCount | |
| · rw [hf 138 (by decide)]; exact h.radius | |
| · rw [hf 703 (by decide)]; exact h.highLength | |
| theorem source_frame {r Q d : ℕ} {p : LayoutProgram.SourceBank.Parameters r Q d} | |
| {ps : List (ℕ × ℕ)} | |
| {P : OAI.Algorithms.SubexponentialSAT.Subexp.ConstructivePacking.PackingData (Fin ps.length) | |
| (OAI.Algorithms.SubexponentialSAT.MulticolorTypes.UniversalType r Q 1)} {a b : State 16 768} | |
| (h : FactorTableNative.SourceMasters p ps P a) | |
| (hf : ∀ i ∈ sourcePorts, b.stacks i = a.stacks i) : | |
| FactorTableNative.SourceMasters p ps P b := by | |
| constructor | |
| · rw [hf 130 (by decide)]; exact h.colors | |
| · rw [hf 131 (by decide)]; exact h.nodes | |
| · rw [hf 132 (by decide)]; exact h.typeWidth | |
| · rw [hf 710 (by decide)]; exact h.positive | |
| · rw [hf 711 (by decide)]; exact h.negative | |
| · rw [hf 140 (by decide)]; exact h.scalarWidth | |
| · rw [hf 712 (by decide)]; exact h.power | |
| · exact h.powerNegative | |
| · rw [hf 138 (by decide)]; exact h.radius | |
| · rw [hf 139 (by decide)]; exact h.offset | |
| · rw [hf 135 (by decide)]; exact h.metadata | |
| · rw [hf 136 (by decide)]; exact h.plans | |
| · rw [hf 713 (by decide)]; exact h.inverses | |
| · rw [hf 714 (by decide)]; exact h.negatives | |
| · rw [hf 715 (by decide)]; exact h.differences | |
| · rw [hf 717 (by decide)]; exact h.ringWidth | |
| · rw [hf 716 (by decide)]; exact h.rowWidth | |
| · rw [hf 280 (by decide)]; exact h.zero | |
| · rw [hf 207 (by decide)]; exact h.one | |
| · rw [hf 211 (by decide)]; exact h.minusOne | |
| · rw [hf 728 (by decide)]; exact h.inverseDenominator | |
| /-- Physical entry facts produced by the actual addressed loader, ring | |
| producer, accepted-head overlay, and the previous accumulator's reset. -/ | |
| structure Entry {r Q n d : ℕ} (q : Factor.Spec r Q n d) (P M S : ℕ) | |
| (a : FactorAssignmentProgram.Data) : Prop where | |
| scalar : FactorTableNative.ScalarMasters q.p.t q.p.model q.p.modulus q.p.cache q.J q.p.R | |
| q.theta (projectState localRegister FactorTableProgram.basePort a) n | |
| masters : FactorTableNative.SourceMasters q.p q.ps q.packing | |
| (projectState localRegister FactorTableProgram.basePort a) | |
| incoming : WordBound P a | |
| copies : ∀ pair ∈ LeafNodeCacheProgram.directCopies, | |
| (a.stacks (lowStack pair.1)).length ≤ M | |
| ambientCap : (a.stacks 128).length ≤ M | |
| oneCap : (a.stacks 207).length ≤ M | |
| cacheFits : 4*M+6 ≤ P | |
| seedFits : FactorAssignmentLoop.byteBound n (baseWidth 3 q.p.t) d q.u q.J ≤ P | |
| lowBlank : ∀ i : Fin 56, a.stacks (i.castAdd 840) = [] | |
| width : a.stacks 202 = q.width | |
| degree : a.stacks 204 = List.replicate d true | |
| precision : a.stacks 212 = List.replicate q.u true | |
| minus : q.minus = q.p.minusOne | |
| digits : a.stacks 281 = IdempotentApplyProgram.triplesTape q.digits | |
| rows : a.stacks 701 = Encoding.encodeList id q.rawRows | |
| clauses : a.stacks 700 = Encoding.encodeList id q.clauses | |
| count : a.stacks 704 = List.replicate q.rawRows.length true | |
| mark : a.stacks 705 = Encoding.encodeNat q.mark | |
| flag : a.stacks 706 = [q.marked] | |
| correction : (a.stacks 857).length = n | |
| hashWidth : (a.stacks 708).length = q.bitWidth | |
| hashModulus : BinaryArithmetic.toNat (a.stacks 707) = q.clauses.length | |
| size : 1029*P+99+n+n*FactorTableProgram.literalRecordBound n | |
| (FactorTableNative.specializedPayloadBound n q.u q.J (baseWidth 3 q.p.t) d)+1 ≤ S | |
| radius : q.p.R+1 ≤ Q | |
| /-- The genuine query's physical ring words and the accepted assignment word | |
| supply the scalar producer boundary; its zero law comes from the same model. -/ | |
| theorem query_scalar {r Q n d M : ℕ} {q : Factor.Spec r Q n d} {node : Fin Q} | |
| {H : Finset (Fin n)} {high : H → Bool} {E U : Finset (Fin n)} | |
| {a : FactorAssignmentProgram.Data} | |
| (h : QueryTupleState.QueryReady q node H high E U M a) | |
| (hchoices : (a.stacks 145).length = n) : | |
| FactorTableNative.ScalarMasters q.p.t q.p.model q.p.modulus q.p.cache q.J q.p.R | |
| q.theta (projectState localRegister FactorTableProgram.basePort a) n := by | |
| constructor | |
| · exact Nat.mul_pos q.p.ht (Nat.zero_lt_succ _) | |
| · exact q.p.hz | |
| · exact DensePolynomialProgram.model_zero_bits q.p.t q.p.model q.p.modulus q.p.cache q.p.hz | |
| · exact h.modulus | |
| · change (a.stacks 202).length = _ | |
| rw [h.width] | |
| exact q.widthLength | |
| · exact h.scalarZero | |
| · exact h.table | |
| · change (a.stacks 204).length = d | |
| rw [h.degree,List.length_replicate] | |
| · exact hchoices | |
| · exact h.zero | |
| · exact h.one | |
| · exact h.theta | |
| · exact h.ambient | |
| · exact h.order | |
| · exact h.radius | |
| · change (a.stacks 703).length = n | |
| rw [h.highBits,List.length_ofFn] | |
| /-- All source-row metadata come from the actual query's retained words. -/ | |
| theorem query_source {r Q n d M : ℕ} {q : Factor.Spec r Q n d} {node : Fin Q} | |
| {H : Finset (Fin n)} {high : H → Bool} {E U : Finset (Fin n)} | |
| {a : FactorAssignmentProgram.Data} | |
| (h : QueryTupleState.QueryReady q node H high E U M a) : | |
| FactorTableNative.SourceMasters q.p q.ps q.packing | |
| (projectState localRegister FactorTableProgram.basePort a) := by | |
| refine ⟨h.colors,h.nodes,h.typeWidth,h.positive,h.negative,h.sourceWidth,h.power, | |
| h.powerNegative,h.radius,h.offset,h.metadata,h.plans,h.inverses,h.negatives, | |
| h.differences,h.ringWidth,h.rowWidth,h.zero,h.one,?_,h.inverseDenominator⟩ | |
| change a.stacks 211 = RingProgram.flat q.p.minusOne | |
| rw [h.minus,h.sourceMinus] | |
| /-- The actual query masters, accepted145 overlay and produced low-bank reset | |
| instantiate the assignment boundary. Master cap M and structural cap P remain | |
| separate so setup restores P before every accepted assignment. -/ | |
| theorem entry_of_query {r Q n d P M S : ℕ} {q : Factor.Spec r Q n d} {node : Fin Q} | |
| {H : Finset (Fin n)} {high : H → Bool} {E U : Finset (Fin n)} | |
| {a : FactorAssignmentProgram.Data} | |
| (h : QueryTupleState.QueryReady q node H high E U M a) | |
| (ha : WordBound P a) (hchoices : (a.stacks 145).length = n) | |
| (hlow : ∀ i : Fin 56, a.stacks (i.castAdd 840) = []) | |
| (hcache : 4*M+6 ≤ P) | |
| (hseed : FactorAssignmentLoop.byteBound n (baseWidth 3 q.p.t) d q.u q.J ≤ P) | |
| (hsize : 1029*P+99+n+n*FactorTableProgram.literalRecordBound n | |
| (FactorTableNative.specializedPayloadBound n q.u q.J (baseWidth 3 q.p.t) d)+1 ≤ S) | |
| (hradius : q.p.R+1 ≤ Q) : Entry q P M S a := by | |
| refine ⟨query_scalar h hchoices,query_source h,ha,h.cacheCaps,h.ambientCap,h.oneCap, | |
| hcache,hseed,hlow,h.width,h.degree,?_,h.sourceMinus,?_,h.rows,h.clauses, | |
| h.rowCount,h.markedIndex,h.markedFlag,?_,h.indexWidth,h.indexModulus,hsize,hradius⟩ | |
| · rw [h.lifting] | |
| exact h.precision | |
| · exact h.code.trans (IdempotentApplyProgram.coefficient_tape q.code) | |
| · rw [h.inner,List.length_ofFn] | |
| /-- This is the actual prefix of assignment, before copying the ID stream. -/ | |
| def prepare : Code := .seq «initialize» setup | |
| def prepareCost (a : FactorAssignmentProgram.Data) : ℕ := | |
| initializeCost a + setupCost (initialized a) | |
| /-- Updates of the three actual loop ports preserve every other stack. -/ | |
| theorem loop_state_frame {n B d : ℕ} (base : Fin 896 → List Bool) | |
| (regs : Fin 40 → Bool) (seed : FactorAssignmentLoop.Raw n B d) | |
| (tail payload : List Bool) (i : Fin 896) | |
| (h149 : i ≠ 149) (h150 : i ≠ 150) (h151 : i ≠ 151) : | |
| (FactorAssignmentLoop.state base regs seed tail payload).stacks i = base i := by | |
| simp only [FactorAssignmentLoop.state, Function.update_of_ne h149, | |
| Function.update_of_ne h150, Function.update_of_ne h151] | |
| /-- Every parsed record has the same chosen structural bound, independently | |
| of the prior prefix's transient workspace. -/ | |
| theorem loop_state_bound {n B d u J P : ℕ} (a : FactorAssignmentProgram.Data) | |
| (regs : Fin 40 → Bool) (seed : FactorAssignmentLoop.Raw n B d) | |
| (tail : List Bool) (f : ℕ) (ha : WordBound P a) | |
| (hseed : NativeSemantics.Good ∅ u J seed) | |
| (hcapacity : FactorAssignmentLoop.byteBound n B d u J ≤ P) | |
| (htail : tail.length ≤ P) (hf : f+1 ≤ P) : | |
| WordBound P (FactorAssignmentLoop.state a.stacks regs seed tail | |
| (Encoding.encodeNat f).reverse) := by | |
| have hs : (Product.bytes seed).length ≤ P := | |
| (TruncatedRingProgram.empty_bytes_length_le (a := seed) ⟨hseed.valid,hseed.nodup⟩).trans hcapacity | |
| intro i | |
| by_cases hi149 : i = 149 | |
| · subst i | |
| simpa only [FactorAssignmentLoop.state, Function.update_self, List.length_reverse, | |
| Encoding.length_encodeNat] using hf | |
| by_cases hi150 : i = 150 | |
| · subst i | |
| simpa only [FactorAssignmentLoop.state, Function.update_of_ne (by decide : (150 : Fin 896) ≠ 149), | |
| Function.update_self] using htail | |
| by_cases hi151 : i = 151 | |
| · subst i | |
| simpa only [FactorAssignmentLoop.state, Function.update_of_ne (by decide : (151 : Fin 896) ≠ 149), | |
| Function.update_of_ne (by decide : (151 : Fin 896) ≠ 150), Function.update_self] using hs | |
| rw [loop_state_frame _ _ _ _ _ i hi149 hi150 hi151] | |
| exact ha i | |
| /-- Physical prepared-store facts, with no evaluator, layout service, or | |
| query result among the fields. The mutable149/150/151 fields are supplied by | |
| the concrete record reader and current Good-empty-support accumulator. -/ | |
| structure Ready {r Q n d : ℕ} (q : Factor.Spec r Q n d) (P S : ℕ) | |
| (one : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (a : FactorAssignmentProgram.Data) : Prop where | |
| scalar : FactorTableNative.ScalarMasters q.p.t q.p.model q.p.modulus q.p.cache q.J q.p.R | |
| q.theta (projectState localRegister FactorTableProgram.basePort a) n | |
| masters : FactorTableNative.SourceMasters q.p q.ps q.packing | |
| (projectState localRegister FactorTableProgram.basePort a) | |
| incoming : ∀ i, (a.stacks i).length ≤ P | |
| size : 1029*P+99+n+n*FactorTableProgram.literalRecordBound n | |
| (FactorTableNative.specializedPayloadBound n q.u q.J (baseWidth 3 q.p.t) d)+1 ≤ S | |
| radius : q.p.R+1 ≤ Q | |
| rows : a.stacks 701 = Encoding.encodeList id q.rawRows | |
| clauses : a.stacks 700 = Encoding.encodeList id q.clauses | |
| count : a.stacks 704 = List.replicate q.rawRows.length true | |
| mark : a.stacks 705 = Encoding.encodeNat q.mark | |
| flag : a.stacks 706 = [q.marked] | |
| blank : ∀ i ∈ callbackScratch, a.stacks (lowStack i) = [] | |
| tableBlank : ∀ i ∈ FactorTableSpace.writtenPorts, i ≠ 62 → i ≠ 556 → a.stacks i = [] | |
| correction : (a.stacks 857).length = n | |
| hashWidth : (a.stacks 708).length = q.bitWidth | |
| hashModulus : BinaryArithmetic.toNat (a.stacks 707) = q.clauses.length | |
| ringShape : (a.stacks 280).length = d * baseWidth 3 q.p.t | |
| low : ∀ i : Fin 56, a.stacks (lowStack (Factor.nativeStacks (Memory.lowPort i))) = | |
| low q.ctx i | |
| oneBytes : a.stacks 69 = Product.bytes one | |
| minusBytes : a.stacks 76 = RingProgram.flat q.minus | |
| tape : a.stacks 143 = IdempotentApplyProgram.triplesTape q.digits | |
| shape : (a.stacks 88).length = n | |
| clauseOutput : a.stacks 63 = [] | |
| clauseWork : ∀ i ∈ FactorServices.clauseScratch, | |
| a.stacks (lowStack (Clause.callerStacks i)) = [] | |
| seedFits : FactorAssignmentLoop.byteBound n (baseWidth 3 q.p.t) d q.u q.J ≤ P | |
| variable {r Q n d P M S : ℕ} {q : Factor.Spec r Q n d} | |
| {one : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d} | |
| {a : FactorAssignmentProgram.Data} | |
| theorem Ready.input (h : Ready q P S one a) | |
| (regs : Fin 40 → Bool) (seed : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (tail : List Bool) (f : ℕ) (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (htail : tail.length ≤ P) (hf : f+1 ≤ P) : | |
| FactorAssignmentCallback.Input q P S one seed | |
| (FactorAssignmentLoop.state a.stacks regs seed tail (Encoding.encodeNat f).reverse) f := by | |
| let b := FactorAssignmentLoop.state a.stacks regs seed tail (Encoding.encodeNat f).reverse | |
| have frame (i : Fin 896) (h149 : i ≠ 149) (h150 : i ≠ 150) (h151 : i ≠ 151) : | |
| b.stacks i = a.stacks i := loop_state_frame _ _ _ _ _ i h149 h150 h151 | |
| have localFrame (i : Fin 768) | |
| (hi : i ∈ scalarPorts ∨ i ∈ sourcePorts) : | |
| (projectState localRegister FactorTableProgram.basePort b).stacks i = | |
| (projectState localRegister FactorTableProgram.basePort a).stacks i := by | |
| have hn := (List.forall_iff_forall_mem.mp (by decide) : ∀ i ∈ scalarPorts ++ sourcePorts, | |
| FactorTableProgram.basePort i ≠ 149 ∧ FactorTableProgram.basePort i ≠ 150 ∧ | |
| FactorTableProgram.basePort i ≠ 151) i (List.mem_append.mpr hi) | |
| exact frame _ hn.1 hn.2.1 hn.2.2 | |
| refine ⟨scalar_frame h.scalar (fun i hi => localFrame i (Or.inl hi)), | |
| source_frame h.masters (fun i hi => localFrame i (Or.inr hi)), | |
| loop_state_bound a regs seed tail f h.incoming hseed h.seedFits htail hf, | |
| h.size,h.radius,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_⟩ | |
| · exact (frame 701 (by decide) (by decide) (by decide)).trans h.rows | |
| · exact (frame 700 (by decide) (by decide) (by decide)).trans h.clauses | |
| · exact (frame 704 (by decide) (by decide) (by decide)).trans h.count | |
| · exact (frame 705 (by decide) (by decide) (by decide)).trans h.mark | |
| · exact (frame 706 (by decide) (by decide) (by decide)).trans h.flag | |
| · simp only [FactorAssignmentLoop.state, Function.update_self] | |
| · simp only [FactorAssignmentLoop.state, | |
| Function.update_of_ne (by decide : (151 : Fin 896) ≠ 149), | |
| Function.update_of_ne (by decide : (151 : Fin 896) ≠ 150), Function.update_self] | |
| · intro i hi | |
| have hn := (List.forall_iff_forall_mem.mp (by decide) : ∀ i ∈ callbackScratch, | |
| lowStack i ≠ 149 ∧ lowStack i ≠ 150 ∧ lowStack i ≠ 151) i hi | |
| exact (frame _ hn.1 hn.2.1 hn.2.2).trans (h.blank i hi) | |
| · intro i hi h62 h556 | |
| have ne (j : Fin 896) (hj : j.val < 340 ∧ j ≠ 62) : i ≠ j := by | |
| intro he | |
| subst i | |
| exact FactorTableSpace.caller_port_not_written j (Or.inl hj) hi | |
| exact (frame i (ne 149 (by decide)) (ne 150 (by decide)) | |
| (ne 151 (by decide))).trans (h.tableBlank i hi h62 h556) | |
| · rw [frame 857 (by decide) (by decide) (by decide)]; exact h.correction | |
| · rw [frame 708 (by decide) (by decide) (by decide)]; exact h.hashWidth | |
| · rw [frame 707 (by decide) (by decide) (by decide)]; exact h.hashModulus | |
| · rw [frame 280 (by decide) (by decide) (by decide)]; exact h.ringShape | |
| · intro i | |
| have hn : lowStack (Factor.nativeStacks (Memory.lowPort i)) ≠ 149 ∧ | |
| lowStack (Factor.nativeStacks (Memory.lowPort i)) ≠ 150 ∧ | |
| lowStack (Factor.nativeStacks (Memory.lowPort i)) ≠ 151 := by | |
| have hi := i.isLt | |
| have hv : (lowStack (Factor.nativeStacks (Memory.lowPort i))).val = i.val := rfl | |
| constructor | |
| · intro he | |
| have hh := congrArg Fin.val he | |
| rw [hv] at hh | |
| norm_num at hh | |
| omega | |
| constructor | |
| · intro he | |
| have hh := congrArg Fin.val he | |
| rw [hv] at hh | |
| norm_num at hh | |
| omega | |
| · intro he | |
| have hh := congrArg Fin.val he | |
| rw [hv] at hh | |
| norm_num at hh | |
| omega | |
| exact (frame _ hn.1 hn.2.1 hn.2.2).trans (h.low i) | |
| · exact (frame 69 (by decide) (by decide) (by decide)).trans h.oneBytes | |
| · exact (frame 76 (by decide) (by decide) (by decide)).trans h.minusBytes | |
| · exact (frame 143 (by decide) (by decide) (by decide)).trans h.tape | |
| · rw [frame 88 (by decide) (by decide) (by decide)]; exact h.shape | |
| · exact (frame 63 (by decide) (by decide) (by decide)).trans h.clauseOutput | |
| · intro i hi | |
| have hn := (List.forall_iff_forall_mem.mp (by decide) : ∀ i ∈ FactorServices.clauseScratch, | |
| lowStack (Clause.callerStacks i) ≠ 149 ∧ lowStack (Clause.callerStacks i) ≠ 150 ∧ | |
| lowStack (Clause.callerStacks i) ≠ 151) i hi | |
| exact (frame _ hn.1 hn.2.1 hn.2.2).trans (h.clauseWork i hi) | |
| /-- The same fixed initializer/cache command constructs every prepared fact | |
| used by the concrete callback. The fixed boundary P is restored on return. -/ | |
| theorem Entry.prepare (h : Entry q P M S a) : | |
| ∃ b, Eval prepare (prepareCost a) a b ∧ | |
| Ready q P S (oneEntries (n := n) q.p.ops.oneRun.1) b ∧ | |
| NativeSemantics.Good ∅ q.u q.J (oneEntries (n := n) q.p.ops.oneRun.1) ∧ | |
| TruncatedRingProgram.rawDenote q.p.ops.decode (oneEntries (n := n) q.p.ops.oneRun.1) = | |
| Squarefree.canonical q.u q.J 1 ∧ | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode | |
| (oneEntries (n := n) q.p.ops.oneRun.1) = 1 ∧ | |
| (∀ i ∈ retainedPorts, b.stacks i = a.stacks i) ∧ | |
| (∀ i ∈ ([149,150,151,159,854] : List (Fin 896)), b.stacks i = []) := by | |
| let a0 := initialized a | |
| have initFrame (i : Fin 896) (hi : i ∈ retainedPorts) : a0.stacks i = a.stacks i := by | |
| rw [initialized_stacks, ite_eq_right (retained_not_entry i hi)] | |
| have scalarMem (i : Fin 768) (hi : i ∈ scalarPorts) : | |
| FactorTableProgram.basePort i ∈ retainedPorts := | |
| List.mem_append_left _ (List.mem_map.mpr ⟨i,List.mem_append_left _ hi,rfl⟩) | |
| have sourceMem (i : Fin 768) (hi : i ∈ sourcePorts) : | |
| FactorTableProgram.basePort i ∈ retainedPorts := | |
| List.mem_append_left _ (List.mem_map.mpr ⟨i,List.mem_append_right _ hi,rfl⟩) | |
| have hscalar := scalar_frame (b := projectState localRegister FactorTableProgram.basePort a0) | |
| h.scalar (fun i hi => initFrame _ (scalarMem i hi)) | |
| have hmasters := source_frame (b := projectState localRegister FactorTableProgram.basePort a0) | |
| h.masters (fun i hi => initFrame _ (sourceMem i hi)) | |
| have hlow : ∀ i : Fin 56, a0.stacks (i.castAdd 840) = [] := by | |
| intro i | |
| rw [initialized_stacks] | |
| split_ifs | |
| · rfl | |
| · exact h.lowBlank i | |
| have hn : (a0.stacks 128).length = n := by | |
| rw [show a0.stacks 128 = List.replicate n true from hscalar.ambientCount] | |
| simp | |
| obtain ⟨b,he,hlo,hunit,hgood,hraw,hdense,hminus,hminusValue,hdigits,hshape,htable,hframe⟩ := | |
| FactorTableDenotation.setup_source_context q.p n q.u q.J q.hu q.hJ q.width | |
| q.widthLength q.digits a0 hlow hn hscalar.modulus | |
| ((initFrame 202 (by decide)).trans h.width) hscalar.zero hscalar.table | |
| ((initFrame 204 (by decide)).trans h.degree) | |
| ((initFrame 212 (by decide)).trans h.precision) hscalar.targetCount hscalar.oneWord | |
| hmasters.minusOne ((initFrame 281 (by decide)).trans h.digits) | |
| have frame (i : Fin 896) (hi : i ∈ retainedPorts) : b.stacks i = a.stacks i := | |
| (hframe i (retained_not_cache i hi)).trans (initFrame i hi) | |
| have hinit : WordBound P a0 := initialized_wordBound a P h.incoming | |
| have shrink (i : Fin 896) : (a0.stacks i).length ≤ (a.stacks i).length := by | |
| rw [initialized_stacks] | |
| split_ifs | |
| · simp | |
| · exact le_rfl | |
| obtain ⟨c,hec,hbound,_⟩ := setup_eval_wordBound_max a0 P M hinit | |
| (fun pair hp => (shrink (lowStack pair.1)).trans (h.copies pair hp)) | |
| ((shrink 128).trans h.ambientCap) ((shrink 207).trans h.oneCap) | |
| have hcb : c = b := Eval.final_unique 0 hec he | |
| have hb : WordBound P b := by | |
| simpa only [hcb,max_eq_left h.cacheFits] using hbound | |
| obtain ⟨z,hez,hcache,hhigh⟩ := setup_eval a0 | |
| have hzb : z = b := Eval.final_unique 0 hez he | |
| have empty (i : Fin 896) (hi : i ∈ entryScratch) : b.stacks i = [] := by | |
| have hi0 : a0.stacks i = [] := by rw [initialized_stacks, ite_eq_left hi] | |
| have hnot : i ∉ LeafNodeCacheProgram.cachePorts.map lowStack := entry_not_cache i hi | |
| by_cases hlt : i.val < 768 | |
| · let j : Fin 768 := ⟨i.val,hlt⟩ | |
| have hj : lowStack j = i := Fin.ext rfl | |
| have hn : j ∉ LeafNodeCacheProgram.cachePorts := by | |
| intro hm | |
| exact hnot (List.mem_map.mpr ⟨j,hm,hj⟩) | |
| rw [← hzb,← hj,hcache j,LeafNodeCacheProgram.cache_frame _ j hn, | |
| cacheStart,clearMany_stacks] | |
| split_ifs | |
| · rfl | |
| · exact hi0 | |
| · rw [← hzb,hhigh i (by omega)] | |
| exact hi0 | |
| have hready : Ready q P S (oneEntries (n := n) q.p.ops.oneRun.1) b := by | |
| refine ⟨scalar_frame h.scalar (fun i hi => frame _ (scalarMem i hi)), | |
| source_frame h.masters (fun i hi => frame _ (sourceMem i hi)),hb,h.size,h.radius, | |
| ?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,?_,hunit,?_,hdigits,hshape,?_,?_,h.seedFits⟩ | |
| · exact (frame 701 (by decide)).trans h.rows | |
| · exact (frame 700 (by decide)).trans h.clauses | |
| · exact (frame 704 (by decide)).trans h.count | |
| · exact (frame 705 (by decide)).trans h.mark | |
| · exact (frame 706 (by decide)).trans h.flag | |
| · intro i hi | |
| exact empty (lowStack i) (List.mem_append_left _ | |
| (List.mem_append_right _ (List.mem_map.mpr ⟨i,hi,rfl⟩))) | |
| · intro i hi h62 h556 | |
| exact empty i (table_written_entry i hi h556) | |
| · rw [frame 857 (by decide)]; exact h.correction | |
| · rw [frame 708 (by decide)]; exact h.hashWidth | |
| · rw [frame 707 (by decide)]; exact h.hashModulus | |
| · rw [frame 280 (by decide)] | |
| rw [show a.stacks 280 = RingProgram.flat q.p.ops.zeroRun.1 from h.scalar.zeroWord, | |
| RingProgram.flat_length] | |
| · intro i | |
| exact hlo i | |
| · exact hminus.trans (congrArg RingProgram.flat h.minus.symm) | |
| · exact empty 63 (by decide) | |
| · intro i hi | |
| exact empty _ ((List.forall_iff_forall_mem.mp (by decide) : ∀ i ∈ FactorServices.clauseScratch, | |
| lowStack (Clause.callerStacks i) ∈ entryScratch) i hi) | |
| exact ⟨b,(initialize_eval a).seq he,hready,hgood,hraw,hdense,frame, | |
| fun i hi => empty i (List.mem_append_left _ (List.mem_append_left _ hi))⟩ | |
| /-- Initialization and cache reconstruction cost one fixed linear polynomial | |
| in the structural boundary, independently of the number of factor records. -/ | |
| theorem prepareCost_le (a : FactorAssignmentProgram.Data) (P : ℕ) (ha : WordBound P a) : | |
| prepareCost a ≤ entryScratch.length * (2*P+3) + 1100*(P+1) + 2 := by | |
| have hi := initializeCost_le a P ha | |
| have hs := setupCost_le (initialized a) P (initialized_wordBound a P ha) | |
| unfold prepareCost | |
| omega | |
| /-- The running record ports are disjoint from all three assignment masters. | |
| Thus every factor value is read from the same actual accepted assignment. -/ | |
| theorem loop_value (a : FactorAssignmentProgram.Data) (regs : Fin 40 → Bool) | |
| (seed : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (tail payload : List Bool) (f : ℕ) : | |
| q.value ((FactorAssignmentLoop.state a.stacks regs seed tail payload).stacks ∘ lowStack) f = | |
| q.value (a.stacks ∘ lowStack) f := by | |
| have hj (j : ℕ) : Factor.factorJet q.p q.ps q.packing n f j q.theta | |
| ((FactorAssignmentLoop.state a.stacks regs seed tail payload).stacks ∘ lowStack) = | |
| Factor.factorJet q.p q.ps q.packing n f j q.theta (a.stacks ∘ lowStack) := by | |
| apply Factor.factorJet_frame | |
| all_goals exact loop_state_frame _ _ _ _ _ _ (by decide) (by decide) (by decide) | |
| unfold Factor.Spec.value Factor.Semantics.hashValue Factor.Semantics.markedValue | |
| simp_rw [hj] | |
| /-- The actual prepared store instantiates the callback used by the record | |
| fold. The output witness, polynomial cost, exact frame and semantic product | |
| all refer to this one fixed callback run. -/ | |
| theorem Ready.callback_eval (h : Ready q P S one a) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (honeval : TruncatedRingProgram.rawDenote q.p.ops.decode one = | |
| Squarefree.canonical q.u q.J 1) | |
| (regs : Fin 40 → Bool) (seed : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (tail : List Bool) (f width Z : ℕ) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (htail : tail.length ≤ P) (hf : f+1 ≤ P) | |
| (hwidth : ∀ hi : f < q.rows.length, | |
| ∀ w ∈ HashInputProgram.Expansion.weightedRow q.p.t d q.source q.rows[f], | |
| w.literals.length ≤ width) | |
| (hZ : 1 ≤ Z) (hP : P ≤ Z) (hbit : q.bitWidth ≤ Z) | |
| (hshape : d*baseWidth 3 q.p.t ≤ Z) | |
| (hhashScale : ∀ hi : f < q.rows.length, | |
| FactorEvaluationSpace.inputScale (baseWidth 3 q.p.t) d n q.u q.J | |
| width q.rows[f].length q.digits.length ≤ Z) | |
| (hmarkScale : FactorEvaluationSpace.inputScale (baseWidth 3 q.p.t) d n q.u q.J | |
| q.markedClause.length 0 0 ≤ Z) : | |
| ∃ out : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d, | |
| NativeSemantics.Good ∅ q.u q.J out ∧ | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode out = | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode seed * | |
| QueryEvaluation.specializeDense q.u q.J | |
| (fun v => decide (v ∈ Squarefree.decodeMask n (a.stacks 857))) | |
| (q.value (a.stacks ∘ lowStack) f) ∧ | |
| ∃ steps ≤ FactorAssignmentCallback.uniformCallbackBudget q P S Z, ∃ rr, | |
| Eval FactorAssignmentProgram.callback steps | |
| (FactorAssignmentLoop.state a.stacks regs seed tail (Encoding.encodeNat f).reverse) | |
| (FactorAssignmentLoop.state a.stacks rr out tail []) ∧ | |
| rr 13 = false ∧ rr 14 = true ∧ rr 15 = false := by | |
| let b := FactorAssignmentLoop.state a.stacks regs seed tail (Encoding.encodeNat f).reverse | |
| have hi := h.input regs seed tail f hseed htail hf | |
| obtain ⟨out,rf,steps,z,hout,hvalue,hsteps,he,hframe,h13,h14,h15⟩ := | |
| FactorAssignmentCallback.callback_eval_correct hi hone hseed honeval width hwidth | |
| have hcost := FactorAssignmentCallback.callbackBudget_le hi width Z hZ hP hbit | |
| hshape hhashScale hmarkScale rf | |
| have heq := FactorAssignmentCallback.result_eq_state a.stacks regs seed out tail | |
| (Encoding.encodeNat f).reverse z hframe | |
| refine ⟨out,hout,?_,steps,hsteps.trans hcost,z.regs,?_,h13,h14,h15⟩ | |
| · have hmask : b.stacks 857 = a.stacks 857 := | |
| loop_state_frame _ _ _ _ _ 857 (by decide) (by decide) (by decide) | |
| have hvalueFrame : q.value (b.stacks ∘ lowStack) f = q.value (a.stacks ∘ lowStack) f := | |
| loop_value a regs seed tail (Encoding.encodeNat f).reverse f | |
| calc | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode out = | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode seed * | |
| QueryEvaluation.specializeDense q.u q.J | |
| (fun v => decide (v ∈ Squarefree.decodeMask n (b.stacks 857))) | |
| (q.value (b.stacks ∘ lowStack) f) := hvalue | |
| _ = TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode seed * | |
| QueryEvaluation.specializeDense q.u q.J | |
| (fun v => decide (v ∈ Squarefree.decodeMask n (a.stacks 857))) | |
| (q.value (a.stacks ∘ lowStack) f) := by rw [hmask, hvalueFrame] | |
| · rw [heq] at he | |
| exact he | |
| end | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentBoundary | |