Download data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockwiseEnumeration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 11 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockwiseEnumeration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockwiseEnumeration.lean
-
curl -L -o BlockwiseEnumeration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/Subexp/BlockwiseEnumeration.lean
11 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.SubexpLayoutSpec | |
| import OAI.Algorithms.SubexponentialSAT.ComputablePackingSplit | |
| import OAI.Algorithms.SubexponentialSAT.Subexp.ConstructivePacking | |
| namespace OAI.Algorithms | |
| /-! | |
| # Explicit enumeration by copying local block coordinates | |
| The input is an explicit local decomposition. Global coordinates are obtained | |
| by copying this decomposition into each packed block and retaining the values | |
| on leftover coordinates. Finite tuples are encoded by ordinary mixed-radix | |
| equivalences. No basis of the global vector space is chosen or searched for. | |
| -/ | |
| namespace SubexponentialSAT.Subexp.BlockwiseEnumeration | |
| open scoped BigOperators | |
| /-- Finite local coordinate data, supplied by the searches on one universal | |
| block. The inverses are data, not existentially chosen coordinate maps. -/ | |
| structure LocalData (K : Type*) [Semiring K] (U : Type*) [Fintype U] | |
| (r : β) (W : Fin r β Submodule K (U β K)) where | |
| outerCount : β | |
| innerCount : Fin r β β | |
| outerBase : Fin outerCount β U β K | |
| incrementEquiv : β g, Fin (innerCount g) β W g | |
| assignmentEquiv : (U β K) β (Fin outerCount Γ β g, Fin (innerCount g)) | |
| reconstruction : β o x, assignmentEquiv.symm (o, x) = | |
| outerBase o + β g, (incrementEquiv g (x g)).val | |
| /-- Explicit base-`p` encoding of a vector over the prime residue ring. -/ | |
| def zmodVectorEquiv (p n : β) [NeZero p] : | |
| (Fin n β ZMod p) β Fin (p ^ n) := | |
| (Equiv.piCongrRight fun _ => (ZMod.finEquiv p).symm.toEquiv).trans | |
| finFunctionFinEquiv | |
| /-- Reindexing a function along supplied finite coordinate data. -/ | |
| def reindexFunction {A B K : Type*} (e : A β B) : (B β K) β (A β K) where | |
| toFun f a := f (e a) | |
| invFun f b := f (e.symm b) | |
| left_inv f := by funext b; simp | |
| right_inv f := by funext a; simp | |
| section Packed | |
| variable {K I U V : Type*} [Field K] [Fintype I] [Fintype U] | |
| [DecidableEq V] {r : β} {W : Fin r β Submodule K (U β K)} | |
| open ComputablePackingSplit | |
| /-- The outer coordinates are the untouched values and one local outer index | |
| for every block. -/ | |
| abbrev PackedOuter (e : I Γ U βͺ V) (D : LocalData K U r W) := | |
| (Leftover e β K) Γ (I β Fin D.outerCount) | |
| /-- One local inner index in every block. -/ | |
| abbrev PackedInner (D : LocalData K U r W) (g : Fin r) := | |
| I β Fin (D.innerCount g) | |
| /-- Restrict to each block, apply its supplied local coordinate map, and keep | |
| the leftover values. The inverse uses only local reconstruction and scatter. -/ | |
| def packedAssignmentEquiv (e : I Γ U βͺ V) (D : LocalData K U r W) : | |
| (V β K) β (PackedOuter e D Γ β g, PackedInner (I := I) D g) where | |
| toFun v := | |
| (((split e v).2, fun i => (D.assignmentEquiv ((split e v).1 i)).1), | |
| fun g i => (D.assignmentEquiv ((split e v).1 i)).2 g) | |
| invFun z := (split e).symm | |
| (fun i => D.assignmentEquiv.symm (z.1.2 i, fun g => z.2 g i), z.1.1) | |
| left_inv v := by | |
| apply (split e).injective | |
| rw [LinearEquiv.apply_symm_apply] | |
| apply Prod.ext | |
| Β· funext i | |
| exact D.assignmentEquiv.symm_apply_apply _ | |
| Β· rfl | |
| right_inv z := by | |
| dsimp only | |
| rw [LinearEquiv.apply_symm_apply] | |
| apply Prod.ext | |
| Β· apply Prod.ext | |
| Β· rfl | |
| Β· funext i | |
| exact congrArg Prod.fst (D.assignmentEquiv.apply_symm_apply _) | |
| Β· funext g i | |
| exact congrFun (congrArg Prod.snd (D.assignmentEquiv.apply_symm_apply _)) g | |
| /-- Scatter one local vector from the selected color into each block. -/ | |
| def packedIncrementEquiv (e : I Γ U βͺ V) (D : LocalData K U r W) (g : Fin r) : | |
| PackedInner (I := I) D g β DirectSums.packedSubspace e (W g) where | |
| toFun x := β¨assemble e (fun i => (D.incrementEquiv g (x i)).val, 0), by | |
| apply (DirectSums.mem_packedSubspace_iff e (W g) _).mpr | |
| constructor | |
| Β· intro i | |
| simpa only [assemble_on_block] using (D.incrementEquiv g (x i)).property | |
| Β· intro v hv | |
| exact assemble_outside e _ v hvβ© | |
| invFun v i := (D.incrementEquiv g).symm | |
| β¨fun u => v.val (e (i, u)), DirectSums.packed_restriction_mem e (W g) v.property iβ© | |
| left_inv x := by | |
| funext i | |
| apply (D.incrementEquiv g).symm_apply_eq.mpr | |
| apply Subtype.ext | |
| funext u | |
| exact assemble_on_block e _ i u | |
| right_inv v := by | |
| apply Subtype.ext | |
| funext a | |
| change assemble e _ a = v.val a | |
| by_cases ha : a β Set.range e | |
| Β· obtain β¨β¨i, uβ©, rflβ© := ha | |
| rw [assemble_on_block] | |
| exact congrFun (congrArg Subtype.val | |
| ((D.incrementEquiv g).apply_symm_apply _)) u | |
| Β· rw [assemble_outside e _ a ha] | |
| exact (DirectSums.packed_zero_outside e (W g) v.property a ha).symm | |
| /-- Copy the local complement values and the untouched coordinates. -/ | |
| def packedOuterBase (e : I Γ U βͺ V) (D : LocalData K U r W) | |
| (o : PackedOuter e D) : V β K := | |
| assemble e (fun i => D.outerBase (o.2 i), o.1) | |
| theorem packed_reconstruction (e : I Γ U βͺ V) (D : LocalData K U r W) | |
| (o : PackedOuter e D) (x : β g, PackedInner (I := I) D g) : | |
| (packedAssignmentEquiv e D).symm (o, x) = | |
| packedOuterBase e D o + β g, (packedIncrementEquiv e D g (x g)).val := by | |
| funext a | |
| by_cases ha : a β Set.range e | |
| Β· obtain β¨β¨i, uβ©, rflβ© := ha | |
| change assemble e _ (e (i, u)) = _ | |
| simp only [assemble_on_block, packedOuterBase, packedIncrementEquiv, | |
| Equiv.coe_fn_mk, Pi.add_apply, Finset.sum_apply] | |
| simpa only [Pi.add_apply, Finset.sum_apply] using | |
| congrFun (D.reconstruction (o.2 i) (fun g => x g i)) u | |
| Β· change assemble e _ a = _ | |
| simp only [assemble_outside e _ a ha, packedOuterBase, packedIncrementEquiv, | |
| Equiv.coe_fn_mk, Pi.add_apply, Finset.sum_apply, Pi.zero_apply, | |
| Finset.sum_const_zero, add_zero] | |
| end Packed | |
| section FiniteIndices | |
| variable {p b l r : β} [Fact p.Prime] | |
| {U V : Type*} [Fintype U] [Fintype V] [DecidableEq V] | |
| {W : Fin r β Submodule (ZMod p) (U β ZMod p)} | |
| /-- A numerical index for the untouched values and copied local complements. | |
| The supplied leftover enumeration is coordinate data, not a chosen basis. -/ | |
| def outerIndexEquiv (e : Fin b Γ U βͺ V) (D : LocalData (ZMod p) U r W) | |
| (leftoverEnum : Fin l β ComputablePackingSplit.Leftover e) : | |
| PackedOuter e D β Fin (p ^ l * D.outerCount ^ b) := | |
| (Equiv.prodCongr | |
| ((reindexFunction leftoverEnum).trans (zmodVectorEquiv p l)) | |
| finFunctionFinEquiv).trans finProdFinEquiv | |
| /-- Encode the independent local inner indices in base `innerCount g`. -/ | |
| def innerIndexEquiv (D : LocalData (ZMod p) U r W) (g : Fin r) : | |
| PackedInner (I := Fin b) D g β Fin (D.innerCount g ^ b) := | |
| finFunctionFinEquiv | |
| /-- The explicit global coordinate data. Only restriction, local coordinate | |
| conversion, scattering, and mixed-radix arithmetic appear in the definitions. -/ | |
| def packedData (e : Fin b Γ U βͺ V) (D : LocalData (ZMod p) U r W) | |
| (leftoverEnum : Fin l β ComputablePackingSplit.Leftover e) | |
| (G : Fin r β Submodule (ZMod p) (V β ZMod p)) | |
| (hG : β g, DirectSums.packedSubspace e (W g) = G g) : | |
| LocalData (ZMod p) V r G where | |
| outerCount := p ^ l * D.outerCount ^ b | |
| innerCount g := D.innerCount g ^ b | |
| outerBase o := packedOuterBase e D ((outerIndexEquiv e D leftoverEnum).symm o) | |
| incrementEquiv g := (innerIndexEquiv D g).symm.trans | |
| { toFun := fun x => β¨(packedIncrementEquiv e D g x).val, by | |
| rw [β hG g] | |
| exact (packedIncrementEquiv e D g x).propertyβ© | |
| invFun := fun x => (packedIncrementEquiv e D g).symm β¨x.val, by | |
| rw [hG g] | |
| exact x.propertyβ© | |
| left_inv := fun x => (packedIncrementEquiv e D g).symm_apply_apply x | |
| right_inv := by | |
| intro x | |
| apply Subtype.ext | |
| change ((packedIncrementEquiv e D g) | |
| ((packedIncrementEquiv e D g).symm β¨x.val, _β©)).val = x.val | |
| exact congrArg Subtype.val ((packedIncrementEquiv e D g).apply_symm_apply _) } | |
| assignmentEquiv := (packedAssignmentEquiv e D).trans | |
| (Equiv.prodCongr (outerIndexEquiv e D leftoverEnum) | |
| (Equiv.piCongrRight fun g => innerIndexEquiv D g)) | |
| reconstruction o x := by | |
| exact packed_reconstruction e D ((outerIndexEquiv e D leftoverEnum).symm o) | |
| (fun g => (innerIndexEquiv D g).symm (x g)) | |
| @[simp] theorem packedData_outerCount (e : Fin b Γ U βͺ V) | |
| (D : LocalData (ZMod p) U r W) | |
| (leftoverEnum : Fin l β ComputablePackingSplit.Leftover e) | |
| (G : Fin r β Submodule (ZMod p) (V β ZMod p)) | |
| (hG : β g, DirectSums.packedSubspace e (W g) = G g) : | |
| (packedData e D leftoverEnum G hG).outerCount = p ^ l * D.outerCount ^ b := rfl | |
| @[simp] theorem packedData_innerCount (e : Fin b Γ U βͺ V) | |
| (D : LocalData (ZMod p) U r W) | |
| (leftoverEnum : Fin l β ComputablePackingSplit.Leftover e) | |
| (G : Fin r β Submodule (ZMod p) (V β ZMod p)) | |
| (hG : β g, DirectSums.packedSubspace e (W g) = G g) (g : Fin r) : | |
| (packedData e D leftoverEnum G hG).innerCount g = D.innerCount g ^ b := rfl | |
| end FiniteIndices | |
| section Layout | |
| variable {p k Ξ r b l : β} {tau : β} [Fact p.Prime] | |
| {V F E U : Type*} [Fintype V] [DecidableEq V] [Fintype F] [Fintype U] | |
| [Field E] [Algebra (ZMod p) E] | |
| {P : Factor.Pattern V F} {c : SubexpLayoutSpec.Parameters p k Ξ r tau} | |
| /-- Directly package explicit coordinate data into the enumeration interface | |
| used by the counting algorithm. -/ | |
| def toEnumerationData (L : SubexpLayoutSpec.Layout (E := E) P c) (t : Fin c.Q) | |
| (D : LocalData (ZMod p) V r (L.K t)) : SubexpLayoutSpec.EnumerationData L t where | |
| outerCount := D.outerCount | |
| innerCount := D.innerCount | |
| outerBase := D.outerBase | |
| incrementEquiv := D.incrementEquiv | |
| assignmentEquiv := D.assignmentEquiv | |
| reconstruction := D.reconstruction | |
| /-- The actual layout consumer. Equality with the packed local spaces is the | |
| only bridge required; for the layout assembled from complete blocks it is | |
| definitional equality. -/ | |
| def ofPackedSpaces (L : SubexpLayoutSpec.Layout (E := E) P c) (t : Fin c.Q) | |
| (e : Fin b Γ U βͺ V) {W : Fin r β Submodule (ZMod p) (U β ZMod p)} | |
| (D : LocalData (ZMod p) U r W) | |
| (leftoverEnum : Fin l β ComputablePackingSplit.Leftover e) | |
| (hK : L.K t = fun g => DirectSums.packedSubspace e (W g)) : | |
| SubexpLayoutSpec.EnumerationData L t := | |
| toEnumerationData L t | |
| (packedData e D leftoverEnum (L.K t) (fun g => congrFun hK.symm g)) | |
| /-- Use the executable bucket packing and its explicit leftover list directly. -/ | |
| def ofPackingData [DecidableEq U] | |
| (L : SubexpLayoutSpec.Layout (E := E) P c) (t : Fin c.Q) | |
| (packing : ConstructivePacking.PackingData V U) | |
| {W : Fin r β Submodule (ZMod p) (U β ZMod p)} | |
| (D : LocalData (ZMod p) U r W) | |
| (hK : L.K t = fun g => | |
| DirectSums.packedSubspace packing.completeBlocks.embed (W g)) : | |
| SubexpLayoutSpec.EnumerationData L t := | |
| ofPackedSpaces L t packing.completeBlocks.embed D packing.leftoverEquiv hK | |
| end Layout | |
| end SubexponentialSAT.Subexp.BlockwiseEnumeration | |
| end OAI.Algorithms | |