Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorTableDenotation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 20 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorTableDenotation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorTableDenotation.lean
-
curl -L -o FactorTableDenotation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/FactorTableDenotation.lean
20 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorTablePayloadMeaning | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorCacheProgram | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.LeafProgramFactorInput | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.QueryJetCanonical | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.RingProgramSerialization | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLog.PerturbationAssemblySourceStored | |
| /-! The actual normalized incidence payload has the canonical scalarized | |
| source denotation. Source arrays are witnesses produced by the finite source | |
| machine; their full polynomial meanings identify one fixed incidence jet. -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorTableDenotation | |
| open OAI OAI.Algorithms.SubexponentialSAT.SqrtLog OAI.Algorithms.SubexponentialSAT.SubexpLiftRing OAI.Algorithms.SubexponentialSAT.SubexpQuarticRing | |
| open MomentsProgram TruncatedRingProgram DensePolynomialProgram | |
| open OAI.Algorithms.SubexponentialSAT.Subexp.ConstructivePacking OAI.Algorithms.SubexponentialSAT.MulticolorTypes LayoutProgram | |
| open scoped BigOperators | |
| noncomputable section | |
| variable {R : Type*} [CommRing R] | |
| theorem product_bytes_injective {n B d : ℕ} (hB : 0 < B) : | |
| Function.Injective (Product.bytes : List (Product.Entry n B d) → List Bool) := by | |
| intro xs | |
| induction xs with | |
| | nil => | |
| intro ys h | |
| cases ys with | |
| | nil => rfl | |
| | cons y ys => | |
| have hl := congrArg List.length h | |
| simp [Product.bytes, Normalize.bytes, Squarefree.Program.encodeDictionary, | |
| Squarefree.Program.rawEntries] at hl | |
| omega | |
| | cons x xs ih => | |
| intro ys h | |
| cases ys with | |
| | nil => | |
| have hl := congrArg List.length h | |
| simp [Product.bytes, Normalize.bytes, Squarefree.Program.encodeDictionary, | |
| Squarefree.Program.rawEntries] at hl | |
| | cons y ys => | |
| change (Encoding.frame (Squarefree.encodeIndex x.1) ++ | |
| Encoding.frame (RingProgram.flat x.2)) ++ Product.bytes xs = | |
| (Encoding.frame (Squarefree.encodeIndex y.1) ++ | |
| Encoding.frame (RingProgram.flat y.2)) ++ Product.bytes ys at h | |
| rw [List.append_assoc, List.append_assoc] at h | |
| obtain ⟨hk, ht⟩ := Encoding.frame_append_injective h | |
| obtain ⟨hc, ht⟩ := Encoding.frame_append_injective ht | |
| exact congrArg₂ List.cons (Prod.ext (Squarefree.encodeIndex_injective hk) | |
| (RingProgram.flat_injective hB hc)) (ih ht) | |
| theorem normalized_specialization_raw (p t : ℕ) [Fact p.Prime] | |
| (M : SubexpPreparedQuartic.Modulus p t) (cache : RingProgram.ScalarCache p t) | |
| {n d : ℕ} (scalar : ZMod (p ^ t) →+* R) (basis : Fin d → R) | |
| (U : Finset (Fin n)) (source : List (Product.Entry n (baseWidth p t) d)) : | |
| let f := RingProgram.denote (RingProgram.scalarRing p t M cache) scalar basis | |
| rawDenote f (Normalize.run p t M cache (HeadEvaluation.specializeEntries U source) []) = | |
| Moments.jetScalar (Moments.jetEval (fun v => if v ∈ U then (1 : R) else 0) | |
| (by intro v; split <;> simp) (rawDenote f source)) := by | |
| dsimp only | |
| rw [normalize_denote p t M cache scalar basis _ [] (by simp [Squarefree.Sparse.keys])] | |
| have hz : rawDenote (n := n) | |
| (RingProgram.denote (RingProgram.scalarRing p t M cache) scalar basis) [] = 0 := by | |
| simp [rawDenote, Dictionary.denoteTable, Squarefree.Sparse.denote, Squarefree.Sparse.decode] | |
| rw [hz, add_zero, QueryProducerSpace.specialized_raw_denote] | |
| /-- The exact correction word is interpreted on the declared ambient type. -/ | |
| def specializedJet {n : ℕ} (u J : ℕ) (mask : List Bool) | |
| (jet : Squarefree.Jet (Fin n) R) : Squarefree.Jet (Fin n) R := | |
| Squarefree.canonical u J (Moments.jetScalar (Moments.jetEval | |
| (fun v => if v ∈ Squarefree.decodeMask n mask then (1 : R) else 0) | |
| (by intro v; split <;> simp) jet)) | |
| theorem specializedJet_atom_origin {n : ℕ} (u J : ℕ) (mask : List Bool) (c : R) : | |
| specializedJet (n := n) u J mask (Squarefree.Sparse.atom Squarefree.Index.origin c) = | |
| Squarefree.canonical u J (Squarefree.Sparse.atom Squarefree.Index.origin c) := by | |
| unfold specializedJet | |
| rw [HeadEvaluation.specialize_atom] | |
| simp [Squarefree.Index.origin] | |
| theorem rawDenote_constant {n B d : ℕ} (u J : ℕ) | |
| (f : RingProgram.Code (Word B) d → R) (c : RingProgram.Code (Word B) d) : | |
| rawDenote (n := n) f (Squarefree.Sparse.constant u J c) = | |
| Squarefree.canonical u J (Squarefree.Sparse.atom Squarefree.Index.origin (f c)) := by | |
| have hm : Dictionary.denoteTable f (Squarefree.Sparse.constant (V := Fin n) u J c) = | |
| Squarefree.Sparse.constant u J (f c) := by | |
| by_cases h : 0 < u ∧ 0 < J <;> | |
| simp [Squarefree.Sparse.constant, h, Dictionary.denoteTable] | |
| change Squarefree.Sparse.denote _ = _ | |
| rw [hm, Squarefree.Sparse.denote_constant] | |
| theorem oneEntries_rawDenote {n B d : ℕ} | |
| (f : RingProgram.Code (Word B) d → R) (one : RingProgram.Code (Word B) d) | |
| (hone : f one = 1) : | |
| rawDenote f (FactorAssignmentProgram.oneEntries (n := n) one) = 1 := by | |
| simp [FactorAssignmentProgram.oneEntries, rawDenote, Dictionary.denoteTable, | |
| Squarefree.Sparse.denote, Squarefree.Sparse.decode, hone] | |
| /-- The actual singleton identity is neutral even when one cutoff is zero. -/ | |
| theorem oneEntries_rawValue {n B d : ℕ} (u J : ℕ) | |
| (f : RingProgram.Code (Word B) d → R) (one : RingProgram.Code (Word B) d) | |
| (hone : f one = 1) : | |
| rawValue u J f (FactorAssignmentProgram.oneEntries (n := n) one) = 1 := by | |
| rw [rawValue, oneEntries_rawDenote f one hone, map_one] | |
| /-- The raw identity also determines the bounded dense readout without any | |
| injectivity assumption about coefficient encodings. -/ | |
| theorem rawValue_of_specialized {n B d : ℕ} (u J : ℕ) (mask : List Bool) | |
| (f : RingProgram.Code (Word B) d → R) (entries : List (Product.Entry n B d)) | |
| (jet : Squarefree.Jet (Fin n) R) | |
| (h : rawDenote f entries = specializedJet u J mask jet) : | |
| rawValue u J f entries = Dense.ofPolynomial u J (Moments.jetEval | |
| (fun v => if v ∈ Squarefree.decodeMask n mask then (1 : R) else 0) | |
| (by intro v; split <;> simp) jet) := by | |
| rw [rawValue, h, specializedJet, jetProjection_canonical, jetProjection_jetScalar] | |
| /-- Normalization and dimension transport retain the exact canonical raw | |
| identity; the native source theorem instantiates its source equality below. -/ | |
| theorem specialized_source_realizes (p t : ℕ) [Fact p.Prime] | |
| (M : SubexpPreparedQuartic.Modulus p t) (cache : RingProgram.ScalarCache p t) | |
| {m n d : ℕ} (scalar : ZMod (p ^ t) →+* R) (basis : Fin d → R) | |
| (u J : ℕ) (mask : List Bool) (source : List (Product.Entry m (baseWidth p t) d)) | |
| (hn : m = n) (hvalid : ∀ a ∈ source, Product.ValidKey Finset.univ u J a.1) | |
| (jet : Squarefree.Jet (Fin n) R) | |
| (hsource : PerturbationAssembly.castJet hn | |
| (rawDenote (RingProgram.denote (RingProgram.scalarRing p t M cache) scalar basis) source) = | |
| Squarefree.canonical u J jet) : | |
| ∃ entries : List (Product.Entry n (baseWidth p t) d), | |
| Product.bytes (Normalize.run p t M cache | |
| (HeadEvaluation.specializeEntries (Squarefree.decodeMask m mask) source) []) = | |
| Product.bytes entries ∧ Good ∅ u J entries ∧ | |
| rawDenote (RingProgram.denote (RingProgram.scalarRing p t M cache) scalar basis) entries = | |
| specializedJet u J mask jet := by | |
| cases hn | |
| refine ⟨_, rfl, normalize_good p t M cache ∅ u J _ [] | |
| (QueryProducerSpace.specialized_valid _ source hvalid) Good.nil, ?_⟩ | |
| rw [normalized_specialization_raw] | |
| change rawDenote _ source = Squarefree.canonical u J jet at hsource | |
| rw [hsource] | |
| have hh := QueryJetSemantics.jetScalar_eval_canonical (W := Fin m) u J | |
| (fun v => decide (v ∈ Squarefree.decodeMask m mask)) jet | |
| have hf : Squarefree.boolValue (R := R) (fun v => decide (v ∈ Squarefree.decodeMask m mask)) = | |
| (fun v => if v ∈ Squarefree.decodeMask m mask then (1 : R) else 0) := by | |
| funext v | |
| simp [Squarefree.boolValue] | |
| simpa only [specializedJet, hf] using hh | |
| /-- The fixed source incidence is independent of the source call's array witness. -/ | |
| def fixedLowJet {r Q d : ℕ} (p : SourceBank.Parameters r Q d) | |
| (ps : List (ℕ × ℕ)) (P : PackingData (Fin ps.length) (UniversalType r Q 1)) | |
| (n f j : ℕ) (theta : Coeff (baseWidth 3 p.t) d) (choice : List Bool) : | |
| Squarefree.Jet (Fin n) (p.model.O p.t) := | |
| Moments.incidenceJet (PerturbationAssembly.fixedSourceRow p ps P n f j) | |
| (p.ops.decode theta) | |
| (∑ v : Fin n, (PerturbationAssembly.fixedSourceRow p ps P n f j v).eval | |
| (p.ops.decode theta) * (if choice.getD v.val false then 1 else 0)) | |
| /-- The actual additive normalizer returns an empty-support dictionary whose | |
| whole raw denotation is the intended specialized incidence, at both cutoffs. -/ | |
| theorem low_payload_realizes {r Q d : ℕ} (p : SourceBank.Parameters r Q d) | |
| (ps : List (ℕ × ℕ)) (P : PackingData (Fin ps.length) (UniversalType r Q 1)) | |
| (u J n f j : ℕ) (hu : 0 < u) (hJ : 0 < J) | |
| (theta : Coeff (baseWidth 3 p.t) d) | |
| (xs : List (Fixed.Array (baseWidth 3 p.t) d (p.R + 1))) | |
| (hx : xs.length = n) (choice mask : List Bool) (hc : choice.length = n) | |
| (hs : PerturbationAssembly.sourceRowProperty p ps P n f j xs) : | |
| ∃ entries : List (Product.Entry n (baseWidth 3 p.t) d), | |
| FactorTableNative.specializedRowPayload p.t p.model p.modulus p.cache J (p.R + 1) | |
| theta (PerturbationAssembly.pairChoice xs choice) mask = Product.bytes entries ∧ | |
| Good ∅ u J entries ∧ | |
| rawDenote p.ops.decode entries = | |
| specializedJet u J mask (fixedLowJet p ps P n f j theta choice) := by | |
| let pairs := PerturbationAssembly.pairChoice xs choice | |
| have hpairs : pairs.length = n := | |
| (PerturbationAssembly.pairChoice_length xs choice (hx.trans hc.symm)).trans hx | |
| let source := QueryProducerSpace.emittedSource p.t p.model p.modulus p.cache | |
| J (p.R + 1) theta pairs | |
| have hvalid : ∀ a ∈ source, Product.ValidKey Finset.univ u J a.1 := | |
| QueryProducerSpace.incidence_valid p.ops u J hu hJ theta _ _ | |
| have hsources := PerturbationAssembly.sourceRows_nativeStored p ps P u J n f j hu hJ | |
| theta xs hx choice hc hs | |
| change PerturbationAssembly.castJet hpairs (rawDenote p.ops.decode source) = | |
| Squarefree.canonical u J (fixedLowJet p ps P n f j theta choice) at hsources | |
| exact specialized_source_realizes 3 p.t p.modulus p.cache | |
| (LiftRing.of (p.model.F p.t)) (RingBasis.basis (p.model.F p.t)) | |
| u J mask source hpairs hvalid (fixedLowJet p ps P n f j theta choice) hsources | |
| /-- High coordinates return the physically stored scalar zero or one, with the | |
| same origin encoding used by the low producer. -/ | |
| theorem constant_payload_realizes {n B d : ℕ} (u J : ℕ) (hu : 0 < u) (hJ : 0 < J) | |
| (f : RingProgram.Code (Word B) d → R) (c : RingProgram.Code (Word B) d) | |
| (mask : List Bool) : | |
| ∃ entries : List (Product.Entry n B d), | |
| Encoding.frame (PerturbationAssembly.originKey n) ++ Encoding.frame (RingProgram.flat c) = | |
| Product.bytes entries ∧ Good ∅ u J entries ∧ | |
| rawDenote f entries = specializedJet u J mask (Squarefree.Sparse.atom Squarefree.Index.origin (f c)) := by | |
| refine ⟨Squarefree.Sparse.constant u J c, ?_, constant_good u J c, ?_⟩ | |
| · rw [show Squarefree.Sparse.constant (V := Fin n) u J c = [(Squarefree.Index.origin, c)] by | |
| simp [Squarefree.Sparse.constant, hu, hJ]] | |
| exact (PerturbationAssembly.origin_dictionary n c).trans | |
| (QueryProducerSpace.dictionaryBits_productBytes _) | |
| · rw [rawDenote_constant, specializedJet_atom_origin] | |
| /-- The actual producer's branch-sensitive bytes admit a valid typed witness | |
| with the fixed source meaning. No coefficient values are supplied by a caller. -/ | |
| theorem payload_realizes {r Q d : ℕ} (p : SourceBank.Parameters r Q d) | |
| (ps : List (ℕ × ℕ)) (P : PackingData (Fin ps.length) (UniversalType r Q 1)) | |
| (u J n f j : ℕ) (hu : 0 < u) (hJ : 0 < J) | |
| (theta : Coeff (baseWidth 3 p.t) d) (s : FactorTableProgram.OuterStore) | |
| (payload : List Bool) (hc : (s 546).length = n) | |
| (hz : s 547 = RingProgram.flat p.ops.zeroRun.1) | |
| (ho : s 548 = RingProgram.flat p.ops.oneRun.1) | |
| (h : FactorTableNative.PayloadMeaning p ps P u J n f theta s j payload) : | |
| ∃ entries : List (Product.Entry n (baseWidth 3 p.t) d), | |
| payload = Product.bytes entries ∧ Good ∅ u J entries ∧ | |
| rawDenote p.ops.decode entries = specializedJet u J (s 857) | |
| (PerturbationAssembly.sourceIncidenceJet p ps P n f j theta | |
| (FactorTableProgram.projectBase s)) := by | |
| have hsource := h.source | |
| cases hb : (s 574).getD j false | |
| · simp only [hb, Bool.false_eq_true, ite_false] at hsource | |
| obtain ⟨xs, hx, hs, hpayload⟩ := hsource | |
| obtain ⟨entries, hbytes, hgood, hmeaning⟩ := | |
| low_payload_realizes p ps P u J n f j hu hJ theta xs hx (s 546) (s 857) hc hs | |
| refine ⟨entries, hpayload.trans hbytes, hgood, ?_⟩ | |
| simpa only [PerturbationAssembly.sourceIncidenceJet, | |
| show FactorTableProgram.projectBase s 574 = s 574 from rfl, | |
| show FactorTableProgram.projectBase s 546 = s 546 from rfl, | |
| hb, Bool.false_eq_true, ite_false, fixedLowJet] using hmeaning | |
| · simp only [hb, ite_true] at hsource | |
| let c := if (s 575).getD j false then p.ops.oneRun.1 else p.ops.zeroRun.1 | |
| have hbytes : payload = Encoding.frame (PerturbationAssembly.originKey n) ++ | |
| Encoding.frame (RingProgram.flat c) := by | |
| rw [hsource] | |
| cases hh : (s 575).getD j false <;> | |
| simp only [c, hh, Bool.false_eq_true, ite_false, ite_true, hz, ho] | |
| have hvalue : p.ops.decode c = if (s 575).getD j false then 1 else 0 := by | |
| cases hh : (s 575).getD j false <;> | |
| simp only [c, hh, Bool.false_eq_true, ite_false, ite_true, | |
| p.ops.one_correct, p.ops.zero_correct] | |
| obtain ⟨entries, he, hg, hv⟩ := constant_payload_realizes (n := n) u J hu hJ p.ops.decode c (s 857) | |
| refine ⟨entries, hbytes.trans he, hg, ?_⟩ | |
| rw [hvalue] at hv | |
| simpa only [PerturbationAssembly.sourceIncidenceJet, | |
| show FactorTableProgram.projectBase s 574 = s 574 from rfl, | |
| show FactorTableProgram.projectBase s 575 = s 575 from rfl, | |
| hb, ite_true] using hv | |
| /-- Exact physical byte decoding transports the source meaning to the same | |
| entries consumed by the actual arithmetic run. No semantic encoding | |
| injectivity or extra validity premise is required. -/ | |
| theorem payload_typed_correct {r Q d : ℕ} (p : SourceBank.Parameters r Q d) | |
| (ps : List (ℕ × ℕ)) (P : PackingData (Fin ps.length) (UniversalType r Q 1)) | |
| (u J n f j : ℕ) (hu : 0 < u) (hJ : 0 < J) | |
| (theta : Coeff (baseWidth 3 p.t) d) (s : FactorTableProgram.OuterStore) | |
| (payload : List Bool) (hc : (s 546).length = n) | |
| (hz : s 547 = RingProgram.flat p.ops.zeroRun.1) | |
| (ho : s 548 = RingProgram.flat p.ops.oneRun.1) | |
| (h : FactorTableNative.PayloadMeaning p ps P u J n f theta s j payload) | |
| (entries : List (Product.Entry n (baseWidth 3 p.t) d)) | |
| (hbytes : payload = Product.bytes entries) : | |
| Good ∅ u J entries ∧ | |
| rawDenote p.ops.decode entries = specializedJet u J (s 857) | |
| (PerturbationAssembly.sourceIncidenceJet p ps P n f j theta | |
| (FactorTableProgram.projectBase s)) := by | |
| obtain ⟨semantic, hs, hg, hv⟩ := | |
| payload_realizes p ps P u J n f j hu hJ theta s payload hc hz ho h | |
| have he : entries = semantic := product_bytes_injective | |
| (Nat.mul_pos p.ht (Nat.zero_lt_succ _)) (hbytes.symm.trans hs) | |
| simpa only [he] using And.intro hg hv | |
| /-- The concrete scalar decoder and multiplication table are those of the | |
| same source ring that produced the cached coefficient words. -/ | |
| theorem source_context_decode {r Q d : ℕ} (p : SourceBank.Parameters r Q d) | |
| (n u J : ℕ) (width : List Bool) (hw : width.length = baseWidth 3 p.t) : | |
| RingProgram.denote | |
| (RingProgram.scalarRing 3 p.t (LeafProgram.Factor.sourceContext p n u J width hw).modulus | |
| (LeafProgram.Factor.sourceContext p n u J width hw).cache) | |
| (LiftRing.of (p.model.F p.t)) (RingBasis.basis (p.model.F p.t)) = p.ops.decode := rfl | |
| /-- Paid cache setup identifies the actual source context, encoded ring unit, | |
| negative unit, and idempotent tape. All assumptions are physical master words; | |
| the table law and coefficient meanings come from the same produced source ring. -/ | |
| theorem setup_source_context {r Q d : ℕ} (p : SourceBank.Parameters r Q d) | |
| (n u J : ℕ) (hu : 0 < u) (hJ : 0 < J) | |
| (width : List Bool) (hw : width.length = baseWidth 3 p.t) | |
| (digits : List (IdempotentApplyProgram.Triple (RingProgram.ScalarCode 3 p.t))) | |
| (a : FactorAssignmentProgram.Data) | |
| (hempty : ∀ i : Fin 56, a.stacks (i.castAdd 840) = []) | |
| (hn : (a.stacks 128).length = n) | |
| (hm : a.stacks 194 = p.modulus.bits) | |
| (hwidth : a.stacks 202 = width) (hz : a.stacks 203 = p.cache.zero.val) | |
| (htable : a.stacks 201 = RingTriple.tableEncoding | |
| (HornerProgram.modelTable p.t p.model p.modulus p.cache)) | |
| (hdegree : a.stacks 204 = List.replicate d true) | |
| (hprec : a.stacks 212 = List.replicate u true) | |
| (hjet : a.stacks 243 = List.replicate J true) | |
| (hone : a.stacks 207 = RingProgram.flat p.ops.oneRun.1) | |
| (hminus : a.stacks 211 = RingProgram.flat p.minusOne) | |
| (hdigits : a.stacks 281 = IdempotentApplyProgram.triplesTape digits) : | |
| ∃ b, StructuredCalls.Eval FactorAssignmentProgram.setup | |
| (FactorAssignmentProgram.setupCost a) a b ∧ | |
| (∀ i : Fin 56, b.stacks (i.castAdd 840) = IdempotentApplyProgram.Steps.low | |
| (LeafProgram.Factor.sourceContext p n u J width hw) i) ∧ | |
| b.stacks 69 = Product.bytes (FactorAssignmentProgram.oneEntries (n := n) p.ops.oneRun.1) ∧ | |
| LeafProgram.NativeSemantics.Good ∅ u J (FactorAssignmentProgram.oneEntries (n := n) p.ops.oneRun.1) ∧ | |
| rawDenote p.ops.decode (FactorAssignmentProgram.oneEntries (n := n) p.ops.oneRun.1) = | |
| Squarefree.canonical u J 1 ∧ | |
| rawValue u J p.ops.decode (FactorAssignmentProgram.oneEntries (n := n) p.ops.oneRun.1) = 1 ∧ | |
| b.stacks 76 = RingProgram.flat p.minusOne ∧ p.ops.decode p.minusOne = -1 ∧ | |
| b.stacks 143 = IdempotentApplyProgram.triplesTape digits ∧ | |
| (b.stacks 88).length = n ∧ | |
| (∀ i j : Fin d, RingBasis.basis (p.model.F p.t) i * RingBasis.basis (p.model.F p.t) j = | |
| ∑ k, LiftRing.of (p.model.F p.t) | |
| (wordValue 3 p.t ((LeafProgram.Factor.sourceContext p n u J width hw).table i j k)) * | |
| RingBasis.basis (p.model.F p.t) k) ∧ | |
| ∀ i : Fin 896, i ∉ FactorAssignmentProgram.cachePorts.map FactorAssignmentProgram.lowStack → | |
| b.stacks i = a.stacks i := by | |
| obtain ⟨b, he, hlo, hunit, hgood, hframe⟩ := | |
| FactorAssignmentProgram.setup_context a p.ops.oneRun.1 u J hu hJ hempty hn hone | |
| obtain ⟨c, hec, hcache, _⟩ := FactorAssignmentProgram.setup_eval a | |
| have hcb : c = b := StructuredCalls.Eval.final_unique 0 hec he | |
| have copied (pair : Fin 768 × Fin 768) (hp : pair ∈ LeafNodeCacheProgram.directCopies) : | |
| b.stacks (FactorAssignmentProgram.lowStack pair.2) = | |
| a.stacks (FactorAssignmentProgram.lowStack pair.1) := by | |
| rw [← hcb] | |
| exact (hcache pair.2).trans (FactorAssignmentProgram.setup_direct_word _ pair hp) | |
| refine ⟨b, he, ?_, hunit, hgood, ?_, oneEntries_rawValue u J _ _ p.ops.one_correct, | |
| ?_, p.hminus, ?_, ?_, LeafProgram.NativeSemantics.model_table_correct p.t p.ht p.hd p.model p.modulus p.cache, | |
| hframe⟩ | |
| · intro i | |
| rw [hlo i, hm, hwidth, hz, htable, hdegree, hprec, hjet] | |
| rfl | |
| · rw [FactorAssignmentProgram.oneEntries_eq_constant _ u J hu hJ, | |
| rawDenote_constant, p.ops.one_correct, Squarefree.Sparse.atom_origin_one] | |
| · exact (copied (211,76) (by decide)).trans hminus | |
| · exact (copied (281,143) (by decide)).trans hdigits | |
| · exact (congrArg List.length (copied (128,88) (by decide))).trans hn | |
| end | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorTableDenotation | |