math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /FactorAssignmentCallbackNative.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentCallbackNative.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 46.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentCallbackNative.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentCallbackNative.lean
-
curl -L -o FactorAssignmentCallbackNative.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorAssignmentCallbackNative.lean
46.4 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentCallback | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentBranches | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorTableDenotation | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramFactorSpec | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramFactorJet | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramAssignmentConcrete | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.QueryJetSelected | |
| /-! Concrete physical inputs for the streamed factor callback. The source | |
| context is the actual q.ctx, and the dispatcher determines every selected row | |
| and clause. These predicates contain stored words and finite size bounds only. | |
| Their construction from the actual loader/cache run remains an integration step. -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentCallback | |
| open OAI BitProgram StructuredCalls SubexpLiftRing SubexpQuarticRing | |
| open SqrtLog SqrtLog.LeafProgram HashCircuitProgram HashCircuitProgram.Native | |
| open IdempotentApplyProgram.Steps MomentsProgram NativeSemantics | |
| open FactorAssignmentProgram | |
| open Subexp.ConstructivePacking MulticolorTypes LayoutProgram DensePolynomialProgram | |
| noncomputable section | |
| /-- Exact selected-payload state produced by the concrete dispatcher. -/ | |
| def fetched {r Q n d : ℕ} (q : Factor.Spec r Q n d) | |
| (a : FactorAssignmentProgram.Data) (f : ℕ) (rf : Fin 8 → Bool) : | |
| FactorAssignmentProgram.Data := dispatched a rf q.rawRows q.clauses q.marked q.mark f | |
| /-- Physical callback boundary, specialized to the source's actual arithmetic | |
| context. In particular no incidence family or evaluator execution is a field. -/ | |
| structure Input {r Q n d : ℕ} (q : Factor.Spec r Q n d) (A S : ℕ) | |
| (one seed : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (a : FactorAssignmentProgram.Data) (f : ℕ) : 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 ≤ A | |
| size : 1029*A+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] | |
| factor : a.stacks 149 = (Encoding.encodeNat f).reverse | |
| seedBytes : a.stacks 151 = Product.bytes seed | |
| 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)) = [] | |
| variable {r Q n d A S : ℕ} {q : Factor.Spec r Q n d} | |
| {one seed : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d} | |
| {a : FactorAssignmentProgram.Data} {f : ℕ} | |
| theorem Input.fetched_stacks (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| (fetched q a f rf).stacks = Function.update a.stacks 154 | |
| (LeafFactorDispatchProgram.selectedPayload q.rawRows q.clauses q.marked q.mark f) := by | |
| rw [fetched, dispatched_stacks a rf q.rawRows q.clauses q.marked q.mark f | |
| h.rows h.clauses h.count h.mark, callbackInitial_stacks a h.blank] | |
| theorem Input.fetched_frame (h : Input q A S one seed a f) (rf : Fin 8 → Bool) | |
| (i : Fin 896) (hi : i ≠ 154) : (fetched q a f rf).stacks i = a.stacks i := by | |
| rw [h.fetched_stacks rf, Function.update_of_ne hi] | |
| theorem Input.fetched_low_frame (h : Input q A S one seed a f) (rf : Fin 8 → Bool) | |
| (i : Fin 768) (hi : i ≠ 154) : | |
| (projectState id lowStack (fetched q a f rf)).stacks i = a.stacks (lowStack i) := by | |
| apply h.fetched_frame rf | |
| intro he | |
| exact hi (Fin.ext (congrArg (fun k : Fin 896 => k.val) he)) | |
| /-- A selected record is bounded by the actual serialized master containing | |
| it. This includes the neutral empty payload. -/ | |
| theorem Input.payload_length (h : Input q A S one seed a f) : | |
| (LeafFactorDispatchProgram.selectedPayload q.rawRows q.clauses q.marked q.mark f).length ≤ A := by | |
| unfold LeafFactorDispatchProgram.selectedPayload | |
| split_ifs with hh hm | |
| · rw [List.getD_eq_getElem _ _ hh] | |
| exact (HashInputProgram.Loop.original_payload_length_le q.rawRows _ | |
| (List.getElem_mem hh)).trans (by rw [← h.rows]; exact h.incoming 701) | |
| · have hb : q.marked = true := (Bool.and_eq_true_iff.mp hm).1 | |
| have hv : q.mark < q.clauses.length := by | |
| simpa only [Factor.Spec.clauses, HashInputProgram.Expansion.encodedClauses, | |
| List.length_map] using q.markValid hb | |
| rw [List.getD_eq_getElem _ _ hv] | |
| exact (HashInputProgram.Loop.original_payload_length_le q.clauses _ | |
| (List.getElem_mem hv)).trans (by rw [← h.clauses]; exact h.incoming 700) | |
| · simp | |
| theorem Input.fetched_wordBound (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| ∀ i, ((fetched q a f rf).stacks i).length ≤ A := by | |
| intro i | |
| rw [h.fetched_stacks rf] | |
| by_cases hi : i = 154 | |
| · subst i | |
| simpa only [Function.update_self] using h.payload_length | |
| · simpa only [Function.update_of_ne hi] using h.incoming i | |
| /-- Source master words survive dispatch and the concrete unary factor-ID | |
| conversion; only the selected payload154 and selected-factor word556 change. -/ | |
| theorem Input.table_frame (h : Input q A S one seed a f) (rf : Fin 8 → Bool) | |
| (i : Fin 768) (hi154 : FactorTableProgram.basePort i ≠ 154) | |
| (hi556 : FactorTableProgram.basePort i ≠ 556) : | |
| (projectState id FactorTableProgram.basePort | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)).stacks i = | |
| (projectState localRegister FactorTableProgram.basePort a).stacks i := by | |
| change (FactorAssignmentBranches.identified (fetched q a f rf) f).stacks | |
| (FactorTableProgram.basePort i) = a.stacks (FactorTableProgram.basePort i) | |
| rw [FactorAssignmentBranches.identified_stacks, Function.update_of_ne hi556, | |
| h.fetched_frame rf _ hi154] | |
| theorem Input.table_scalar (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| FactorTableNative.ScalarMasters q.p.t q.p.model q.p.modulus q.p.cache q.J q.p.R | |
| q.theta (projectState id FactorTableProgram.basePort | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)) n := by | |
| have H := h.table_frame rf | |
| refine ⟨h.scalar.widthPositive, h.scalar.zeroCanonical, h.scalar.zeroBits, | |
| ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ | |
| · rw [H 194 (by decide) (by decide)]; exact h.scalar.modulus | |
| · rw [H 202 (by decide) (by decide)]; exact h.scalar.width | |
| · rw [H 203 (by decide) (by decide)]; exact h.scalar.zero | |
| · rw [H 201 (by decide) (by decide)]; exact h.scalar.table | |
| · rw [H 204 (by decide) (by decide)]; exact h.scalar.degree | |
| · rw [H 145 (by decide) (by decide)]; exact h.scalar.choicesLength | |
| · rw [H 280 (by decide) (by decide)]; exact h.scalar.zeroWord | |
| · rw [H 207 (by decide) (by decide)]; exact h.scalar.oneWord | |
| · rw [H 78 (by decide) (by decide)]; exact h.scalar.thetaWord | |
| · rw [H 128 (by decide) (by decide)]; exact h.scalar.ambientCount | |
| · rw [H 243 (by decide) (by decide)]; exact h.scalar.targetCount | |
| · rw [H 138 (by decide) (by decide)]; exact h.scalar.radius | |
| · rw [H 703 (by decide) (by decide)]; exact h.scalar.highLength | |
| theorem Input.table_masters (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| FactorTableNative.SourceMasters q.p q.ps q.packing | |
| (projectState id FactorTableProgram.basePort | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)) := by | |
| have H := h.table_frame rf | |
| constructor | |
| · rw [H 130 (by decide) (by decide)]; exact h.masters.colors | |
| · rw [H 131 (by decide) (by decide)]; exact h.masters.nodes | |
| · rw [H 132 (by decide) (by decide)]; exact h.masters.typeWidth | |
| · rw [H 710 (by decide) (by decide)]; exact h.masters.positive | |
| · rw [H 711 (by decide) (by decide)]; exact h.masters.negative | |
| · rw [H 140 (by decide) (by decide)]; exact h.masters.scalarWidth | |
| · rw [H 712 (by decide) (by decide)]; exact h.masters.power | |
| · exact h.masters.powerNegative | |
| · rw [H 138 (by decide) (by decide)]; exact h.masters.radius | |
| · rw [H 139 (by decide) (by decide)]; exact h.masters.offset | |
| · rw [H 135 (by decide) (by decide)]; exact h.masters.metadata | |
| · rw [H 136 (by decide) (by decide)]; exact h.masters.plans | |
| · rw [H 713 (by decide) (by decide)]; exact h.masters.inverses | |
| · rw [H 714 (by decide) (by decide)]; exact h.masters.negatives | |
| · rw [H 715 (by decide) (by decide)]; exact h.masters.differences | |
| · rw [H 717 (by decide) (by decide)]; exact h.masters.ringWidth | |
| · rw [H 716 (by decide) (by decide)]; exact h.masters.rowWidth | |
| · rw [H 280 (by decide) (by decide)]; exact h.masters.zero | |
| · rw [H 207 (by decide) (by decide)]; exact h.masters.one | |
| · rw [H 211 (by decide) (by decide)]; exact h.masters.minusOne | |
| · rw [H 728 (by decide) (by decide)]; exact h.masters.inverseDenominator | |
| /-- The actual source-table readiness is derived from fixed physical masters | |
| and the already stored original ID; it is not provided by a caller service. -/ | |
| theorem Input.table_ready (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| FactorTableNative.Ready q.p q.ps q.packing q.u q.J n f A S q.theta | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f) := by | |
| apply FactorTableNative.Ready.of_masters q.hu q.hJ (h.table_scalar rf) (h.table_masters rf) | |
| · change (FactorAssignmentBranches.identified (fetched q a f rf) f).stacks 556 = _ | |
| simp only [FactorAssignmentBranches.identified_stacks, Function.update_self] | |
| · change ((FactorAssignmentBranches.identified (fetched q a f rf) f).stacks 857).length = n | |
| rw [FactorAssignmentBranches.identified_stacks, Function.update_of_ne (by decide), | |
| h.fetched_frame rf 857 (by decide)] | |
| exact h.correction | |
| · intro i | |
| change ((FactorAssignmentBranches.identified (fetched q a f rf) f).stacks i).length ≤ A | |
| rw [FactorAssignmentBranches.identified_stacks] | |
| by_cases hi : i = 556 | |
| · subst i | |
| have hf := h.incoming 149 | |
| rw [h.factor, List.length_reverse] at hf | |
| simp only [Encoding.length_encodeNat] at hf | |
| simp only [Function.update_self, List.length_replicate] | |
| omega | |
| · rw [Function.update_of_ne hi] | |
| exact h.fetched_wordBound rf i | |
| · exact h.size | |
| · exact h.radius | |
| /-- The hash source bytes are the actual row selected by f, in the unchanged | |
| original raw-row order. No arbitrary raw payload is assumed. -/ | |
| theorem Input.fetched_hash (h : Input q A S one seed a f) (rf : Fin 8 → Bool) | |
| (hf : f < q.rows.length) : | |
| Factor.HashInput q.ctx q.minus one seed q.source q.rows[f] q.digits q.bitWidth | |
| (projectState id lowStack (fetched q a f rf)) := by | |
| have H := h.fetched_low_frame rf | |
| constructor | |
| · change (fetched q a f rf).stacks 154 = _ | |
| rw [h.fetched_stacks rf] | |
| simp [LeafFactorDispatchProgram.selectedPayload, Factor.Spec.rawRows, hf] | |
| · exact (H 700 (by decide)).trans | |
| (h.clauses.trans (HashInputProgram.Expansion.original_source_bytes q.source)) | |
| · rw [H 708 (by decide)]; exact h.hashWidth | |
| · rw [H 707 (by decide)]; exact h.hashModulus | |
| · rw [H 280 (by decide)]; exact h.ringShape | |
| · exact (H 64 (by decide)).trans (h.blank 64 (by decide)) | |
| · intro i hi | |
| have hn : i ≠ 154 := by | |
| intro he | |
| subst i | |
| norm_num [Expansion.scratch, Fin.ext_iff, Fin.coe_ofNat_eq_mod] at hi | |
| rw [H i hn] | |
| apply h.blank i | |
| simp only [callbackScratch, List.mem_append] | |
| exact Or.inl (Or.inr hi) | |
| · exact (H 358 (by decide)).trans (h.blank 358 (by decide)) | |
| · exact (H 359 (by decide)).trans (h.blank 359 (by decide)) | |
| · intro i | |
| rw [Factor.indicatorStacks_low, H _ (Factor.low_ne i 154 (by decide))] | |
| exact h.low i | |
| · exact (H 69 (by decide)).trans h.oneBytes | |
| · exact (H 76 (by decide)).trans h.minusBytes | |
| · exact (H 143 (by decide)).trans h.tape | |
| · rw [H 88 (by decide)]; exact h.shape | |
| · intro i hi | |
| have hn : Factor.indicatorStacks i ≠ 154 := | |
| (by decide : ∀ i ∈ FactorServices.indicatorScratch, | |
| Factor.indicatorStacks i ≠ (154 : Fin 768)) i hi | |
| rw [H _ hn] | |
| apply h.blank | |
| simp only [callbackScratch, List.mem_append] | |
| exact Or.inl (Or.inl (Or.inl (Or.inl (List.mem_map.mpr ⟨i, hi, rfl⟩)))) | |
| · exact (H 151 (by decide)).trans h.seedBytes | |
| · exact (H 159 (by decide)).trans (h.blank 159 (by decide)) | |
| /-- Actual marked-clause bytes retain literal polarity and original variable | |
| IDs; this is the source's clause-violation expression, not its complement. -/ | |
| theorem Input.fetched_marked (h : Input q A S one seed a f) (rf : Fin 8 → Bool) | |
| (hm : q.marked = true) (hf : f = q.rows.length) : | |
| let state := projectState id lowStack (fetched q a f rf) | |
| state.stacks 154 = Encoding.encodeList id (q.markedClause.map Clause.literalBits) ∧ | |
| state.stacks 63 = [] ∧ | |
| (∀ i, state.stacks (Clause.callerStacks (Memory.lowPort i)) = IdempotentApplyProgram.Steps.low q.ctx i) ∧ | |
| state.stacks 69 = Product.bytes one ∧ state.stacks 76 = RingProgram.flat q.minus ∧ | |
| (∀ i ∈ FactorServices.clauseScratch, state.stacks (Clause.callerStacks i) = []) ∧ | |
| state.stacks 151 = Product.bytes seed ∧ state.stacks 159 = [] := by | |
| dsimp only | |
| have H := h.fetched_low_frame rf | |
| refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ | |
| · have he : f = q.rawRows.length := by simpa [Factor.Spec.rawRows] using hf | |
| have hv := q.markValid hm | |
| have hp : q.markedClause = q.source[q.mark] := by | |
| simp [Factor.Spec.markedClause, List.getElem?_eq_getElem hv] | |
| change (fetched q a f rf).stacks 154 = _ | |
| rw [h.fetched_stacks rf] | |
| have payload (ls : List (SAT.Literal (Fin n))) : | |
| HashInputProgram.clausePayload ls = Encoding.encodeList id (ls.map Clause.literalBits) := by | |
| induction ls with | |
| | nil => rfl | |
| | cons l ls ih => | |
| change true :: (Encoding.frame (Encoding.encodeNat (Encoding.literalCode l)) ++ | |
| HashInputProgram.clausePayload ls) = _ | |
| simp only [List.map_cons, Encoding.encodeList, Clause.literalBits, ih, id_eq] | |
| simp [LeafFactorDispatchProgram.selectedPayload, he, hm, Factor.Spec.clauses, | |
| HashInputProgram.Expansion.encodedClauses, hp, List.getElem?_eq_getElem hv, payload] | |
| · exact (H 63 (by decide)).trans h.clauseOutput | |
| · intro i | |
| change (projectState id lowStack (fetched q a f rf)).stacks | |
| (Factor.nativeStacks (Memory.lowPort i)) = _ | |
| rw [H _ (Factor.low_ne i 154 (by decide))] | |
| exact h.low i | |
| · exact (H 69 (by decide)).trans h.oneBytes | |
| · exact (H 76 (by decide)).trans h.minusBytes | |
| · intro i hi | |
| have hn : Clause.callerStacks i ≠ 154 := | |
| (by decide : ∀ i ∈ FactorServices.clauseScratch, | |
| Clause.callerStacks i ≠ (154 : Fin 768)) i hi | |
| rw [H _ hn] | |
| exact h.clauseWork i hi | |
| · exact (H 151 (by decide)).trans h.seedBytes | |
| · exact (H 159 (by decide)).trans (h.blank 159 (by decide)) | |
| /-- The table-private boundary is unaffected by the selected payload port. -/ | |
| theorem Input.table_private (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| ∀ i ∈ FactorTableSpace.writtenPorts, i ≠ 62 → i ≠ 556 → | |
| (fetched q a f rf).stacks i = [] := by | |
| intro i hi h62 h556 | |
| have hn : i ≠ 154 := by | |
| intro he | |
| subst i | |
| exact FactorTableSpace.caller_port_not_written 154 (Or.inl (by decide)) hi | |
| rw [h.fetched_frame rf i hn] | |
| exact h.tableBlank i hi h62 h556 | |
| /-- The source-table projection uses the current ambient assignment and fixed | |
| high data, exactly as the original source factor does. -/ | |
| theorem Input.staged_factorJet (h : Input q A S one seed a f) | |
| (rf : Fin 8 → Bool) (j : ℕ) : | |
| PerturbationAssembly.sourceIncidenceJet q.p q.ps q.packing n f j q.theta | |
| (FactorTableProgram.projectBase | |
| (FactorTableProgram.staged | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)).stacks) = | |
| Factor.factorJet q.p q.ps q.packing n f j q.theta (a.stacks ∘ lowStack) := by | |
| let input := FactorAssignmentBranches.tableInput (fetched q a f rf) f | |
| let old := projectState id FactorTableProgram.basePort (FactorTableProgram.initialized input) | |
| have hp := congrArg StructuredProgram.State.stacks (FactorTableNative.project_staged input) | |
| change FactorTableProgram.projectBase (FactorTableProgram.staged input).stacks = | |
| (Incidence.staged old).stacks at hp | |
| rw [hp] | |
| have he := Factor.factorJet_staged q.p q.ps q.packing q.J n f j q.theta old | |
| ((h.table_scalar rf).initialized input) | |
| apply he.trans | |
| refine Factor.factorJet_frame q.p q.ps q.packing n f j q.theta old.stacks | |
| (a.stacks ∘ lowStack) ?_ ?_ ?_ | |
| all_goals dsimp only [old, projectState, Function.comp_apply] | |
| · exact (FactorTableSpace.initialized_base_external input 145 (by decide)).trans | |
| (h.table_frame rf 145 (by decide) (by decide)) | |
| · exact (FactorTableSpace.initialized_base_external input 702 (by decide)).trans | |
| (h.table_frame rf 702 (by decide) (by decide)) | |
| · exact (FactorTableSpace.initialized_base_external input 703 (by decide)).trans | |
| (h.table_frame rf 703 (by decide) (by decide)) | |
| /-- Correction specialization retains the precise current U word, separately | |
| from the high mask and current-head mask. -/ | |
| theorem Input.staged_correction (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| (FactorTableProgram.staged | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)).stacks 857 = a.stacks 857 := by | |
| rw [FactorTableNative.staged_mask] | |
| change (FactorAssignmentBranches.identified (fetched q a f rf) f).stacks 857 = _ | |
| rw [FactorAssignmentBranches.identified_stacks, Function.update_of_ne (by decide)] | |
| exact h.fetched_frame rf 857 (by decide) | |
| /-- The exact entries consumed by native arithmetic have the original source | |
| meaning. The byte-injectivity theorem transports denotation without replacing | |
| those entries by another valid representation. -/ | |
| theorem Input.payload_correct (h : Input q A S one seed a f) | |
| (rf : Fin 8 → Bool) (v : Fin n) | |
| (entries : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (hm : FactorTableNative.PayloadMeaning q.p q.ps q.packing q.u q.J n f q.theta | |
| (FactorTableProgram.staged | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)).stacks v.val | |
| (Product.bytes entries)) : | |
| TruncatedRingProgram.Good ∅ q.u q.J entries ∧ | |
| TruncatedRingProgram.rawDenote q.p.ops.decode entries = | |
| FactorTableDenotation.specializedJet q.u q.J (a.stacks 857) | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta (a.stacks ∘ lowStack)) := by | |
| have hc := (h.table_ready rf).staged_common | |
| have hv := FactorTableDenotation.payload_typed_correct q.p q.ps q.packing | |
| q.u q.J n f v.val q.hu q.hJ q.theta _ _ hc.choicesLength hc.zeroWord hc.oneWord hm entries rfl | |
| rw [h.staged_correction rf, h.staged_factorJet rf v.val] at hv | |
| exact hv | |
| /-- The explicit paid ordinary-branch cost, on the exact dispatched state. -/ | |
| def hashBranchBudget (q : Factor.Spec r Q n d) (A S width : ℕ) | |
| (a : FactorAssignmentProgram.Data) (f : ℕ) (hf : f < q.rows.length) (rf : Fin 8 → Bool) : ℕ := | |
| 7 * (f + 1) + 7 + | |
| FactorAssignmentBranches.tableTime q.p q.u q.J n A S (fetched q a f rf) f + | |
| (9 * ((fetched q a f rf).stacks 154).length + 11 + | |
| HashInputProgram.Loop.uniformBudget q.p.t (d-1) q.bitWidth | |
| ((fetched q a f rf).stacks 707) q.clauses q.rows[f].length + | |
| FactorEvaluationSpace.serviceBudget (baseWidth 3 q.p.t) d n q.u q.J | |
| width q.rows[f].length q.digits.length) | |
| /-- Actual ordinary dispatch, table production, expansion, indicator, | |
| accumulator multiplication and record return, specialized to q.ctx. -/ | |
| theorem hash_callback_eval (h : Input q A S one seed a f) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (hf : f < q.rows.length) (width : ℕ) | |
| (hwidth : ∀ w ∈ HashInputProgram.Expansion.weightedRow q.p.t d q.source q.rows[f], | |
| w.literals.length ≤ width) : | |
| ∃ (rf : Fin 8 → Bool) | |
| (incidence : Fin n → FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (steps : ℕ) (z : FactorAssignmentProgram.Data), | |
| (∀ v, TruncatedRingProgram.Good ∅ q.u q.J (incidence v)) ∧ | |
| (∀ v, TruncatedRingProgram.rawDenote q.p.ops.decode (incidence v) = | |
| FactorTableDenotation.specializedJet q.u q.J (a.stacks 857) | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta (a.stacks ∘ lowStack))) ∧ | |
| let result := Product.run 3 q.p.t q.ctx.modulus q.ctx.cache q.ctx.table q.u q.J seed | |
| (Indicator.result q.ctx q.minus one incidence | |
| (HashInputProgram.Expansion.weightedRow q.p.t d q.source q.rows[f]) q.digits) [] | |
| NativeSemantics.Good ∅ q.u q.J result ∧ | |
| steps ≤ clearCallbackCost a + 9 * (a.stacks 149).length + 14 + | |
| LeafFactorDispatchProgram.budget q.rawRows q.clauses q.mark f + | |
| hashBranchBudget q A S width a f hf rf ∧ | |
| Eval FactorAssignmentProgram.callback steps a z ∧ | |
| z.stacks = Function.update (Function.update a.stacks 149 []) 151 (Product.bytes result) ∧ | |
| z.regs 13 = false ∧ z.regs 14 = true ∧ z.regs 15 = false := by | |
| have hvalid : q.marked = true → q.mark < q.clauses.length := by | |
| simpa only [Factor.Spec.clauses, HashInputProgram.Expansion.encodedClauses, List.length_map] | |
| using q.markValid | |
| obtain ⟨kd,rf,hkd,hd,h5,_⟩ := dispatch_eval a q.rawRows q.clauses q.marked q.mark f | |
| h.rows h.clauses h.count h.mark h.flag h.factor hvalid | |
| have hn : f < q.rawRows.length := by simpa only [Factor.Spec.rawRows, List.length_map] using hf | |
| have hrole : (fetched q a f rf).regs 5 = true := by simpa [fetched, hn] using h5 | |
| have hid : (fetched q a f rf).stacks 149 = (Encoding.encodeNat f).reverse := | |
| (h.fetched_frame rf 149 (by decide)).trans h.factor | |
| have h556 : (fetched q a f rf).stacks 556 = [] := | |
| (h.fetched_frame rf 556 (by decide)).trans (h.blank 556 (by decide)) | |
| have h62 : (fetched q a f rf).stacks 62 = [] := | |
| (h.fetched_frame rf 62 (by decide)).trans (h.blank 62 (by decide)) | |
| obtain ⟨incidence,kb,b,hgood,hmeaning,hkb,hresult,heb,hstore⟩ := | |
| FactorAssignmentBranches.hashFactor_eval q.p q.ps q.packing q.ctx f A S q.theta q.minus | |
| one seed hone hseed q.source q.rows[f] q.digits q.bitWidth width q.bitWidthPositive | |
| q.sourceBound hwidth (fetched q a f rf) hid h556 h62 (h.table_ready rf) | |
| (h.table_private rf) (h.fetched_hash rf hf) | |
| have he := callback_chosen_eval a b rf q.rawRows q.clauses q.marked q.mark f kd (kb+1) _ | |
| h.rows h.clauses h.count h.mark h.blank hd (choose_hash hrole heb) hstore | |
| refine ⟨rf,incidence,_,callbackFinished b,hgood,?_,hresult,?_,he.1, | |
| he.2.1,he.2.2.1,he.2.2.2.1,he.2.2.2.2⟩ | |
| · intro v | |
| exact (h.payload_correct rf v (incidence v) (hmeaning v)).2 | |
| · change kb ≤ hashBranchBudget q A S width a f hf rf at hkb | |
| omega | |
| /-- Explicit paid cost of the actual marked-clause branch. -/ | |
| def markedBranchBudget (q : Factor.Spec r Q n d) (A S : ℕ) | |
| (a : FactorAssignmentProgram.Data) (f : ℕ) (rf : Fin 8 → Bool) : ℕ := | |
| 7 * (f + 1) + 7 + | |
| FactorAssignmentBranches.tableTime q.p q.u q.J n A S (fetched q a f rf) f + | |
| (9 * ((fetched q a f rf).stacks 154).length + 9 + | |
| FactorEvaluationSpace.serviceBudget (baseWidth 3 q.p.t) d n q.u q.J | |
| q.markedClause.length 0 0) | |
| /-- Actual marked dispatch and clause violation arithmetic, retaining the | |
| very specialized incidence entries returned by the table run. -/ | |
| theorem marked_callback_eval (h : Input q A S one seed a f) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (hm : q.marked = true) (hf : f = q.rows.length) : | |
| ∃ (rf : Fin 8 → Bool) | |
| (incidence : Fin n → FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (steps : ℕ) (z : FactorAssignmentProgram.Data), | |
| (∀ v, TruncatedRingProgram.Good ∅ q.u q.J (incidence v)) ∧ | |
| (∀ v, TruncatedRingProgram.rawDenote q.p.ops.decode (incidence v) = | |
| FactorTableDenotation.specializedJet q.u q.J (a.stacks 857) | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta (a.stacks ∘ lowStack))) ∧ | |
| let result := Product.run 3 q.p.t q.ctx.modulus q.ctx.cache q.ctx.table q.u q.J seed | |
| (FactorServices.clauseResult q.ctx q.minus one incidence q.markedClause) [] | |
| NativeSemantics.Good ∅ q.u q.J result ∧ | |
| steps ≤ clearCallbackCost a + 9 * (a.stacks 149).length + 15 + | |
| LeafFactorDispatchProgram.budget q.rawRows q.clauses q.mark f + | |
| markedBranchBudget q A S a f rf ∧ | |
| Eval FactorAssignmentProgram.callback steps a z ∧ | |
| z.stacks = Function.update (Function.update a.stacks 149 []) 151 (Product.bytes result) ∧ | |
| z.regs 13 = false ∧ z.regs 14 = true ∧ z.regs 15 = false := by | |
| have hvalid : q.marked = true → q.mark < q.clauses.length := by | |
| simpa only [Factor.Spec.clauses, HashInputProgram.Expansion.encodedClauses, List.length_map] | |
| using q.markValid | |
| obtain ⟨kd,rf,hkd,hd,h5,h6⟩ := dispatch_eval a q.rawRows q.clauses q.marked q.mark f | |
| h.rows h.clauses h.count h.mark h.flag h.factor hvalid | |
| have hn : f = q.rawRows.length := by simpa only [Factor.Spec.rawRows, List.length_map] using hf | |
| have hrole5 : (fetched q a f rf).regs 5 = false := by simpa [fetched, hn] using h5 | |
| have hrole6 : (fetched q a f rf).regs 6 = true := by simpa [fetched, hm, hn] using h6 | |
| have hid : (fetched q a f rf).stacks 149 = (Encoding.encodeNat f).reverse := | |
| (h.fetched_frame rf 149 (by decide)).trans h.factor | |
| have h556 : (fetched q a f rf).stacks 556 = [] := | |
| (h.fetched_frame rf 556 (by decide)).trans (h.blank 556 (by decide)) | |
| have h359 : (fetched q a f rf).stacks 359 = [] := | |
| (h.fetched_frame rf 359 (by decide)).trans (h.blank 359 (by decide)) | |
| have h62 : (fetched q a f rf).stacks 62 = [] := | |
| (h.fetched_frame rf 62 (by decide)).trans (h.blank 62 (by decide)) | |
| obtain ⟨hraw, houtput, hlow, honeBytes, hminus, hwork, hseedBytes, htemporary⟩ := | |
| h.fetched_marked rf hm hf | |
| obtain ⟨incidence,kb,b,hgood,hmeaning,hkb,hresult,heb,hstore⟩ := | |
| FactorAssignmentBranches.markedFactor_eval q.p q.ps q.packing q.ctx f A S q.theta q.minus | |
| one seed hone hseed q.markedClause (fetched q a f rf) hid h556 h359 h62 | |
| (h.table_ready rf) (h.table_private rf) hraw houtput hlow honeBytes hminus | |
| hwork hseedBytes htemporary | |
| have he := callback_chosen_eval a b rf q.rawRows q.clauses q.marked q.mark f kd (kb+2) _ | |
| h.rows h.clauses h.count h.mark h.blank hd (choose_marked hrole5 hrole6 heb) hstore | |
| refine ⟨rf,incidence,_,callbackFinished b,hgood,?_,hresult,?_,he.1, | |
| he.2.1,he.2.2.1,he.2.2.2.1,he.2.2.2.2⟩ | |
| · intro v | |
| exact (h.payload_correct rf v (incidence v) (hmeaning v)).2 | |
| · change kb ≤ markedBranchBudget q A S a f rf at hkb | |
| omega | |
| /-- Neutral original IDs execute their paid record path and preserve the | |
| complete accumulated dictionary. -/ | |
| theorem neutral_callback_eval (h : Input q A S one seed a f) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (hh : ¬ f < q.rows.length) | |
| (hm : (q.marked && decide (f = q.rows.length)) = false) : | |
| ∃ steps z, | |
| NativeSemantics.Good ∅ q.u q.J seed ∧ | |
| steps ≤ clearCallbackCost a + 9 * (a.stacks 149).length + 15 + | |
| LeafFactorDispatchProgram.budget q.rawRows q.clauses q.mark f ∧ | |
| Eval FactorAssignmentProgram.callback steps a z ∧ | |
| z.stacks = Function.update (Function.update a.stacks 149 []) 151 (Product.bytes seed) ∧ | |
| z.regs 13 = false ∧ z.regs 14 = true ∧ z.regs 15 = false := by | |
| have hvalid : q.marked = true → q.mark < q.clauses.length := by | |
| simpa only [Factor.Spec.clauses, HashInputProgram.Expansion.encodedClauses, List.length_map] | |
| using q.markValid | |
| obtain ⟨steps,z,hs,he,hz,h13,h14,h15⟩ := callback_neutral_frame a q.rawRows q.clauses | |
| q.marked q.mark f h.rows h.clauses h.count h.mark h.flag h.factor hvalid | |
| (by simpa only [Factor.Spec.rawRows, List.length_map] using hh) | |
| (by simpa only [Factor.Spec.rawRows, List.length_map] using hm) h.blank | |
| refine ⟨steps,z,hseed,hs,he,?_,h13,h14,h15⟩ | |
| rw [hz] | |
| symm | |
| apply Function.update_eq_self_iff.mpr | |
| simpa only [Function.update_of_ne (show (151 : Fin 896) ≠ 149 by decide)] using h.seedBytes.symm | |
| /-- Dense multiplication for the same selected native factor. The source jet | |
| uses all original factor IDs, but the concrete incidence family is the one | |
| just produced for f; no table for other IDs is constructed or assumed. -/ | |
| theorem selected_step_value | |
| (s : Fin 768 → List Bool) (mask : List Bool) | |
| (incidence : Fin n → FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (honeval : NativeSemantics.rawDenote q.p.ops.decode one = | |
| Squarefree.canonical q.u q.J 1) | |
| (hi : ∀ v, TruncatedRingProgram.Good ∅ q.u q.J (incidence v)) | |
| (hinc : ∀ v, TruncatedRingProgram.rawDenote q.p.ops.decode (incidence v) = | |
| FactorTableDenotation.specializedJet q.u q.J mask | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta s)) | |
| (factor : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (hfactor : AssignmentSemantics.selectedFactor q.ctx q.minus one (fun _ => incidence) | |
| (AssignmentConcrete.weightedHashes q) q.marked q.markedClause q.digits f = some factor) : | |
| let result := Product.run 3 q.p.t q.ctx.modulus q.ctx.cache q.ctx.table q.u q.J seed factor [] | |
| NativeSemantics.Good ∅ q.u q.J result ∧ | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode result = | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode seed * | |
| QueryEvaluation.specializeDense q.u q.J | |
| (fun v => decide (v ∈ Squarefree.decodeMask n mask)) (q.value s f) := by | |
| have scalarize {R : Type} [CommRing R] {m : ℕ} (u J : ℕ) (mask : List Bool) | |
| (jet : Squarefree.Jet (Fin m) R) : | |
| FactorTableDenotation.specializedJet u J mask jet = | |
| Squarefree.canonical u J (Moments.jetScalar (Moments.jetEval | |
| (Squarefree.boolValue (fun v => decide (v ∈ Squarefree.decodeMask m mask))) | |
| (Squarefree.boolValue_idempotent _) jet)) := by | |
| have hvalue : (fun v : Fin m => if v ∈ Squarefree.decodeMask m mask then (1 : R) else 0) = | |
| Squarefree.boolValue (fun v => decide (v ∈ Squarefree.decodeMask m mask)) := by | |
| funext v | |
| simp [Squarefree.boolValue] | |
| simp only [FactorTableDenotation.specializedJet, hvalue] | |
| have rawEq {R : Type} [CommRing R] {m B e : ℕ} | |
| (decode : RingProgram.Code (Word B) e → R) (entries : List (Product.Entry m B e)) : | |
| NativeSemantics.rawDenote decode entries = TruncatedRingProgram.rawDenote decode entries := rfl | |
| let U : Fin n → Bool := fun v => decide (v ∈ Squarefree.decodeMask n mask) | |
| have hjet (v : Fin n) : NativeSemantics.rawDenote q.p.ops.decode (incidence v) = | |
| Squarefree.canonical q.u q.J | |
| (Moments.jetScalar (Moments.jetEval (Squarefree.boolValue U) | |
| (Squarefree.boolValue_idempotent U) | |
| (AssignmentConcrete.sourceJets q s f v))) := by | |
| unfold AssignmentConcrete.sourceJets | |
| exact (rawEq (R := q.p.model.O q.p.t) q.p.ops.decode (incidence v)).trans ((hinc v).trans | |
| (scalarize (R := q.p.model.O q.p.t) (m := n) q.u q.J mask | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta s))) | |
| have hh := QueryJetSemantics.selectedFactor_step_specialized_dense q.ctx | |
| (LiftRing.of (q.p.model.F q.p.t)) (RingBasis.basis (q.p.model.F q.p.t)) | |
| (Factor.Semantics.context_table_correct q.p q.u q.J q.width q.widthLength) | |
| q.p.hd (Factor.Semantics.basis_zero q.p) q.hu q.hJ q.minus one seed | |
| (fun _ => incidence) hone hseed (fun _ v => ⟨(hi v).valid, (hi v).nodup⟩) | |
| q.minusValue honeval U (AssignmentConcrete.sourceJets q s) | |
| (AssignmentConcrete.weightedHashes q) q.marked q.markedClause f | |
| (fun _ _ _ l _ => hjet l.variable) (fun _ _ l _ => hjet l.variable) | |
| q.code factor hfactor | |
| refine ⟨hh.1, hh.2.trans ?_⟩ | |
| exact congrArg (fun value => TruncatedRingProgram.rawValue q.u q.J | |
| q.p.ops.decode seed * QueryEvaluation.specializeDense q.u q.J U value) | |
| (AssignmentConcrete.value_eq_selectedValue q s f).symm | |
| /-- The ordinary branch computes the precise original hash selected by f, | |
| followed by multiplication into the same current seed. -/ | |
| theorem hash_step_value | |
| (s : Fin 768 → List Bool) (mask : List Bool) | |
| (incidence : Fin n → FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (honeval : NativeSemantics.rawDenote q.p.ops.decode one = | |
| Squarefree.canonical q.u q.J 1) | |
| (hi : ∀ v, TruncatedRingProgram.Good ∅ q.u q.J (incidence v)) | |
| (hinc : ∀ v, TruncatedRingProgram.rawDenote q.p.ops.decode (incidence v) = | |
| FactorTableDenotation.specializedJet q.u q.J mask | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta s)) | |
| (hf : f < q.rows.length) : | |
| let factor := Indicator.result q.ctx q.minus one incidence | |
| (HashInputProgram.Expansion.weightedRow q.p.t d q.source q.rows[f]) q.digits | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode | |
| (Product.run 3 q.p.t q.ctx.modulus q.ctx.cache q.ctx.table q.u q.J seed factor []) = | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode seed * | |
| QueryEvaluation.specializeDense q.u q.J | |
| (fun v => decide (v ∈ Squarefree.decodeMask n mask)) (q.value s f) := by | |
| apply (selected_step_value s mask incidence hone hseed honeval hi hinc _ ?_).2 | |
| simp [AssignmentSemantics.selectedFactor, AssignmentConcrete.weightedHashes, hf] | |
| /-- The marked branch retains the source clause's violation polynomial and | |
| multiplies it into the same current seed. -/ | |
| theorem marked_step_value | |
| (s : Fin 768 → List Bool) (mask : List Bool) | |
| (incidence : Fin n → FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (honeval : NativeSemantics.rawDenote q.p.ops.decode one = | |
| Squarefree.canonical q.u q.J 1) | |
| (hi : ∀ v, TruncatedRingProgram.Good ∅ q.u q.J (incidence v)) | |
| (hinc : ∀ v, TruncatedRingProgram.rawDenote q.p.ops.decode (incidence v) = | |
| FactorTableDenotation.specializedJet q.u q.J mask | |
| (Factor.factorJet q.p q.ps q.packing n f v.val q.theta s)) | |
| (hm : q.marked = true) (hf : f = q.rows.length) : | |
| let factor := FactorServices.clauseResult q.ctx q.minus one incidence q.markedClause | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode | |
| (Product.run 3 q.p.t q.ctx.modulus q.ctx.cache q.ctx.table q.u q.J seed factor []) = | |
| TruncatedRingProgram.rawValue q.u q.J q.p.ops.decode seed * | |
| QueryEvaluation.specializeDense q.u q.J | |
| (fun v => decide (v ∈ Squarefree.decodeMask n mask)) (q.value s f) := by | |
| apply (selected_step_value s mask incidence hone hseed honeval hi hinc _ ?_).2 | |
| simp [AssignmentSemantics.selectedFactor, AssignmentConcrete.weightedHashes, hf, hm, | |
| FactorServices.clauseResult] | |
| /-- The explicit cost keeps every dispatcher scan and every native branch. | |
| It is a proof-side numerical envelope, never a traversal over possible states. -/ | |
| def callbackBudget (q : Factor.Spec r Q n d) (A S width : ℕ) | |
| (a : FactorAssignmentProgram.Data) (f : ℕ) (rf : Fin 8 → Bool) : ℕ := | |
| clearCallbackCost a + 9 * (a.stacks 149).length + 15 + | |
| LeafFactorDispatchProgram.budget q.rawRows q.clauses q.mark f + | |
| if hf : f < q.rows.length then hashBranchBudget q A S width a f hf rf | |
| else if q.marked && decide (f = q.rows.length) then markedBranchBudget q A S a f rf else 0 | |
| /-- The concrete callback produces the exact specialized original factor | |
| value. Its whole raw output, physical frame, paid execution, and arithmetic | |
| meaning refer to one and the same actual execution. -/ | |
| theorem callback_eval_correct (h : Input q A S one seed a f) | |
| (hone : NativeSemantics.Good ∅ q.u q.J one) | |
| (hseed : NativeSemantics.Good ∅ q.u q.J seed) | |
| (honeval : NativeSemantics.rawDenote q.p.ops.decode one = | |
| Squarefree.canonical q.u q.J 1) | |
| (width : ℕ) | |
| (hwidth : ∀ hf : f < q.rows.length, | |
| ∀ w ∈ HashInputProgram.Expansion.weightedRow q.p.t d q.source q.rows[f], | |
| w.literals.length ≤ width) : | |
| ∃ (out : FactorAssignmentLoop.Raw n (baseWidth 3 q.p.t) d) | |
| (rf : Fin 8 → Bool) (steps : ℕ) (z : FactorAssignmentProgram.Data), | |
| 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 ≤ callbackBudget q A S width a f rf ∧ | |
| Eval FactorAssignmentProgram.callback steps a z ∧ | |
| z.stacks = Function.update (Function.update a.stacks 149 []) 151 (Product.bytes out) ∧ | |
| z.regs 13 = false ∧ z.regs 14 = true ∧ z.regs 15 = false := by | |
| by_cases hf : f < q.rows.length | |
| · obtain ⟨rf,incidence,k,z,hi,hinc,hout,hk,he,hz,h13,h14,h15⟩ := | |
| hash_callback_eval h hone hseed hf width (hwidth hf) | |
| refine ⟨_,rf,k,z,hout,hash_step_value _ _ incidence hone hseed honeval hi hinc hf, | |
| ?_,he,hz,h13,h14,h15⟩ | |
| simp only [callbackBudget, dite_eq_left hf] | |
| omega | |
| · by_cases hm : (q.marked && decide (f = q.rows.length)) = true | |
| · have hb : q.marked = true := (Bool.and_eq_true_iff.mp hm).1 | |
| have hid : f = q.rows.length := of_decide_eq_true (Bool.and_eq_true_iff.mp hm).2 | |
| obtain ⟨rf,incidence,k,z,hi,hinc,hout,hk,he,hz,h13,h14,h15⟩ := | |
| marked_callback_eval h hone hseed hb hid | |
| refine ⟨_,rf,k,z,hout,marked_step_value _ _ incidence hone hseed honeval hi hinc hb hid, | |
| ?_,he,hz,h13,h14,h15⟩ | |
| simpa only [callbackBudget, dite_eq_right hf, hm, ite_true] using hk | |
| · have hb : (q.marked && decide (f = q.rows.length)) = false := | |
| Bool.eq_false_iff.mpr hm | |
| obtain ⟨k,z,hout,hk,he,hz,h13,h14,h15⟩ := neutral_callback_eval h hseed hf hb | |
| refine ⟨seed,(fun _ => false),k,z,hout,?_,?_,he,hz,h13,h14,h15⟩ | |
| · simp only [Factor.Spec.value, dite_eq_right hf, hb, Bool.false_eq_true, ite_false, | |
| map_one, mul_one] | |
| · simpa only [callbackBudget, dite_eq_right hf, hb, Bool.false_eq_true, ite_false, | |
| Nat.add_zero] using hk | |
| /-- Uniform source-table work: the actual staged high-mask word is bounded | |
| by the entry's physical word cap, independently of dispatcher registers. -/ | |
| def tableBudget (q : Factor.Spec r Q n d) (A S : ℕ) : ℕ := | |
| 1000000 * (A + n + | |
| FactorTableNative.specializedLiteralWork q.p q.u q.J n S (1029*A+99) + | |
| FactorTableNative.specializedPayloadBound n q.u q.J (baseWidth 3 q.p.t) d + 1)^2 | |
| theorem Input.tableTime_le (h : Input q A S one seed a f) (rf : Fin 8 → Bool) : | |
| FactorAssignmentBranches.tableTime q.p q.u q.J n A S (fetched q a f rf) f ≤ | |
| tableBudget q A S := by | |
| have hstage := FactorTableSpace.staged_stack_bound | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f) A | |
| (h.table_ready rf).incoming 574 | |
| have hwork : FactorTableNative.specializedLiteralWork q.p q.u q.J n S | |
| ((FactorTableProgram.staged | |
| (FactorAssignmentBranches.tableInput (fetched q a f rf) f)).stacks 574).length ≤ | |
| FactorTableNative.specializedLiteralWork q.p q.u q.J n S (1029*A+99) := by | |
| unfold FactorTableNative.specializedLiteralWork | |
| omega | |
| apply (FactorTableSpace.commandBudget_le A n _ _).trans | |
| unfold tableBudget | |
| gcongr | |
| theorem Input.factor_le (h : Input q A S one seed a f) : f ≤ A := by | |
| have hf := h.incoming 149 | |
| rw [h.factor, List.length_reverse] at hf | |
| simp only [Encoding.length_encodeNat] at hf | |
| omega | |
| /-- The actual dispatcher pays for all losing records in both encoded masters. -/ | |
| theorem Input.dispatchBudget_le (h : Input q A S one seed a f) : | |
| LeafFactorDispatchProgram.budget q.rawRows q.clauses q.mark f ≤ 102*A+138 := by | |
| have hrow := h.incoming 701 | |
| have hclause := h.incoming 700 | |
| have hcount := h.incoming 704 | |
| have hmark := h.incoming 705 | |
| rw [h.rows] at hrow | |
| rw [h.clauses] at hclause | |
| rw [h.count, List.length_replicate] at hcount | |
| rw [h.mark] at hmark | |
| simp only [Encoding.length_encodeNat] at hmark | |
| have hid := h.factor_le | |
| unfold LeafFactorDispatchProgram.budget LeafFactorDispatchProgram.dispatchBound | |
| LeafFactorDispatchProgram.branchBound | |
| omega | |
| /-- The complete per-record bound is fixed before the record scan. Z bounds | |
| only explicit source dimensions, serialized inputs and retained arithmetic | |
| capacity; no evaluator or run is assumed. -/ | |
| def uniformCallbackBudget (q : Factor.Spec r Q n d) (A S Z : ℕ) : ℕ := | |
| callbackScratch.length * (2*A+3) + 128*A+200 + tableBudget q A S + | |
| 2000*Z^3 + 14000000*Z^9 | |
| theorem callbackBudget_le (h : Input q A S one seed a f) (width Z : ℕ) | |
| (hZ : 1 ≤ Z) (hA : A ≤ Z) (hbit : q.bitWidth ≤ Z) | |
| (hshape : d*baseWidth 3 q.p.t ≤ Z) | |
| (hhashScale : ∀ hf : 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) | |
| (rf : Fin 8 → Bool) : | |
| callbackBudget q A S width a f rf ≤ uniformCallbackBudget q A S Z := by | |
| have hclear' : clearCallbackCost a ≤ callbackScratch.length * (2*A+3)+1 := by | |
| unfold clearCallbackCost | |
| have hc := SubexpSetupStorage.clearManyCost_le callbackScratch | |
| (projectState localRegister lowStack a) A (fun i => h.incoming (lowStack i)) | |
| omega | |
| have hraw := h.incoming 149 | |
| have hdispatch := h.dispatchBudget_le | |
| have htable := h.tableTime_le rf | |
| have hid := h.factor_le | |
| have hp : ((fetched q a f rf).stacks 154).length ≤ A := h.fetched_wordBound rf 154 | |
| have hmod : ((fetched q a f rf).stacks 707).length ≤ Z := | |
| (h.fetched_wordBound rf 707).trans hA | |
| have hclauses : (Encoding.encodeList id q.clauses).length ≤ Z := by | |
| rw [← h.clauses] | |
| exact (h.incoming 700).trans hA | |
| have hcount : q.clauses.length ≤ Z := | |
| (Nat.le_succ _).trans ((Encoding.length_encodeList_lower id q.clauses).trans hclauses) | |
| by_cases hf : f < q.rows.length | |
| · have hs := hhashScale hf | |
| have hterms : q.rows[f].length ≤ Z := by | |
| unfold FactorEvaluationSpace.inputScale at hs | |
| omega | |
| have hexp := FactorBounds.expansionBound_le q.bitWidth | |
| ((fetched q a f rf).stacks 707).length q.clauses.length | |
| (Encoding.encodeList id q.clauses).length ((d-1+1)*baseWidth 3 q.p.t) | |
| q.rows[f].length Z hZ hbit hmod hcount hclauses | |
| (by simpa only [Nat.sub_add_cancel q.p.hd] using hshape) hterms | |
| change HashInputProgram.Loop.uniformBudget q.p.t (d-1) q.bitWidth | |
| ((fetched q a f rf).stacks 707) q.clauses q.rows[f].length ≤ 2000*Z^3 at hexp | |
| have hservice : FactorEvaluationSpace.serviceBudget (baseWidth 3 q.p.t) d n q.u q.J | |
| width q.rows[f].length q.digits.length ≤ 14000000*Z^9 := by | |
| unfold FactorEvaluationSpace.serviceBudget | |
| gcongr | |
| simp only [callbackBudget, dite_eq_left hf, hashBranchBudget, uniformCallbackBudget] | |
| omega | |
| · have hservice : FactorEvaluationSpace.serviceBudget (baseWidth 3 q.p.t) d n q.u q.J | |
| q.markedClause.length 0 0 ≤ 14000000*Z^9 := by | |
| unfold FactorEvaluationSpace.serviceBudget | |
| gcongr | |
| simp only [callbackBudget, dite_eq_right hf, uniformCallbackBudget] | |
| split | |
| · unfold markedBranchBudget | |
| omega | |
| · omega | |
| /-- A fixed ninth power bounds the callback's composed numerical envelope. | |
| The degree does not depend on the input or the number of scanned factors. -/ | |
| theorem callback_cost_polynomial (a A n K L Z : ℕ) : | |
| a*(2*A+3)+128*A+200+1000000*(A+n+K+L+1)^2+2000*Z^3+14000000*Z^9 ≤ | |
| 16000000*(a+A+n+K+L+Z+1)^9 := by | |
| let X := a+A+n+K+L+Z+1 | |
| have hX : 1 ≤ X := by dsimp [X]; omega | |
| have ha : a ≤ X := by dsimp [X]; omega | |
| have hA : A ≤ X := by dsimp [X]; omega | |
| have hZ : Z ≤ X := by dsimp [X]; omega | |
| have hsum : A+n+K+L+1 ≤ X := by dsimp [X]; omega | |
| have h1 : 1 ≤ X^9 := Nat.one_le_pow _ _ hX | |
| have hx : X ≤ X^9 := by simpa using Nat.pow_le_pow_right hX (show 1 ≤ 9 by decide) | |
| have h2 : X^2 ≤ X^9 := Nat.pow_le_pow_right hX (by decide) | |
| have h3 : X^3 ≤ X^9 := Nat.pow_le_pow_right hX (by decide) | |
| have hclear : a*(2*A+3) ≤ 5*X^2 := by | |
| have hh : a*(2*A+3) ≤ X*(2*X+3) := by gcongr | |
| nlinarith | |
| have htable : (A+n+K+L+1)^2 ≤ X^2 := by gcongr | |
| have hz3 : Z^3 ≤ X^3 := by gcongr | |
| have hz9 : Z^9 ≤ X^9 := by gcongr | |
| change _ ≤ 16000000*X^9 | |
| omega | |
| /-- The only large service terms are the already explicit source and | |
| specialization budgets, inside a fixed power. -/ | |
| theorem uniformCallbackBudget_polynomial (q : Factor.Spec r Q n d) (A S Z : ℕ) : | |
| uniformCallbackBudget q A S Z ≤ | |
| 16000000 * (callbackScratch.length + A + n + | |
| FactorTableNative.specializedLiteralWork q.p q.u q.J n S (1029*A+99) + | |
| FactorTableNative.specializedPayloadBound n q.u q.J (baseWidth 3 q.p.t) d + Z + 1)^9 := by | |
| exact callback_cost_polynomial callbackScratch.length A n _ _ Z | |
| end | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentCallback | |