File size: 3,131 Bytes
a2ee19a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | import OAI.Probability.SATComputability.ClauseRestoration
namespace OAI
namespace FixedClauseThreshold.Computability
open scoped Classical
abbrev Triple (A : Type*) := A × A × A
abbrev TripleClasses (A : Type*) :=
Triple A ⊕ (Fin 3 × Bool × A × A) ⊕ (Fin 3 × Bool × Bool × A) ⊕ Triple Bool
def splitTriple {A : Type*} : Triple (Bool ⊕ A) → TripleClasses A
| (.inr a,.inr b,.inr c) => .inl (a,b,c)
| (.inl a,.inr b,.inr c) => .inr (.inl (0,a,b,c))
| (.inr a,.inl b,.inr c) => .inr (.inl (1,b,a,c))
| (.inr a,.inr b,.inl c) => .inr (.inl (2,c,a,b))
| (.inr a,.inl b,.inl c) => .inr (.inr (.inl (0,b,c,a)))
| (.inl a,.inr b,.inl c) => .inr (.inr (.inl (1,a,c,b)))
| (.inl a,.inl b,.inr c) => .inr (.inr (.inl (2,a,b,c)))
| (.inl a,.inl b,.inl c) => .inr (.inr (.inr (a,b,c)))
def joinTriple {A : Type*} : TripleClasses A → Triple (Bool ⊕ A)
| .inl (a,b,c) => (.inr a,.inr b,.inr c)
| .inr (.inl (i,b,a,c)) =>
if i = 0 then (.inl b,.inr a,.inr c)
else if i = 1 then (.inr a,.inl b,.inr c)
else (.inr a,.inr c,.inl b)
| .inr (.inr (.inl (i,a,b,c))) =>
if i = 0 then (.inr c,.inl a,.inl b)
else if i = 1 then (.inl a,.inr c,.inl b)
else (.inl a,.inl b,.inr c)
| .inr (.inr (.inr (a,b,c))) => (.inl a,.inl b,.inl c)
def tripleClassesEquiv (A : Type*) : Triple (Bool ⊕ A) ≃ TripleClasses A where
toFun := splitTriple
invFun := joinTriple
left_inv := by
rintro ⟨a,b,c⟩
cases a <;> cases b <;> cases c <;> rfl
right_inv := by
rintro (⟨a,b,c⟩ | (⟨i,a,b,c⟩ | (⟨i,a,b,c⟩ | ⟨a,b,c⟩)))
· rfl
· fin_cases i <;> rfl
· fin_cases i <;> rfl
· rfl
def literalSplitEquiv (n : ℕ) : SignedLiteral (n+1) ≃ Bool ⊕ SignedLiteral n where
toFun l := Fin.cases (.inl l.2) (fun j => .inr (j,l.2)) l.1
invFun := fun l => match l with
| .inl b => (0,b)
| .inr (j,b) => (j.succ,b)
left_inv := by
rintro ⟨i,b⟩
refine Fin.cases rfl (fun j => ?_) i
rfl
right_inv := by
rintro (b | ⟨j,b⟩) <;> rfl
def tripleVectorEquiv (A : Type*) : (Fin 3 → A) ≃ Triple A where
toFun f := (f 0,f 1,f 2)
invFun t := ![t.1,t.2.1,t.2.2]
left_inv := by intro f; funext i; fin_cases i <;> rfl
right_inv := by rintro ⟨a,b,c⟩; rfl
def clauseClassesEquiv (n : ℕ) : (Fin 3 → SignedLiteral (n+1)) ≃ TripleClasses (SignedLiteral n) :=
(Equiv.arrowCongr (Equiv.refl _) (literalSplitEquiv n)).trans
((tripleVectorEquiv _).trans (tripleClassesEquiv _))
theorem clauseClasses_base_card (n : ℕ) :
Fintype.card (Triple (SignedLiteral n)) = 8*n^3 := by
simp [Triple, SignedLiteral, Fintype.card_prod, Fintype.card_fin]
ring
theorem clauseClasses_single_card (n : ℕ) :
Fintype.card (Fin 3 × Bool × SignedLiteral n × SignedLiteral n) = 24*n^2 := by
simp [SignedLiteral, Fintype.card_prod, Fintype.card_fin]
ring
theorem clauseClasses_double_card (n : ℕ) :
Fintype.card (Fin 3 × Bool × Bool × SignedLiteral n) = 24*n := by
simp [SignedLiteral, Fintype.card_prod, Fintype.card_fin]
ring
end FixedClauseThreshold.Computability
end OAI
|