id int64 1 500 | thm_name stringlengths 5 86 | thm_stmt stringlengths 30 2.63k | lean_root stringclasses 23 values | rel_path stringlengths 13 61 | imports listlengths 0 35 | used_lib_defs listlengths 1 144 | used_repo_defs listlengths 1 251 | lib_lemmas listlengths 1 172 | repo_lemmas listlengths 1 148 | used_local_defs listlengths 0 85 | used_local_lemmas listlengths 0 57 | local_ctx stringlengths 35 30.7k | target_theorem stringlengths 33 1.57k | ground_truth_proof stringlengths 6 26.5k | nesting_depth int64 1 27 | transitive_dep_count int64 1 480 | subset_aristotle bool 2 classes | category stringclasses 5 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
301 | TermUnop.alt_lang | lemma TermUnop.alt_lang {t : Term} (op : TermUnop) :
(op.subst_arity' ▸ (op.subst t).language) =
let lop : Set (BitVecs 2) := op.openTerm_arity' ▸ op.openTerm.language
let lop' : Set (BitVecs (t.arity + 2)) := lop.lift (λ i ↦ i.natAdd t.arity)
let lt : Set (BitVecs (t.arity + 2)) := t.language.lift (λ i ↦ i.castLE (by omega))
let l := lt ∩ lop'
l.proj (liftUnop t.arity) | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "Fin.natAdd",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
}
] | [
{
"name": "syntax \"xor\" : MLIR.Pretty.uniform_op",
"content": "syntax \"xor\" : MLIR.Pretty.uniform_op\n\nsyntax \"max\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "sub",
"content": "def sub (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).1"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "neg",
"content": "def neg (x : BitStream) : BitStream :=\n fun n => (negAux x n).1"
},
{
"name": "negAux",
"content": "def negAux (x : BitStream) : Nat → Bool × Bool\n | 0 => (x 0, !(x 0))\n | n+1 =>\n let borrow := (negAux x n).2\n let a := x (n + 1)\n (xor (!a) borrow, !a && borrow)"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "BitVecs.cast",
"content": "def BitVecs.cast (bvs : BitVecs n) (h : n = n') : BitVecs n' :=\n { w := bvs.w, bvs := h ▸ bvs.bvs }"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "Term.language",
"content": "def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=\n { bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }"
},
{
"name": "Formula.arity",
"content": "@[simp]\ndef Formula.arity : Formula → Nat\n| width _ _ => 0\n| atom _ t1 t2 => max t1.arity t2.arity\n| msbSet t => t.arity\n| unop _ φ => φ.arity\n| binop _ φ1 φ2 => max φ1.arity φ2.arity"
},
{
"name": "Term.evalFinBV",
"content": "@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=\n match t with\n | .var n => vars (Fin.last n)\n | .zero => BitVec.zero w\n | .one => 1\n | .negOne => -1\n | .ofNat n => BitVec.ofNat _ n\n | .and t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | .or t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | .xor t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | .not t => ~~~(t.evalFinBV vars)\n \n | .add t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | .sub t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | .neg t => -(t.evalFinBV vars)\n | .shiftL a n => (a.evalFinBV vars) <<< n"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Fin.ext_iff",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.mod_le",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "eq_iff_iff",
"module": "Init.Core"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "ite_cond_eq_true",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
},
{
"name": "List.Vector.append_get_ge",
"content": "@[simp]\nlemma List.Vector.append_get_ge {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: n ≤ i) :\n (x ++ y).get i = y.get ((i.cast (Nat.add_comm n m) |>.subNat n hlt))"
},
{
"name": "List.Vector.append_get_lt",
"content": "@[simp]\nlemma List.Vector.append_get_lt {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: i < n) :\n (x ++ y).get i = x.get (i.castLT hlt)"
},
{
"name": "BitVecs.transport_getElem",
"content": "@[simp]\nlemma BitVecs.transport_getElem {bvs : BitVecs m} (f : Fin n → Fin m) (i : Fin n) :\n (bvs.transport f).bvs.get i = bvs.bvs.get (f i)"
}
] | [
{
"name": "NFA.msbState",
"content": "inductive NFA.msbState : Type where\n| i | f\nderiving DecidableEq, Fintype"
},
{
"name": "liftUnop",
"content": "def liftUnop n : Fin (n + 1) → Fin (n + 2) :=\n fun k =>\n if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "TermBinop",
"content": "inductive TermBinop where\n| and | or | xor | add | sub"
},
{
"name": "TermBinop.subst",
"content": "def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=\n match op with\n | .and => .and t₁ t₂\n | .or => .or t₁ t₂\n | .xor => .xor t₁ t₂\n | .add => .add t₁ t₂\n | .sub => .sub t₁ t₂"
},
{
"name": "TermBinop.openTerm",
"content": "def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)"
},
{
"name": "TermUnop",
"content": "inductive TermUnop where\n| neg | not | shiftL (k : Nat)"
},
{
"name": "TermUnop.openTerm",
"content": "def TermUnop.openTerm (op : TermUnop) : Term :=\n match op with\n | .neg => .neg (.var 0)\n | .not => .not (.var 0)\n | .shiftL k => .shiftL (.var 0) k"
},
{
"name": "TermUnop.openTerm_arity'",
"content": "@[simp]\ndef TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :="
},
{
"name": "TermUnop.subst",
"content": "def TermUnop.subst (op : TermUnop) (t : Term) : Term :=\n match op with\n | .neg => .neg t\n | .not => .not t\n | .shiftL k => .shiftL t k"
},
{
"name": "swapLastTwo",
"content": "def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=\n if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x"
}
] | [
{
"name": "TermBinop.subst_arity'",
"content": "lemma TermBinop.subst_arity' {op : TermBinop} : (op.subst t₁ t₂).arity + 1= t₁.arity ⊔ t₂.arity + 1"
},
{
"name": "BitVecs.cast_eq",
"content": "@[simp]\nlemma BitVecs.cast_eq (x : BitVecs n) (h : n = n') : h ▸ x = x.cast h"
},
{
"name": "Fin.natAdd_zero'",
"content": "lemma Fin.natAdd_zero' [h : NeZero m] : Fin.natAdd (m := m) n 0 = n"
},
{
"name": "TermUnop.subst_arity'",
"content": "@[simp]\nlemma TermUnop.subst_arity' {op : TermUnop} : (op.subst t).arity + 1 = t.arity + 1"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
section fsm
variable {arity : Type} [FinEnum arity]
open BitStream in
end fsm
section nfas_relations
inductive NFA.msbState : Type where
| i | f
deriving DecidableEq, Fintype
end nfas_relations
def liftUnop n : Fin (n + 1) → Fin (n + 2) :=
fun k =>
if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/
)
inductive TermBinop where
| and | or | xor | add | sub
def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=
match op with
| .and => .and t₁ t₂
| .or => .or t₁ t₂
| .xor => .xor t₁ t₂
| .add => .add t₁ t₂
| .sub => .sub t₁ t₂
def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)
inductive TermUnop where
| neg | not | shiftL (k : Nat)
def TermUnop.openTerm (op : TermUnop) : Term :=
match op with
| .neg => .neg (.var 0)
| .not => .not (.var 0)
| .shiftL k => .shiftL (.var 0) k
@[simp]
def TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :=
def TermUnop.subst (op : TermUnop) (t : Term) : Term :=
match op with
| .neg => .neg t
| .not => .not t
| .shiftL k => .shiftL t k
def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=
if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x | lemma TermUnop.alt_lang {t : Term} (op : TermUnop) :
(op.subst_arity' ▸ (op.subst t).language) =
let lop : Set (BitVecs 2) := | := op.openTerm_arity' ▸ op.openTerm.language
let lop' : Set (BitVecs (t.arity + 2)) := lop.lift (λ i ↦ i.natAdd t.arity)
let lt : Set (BitVecs (t.arity + 2)) := t.language.lift (λ i ↦ i.castLE (by omega))
let l := lt ∩ lop'
l.proj (liftUnop t.arity)
:= by
simp [Term.language]
ext bvs
simp
generalize_proofs h₁ h₂ h₃ h₄ h₅
constructor
· rintro heq
let bvs' := bvs.bvs ++ (t.evalFinBV (λ n ↦ bvs.bvs.get n) ::ᵥ List.Vector.nil) |>.transport swapLastTwo
use ⟨_, bvs'⟩
split_ands
· simp [bvs']
have heq : (swapLastTwo (Fin.castLE h₃ (Fin.last t.arity))) = Fin.last (t.arity + 1) := by
simp [swapLastTwo]
split_ifs with h₁ h₂
· exfalso; rw [Fin.ext_iff] at h₁
simp at h₁
· rfl
· exfalso; apply h₂; ext; simp; exact Eq.symm (Nat.mod_eq_of_lt h₃)
rw [heq]
rw [List.Vector.append_get_ge]
on_goal 2 => simp
simp
congr
ext1 x
rw [List.Vector.append_get_lt]
on_goal 2 => simp +arith
congr!
· rw [BitVecs.cast_eq] at heq ⊢
unfold BitVecs.cast
simp
simp [BitVecs.cast] at heq
have hget : bvs'.get (Fin.natAdd t.arity 1) = bvs.bvs.get t.arity := by
simp [bvs']
rw [List.Vector.append_get_lt]
on_goal 2 => simp +arith; exact Nat.mod_le t.arity (t.arity + 2)
· congr
ext
simp +arith
rw [hget]
convert heq using 1
· have hbvs' : bvs'.get t.arity = t.evalFinBV fun n => bvs.bvs.get n := by
simp [bvs']
simp [openTerm]
rcases op <;> simp [hbvs', Fin.natAdd_zero'] <;> rfl
· congr!; ext; simp
· ext1
· simp
next i =>
simp [bvs', liftUnop]
split_ifs with h
· subst h
simp
rw [List.Vector.append_get_lt]
on_goal 2 => simp +arith; exact Nat.mod_le t.arity (t.arity + 2)
congr
ext; simp +arith
· simp [h]
congr!
· rintro ⟨bvs', ⟨⟨heq₁, heq₂⟩, heq₃⟩⟩
rw [BitVecs.cast_eq] at *
simp [BitVecs.cast] at *
rw [←heq₃]
conv_rhs =>
simp only [BitVecs.transport_getElem]
simp [liftUnop]
rw [ite_cond_eq_true]
rfl
tactic => simp only [eq_iff_iff, iff_true]; ext1; simp
convert heq₂ using 1
rcases op with _ | _ | _ <;>
. simp [subst, openTerm] at *; congr | 4 | 63 | false | Compiler |
302 | formula_language | theorem formula_language (φ : Formula) :
φ.language = { (bvs : BitVecs φ.arity) | φ.sat (fun k => bvs.bvs.get k) } | lean-mlir | Blase/Blase/AutoStructs/Defs.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.ForMathlib"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "impl",
"module": "Mathlib.Deprecated.MLList.BestFirst"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.card",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "atom",
"module": "Leanwuzla.Sexp.Basic"
},
{
"name": "Fin.isValue",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set.instMembership",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.Mem",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "List.Vector.get",
"module": "Mathlib.Data.Vector.Defs"
}
] | [
{
"name": "syntax \"max\" : MLIR.Pretty.uniform_op",
"content": "syntax \"max\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "WidthPredicate",
"content": "inductive WidthPredicate\n| eq\n| neq\n| lt\n| le\n| gt\n| ge\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "BitVecs.cast",
"content": "def BitVecs.cast (bvs : BitVecs n) (h : n = n') : BitVecs n' :=\n { w := bvs.w, bvs := h ▸ bvs.bvs }"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Fin.val_last",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "le_add_iff_nonneg_right",
"module": "Mathlib.Algebra.Order.Monoid.Unbundled.Basic"
},
{
"name": "zero_le",
"module": "Mathlib.Algebra.Order.Monoid.Canonical.Defs"
},
{
"name": "Set.compl_def",
"module": "Mathlib.Order.BooleanAlgebra.Set"
},
{
"name": "Set.mem_image",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Set.mem_inter_iff",
"module": "Mathlib.Data.Set.Basic"
},
{
"name": "Set.preimage_setOf_eq",
"module": "Mathlib.Data.Set.Image"
}
] | [
{
"name": "List.Vector.append_get_ge",
"content": "@[simp]\nlemma List.Vector.append_get_ge {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: n ≤ i) :\n (x ++ y).get i = y.get ((i.cast (Nat.add_comm n m) |>.subNat n hlt))"
},
{
"name": "List.Vector.append_get_lt",
"content": "@[simp]\nlemma List.Vector.append_get_lt {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: i < n) :\n (x ++ y).get i = x.get (i.castLT hlt)"
},
{
"name": "BitVecs.transport_getElem",
"content": "@[simp]\nlemma BitVecs.transport_getElem {bvs : BitVecs m} (f : Fin n → Fin m) (i : Fin n) :\n (bvs.transport f).bvs.get i = bvs.bvs.get (f i)"
}
] | [
{
"name": "liftMaxSucc1",
"content": "def liftMaxSucc1 (n m : Nat) : Fin (n + 1) → Fin (max n m + 2) :=\n fun k => if _ : k = n then Fin.last (max n m) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMaxSucc2",
"content": "def liftMaxSucc2 (n m : Nat) : Fin (m + 1) → Fin (max n m + 2) :=\n fun k => if _ : k = m then Fin.last (max n m + 1) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftLast2",
"content": "def liftLast2 n : Fin 2 → Fin (n + 2)\n| 0 => n\n| 1 => Fin.last (n + 1)"
},
{
"name": "liftExcept2",
"content": "def liftExcept2 n : Fin n → Fin (n + 2) :=\n fun k => Fin.castLE (by admit /- proof elided -/\n ) k"
},
{
"name": "liftMax1",
"content": "def liftMax1 (n m : Nat) : Fin n → Fin (max n m) :=\n fun k => k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMax2",
"content": "def liftMax2 (n m : Nat) : Fin m → Fin (max n m) :=\n fun k => k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "Term.evalFinBV",
"content": "@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=\n match t with\n | .var n => vars (Fin.last n)\n | .zero => BitVec.zero w\n | .one => 1\n | .negOne => -1\n | .ofNat n => BitVec.ofNat _ n\n | .and t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | .or t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | .xor t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | .not t => ~~~(t.evalFinBV vars)\n \n | .add t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | .sub t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | .neg t => -(t.evalFinBV vars)\n | .shiftL a n => (a.evalFinBV vars) <<< n"
},
{
"name": "Term.language",
"content": "def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=\n { bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }"
},
{
"name": "RelationOrdering",
"content": "inductive RelationOrdering\n| lt | le | gt | ge\nderiving Repr, Fintype"
},
{
"name": "Relation",
"content": "inductive Relation\n| eq\n| signed (ord : RelationOrdering)\n| unsigned (ord : RelationOrdering)\nderiving Repr"
},
{
"name": "evalRelation",
"content": "def evalRelation (rel : Relation) {w} (bv1 bv2 : BitVec w) : Prop :=\n match rel with\n | .eq => bv1 = bv2\n | .signed .lt => bv1.slt bv2\n | .signed .le => bv1.sle bv2\n | .signed .gt => bv2.slt bv1\n | .signed .ge => bv2.sle bv1\n | .unsigned .lt => bv1.ult bv2\n | .unsigned .le => bv1.ule bv2\n | .unsigned .gt => bv2.ult bv1\n | .unsigned .ge => bv2.ule bv1"
},
{
"name": "Relation.language",
"content": "@[simp]\ndef Relation.language (rel : Relation) : Set (BitVecs 2) :=\n { bvs | evalRelation rel (bvs.bvs.get 0) (bvs.bvs.get 1) }"
},
{
"name": "Binop",
"content": "inductive Binop\n| and | or | impl | equiv\nderiving Repr"
},
{
"name": "evalBinop",
"content": "def evalBinop (op : Binop) (b1 b2 : Prop) : Prop :=\n match op with\n | .and => b1 ∧ b2\n | .or => b1 ∨ b2\n | .impl => b1 → b2\n | .equiv => b1 ↔ b2"
},
{
"name": "langBinop",
"content": "def langBinop (op : Binop) (l1 l2 : Set (BitVecs n)) : Set (BitVecs n) :=\n match op with\n | .and => l1 ∩ l2\n | .or => l1 ∪ l2\n | .impl => l1ᶜ ∪ l2\n | .equiv => (l1ᶜ ∪ l2) ∩ (l2ᶜ ∪ l1)"
},
{
"name": "Unop",
"content": "inductive Unop\n| neg\nderiving Repr"
},
{
"name": "Formula",
"content": "inductive Formula : Type\n| width : WidthPredicate → Nat → Formula\n| atom : Relation → Term → Term → Formula\n| msbSet : Term → Formula\n| unop : Unop → Formula → Formula\n| binop : Binop → Formula → Formula → Formula\nderiving Repr"
},
{
"name": "Formula.arity",
"content": "@[simp]\ndef Formula.arity : Formula → Nat\n| width _ _ => 0\n| atom _ t1 t2 => max t1.arity t2.arity\n| msbSet t => t.arity\n| unop _ φ => φ.arity\n| binop _ φ1 φ2 => max φ1.arity φ2.arity"
},
{
"name": "WidthPredicate.sat",
"content": "@[simp]\ndef WidthPredicate.sat (wp : WidthPredicate) (w n : Nat) : Bool :=\n match wp with\n | .eq => w = n\n | .neq => w ≠ n\n | .lt => w < n\n | .le => w ≤ n\n | .gt => w > n\n | .ge => w ≥ n"
},
{
"name": "Formula.sat",
"content": "@[simp]\ndef Formula.sat {w : Nat} (φ : Formula) (ρ : Fin φ.arity → BitVec w) : Prop :=\n match φ with\n | .width wp n => wp.sat w n\n | .atom rel t1 t2 =>\n let bv1 := t1.evalFinBV (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n let bv2 := t2.evalFinBV (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n evalRelation rel bv1 bv2\n | .unop .neg φ => ¬ φ.sat ρ\n | .binop op φ1 φ2 =>\n let b1 := φ1.sat (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n let b2 := φ2.sat (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n evalBinop op b1 b2\n | .msbSet t => (t.evalFinBV ρ).msb"
},
{
"name": "_root_.Set.lift",
"content": "@[simp]\ndef _root_.Set.lift (f : Fin n → Fin m) (bvs : Set (BitVecs n)) : Set (BitVecs m) :=\n BitVecs.transport f ⁻¹' bvs"
},
{
"name": "_root_.Set.proj",
"content": "@[simp]\ndef _root_.Set.proj (f : Fin n → Fin m) (bvs : Set (BitVecs m)) : Set (BitVecs n) :=\n BitVecs.transport f '' bvs"
},
{
"name": "langMsb",
"content": "@[simp]\ndef langMsb : Set (BitVecs 1) := { bvs | bvs.bvs.get 0 |>.msb }"
},
{
"name": "Formula.language",
"content": "@[simp]\ndef Formula.language (φ : Formula) : Set (BitVecs φ.arity) :=\n match φ with\n | .width wp n => { bvs | wp.sat bvs.w n }\n | .atom rel t1 t2 =>\n let l1 := t1.language.lift (liftMaxSucc1 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity))\n let l2 := t2.language.lift (liftMaxSucc2 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity))\n let lrel := rel.language.lift $ liftLast2 (max (FinEnum.card (Fin t1.arity)) (FinEnum.card (Fin t2.arity)))\n let l := lrel ∩ l1 ∩ l2\n l.proj (liftExcept2 _)\n | .unop .neg φ => φ.languageᶜ\n | .binop op φ1 φ2 =>\n let l1 := φ1.language.lift $ liftMax1 φ1.arity φ2.arity\n let l2 := φ2.language.lift $ liftMax2 φ1.arity φ2.arity\n langBinop op l1 l2\n | .msbSet t =>\n let lmsb := langMsb.lift $ fun _ => Fin.last t.arity\n let l' := t.language ∩ lmsb\n l'.proj fun n => n.castLE (by admit /- proof elided -/\n )"
}
] | [
{
"name": "evalFin_eq",
"content": "lemma evalFin_eq {t : Term} {vars1 : Fin t.arity → BitVec w1} {vars2 : Fin t.arity → BitVec w2} :\n ∀ (heq : w1 = w2),\n (∀ n, vars1 n = heq ▸ vars2 n) →\n t.evalFinBV vars1 = heq ▸ t.evalFinBV vars2"
},
{
"name": "evalRelation_coe",
"content": "@[simp]\nlemma evalRelation_coe (rel : Relation) (bv1 bv2 : BitVec w1) (heq : w1 = w2) :\n evalRelation rel (heq ▸ bv1) (heq ▸ bv2) = evalRelation rel bv1 bv2"
},
{
"name": "helper1",
"content": "lemma helper1 : (k = 0) → (x ::ᵥ vs).get k = x"
},
{
"name": "helper2",
"content": "lemma helper2 : (k = 1) → (x ::ᵥ y ::ᵥ vs).get k = y"
},
{
"name": "formula_language_case_atom",
"content": "lemma formula_language_case_atom :\n let φ := Formula.atom rel t1 t2\n φ.language = λ (bvs : BitVecs φ.arity) => φ.sat (fun k => bvs.bvs.get k)"
}
] | import Blase.AutoStructs.ForMathlib
import Blase.SingleWidth.Defs
open Fin.NatCast
def liftMaxSucc1 (n m : Nat) : Fin (n + 1) → Fin (max n m + 2) :=
fun k => if _ : k = n then Fin.last (max n m) else k.castLE (by admit /- proof elided -/
)
def liftMaxSucc2 (n m : Nat) : Fin (m + 1) → Fin (max n m + 2) :=
fun k => if _ : k = m then Fin.last (max n m + 1) else k.castLE (by admit /- proof elided -/
)
def liftLast2 n : Fin 2 → Fin (n + 2)
| 0 => n
| 1 => Fin.last (n + 1)
def liftExcept2 n : Fin n → Fin (n + 2) :=
fun k => Fin.castLE (by admit /- proof elided -/
) k
def liftMax1 (n m : Nat) : Fin n → Fin (max n m) :=
fun k => k.castLE (by admit /- proof elided -/
)
def liftMax2 (n m : Nat) : Fin m → Fin (max n m) :=
fun k => k.castLE (by admit /- proof elided -/
)
@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=
match t with
| .var n => vars (Fin.last n)
| .zero => BitVec.zero w
| .one => 1
| .negOne => -1
| .ofNat n => BitVec.ofNat _ n
| .and t₁ t₂ =>
let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
x₁ &&& x₂
| .or t₁ t₂ =>
let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
x₁ ||| x₂
| .xor t₁ t₂ =>
let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
x₁ ^^^ x₂
| .not t => ~~~(t.evalFinBV vars)
| .add t₁ t₂ =>
let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
x₁ + x₂
| .sub t₁ t₂ =>
let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/
) i))
x₁ - x₂
| .neg t => -(t.evalFinBV vars)
| .shiftL a n => (a.evalFinBV vars) <<< n
def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=
{ bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }
inductive RelationOrdering
| lt | le | gt | ge
deriving Repr, Fintype
inductive Relation
| eq
| signed (ord : RelationOrdering)
| unsigned (ord : RelationOrdering)
deriving Repr
def evalRelation (rel : Relation) {w} (bv1 bv2 : BitVec w) : Prop :=
match rel with
| .eq => bv1 = bv2
| .signed .lt => bv1.slt bv2
| .signed .le => bv1.sle bv2
| .signed .gt => bv2.slt bv1
| .signed .ge => bv2.sle bv1
| .unsigned .lt => bv1.ult bv2
| .unsigned .le => bv1.ule bv2
| .unsigned .gt => bv2.ult bv1
| .unsigned .ge => bv2.ule bv1
@[simp]
def Relation.language (rel : Relation) : Set (BitVecs 2) :=
{ bvs | evalRelation rel (bvs.bvs.get 0) (bvs.bvs.get 1) }
inductive Binop
| and | or | impl | equiv
deriving Repr
def evalBinop (op : Binop) (b1 b2 : Prop) : Prop :=
match op with
| .and => b1 ∧ b2
| .or => b1 ∨ b2
| .impl => b1 → b2
| .equiv => b1 ↔ b2
def langBinop (op : Binop) (l1 l2 : Set (BitVecs n)) : Set (BitVecs n) :=
match op with
| .and => l1 ∩ l2
| .or => l1 ∪ l2
| .impl => l1ᶜ ∪ l2
| .equiv => (l1ᶜ ∪ l2) ∩ (l2ᶜ ∪ l1)
inductive Unop
| neg
deriving Repr
inductive Formula : Type
| width : WidthPredicate → Nat → Formula
| atom : Relation → Term → Term → Formula
| msbSet : Term → Formula
| unop : Unop → Formula → Formula
| binop : Binop → Formula → Formula → Formula
deriving Repr
@[simp]
def Formula.arity : Formula → Nat
| width _ _ => 0
| atom _ t1 t2 => max t1.arity t2.arity
| msbSet t => t.arity
| unop _ φ => φ.arity
| binop _ φ1 φ2 => max φ1.arity φ2.arity
@[simp]
def WidthPredicate.sat (wp : WidthPredicate) (w n : Nat) : Bool :=
match wp with
| .eq => w = n
| .neq => w ≠ n
| .lt => w < n
| .le => w ≤ n
| .gt => w > n
| .ge => w ≥ n
@[simp]
def Formula.sat {w : Nat} (φ : Formula) (ρ : Fin φ.arity → BitVec w) : Prop :=
match φ with
| .width wp n => wp.sat w n
| .atom rel t1 t2 =>
let bv1 := t1.evalFinBV (fun n => ρ $ Fin.castLE (by admit /- proof elided -/
) n)
let bv2 := t2.evalFinBV (fun n => ρ $ Fin.castLE (by admit /- proof elided -/
) n)
evalRelation rel bv1 bv2
| .unop .neg φ => ¬ φ.sat ρ
| .binop op φ1 φ2 =>
let b1 := φ1.sat (fun n => ρ $ Fin.castLE (by admit /- proof elided -/
) n)
let b2 := φ2.sat (fun n => ρ $ Fin.castLE (by admit /- proof elided -/
) n)
evalBinop op b1 b2
| .msbSet t => (t.evalFinBV ρ).msb
@[simp]
def _root_.Set.lift (f : Fin n → Fin m) (bvs : Set (BitVecs n)) : Set (BitVecs m) :=
BitVecs.transport f ⁻¹' bvs
@[simp]
def _root_.Set.proj (f : Fin n → Fin m) (bvs : Set (BitVecs m)) : Set (BitVecs n) :=
BitVecs.transport f '' bvs
@[simp]
def langMsb : Set (BitVecs 1) := { bvs | bvs.bvs.get 0 |>.msb }
@[simp]
def Formula.language (φ : Formula) : Set (BitVecs φ.arity) :=
match φ with
| .width wp n => { bvs | wp.sat bvs.w n }
| .atom rel t1 t2 =>
let l1 := t1.language.lift (liftMaxSucc1 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity))
let l2 := t2.language.lift (liftMaxSucc2 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity))
let lrel := rel.language.lift $ liftLast2 (max (FinEnum.card (Fin t1.arity)) (FinEnum.card (Fin t2.arity)))
let l := lrel ∩ l1 ∩ l2
l.proj (liftExcept2 _)
| .unop .neg φ => φ.languageᶜ
| .binop op φ1 φ2 =>
let l1 := φ1.language.lift $ liftMax1 φ1.arity φ2.arity
let l2 := φ2.language.lift $ liftMax2 φ1.arity φ2.arity
langBinop op l1 l2
| .msbSet t =>
let lmsb := langMsb.lift $ fun _ => Fin.last t.arity
let l' := t.language ∩ lmsb
l'.proj fun n => n.castLE (by admit /- proof elided -/
) | theorem formula_language (φ : Formula) :
φ.language = { (bvs : BitVecs φ.arity) | φ.sat (fun k => bvs.bvs.get k) } := | := by
let n : Nat := φ.arity
induction φ
case width wp n =>
simp
case atom rel t1 t2 =>
apply formula_language_case_atom
case unop op φ ih =>
rcases op; simp [ih, Set.compl_def]
case binop op φ1 φ2 ih1 ih2 =>
unfold Formula.language
ext1 bvs
simp [ih1, ih2]
have heq1 : (φ1.sat fun k => bvs.bvs.get (liftMax1 φ1.arity φ2.arity k)) ↔
(φ1.sat fun n => bvs.bvs.get (Fin.castLE (by simp) n)) := by
congr!
have heq2 : (φ2.sat fun k => bvs.bvs.get (liftMax2 φ1.arity φ2.arity k)) = true ↔
(φ2.sat fun n => bvs.bvs.get (Fin.castLE (by simp) n)) = true := by
congr!
rcases op <;>
simp [evalBinop, langBinop, Set.instMembership] <;> simp_all <;> tauto
case msbSet t =>
ext1 bvs; simp only [Formula.arity, Formula.language, Set.proj, Set.lift, langMsb, Fin.isValue,
Set.preimage_setOf_eq, Set.mem_image, Set.mem_inter_iff,
Set.mem_setOf_eq, Formula.sat]
rcases bvs with ⟨w, bvs⟩
constructor
· rintro ⟨bvsb, ⟨ht, hmsb⟩, heq⟩
simp only [Fin.isValue, Formula.arity] at ht hmsb ⊢
unfold Term.language at ht
simp only [BitVecs.transport, List.Vector.transport] at hmsb
simp at ht; rw [←ht] at hmsb; rw [←hmsb]
simp [BitVecs.transport] at heq
obtain ⟨hw, hbvs⟩ := heq
simp; congr 1; simp [hw]
rcases hw; simp
congr 1; ext1 k
simp at hbvs; simp [←hbvs, List.Vector.transport]; congr
· intros heq
use ⟨w,
bvs ++ ((t.evalFinBV fun k => bvs.get $ k.castLE (by simp)) ::ᵥ List.Vector.nil)⟩
unfold Term.language
simp [BitVecs.transport, List.Vector.transport] at heq ⊢
constructor; assumption
ext1 k; simp; congr 1 | 5 | 80 | false | Compiler |
303 | createSink_trans | @[grind =, simp]
lemma createSink_trans [LawfulBEq A] {m : RawCNFA A} (hwf : m.WF) :
s₂ ∈ m.createSink.2.tr s₁ a ↔
(s₁ = m.stateMax ∧ s₂ = m.stateMax) ∨
(s₁ ∈ m.states ∧ s₂ ∈ m.states ∧ s₂ ∈ m.tr s₁ a) | lean-mlir | Blase/Blase/AutoStructs/Basic.lean | [
"import Blase.Blase.AutoStructs.ForLean",
"import Blase.AutoStructs.BundledNfa",
"import Mathlib.Algebra.Group.Nat.Range",
"import Blase.FinEnum"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "LawfulHashable",
"module": "Init.Data.LawfulHashable"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Std.HashSet.mem_insert",
"module": "Std.Data.HashSet.Lemmas"
},
{
"name": "and_true",
"module": "Init.SimpLemmas"
},
{
"name": "beq_iff_eq",
"module": "Init.Core"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
},
{
"name": "Std.HashMap.getD_eq_getD_getElem?",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "Finset.range_add",
"module": "Mathlib.Algebra.Group.Nat.Range"
},
{
"name": "FinEnum.mem_toList",
"module": "Mathlib.Data.FinEnum"
}
] | [
{
"name": "Std.HashMap.mem_of_getElem?",
"content": "@[aesop 50% unsafe]\ntheorem Std.HashMap.mem_of_getElem? [BEq K] [LawfulBEq K] [Hashable K] [LawfulHashable K] {m : Std.HashMap K V} {k : K} :\n m[k]? = some v → k ∈ m"
},
{
"name": "Std.HashMap.mem_iff_getElem?",
"content": "theorem Std.HashMap.mem_iff_getElem? [BEq K] [LawfulBEq K] [Hashable K] [LawfulHashable K] [Inhabited V] {m : Std.HashMap K V} {k : K} :\n k ∈ m ↔ ∃ v, m[k]? = some v"
}
] | [
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA",
"content": "structure RawCNFA (A : Type 0) [BEq A] [Hashable A] [DecidableEq A] [FinEnum A] where\n stateMax : State\n initials : Std.HashSet State\n finals : Std.HashSet State\n trans : Std.HashMap (State × A) (Std.HashSet State)\nderiving Repr"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "RawCNFA",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "RawCNFA.newState",
"content": "def RawCNFA.newState (m : RawCNFA A) : State × RawCNFA A :=\n let old := m.stateMax\n let m := { m with stateMax := old + 1 }\n (old, m)"
},
{
"name": "RawCNFA.addTrans",
"content": "def RawCNFA.addTrans (m : RawCNFA A) (a : A) (s s' : State) : RawCNFA A :=\n let ns := m.trans.getD (s, a) ∅\n let ns := ns.insert s'\n { m with trans := m.trans.insert (s, a) ns }"
},
{
"name": "RawCNFA.addInitial",
"content": "def RawCNFA.addInitial (m : RawCNFA A) (s : State) : RawCNFA A :=\n { m with initials := m.initials.insert s }"
},
{
"name": "RawCNFA.createSink",
"content": "def RawCNFA.createSink (m : RawCNFA A) : State × RawCNFA A :=\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := FinEnum.toList (α := A).foldl (init := m) fun m a =>\n m.addTrans a s s\n (s, m)"
},
{
"name": "RawCNFA.WF",
"content": "structure RawCNFA.WF (m : RawCNFA A) where\n initials_lt : ∀ {s}, s ∈ m.initials → s ∈ m.states\n finals_lt : ∀ {s}, s ∈ m.finals → s ∈ m.states\n trans_src_lt : ∀ s_a ∈ m.trans, s_a.1 ∈ m.states\n trans_tgt_lt : s' ∈ m.tr s a → s' ∈ m.states"
}
] | [
{
"name": "RawCNFA.addInitial_tr",
"content": "@[grind =, simp]\nlemma RawCNFA.addInitial_tr {m : RawCNFA A} : (m.addInitial s'').tr s a = m.tr s a"
},
{
"name": "states_addInitial",
"content": "@[grind =, simp, aesop 50% unsafe]\nlemma states_addInitial (m : RawCNFA A) (s' : State) :\n (m.addInitial s').states = m.states"
},
{
"name": "addTrans_tr",
"content": "@[grind =] -- TODO: should I?\nlemma addTrans_tr (m : RawCNFA A) [LawfulBEq A] {a b : A} {s₁ s₁' s₂ : State} :\n (m.addTrans a s₁ s₂).tr s₁' b = if s₁ = s₁' ∧ a = b then (m.tr s₁ a).insert s₂ else m.tr s₁' b"
},
{
"name": "mem_addTrans_tr",
"content": "@[grind =, simp]\nlemma mem_addTrans_tr (m : RawCNFA A) [LawfulBEq A] (a : A) (s1 s2 : State) :\n s' ∈ (m.addTrans a s1 s2).tr s b ↔\n (s = s1 ∧ s' = s2 ∧ b = a) ∨ s' ∈ m.tr s b"
},
{
"name": "newState_tr",
"content": "@[grind =, simp]\nlemma newState_tr {m : RawCNFA A} : m.newState.2.tr s a = m.tr s a"
},
{
"name": "states_newState",
"content": "@[grind =, simp, aesop 50% unsafe]\nlemma states_newState (m : RawCNFA A) :\n m.newState.2.states = m.states ∪ { m.stateMax }"
},
{
"name": "RawCNFA.WF.trans_src_lt'",
"content": "@[grind ., simp, aesop 50% unsafe]\nlemma RawCNFA.WF.trans_src_lt' {m : RawCNFA A} (hwf : m.WF) :\n ∀ {s a}, (s, a) ∈ m.trans → s ∈ m.states"
},
{
"name": "RawCNFA.WF.trans_src_lt''",
"content": "@[grind ., simp, aesop 50% unsafe]\nlemma RawCNFA.WF.trans_src_lt'' [LawfulBEq A] {m : RawCNFA A} (hwf : m.WF) :\n ∀ {s a s'}, s' ∈ m.tr s a → s ∈ m.states"
}
] | import Mathlib.Algebra.Group.Nat.Range
import Blase.AutoStructs.BundledNfa
import Blase.FinEnum
open SetRel
abbrev State := Nat
structure RawCNFA (A : Type 0) [BEq A] [Hashable A] [DecidableEq A] [FinEnum A] where
stateMax : State
initials : Std.HashSet State
finals : Std.HashSet State
trans : Std.HashMap (State × A) (Std.HashSet State)
deriving Repr
section sim
variable {A : Type} [BEq A] [Hashable A] [DecidableEq A] [FinEnum A]
@[inline]
def RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅
def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax
instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort
end sim
section basics
variable {A : Type} [BEq A] [Hashable A] [DecidableEq A] [FinEnum A]
def RawCNFA.newState (m : RawCNFA A) : State × RawCNFA A :=
let old := m.stateMax
let m := { m with stateMax := old + 1 }
(old, m)
def RawCNFA.addTrans (m : RawCNFA A) (a : A) (s s' : State) : RawCNFA A :=
let ns := m.trans.getD (s, a) ∅
let ns := ns.insert s'
{ m with trans := m.trans.insert (s, a) ns }
def RawCNFA.addInitial (m : RawCNFA A) (s : State) : RawCNFA A :=
{ m with initials := m.initials.insert s }
def RawCNFA.createSink (m : RawCNFA A) : State × RawCNFA A :=
let (s, m) := m.newState
let m := m.addInitial s
let m := FinEnum.toList (α := A).foldl (init := m) fun m a =>
m.addTrans a s s
(s, m)
structure RawCNFA.WF (m : RawCNFA A) where
initials_lt : ∀ {s}, s ∈ m.initials → s ∈ m.states
finals_lt : ∀ {s}, s ∈ m.finals → s ∈ m.states
trans_src_lt : ∀ s_a ∈ m.trans, s_a.1 ∈ m.states
trans_tgt_lt : s' ∈ m.tr s a → s' ∈ m.states | @[grind =, simp]
lemma createSink_trans [LawfulBEq A] {m : RawCNFA A} (hwf : m.WF) :
s₂ ∈ m.createSink.2.tr s₁ a ↔
(s₁ = m.stateMax ∧ s₂ = m.stateMax) ∨
(s₁ ∈ m.states ∧ s₂ ∈ m.states ∧ s₂ ∈ m.tr s₁ a) := | := by
unfold RawCNFA.createSink
simp
let motive (mᵢ : RawCNFA A) (hwf : mᵢ.WF) (as : List A) :=
mᵢ.states = m.states ∪ {m.stateMax} →
∀ a,
s₂ ∈ (as.foldl (λ (m' : RawCNFA A) a => m'.addTrans a m.stateMax m.stateMax)
(init := mᵢ)).tr s₁ a ↔
(s₁ = m.stateMax ∧ s₂ = m.stateMax ∧ a ∈ as) ∨
(s₂ ∈ mᵢ.tr s₁ a)
suffices h : motive (m.newState.2.addInitial m.stateMax) (by simp_all) (FinEnum.toList A) by
simp only [FinEnum.mem_toList, and_true, motive] at h
rw [h] <;> simp only [RawCNFA.addInitial_tr, newState_tr,
states_addInitial, states_newState]
constructor; on_goal 2 => tauto
rintro (h | h); (exact .inl h); right
use (RawCNFA.WF.trans_src_lt'' hwf h),
(RawCNFA.WF.trans_tgt_lt hwf h),
h
generalize_proofs hwf'; revert hwf'
generalize (m.newState.2.addInitial m.stateMax) = mi
induction FinEnum.toList A generalizing mi
case nil =>
rintro hwf'; simp [motive]
case cons a as ih =>
simp [motive]
rintro hwf' hstates b
simp [motive] at ih
rw [ih]
· simp only [mem_addTrans_tr]; tauto
· simp [hwf', hstates]
· simp [hstates] | 4 | 42 | false | Compiler |
304 | ReflectVerif.BvDecide.KInductionCircuits.IsLawful_mkSucc_of_IsLawful | theorem IsLawful_mkSucc_of_IsLawful {arity : Type _}
[DecidableEq arity] [Fintype arity] [Hashable arity]
{fsm : FSM arity} {n : Nat}
(prev : KInductionCircuits fsm n)
(hPrev : prev.IsLawful) :
(mkSucc prev).IsLawful | lean-mlir | Blase/Blase/KInduction/KInduction.lean | [
"import Blase.Fast.Defs",
"import Blase.Vars",
"import Blase.Fast.ForLean",
"import Blase.Blase.Vars",
"import Lean.Meta.ForEachExpr",
"import Mathlib.Data.Bool.Basic",
"import Mathlib.Data.Finset.Defs",
"import Blase.Fast.FiniteStateMachine",
"import Blase.SingleWidth.Syntax",
"import Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec",
"import Blase.Blase.Fast.Circuit",
"import Blase.Fast.BitStream",
"import Blase.EnvBitstream",
"import Mathlib.Data.Finset.Basic",
"import Mathlib.Data.Fin.Basic",
"import Blase.Fast.Decide",
"import Lean",
"import Mathlib.Data.Multiset.FinsetOps"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "input",
"module": "Leanwuzla.Basic"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
},
{
"name": "Bool.xor",
"module": "Init.Data.Bool"
},
{
"name": "Vector.mapM",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Subtype",
"module": "Init.Prelude"
}
] | [
{
"name": "Vars.inputN",
"content": "def Vars.inputN (inp : ι) (k : Nat) {n : Nat} (hkn : k < n := by admit /- proof elided -/\n) : Vars σ ι n :=\n .inputs (Inputs.mk ⟨k, by admit /- proof elided -/\n ⟩ inp)"
},
{
"name": "Vars",
"content": "inductive Vars (σ : Type) (ι : Type) (n : Nat)\n| state (s : Inputs σ (n + 1))\n| inputs (is : Inputs ι n)\n| outputs (os : Fin n) \nderiving DecidableEq, Hashable"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Vars.stateN",
"content": "def Vars.stateN (s : σ) (i : Nat) {n : Nat} (hin : i ≤ n := by admit /- proof elided -/\n) : Vars σ ι n :=\n .state (Inputs.mk ⟨i, by admit /- proof elided -/\n ⟩ s)"
},
{
"name": "Inputs",
"content": "structure Inputs (ι : Type) (n : Nat) : Type where\n ix : Fin n\n input : ι\nderiving DecidableEq, Hashable"
},
{
"name": "Vars.state0",
"content": "def Vars.state0 (s : σ) {n : Nat} : Vars σ ι n :=\n .state (Inputs.mk ⟨0, by admit /- proof elided -/\n ⟩ s)"
},
{
"name": "bigOr",
"content": "def bigOr {α : Type _}\n (cs : List (Circuit α)) : Circuit α :=\n match cs with\n | [] => Circuit.fals\n | c :: cs =>\n c ||| (Circuit.bigOr cs)"
},
{
"name": "bigAnd",
"content": "def bigAnd {α : Type _}\n (cs : List (Circuit α)) : Circuit α :=\n match cs with\n | [] => Circuit.tru\n | c :: cs =>\n c &&& (Circuit.bigAnd cs)"
},
{
"name": "eval",
"content": "@[simp]\ndef eval : Circuit α → (α → Bool) → Bool\n | tru, _ => true\n | fals, _ => false\n | var b x, f => if b then f x else !(f x)\n | and c₁ c₂, f => (eval c₁ f) && (eval c₂ f)\n | or c₁ c₂, f => (eval c₁ f) || (eval c₂ f)\n | xor c₁ c₂, f => Bool.xor (eval c₁ f) (eval c₂ f)"
},
{
"name": "map",
"content": "def map : ∀ (_c : Circuit α) (_f : α → β), Circuit β\n | tru, _ => tru\n | fals, _ => fals\n | var b x, f => var b (f x)\n | and c₁ c₂, f => (map c₁ f) &&& (map c₂ f)\n | or c₁ c₂, f => (map c₁ f) ||| (map c₂ f)\n | xor c₁ c₂, f => (map c₁ f) ^^^ (map c₂ f)"
},
{
"name": "Vars.castLe",
"content": "def Vars.castLe {n m : Nat} (v : Vars σ ι n) (hnm : n ≤ m) : Vars σ ι m :=\n match v with\n | .state ss => .state (ss.castLe (by admit /- proof elided -/\n ))\n | .inputs is => .inputs (is.castLe hnm)\n | .outputs os =>\n .outputs (os.castLE (by admit /- proof elided -/\n ))"
},
{
"name": "castLe",
"content": "def castLe (i : Inputs ι n) (hn : n ≤ m) : Inputs ι m where\n ix := ⟨i.ix, by admit /- proof elided -/\n ⟩\n input := i.input"
}
] | [
{
"name": "List.mem_attach",
"module": "Init.Data.List.Attach"
},
{
"name": "List.mem_map",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.mem_range",
"module": "Init.Data.List.Nat.Range"
},
{
"name": "forall_exists_index",
"module": "Init.PropLemmas"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "eval_map",
"content": "lemma eval_map {c : Circuit α} {f : α → β} {g : β → Bool} :\n eval (map c f) g = eval c (λ x => g (f x))"
},
{
"name": "eval_bigOr_eq_false_iff",
"content": "@[simp]\ntheorem eval_bigOr_eq_false_iff\n (cs : List (Circuit α)) (env : α → Bool):\n (Circuit.bigOr cs).eval env = false ↔\n (∀ (c : Circuit α), c ∈ cs → c.eval env = false)"
},
{
"name": "Vars.castLe_inputs_eq_inputs",
"content": "@[simp]\ntheorem Vars.castLe_inputs_eq_inputs {n i m : Nat} (hi : i < n) (hnm : n ≤ m) :\n (Vars.inputN inp i hi : Vars σ ι n).castLe hnm =\n Vars.inputN inp i (by omega)"
},
{
"name": "Vars.castLe_stateN_eq_stateN",
"content": "@[simp]\ntheorem Vars.castLe_stateN_eq_stateN {n i m : Nat} (hi : i ≤ n) (hnm : n ≤ m) :\n (Vars.stateN s i : Vars σ ι n).castLe hnm =\n Vars.stateN s i (hin := by omega)"
},
{
"name": "Vars.castLe_castLe_eq_castLe_self",
"content": "@[simp]\ntheorem Vars.castLe_castLe_eq_castLe_self {α : Type _} {p q r : Nat}\n (v : Vars α σ p) (h : p ≤ q) (h' : q ≤ r) :\n (v.castLe h).castLe h' = v.castLe (by omega)"
}
] | [
{
"name": "ReflectVerif.BvDecide.mkCarryAssignCircuitNAux",
"content": "def mkCarryAssignCircuitNAux {arity : Type _}\n [DecidableEq arity]\n [Fintype arity]\n [Hashable arity]\n (p : FSM arity) (s : p.α) (n : Nat) : Circuit (Vars p.α arity (n + 1)) :=\n (p.nextStateCirc s).map fun v =>\n match v with\n | .inl t => Vars.stateN t n\n | .inr i => Vars.inputN i n"
},
{
"name": "ReflectVerif.BvDecide.mkCarryAssignCircuitN",
"content": "def mkCarryAssignCircuitN {arity : Type _}\n [DecidableEq arity]\n [Fintype arity]\n [Hashable arity]\n (p : FSM arity) (n : Nat) :\n Circuit (Vars p.α arity (n + 1)) :=\n let carrys := FinEnum.toList p.α |>.map fun s =>\n \n Circuit.xor\n (mkCarryAssignCircuitNAux p s n)\n (Circuit.var true <| Vars.stateN s (n + 1))\n Circuit.bigOr carrys"
},
{
"name": "ReflectVerif.BvDecide.mkOutputAssignCircuitNAux",
"content": "def mkOutputAssignCircuitNAux {arity : Type _}\n [DecidableEq arity]\n [Fintype arity]\n [Hashable arity]\n (p : FSM arity) (n : Nat) : Circuit (Vars p.α arity (n + 1)) :=\n (p.outputCirc).map fun v =>\n match v with\n | .inl s' => Vars.stateN s' n\n | .inr i => Vars.inputN i n"
},
{
"name": "ReflectVerif.BvDecide.mkOutputAssignCircuitN",
"content": "def mkOutputAssignCircuitN {arity : Type _}\n [DecidableEq arity]\n [Fintype arity]\n [Hashable arity]\n (p : FSM arity) (n : Nat) :\n Circuit (Vars p.α arity (n + 1)) :=\n Circuit.xor\n (mkOutputAssignCircuitNAux p n)\n (Circuit.var true <| Vars.outputs ⟨n, by admit /- proof elided -/\n ⟩)"
},
{
"name": "ReflectVerif.BvDecide.mkStateNeqCircuit",
"content": "def mkStateNeqCircuit\n {arity : Type _} {i : Nat}\n [DecidableEq arity] [Fintype arity] [Hashable arity]\n (p : FSM arity) (s t : p.α → Circuit (Vars p.α arity i)) : Circuit (Vars p.α arity i) :=\n Circuit.bigAnd <| FinEnum.toList p.α |>.map fun a => ~~~ (s a) ^^^ (t a)"
},
{
"name": "ReflectVerif.BvDecide.mkStateUniqueCircuitN",
"content": "def mkStateUniqueCircuitN {arity : Type _}\n [DecidableEq arity] [Fintype arity] [Hashable arity]\n (p : FSM arity) (n : Nat) : Circuit (Vars p.α arity n) :=\n let sn : p.α → Circuit (Vars p.α arity n) := fun s =>\n Circuit.var true (Vars.stateN s n)\n let circs := (List.range n).attach |>.map fun ⟨i, hi⟩ =>\n let si : p.α → Circuit (Vars p.α arity n) := fun s =>\n Circuit.var true (Vars.stateN s i (by admit /- proof elided -/\n ))\n (mkStateNeqCircuit p si sn)\n Circuit.bigOr circs"
},
{
"name": "ReflectVerif.BvDecide.KInductionCircuits",
"content": "structure KInductionCircuits {arity : Type _}\n [DecidableEq arity] [Fintype arity] [Hashable arity] (fsm : FSM arity) (n : Nat) where\n \n cInitCarryAssignCirc : Circuit (Vars fsm.α arity 0)\n \n cSuccCarryAssignCirc : Circuit (Vars fsm.α arity (n+2))\n \n cOutAssignCirc : Circuit (Vars fsm.α arity (n + 2))\n \n cStatesUniqueCirc : Circuit (Vars fsm.α arity n)"
},
{
"name": "ReflectVerif.BvDecide.KInductionCircuits.IsLawful",
"content": "structure KInductionCircuits.IsLawful {arity : Type _}\n [DecidableEq arity] [Fintype arity] [Hashable arity] {fsm : FSM arity} {n : Nat}\n (circs : KInductionCircuits fsm n) where\n hCInitCarryAssignCirc :\n ∀ {env : Vars fsm.α arity 0 → Bool},\n (circs.cInitCarryAssignCirc.eval env = false)\n ↔ (∀ (s : fsm.α), fsm.initCarry s = env (Vars.state0 s))\n\n hCSuccCarryAssignCirc :\n ∀ {env : Vars fsm.α arity (n + 2) → Bool},\n (circs.cSuccCarryAssignCirc.eval env = false)\n ↔ (∀ (s : fsm.α) (i : Nat) (hi : i < n + 2),\n env (Vars.stateN s (i + 1)) =\n ((mkCarryAssignCircuitNAux fsm s i).map\n (fun v => v.castLe (by admit /- proof elided -/\n ))).eval env)\n hCOutAssignCirc :\n ∀ {env : Vars fsm.α arity (n + 2) → Bool},\n (circs.cOutAssignCirc.eval env = false)\n ↔ (∀ (i : Nat) (hi : i < n + 2),\n (fsm.outputCirc).eval\n (fun x => match x with\n | .inl s => env (Vars.stateN s i)\n | .inr j => env (Vars.inputN j i)) =\n env (Vars.outputs ⟨i, by admit /- proof elided -/\n ⟩))\n hCStatesUniqueCirc :\n ∀ {env : Vars fsm.α arity (n) → Bool},\n (circs.cStatesUniqueCirc.eval env = false)\n ↔ (∀ (i j : Nat) (hij : i < j ∧ j ≤ n),\n ∃ (s : fsm.α), env (Vars.stateN s i) ≠ env (Vars.stateN s j))"
},
{
"name": "ReflectVerif.BvDecide.KInductionCircuits.castCircLe",
"content": "def castCircLe {n m : Nat} (c : Circuit (Vars fsm.α arity n)) (hnm : n ≤ m := by admit /- proof elided -/\n) :\n Circuit (Vars fsm.α arity m) :=\n c.map (fun v => v.castLe hnm)"
},
{
"name": "ReflectVerif.BvDecide.KInductionCircuits.mkSucc",
"content": "def mkSucc\n (prev : KInductionCircuits fsm n) :\n KInductionCircuits fsm (n + 1) :=\n let cInitCarryAssignCirc := prev.cInitCarryAssignCirc\n { cInitCarryAssignCirc := cInitCarryAssignCirc\n , cSuccCarryAssignCirc :=\n (mkCarryAssignCircuitN fsm (n + 2)) |||\n (castCircLe prev.cSuccCarryAssignCirc)\n , cOutAssignCirc :=\n (mkOutputAssignCircuitN fsm (n + 2)) |||\n (castCircLe prev.cOutAssignCirc)\n , cStatesUniqueCirc :=\n mkStateUniqueCircuitN fsm (n + 1) |||\n (castCircLe prev.cStatesUniqueCirc)\n }"
}
] | [
{
"name": "ReflectVerif.BvDecide.mkCarryAssignCircuitNAux_eval_eq",
"content": "@[simp]\ntheorem mkCarryAssignCircuitNAux_eval_eq {arity : Type _}\n [DecidableEq arity]\n [Fintype arity]\n [Hashable arity]\n (p : FSM arity) (s : p.α) (n : Nat)\n {env : Vars p.α arity (n + 1) → Bool} :\n ((mkCarryAssignCircuitNAux p s n).eval env) = ((p.nextStateCirc s).eval\n (fun x => match x with | .inl x => env (Vars.stateN x n) | .inr x => env (Vars.inputN x n)))"
},
{
"name": "ReflectVerif.BvDecide.mkStateUniqueCircuitN_eq_false_iff",
"content": "theorem mkStateUniqueCircuitN_eq_false_iff {arity : Type _}\n [DecidableEq arity] [Fintype arity] [Hashable arity]\n (p : FSM arity) (n : Nat)\n {env : Vars p.α arity n → Bool} :\n ((mkStateUniqueCircuitN p n).eval env = false) ↔\n (∀ (i : Nat) (hi : i < n), ∃ (s : p.α), env (Vars.stateN s i) ≠ env (Vars.stateN s n))"
}
] | import Mathlib.Data.Bool.Basic
import Mathlib.Data.Fin.Basic
import Mathlib.Data.Finset.Basic
import Mathlib.Data.Finset.Defs
import Mathlib.Data.Multiset.FinsetOps
import Blase.Fast.BitStream
import Blase.Fast.Defs
import Blase.Fast.FiniteStateMachine
import Blase.Fast.Decide
import Blase.SingleWidth.Syntax
import Lean.Meta.ForEachExpr
import Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec
import Blase.Fast.ForLean
import Blase.Vars
import Blase.EnvBitstream
import Lean
open Fin.NatCast
namespace ReflectVerif
open Lean Meta Elab Tactic
namespace BvDecide
open Std Sat AIG
def mkCarryAssignCircuitNAux {arity : Type _}
[DecidableEq arity]
[Fintype arity]
[Hashable arity]
(p : FSM arity) (s : p.α) (n : Nat) : Circuit (Vars p.α arity (n + 1)) :=
(p.nextStateCirc s).map fun v =>
match v with
| .inl t => Vars.stateN t n
| .inr i => Vars.inputN i n
def mkCarryAssignCircuitN {arity : Type _}
[DecidableEq arity]
[Fintype arity]
[Hashable arity]
(p : FSM arity) (n : Nat) :
Circuit (Vars p.α arity (n + 1)) :=
let carrys := FinEnum.toList p.α |>.map fun s =>
Circuit.xor
(mkCarryAssignCircuitNAux p s n)
(Circuit.var true <| Vars.stateN s (n + 1))
Circuit.bigOr carrys
def mkOutputAssignCircuitNAux {arity : Type _}
[DecidableEq arity]
[Fintype arity]
[Hashable arity]
(p : FSM arity) (n : Nat) : Circuit (Vars p.α arity (n + 1)) :=
(p.outputCirc).map fun v =>
match v with
| .inl s' => Vars.stateN s' n
| .inr i => Vars.inputN i n
def mkOutputAssignCircuitN {arity : Type _}
[DecidableEq arity]
[Fintype arity]
[Hashable arity]
(p : FSM arity) (n : Nat) :
Circuit (Vars p.α arity (n + 1)) :=
Circuit.xor
(mkOutputAssignCircuitNAux p n)
(Circuit.var true <| Vars.outputs ⟨n, by admit /- proof elided -/
⟩)
def mkStateNeqCircuit
{arity : Type _} {i : Nat}
[DecidableEq arity] [Fintype arity] [Hashable arity]
(p : FSM arity) (s t : p.α → Circuit (Vars p.α arity i)) : Circuit (Vars p.α arity i) :=
Circuit.bigAnd <| FinEnum.toList p.α |>.map fun a => ~~~ (s a) ^^^ (t a)
def mkStateUniqueCircuitN {arity : Type _}
[DecidableEq arity] [Fintype arity] [Hashable arity]
(p : FSM arity) (n : Nat) : Circuit (Vars p.α arity n) :=
let sn : p.α → Circuit (Vars p.α arity n) := fun s =>
Circuit.var true (Vars.stateN s n)
let circs := (List.range n).attach |>.map fun ⟨i, hi⟩ =>
let si : p.α → Circuit (Vars p.α arity n) := fun s =>
Circuit.var true (Vars.stateN s i (by admit /- proof elided -/
))
(mkStateNeqCircuit p si sn)
Circuit.bigOr circs
structure KInductionCircuits {arity : Type _}
[DecidableEq arity] [Fintype arity] [Hashable arity] (fsm : FSM arity) (n : Nat) where
cInitCarryAssignCirc : Circuit (Vars fsm.α arity 0)
cSuccCarryAssignCirc : Circuit (Vars fsm.α arity (n+2))
cOutAssignCirc : Circuit (Vars fsm.α arity (n + 2))
cStatesUniqueCirc : Circuit (Vars fsm.α arity n)
structure KInductionCircuits.IsLawful {arity : Type _}
[DecidableEq arity] [Fintype arity] [Hashable arity] {fsm : FSM arity} {n : Nat}
(circs : KInductionCircuits fsm n) where
hCInitCarryAssignCirc :
∀ {env : Vars fsm.α arity 0 → Bool},
(circs.cInitCarryAssignCirc.eval env = false)
↔ (∀ (s : fsm.α), fsm.initCarry s = env (Vars.state0 s))
hCSuccCarryAssignCirc :
∀ {env : Vars fsm.α arity (n + 2) → Bool},
(circs.cSuccCarryAssignCirc.eval env = false)
↔ (∀ (s : fsm.α) (i : Nat) (hi : i < n + 2),
env (Vars.stateN s (i + 1)) =
((mkCarryAssignCircuitNAux fsm s i).map
(fun v => v.castLe (by admit /- proof elided -/
))).eval env)
hCOutAssignCirc :
∀ {env : Vars fsm.α arity (n + 2) → Bool},
(circs.cOutAssignCirc.eval env = false)
↔ (∀ (i : Nat) (hi : i < n + 2),
(fsm.outputCirc).eval
(fun x => match x with
| .inl s => env (Vars.stateN s i)
| .inr j => env (Vars.inputN j i)) =
env (Vars.outputs ⟨i, by admit /- proof elided -/
⟩))
hCStatesUniqueCirc :
∀ {env : Vars fsm.α arity (n) → Bool},
(circs.cStatesUniqueCirc.eval env = false)
↔ (∀ (i j : Nat) (hij : i < j ∧ j ≤ n),
∃ (s : fsm.α), env (Vars.stateN s i) ≠ env (Vars.stateN s j))
namespace KInductionCircuits
variable {arity : Type _}
{fsm : FSM arity}
def castCircLe {n m : Nat} (c : Circuit (Vars fsm.α arity n)) (hnm : n ≤ m := by admit /- proof elided -/
) :
Circuit (Vars fsm.α arity m) :=
c.map (fun v => v.castLe hnm)
variable [DecidableEq arity] [Fintype arity] [Hashable arity]
def mkSucc
(prev : KInductionCircuits fsm n) :
KInductionCircuits fsm (n + 1) :=
let cInitCarryAssignCirc := prev.cInitCarryAssignCirc
{ cInitCarryAssignCirc := cInitCarryAssignCirc
, cSuccCarryAssignCirc :=
(mkCarryAssignCircuitN fsm (n + 2)) |||
(castCircLe prev.cSuccCarryAssignCirc)
, cOutAssignCirc :=
(mkOutputAssignCircuitN fsm (n + 2)) |||
(castCircLe prev.cOutAssignCirc)
, cStatesUniqueCirc :=
mkStateUniqueCircuitN fsm (n + 1) |||
(castCircLe prev.cStatesUniqueCirc)
} | theorem IsLawful_mkSucc_of_IsLawful {arity : Type _}
[DecidableEq arity] [Fintype arity] [Hashable arity]
{fsm : FSM arity} {n : Nat}
(prev : KInductionCircuits fsm n)
(hPrev : prev.IsLawful) :
(mkSucc prev).IsLawful := | where
hCInitCarryAssignCirc := by
simp only [mkSucc, castCircLe]
exact hPrev.hCInitCarryAssignCirc
hCSuccCarryAssignCirc := by
simp only [mkSucc, castCircLe, Circuit.eval_map]
simp [Circuit.eval_map]
intros env
constructor
· intros h s i hi
obtain ⟨h₁, h₂⟩ := h
rw [hPrev.hCSuccCarryAssignCirc] at h₂
by_cases hi : i < n + 2
· simp only [Vars.castLe_stateN_eq_stateN, Circuit.eval_map,
Vars.castLe_castLe_eq_castLe_self, mkCarryAssignCircuitNAux_eval_eq,
Vars.castLe_inputs_eq_inputs] at h₂
rw [h₂ s i hi]
· have hi : i = n + 2 := by omega
subst hi
apply h₁
· intros h
constructor
· intros s
simp only at h ⊢
rw [h s _ (by omega)]
· rw [hPrev.hCSuccCarryAssignCirc]
intros s i hi
simp only at h
simp only [Vars.castLe_stateN_eq_stateN, Circuit.eval_map,
Vars.castLe_castLe_eq_castLe_self, mkCarryAssignCircuitNAux_eval_eq,
Vars.castLe_inputs_eq_inputs]
rw [h s i (by omega)]
hCOutAssignCirc := by
simp only [mkSucc, castCircLe]
simp [Circuit.eval_map]
intros env
constructor
· intros h i hi
obtain ⟨h₁, h₂⟩ := h
rw [hPrev.hCOutAssignCirc] at h₂
by_cases hi : i < n + 2
· simp at h₁ h₂ ⊢
rw [h₂ i hi]
· have : i = n + 2 := by omega
subst this
apply h₁
· intros h
constructor
· simp only at h ⊢
rw [h]
· rw [hPrev.hCOutAssignCirc]
intros i hi
simp
apply h
hCStatesUniqueCirc := by
simp only [mkSucc, castCircLe]
simp [Circuit.eval_map]
intros env
constructor
· intros h i j hij hjn
simp [mkStateUniqueCircuitN_eq_false_iff] at h
simp [hPrev.hCStatesUniqueCirc] at h
obtain ⟨h₁, h₂⟩ := h
by_cases hj : j ≤ n
· grind
· have : j = n + 1 := by
omega
subst this
grind
· intros h
constructor
· rw [mkStateUniqueCircuitN_eq_false_iff]
intros i hi
apply h (j := n + 1)
omega
omega
· simp [hPrev.hCStatesUniqueCirc]
intros i j hij jn
simp at h ⊢
apply h i j
omega
omega | 4 | 54 | false | Compiler |
305 | NFA'.autSignedCmp_correct | lemma NFA'.autSignedCmp_correct cmp : autSignedCmp cmp |>.correct2 autSignedCmpSA cmp.srel | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BitVec.ofFin",
"module": "Init.Prelude"
},
{
"name": "cmp",
"module": "Mathlib.Data.Ordering.Basic"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "BitVec.ult",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec.sle",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.slt",
"module": "Init.Data.BitVec.Basic"
}
] | [
{
"name": "RelationOrdering",
"content": "inductive RelationOrdering\n| lt | le | gt | ge\nderiving Repr, Fintype"
},
{
"name": "bv2",
"content": "def bv2 : BitVec 4 := BitVec.ofNat 4 1 "
},
{
"name": "bv1",
"content": "def bv1 : BitVec 4 := BitVec.ofNat 4 5 "
},
{
"name": "instFinEnumBV",
"content": "instance instFinEnumBV : FinEnum (BitVec w) where\n card := 2^w\n equiv := {\n toFun := fun x => x.toFin\n invFun := fun x => BitVec.ofFin x\n left_inv := by admit /- proof elided -/"
}
] | [
{
"name": "BitVec.toNat_eq",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Nat.le_antisymm",
"module": "Init.Prelude"
},
{
"name": "BitVec.toInt_inj",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "le_iff_lt_or_eq",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVRel",
"content": "abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop"
},
{
"name": "NFA'.sa2",
"content": "def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "NFA.signedCmpState",
"content": "inductive NFA.signedCmpState : Type where\n| eq | gt | lt | ltfin | gtfin\nderiving DecidableEq, Fintype"
},
{
"name": "NFA.signedCmpStep",
"content": "def NFA.signedCmpStep (q : NFA.signedCmpState) (a : BitVec 2) : List NFA.signedCmpState :=\n match q, a with\n | .eq, 0 => [ .eq ] | .eq, 3 => [.eq] | .eq, 1 => [.gt, .ltfin] | .eq, 2 => [ .lt, .gtfin ]\n | .gt, 0 => [ .gt, .gtfin ] | .gt, 1 => [ .gt, .ltfin ] | .gt, 3 => [ .gt, .gtfin ] | .gt, 2 => [ .lt, .gtfin ]\n | .lt, 0 => [ .lt, .ltfin ] | .lt, 1 => [ .gt, .ltfin ] | .lt, 2 => [ .lt, .gtfin ] | .lt, 3 => [ .lt, .ltfin ]\n | .gtfin, _ => ∅\n | .ltfin, _ => ∅"
},
{
"name": "NFA.autSignedCmp",
"content": "def NFA.autSignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) signedCmpState where\n step s a := { s' | s' ∈ signedCmpStep s a }\n start := { s | s = signedCmpState.eq }\n accept := { s | s ∈ match cmp with | .lt => [NFA.signedCmpState.ltfin] | .le => [.ltfin, .eq] | .gt => [.gtfin] | .ge => [.gtfin, .eq] }"
},
{
"name": "NFA'.autSignedCmp",
"content": "def NFA'.autSignedCmp (cmp: RelationOrdering) : NFA' 2 :=\n ⟨_, NFA.autSignedCmp cmp⟩"
},
{
"name": "RelationOrdering.srel",
"content": "def RelationOrdering.srel (cmp : RelationOrdering) : BVRel :=\n match cmp with\n | .lt => fun _ bv1 bv2 => bv1.slt bv2\n | .le => fun _ bv1 bv2 => bv1.sle bv2\n | .gt => fun _ bv1 bv2 => bv2.slt bv1\n | .ge => fun _ bv1 bv2 => bv2.sle bv1"
},
{
"name": "NFA'.autSignedCmpSA",
"content": "def NFA'.autSignedCmpSA (q : NFA.signedCmpState) : BVRel :=\n match q with\n | .eq => fun _ bv1 bv2 => bv1 = bv2\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1\n | .ltfin => fun _ bv1 bv2 => bv1.slt bv2\n | .gtfin => fun _ bv1 bv2 => bv2.slt bv1"
}
] | [
{
"name": "ucmp_tricho",
"content": "@[simp]\nlemma ucmp_tricho {bv1 bv2 : BitVec w} : (bv2.ult bv1) = false → (bv1.ult bv2) = false → bv1 = bv2"
},
{
"name": "BitVec.sle_iff_slt_or_eq",
"content": "private lemma BitVec.sle_iff_slt_or_eq {w : ℕ} (bv1 bv2 : BitVec w):\n (bv1.sle bv2) = true ↔ (bv1.slt bv2) = true ∨ bv1 = bv2"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop
def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
variable {arity : Type} [FinEnum arity]
open BitStream in
end fsm
section nfas_relations
inductive NFA.signedCmpState : Type where
| eq | gt | lt | ltfin | gtfin
deriving DecidableEq, Fintype
def NFA.signedCmpStep (q : NFA.signedCmpState) (a : BitVec 2) : List NFA.signedCmpState :=
match q, a with
| .eq, 0 => [ .eq ] | .eq, 3 => [.eq] | .eq, 1 => [.gt, .ltfin] | .eq, 2 => [ .lt, .gtfin ]
| .gt, 0 => [ .gt, .gtfin ] | .gt, 1 => [ .gt, .ltfin ] | .gt, 3 => [ .gt, .gtfin ] | .gt, 2 => [ .lt, .gtfin ]
| .lt, 0 => [ .lt, .ltfin ] | .lt, 1 => [ .gt, .ltfin ] | .lt, 2 => [ .lt, .gtfin ] | .lt, 3 => [ .lt, .ltfin ]
| .gtfin, _ => ∅
| .ltfin, _ => ∅
def NFA.autSignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) signedCmpState where
step s a := { s' | s' ∈ signedCmpStep s a }
start := { s | s = signedCmpState.eq }
accept := { s | s ∈ match cmp with | .lt => [NFA.signedCmpState.ltfin] | .le => [.ltfin, .eq] | .gt => [.gtfin] | .ge => [.gtfin, .eq] }
def NFA'.autSignedCmp (cmp: RelationOrdering) : NFA' 2 :=
⟨_, NFA.autSignedCmp cmp⟩
def RelationOrdering.srel (cmp : RelationOrdering) : BVRel :=
match cmp with
| .lt => fun _ bv1 bv2 => bv1.slt bv2
| .le => fun _ bv1 bv2 => bv1.sle bv2
| .gt => fun _ bv1 bv2 => bv2.slt bv1
| .ge => fun _ bv1 bv2 => bv2.sle bv1
def NFA'.autSignedCmpSA (q : NFA.signedCmpState) : BVRel :=
match q with
| .eq => fun _ bv1 bv2 => bv1 = bv2
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
| .ltfin => fun _ bv1 bv2 => bv1.slt bv2
| .gtfin => fun _ bv1 bv2 => bv2.slt bv1 | lemma NFA'.autSignedCmp_correct cmp : autSignedCmp cmp |>.correct2 autSignedCmpSA cmp.srel := | := by
let getState {w} (bv1 bv2 : BitVec w) : NFA.signedCmpState :=
if bv2.ult bv1 then .gt else if bv1.ult bv2 then .lt else .eq
constructor <;> simp [NFA.autSignedCmp, autSignedCmp, autSignedCmpSA, RelationOrdering.srel]
· cases cmp <;> simp [BitVec.sle_iff_slt_or_eq]; tauto
· rintro (_ | _ | _) <;> simp
· rintro (_ | _ | _) a w bv1 bv2 <;> simp [NFA.stepSet]
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [NFA.signedCmpStep, instFinEnumBV]
· rintro ⟨_, _⟩; use .eq; simp; fin_cases a <;> simp [instFinEnumBV] at * <;> tauto
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [NFA.signedCmpStep, instFinEnumBV]
· rintro _; fin_cases a <;> simp [NFA.signedCmpStep, instFinEnumBV] at *
· use .gt; simp_all
· use (getState bv1 bv2); simp [getState]; split_ifs <;> simp_all; apply ucmp_tricho <;> assumption
· use .gt; simp_all
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [NFA.signedCmpStep, instFinEnumBV]
· rintro _; fin_cases a <;> simp [NFA.signedCmpStep, instFinEnumBV] at *
· use .lt; simp_all
· use (getState bv1 bv2); simp [getState]; split_ifs <;> simp_all; apply ucmp_tricho <;> assumption
· use .lt; simp_all
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [NFA.signedCmpStep, instFinEnumBV]
· rintro _; fin_cases a <;> simp [NFA.signedCmpStep, instFinEnumBV] at *
· use .lt; simp_all
· use (getState bv1 bv2); simp [getState]; split_ifs <;> simp_all; apply ucmp_tricho <;> assumption
· use .lt; simp_all
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [NFA.signedCmpStep, instFinEnumBV]
· rintro _; fin_cases a <;> simp [NFA.signedCmpStep, instFinEnumBV] at *
· use .gt; simp_all
· use (getState bv1 bv2); simp [getState]; split_ifs <;> simp_all; apply ucmp_tricho <;> assumption
· use .gt; simp_all | 4 | 39 | false | Compiler |
306 | product.f_spec | lemma product.f_spec {m₁ m₂ : CNFA n} {s₁ : m₁.m.states} {s₂ : m₂.m.states} :
∀ a s₁' s₂',
(a, (s₁', s₂')) ∈ f m₁ m₂ (s₁, s₂) ↔ s₁'.val ∈ m₁.m.tr s₁ a ∧ s₂'.val ∈ m₂.m.tr s₂ a | lean-mlir | Blase/Blase/AutoStructs/Constructions.lean | [
"import Blase.AutoStructs.Worklist",
"import Mathlib.Tactic.ApplyFun",
"import Mathlib.Data.Fintype.Prod",
"import Blase.Blase.AutoStructs.ForLean",
"import Blase.Blase.AutoStructs.ForMathlib"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Nodup",
"module": "Init.Data.List.Basic"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
},
{
"name": "Function.Injective2",
"module": "Mathlib.Logic.Function.Basic"
}
] | [
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "Std.HashSet.toSet",
"content": "def Std.HashSet.toSet [BEq α] [Hashable α] (m : HashSet α) : Set α := { x | x ∈ m }\n\naxiom hashMap_missing : ∀ {P : Prop}, P"
}
] | [
{
"name": "Array.mem_push",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "Array.mem_toList_iff",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "Array.toList_push",
"module": "Init.Data.Array.Bootstrap"
},
{
"name": "Function.Injective2.eq_iff",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "List.Nodup.append",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "List.append_assoc",
"module": "Init.Data.List.Basic"
},
{
"name": "List.disjoint_singleton",
"module": "Batteries.Data.List.Lemmas"
},
{
"name": "List.mem_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.mem_singleton",
"module": "Init.Data.List.Lemmas"
},
{
"name": "Set.mem_empty_iff_false",
"module": "Mathlib.Data.Set.Basic"
},
{
"name": "Set.mem_insert_iff",
"module": "Mathlib.Data.Set.Insert"
},
{
"name": "Set.union_singleton",
"module": "Mathlib.Data.Set.Insert"
},
{
"name": "and_false",
"module": "Init.SimpLemmas"
},
{
"name": "iff_and_self",
"module": "Init.SimpLemmas"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "or_false",
"module": "Init.SimpLemmas"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
},
{
"name": "ne_or_eq",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Array.mem_def",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.not_mem_empty",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "FinEnum.nodup_toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "List.Nodup.notMem",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "List.dedup_eq_self",
"module": "Mathlib.Data.List.Dedup"
},
{
"name": "List.foldl_nil",
"module": "Init.Data.List.Basic"
},
{
"name": "List.mem_cons",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.nodup_cons",
"module": "Init.Data.List.Pairwise"
},
{
"name": "List.not_mem_nil",
"module": "Init.Data.List.Lemmas"
},
{
"name": "false_and",
"module": "Init.SimpLemmas"
},
{
"name": "false_or",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "Std.HashSet.fold_induction",
"content": "theorem Std.HashSet.fold_induction [BEq α] [LawfulBEq α] [Hashable α]\n {f : β → α → β} {m : HashSet α} {motive : β → Set α → Prop} :\n motive b ∅ →\n (∀ b x s, x ∉ s → motive b s → motive (f b x) (s ∪ {x})) →\n motive (m.fold f b) m.toSet"
},
{
"name": "Std.HashSet.toSet_toList[BEq",
"content": "theorem Std.HashSet.toSet_toList[BEq α] [LawfulBEq α] [Hashable α] (m : HashSet α) : m.toSet = { x | x ∈ m.toList }"
},
{
"name": "Std.HashSet.mem_toSet",
"content": "@[simp]\nlemma Std.HashSet.mem_toSet [BEq α] [Hashable α] (m : HashSet α) : x ∈ m.toSet ↔ x ∈ m"
},
{
"name": "Std.HashSet.mem_attachWith_mem",
"content": "@[simp]\ntheorem Std.HashSet.mem_attachWith_mem [BEq α] [Hashable α] [LawfulBEq α] (m : HashSet α) {P H} (x : α) h :\n ⟨x, h⟩ ∈ m.attachWith P H ↔ x ∈ m"
}
] | [
{
"name": "product.prodArray'",
"content": "@[inline]\ndef product.prodArray' (a : Array γ) :=\n m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>\n m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s1 s2)"
},
{
"name": "product",
"content": "def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=\n worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)\n (by admit /- proof elided -/\n ) f\nwhere final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)\n f (ss : m₁.m.states × m₂.m.states) :=\n let (s1, s2) := ss\n (FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>\n product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))\n (fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as"
}
] | [
{
"name": "product.prodArray_spec_helper",
"content": "include hinj in\nomit [BEq α] [Hashable α] [LawfulBEq α] in\nlemma product.prodArray_spec_helper\n (is : Array γ) (hnd : is.toList.Nodup)\n (s : S₁) (hnew : ∀ s₂, f s s₂ ∉ is):\n let motive (a : Array γ) (S : Set S₂) :=\n a.toList.Nodup ∧\n (∃ r, a.toList = is.toList ++ r ∧ (∀ z ∈ r, ∃ s₁ s₂, z = f s₁ s₂)) ∧\n ∀ s1 s2, f s1 s2 ∈ a ↔ s1 ≠ s ∧ f s1 s2 ∈ is ∨ s1 = s ∧ s2 ∈ S\n let body := m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s s2)\n motive body (m₂.attachWith _ hm₂).toSet"
},
{
"name": "product.prodArray'_spec_full",
"content": "include hinj in\nlemma product.prodArray'_spec_full {aᵢ : Array γ} (hnd: aᵢ.toList.Nodup) (hnin : ∀ s₁ s₂, f s₁ s₂ ∉ aᵢ) :\n (product.prodArray' f hm₁ hm₂ aᵢ).toList.Nodup ∧\n (∃ r, (product.prodArray' f hm₁ hm₂ aᵢ).toList = aᵢ.toList ++ r ∧ (∀ z ∈ r, ∃ s₁ s₂, z = f s₁ s₂)) ∧\n ∀ s₁ s₂, f s₁ s₂ ∈ product.prodArray' f hm₁ hm₂ aᵢ ↔ (s₁.val ∈ m₁ ∧ s₂.val ∈ m₂)"
}
] | import Mathlib.Data.Fintype.Prod
import Blase.AutoStructs.Worklist
import Mathlib.Tactic.ApplyFun
open SetRel
section sink
variable {A : Type} [BEq A] [Hashable A] [DecidableEq A] [FinEnum A]
end sink
section generic_prod
variable {α} [BEq α] [Hashable α] [LawfulBEq α]
variable {β} [BEq β] [Hashable β] [LawfulBEq β]
variable {S₁ : Finset α} {S₂ : Finset β}
variable {γ} (f : S₁ → S₂ → γ) (hinj : Function.Injective2 f)
variable {m₁ : Std.HashSet α} (hm₁ : ∀ s₁ ∈ m₁, s₁ ∈ S₁)
variable {m₂ : Std.HashSet β} (hm₂ : ∀ s₂ ∈ m₂, s₂ ∈ S₂)
@[inline]
def product.prodArray' (a : Array γ) :=
m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>
m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>
is.push (f s1 s2)
end generic_prod
section product
variable {A : Type} [BEq A] [LawfulBEq A] [Hashable A] [DecidableEq A] [FinEnum A]
def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=
worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)
(by admit /- proof elided -/
) f
where final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)
f (ss : m₁.m.states × m₂.m.states) :=
let (s1, s2) := ss
(FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>
product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))
(fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as | lemma product.f_spec {m₁ m₂ : CNFA n} {s₁ : m₁.m.states} {s₂ : m₂.m.states} :
∀ a s₁' s₂',
(a, (s₁', s₂')) ∈ f m₁ m₂ (s₁, s₂) ↔ s₁'.val ∈ m₁.m.tr s₁ a ∧ s₂'.val ∈ m₂.m.tr s₂ a := | := by
suffices heq :
∀ as a (hnd : as.toList.Nodup) (hnd' : (FinEnum.toList (α := BitVec n)).Nodup)
(hnew : ∀ b s₁ s₂, (b, s₁, s₂) ∈ as → b ∉ (FinEnum.toList (α := BitVec n))) s₁' s₂',
(a, (s₁', s₂')) ∈
((FinEnum.toList (α := BitVec n)).foldl (init := as) fun as a =>
product.prodArray' (λ s₁' s₂' ↦ (a, (s₁', s₂')))
(fun _ => m₁.wf.trans_tgt_lt (s := s₁) (a := a)) (fun _ => m₂.wf.trans_tgt_lt (s := s₂) (a := a)) as) ↔
(a, (s₁', s₂')) ∈ as ∨ a ∈ (FinEnum.toList (α := BitVec n)) ∧ s₁'.val ∈ m₁.m.tr s₁ a ∧ s₂'.val ∈ m₂.m.tr s₂ a by
rintro a s₁' s₂'; rw [f, heq]
· simp; rintro h; apply Array.not_mem_empty at h; trivial
· exact List.dedup_eq_self.mp rfl
· exact FinEnum.nodup_toList
· rintro _ _ _ h; apply Array.not_mem_empty at h; trivial
induction (FinEnum.toList (α := BitVec n))
case nil =>
simp only [List.foldl_nil, List.not_mem_nil, false_and, Subtype.forall]
intros _ _ _ _ _ _; tauto
case cons a as ih =>
rintro bs b hnd hnd' hnew s₁' s₂'
obtain ⟨hnd'', ⟨r, hr, hf⟩, hin⟩ := prodArray'_spec_full (fun s₁' s₂' => (a, s₁', s₂'))
(by rintro _ _ _ _ ⟨rfl, rfl, rfl⟩; tauto)
(fun _ => m₁.wf.trans_tgt_lt (s := s₁)) (fun _ => m₂.wf.trans_tgt_lt (s := s₂) (a := a))
hnd
(by dsimp; rintro s₁ s₂ hin; apply hnew at hin; simp at hin)
dsimp
have hmem : ∀ b s₁' s₂', b ≠ a → (b, s₁', s₂') ∈ prodArray' (fun s₁' s₂' => (a, s₁', s₂'))
(fun _ => m₁.wf.trans_tgt_lt (s := s₁) (a := a))
(fun _ => m₂.wf.trans_tgt_lt (s := s₂) (a := a)) bs →
(b, s₁', s₂') ∈ bs := by
rintro b s₁' s₂' hneq hin
rw [Array.mem_def] at hin ⊢; rw [hr] at hin; simp only [List.mem_append] at hin
rcases hin with hin | hin; assumption
obtain ⟨_, _, ⟨rfl, -, -⟩⟩ := hf _ hin; simp at hneq
rw [ih] <;> clear ih; rotate_left
· apply hnd''
· exact (List.nodup_cons.mp hnd').2
· rintro b s₁' s₂' hin; by_cases heq : b = a
· subst heq; apply List.Nodup.notMem hnd'
· specialize hnew b s₁' s₂' (hmem b s₁' s₂' heq hin); simp at hnew; simp [hnew]
by_cases heq : b = a
· subst heq
simp [hin]; clear hin; constructor
· rintro (⟨h1, h2⟩ | ⟨_, h1, h2⟩) <;> right <;> simp [h1, h2]
· rintro (hc | ⟨h1, h2⟩)
· apply hnew at hc; simp at hc
· left; simp [h1, h2]
· simp only [List.mem_cons, heq, false_or]; constructor
· rintro (hin | hin)
· left; apply hmem _ _ _ heq hin
· right; exact hin
· rintro (hin | hin)
· left; rw [Array.mem_def] at hin ⊢; rw [hr]; simp [hin]
· right; exact hin | 4 | 58 | false | Compiler |
307 | Zipper.denote_insertPureCom | theorem denote_insertPureCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]
{newCom : Com d zip.Γ_mid .pure newTys} {vs : HVector zip.Γ_mid.Var newTys} :
(zip.insertPureCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do
let V_mid ← zip.top.denote V_in
zip.bot.denote
((Com.denoteLets newCom V_mid).comap <| newCom.outContextHom.with vs newCom.returnVars)
) | lean-mlir | LeanMLIR/LeanMLIR/Framework/Zipper.lean | [
"import LeanMLIR.Transforms.Rewrite.Match",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Framework.Basic",
"import LeanMLIR.LeanMLIR.HVector"
] | [
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"llvm.and\" : MLIR.Pretty.uniform_op",
"content": "syntax \"llvm.and\" : MLIR.Pretty.uniform_op\n\nsyntax \"llvm.ashr\" : MLIR.Pretty.exact_op\n\nsyntax \"llvm.add\" : MLIR.Pretty.overflow_op\n\nsyntax \"llvm.return\" : MLIR.Pretty.uniform_op"
},
{
"name": "notation:50 x \" ≤ₛ \" y => BitVec.sle x y",
"content": "notation:50 x \" ≤ₛ \" y => BitVec.sle x y"
},
{
"name": "notation:50 x \" >ᵤ \" y => BitVec.ult y x",
"content": "notation:50 x \" >ᵤ \" y => BitVec.ult y x"
},
{
"name": "notation:50 x \" ≥ᵤ \" y => BitVec.ule y x",
"content": "notation:50 x \" ≥ᵤ \" y => BitVec.ule y x"
},
{
"name": "notation:50 x \" <ᵤ \" y => BitVec.ult x y",
"content": "notation:50 x \" <ᵤ \" y => BitVec.ult x y"
},
{
"name": "notation:50 x \" ≥ₛ \" y => BitVec.sle y x",
"content": "notation:50 x \" ≥ₛ \" y => BitVec.sle y x"
},
{
"name": "notation:50 x \" <ₛ \" y => BitVec.slt x y",
"content": "notation:50 x \" <ₛ \" y => BitVec.slt x y"
},
{
"name": "notation:50 x \" >ₛ \" y => BitVec.slt y x",
"content": "notation:50 x \" >ₛ \" y => BitVec.slt y x"
},
{
"name": "notation:50 x \" ≤ᵤ \" y => BitVec.ule x y",
"content": "notation:50 x \" ≤ᵤ \" y => BitVec.ule x y"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $resName:mlir_op_operand = $name:InstCombine.cmp_op_name $x, $y $[: $t]?) => do\n let some opName := extractOpName name.raw\n | Macro.throwUnsupported\n let t ← t.getDM `(mlir_type| _)\n `(mlir_op| $resName:mlir_op_operand = $opName ($x, $y) : ($t, $t) -> (i1) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $resName:mlir_op_operand = $name:InstCombine.int_cast_op $x : $t to $t') => do\n let some opName := extractOpName name.raw\n | Macro.throwUnsupported\n `(mlir_op| $resName:mlir_op_operand = $opName ($x) : ($t) -> $t')"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant( $x $[: $inner_type]?)\n $[: $outer_type]? ) => do\n \n let outer_type ← outer_type.getDM `(mlir_type| _)\n let inner_type := inner_type.getD outer_type\n `(mlir_op| $res:mlir_op_operand = \"llvm.mlir.constant\"()\n {value = $x:neg_num : $inner_type} : () -> ($outer_type) )\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant( ${ $x:term }) $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n let x ← `(MLIR.AST.AttrValue.int $x [mlir_type| $t])\n `(mlir_op| $res:mlir_op_operand = \"llvm.mlir.constant\"() {value = $$($x) } : () -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (true) $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (1 : i1) : i1)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (false) $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (0 : i1) : i1)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant $x $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant($x $[: $t]?) $[: $t]?)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant ${ $x:term } $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant($$($x) $[: $t]?) $[: $t]?)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.icmp $p $x, $y $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n match p.getString with\n | \"eq\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.eq\" ($x, $y) : ($t, $t) -> (i1))\n | \"ne\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ne\" ($x, $y) : ($t, $t) -> (i1))\n | \"slt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.slt\" ($x, $y) : ($t, $t) -> (i1))\n | \"sle\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sle\" ($x, $y) : ($t, $t) -> (i1))\n | \"sgt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sgt\" ($x, $y) : ($t, $t) -> (i1))\n | \"sge\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sge\" ($x, $y) : ($t, $t) -> (i1))\n | \"ult\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ult\" ($x, $y) : ($t, $t) -> (i1))\n | \"ule\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ule\" ($x, $y) : ($t, $t) -> (i1))\n | \"ugt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ugt\" ($x, $y) : ($t, $t) -> (i1))\n | \"uge\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.uge\" ($x, $y) : ($t, $t) -> (i1))\n | _ => Macro.throwErrorAt p s!\"unexpected predicate {p.getString}\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.select $c, $x, $y $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"llvm.select\" ($c, $x, $y) : (i1, $t, $t) -> ($t))"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Hom.with",
"content": "def Hom.with [DecidableEq Ty] {Γ₁ Γ₂ : Ctxt Ty} (f : Γ₁.Hom Γ₂) {ts}\n (v₁ : HVector Γ₁.Var ts) (v₂ : HVector Γ₂.Var ts) : Γ₁.Hom Γ₂ :=\n fun _ w =>\n match v₁.idxOf? w with\n | none => f w\n | some ⟨i, h⟩ => (v₂.get i).cast h"
},
{
"name": "Hom",
"content": "abbrev Hom (Γ Γ' : Ctxt Ty) := ⦃t : Ty⦄ → Γ.Var t → Γ'.Var t"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "Com.outContextHom",
"content": "def Com.outContextHom (com : Com d Γ eff t) : Γ.Hom com.outContext :=\n com.outContextDiff.toHom"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Com.outContextDiff",
"content": "def Com.outContextDiff (com : Com d Γ eff ts) : Γ.Diff com.outContext :=\n ⟨com.bvars, by admit /- proof elided -/\n ⟩"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "Expr.bvars",
"content": "@[simp, grind=] def Expr.bvars (e : Expr d Γ eff Δ) : Nat :=\n (DialectSignature.returnTypes e.op).length"
},
{
"name": "returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "Com.bvars",
"content": "def Com.bvars : Com d Γ eff t → Nat :=\n Com.rec'\n (fun _ => 0)\n (fun e _body bodySize => e.bvars + bodySize)"
},
{
"name": "Diff",
"content": "def Diff (Γ₁ Γ₂ : Ctxt Ty) : Type :=\n {d : Nat // Diff.Valid Γ₁ Γ₂ d}"
},
{
"name": "Diff.Valid",
"content": "@[simp]\nabbrev Diff.Valid (Γ₁ Γ₂ : Ctxt Ty) (d : Nat) : Prop :=\n ∀ {i t}, Γ₁[i]? = some t → Γ₂[i+d]? = some t"
},
{
"name": "toHom",
"content": "def toHom (d : Diff Γ₁ Γ₂) : Hom Γ₁ Γ₂ :=\n fun _ v => ⟨v.val + d.val, d.property v.property⟩"
},
{
"name": "castCtxt",
"content": "def castCtxt (h_eq : Γ = Δ) : Γ.Var ty → Δ.Var ty\n | ⟨i, h⟩ => ⟨i, h_eq ▸ h⟩"
},
{
"name": "Com.denoteLets",
"content": "def Com.denoteLets : (com : Com d Γ eff ty) → (Γv : Valuation Γ) →\n eff.toMonad d.m (com.outContext.Valuation)\n | .rets _, V => pure V\n | .var e body, V =>\n e.denote V >>= body.denoteLets >>= fun V =>\n return V.cast (by admit /- proof elided -/\n )"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Lets.denote",
"content": "def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}\n (lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=\n match lets with\n | .nil => return V\n | .var lets' e => lets'.denote V >>= e.denote"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "HVector.denote",
"content": "def HVector.denote :\n {l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →\n HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l\n | _, .nil => HVector.nil\n | _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)"
},
{
"name": "FlatCom.denote",
"content": "@[simp] abbrev FlatCom.denote [DialectDenote d]\n (flatCom : FlatCom d Γ eff Γ_out ts)\n (V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=\n flatCom.lets.denote V >>= (return flatCom.rets.map ·)"
},
{
"name": "RegionSignature.map",
"content": "def RegionSignature.map (f : Ty → Ty') : RegionSignature Ty → RegionSignature Ty' :=\n List.map fun ⟨Γ, ty⟩ => (Γ.map f, ty.map f)"
},
{
"name": "Signature.map",
"content": "def Signature.map (f : Ty → Ty') : Signature Ty → Signature Ty' :=\n fun sig => {\n sig := sig.sig.map f\n regSig := sig.regSig.map f\n returnTypes := sig.returnTypes.map f\n }"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "Expr.denote",
"content": "def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :\n eff.toMonad d.m (e.outContext.Valuation) :=\n match e with\n | ⟨op, ty_eq, heff, args, regArgs⟩ => do\n let argsDenote := args.map V\n let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote\n return (val ++ V).cast (by admit /- proof elided -/\n )"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "liftEffect",
"content": "def liftEffect [Pure m] {e1 e2 : EffectKind} {α : Type}\n (hle : e1 ≤ e2) (v1 : e1.toMonad m α) : e2.toMonad m α :=\n match e1, e2, hle with\n | .pure, .pure, _ | .impure, .impure, _ => v1\n | .pure, .impure, _ => Pure.pure v1"
},
{
"name": "toMonad",
"content": "def toMonad (e : EffectKind) (m : Type → Type) : Type → Type :=\n match e with\n | pure => Id\n | impure => m"
},
{
"name": "Com.denote",
"content": "def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →\n eff.toMonad d.m (HVector toType ty)\n | .rets vs, Γv => pure (vs.map Γv)\n | .var e body, V => e.denote V >>= body.denote"
},
{
"name": "Com.ty",
"content": "def Com.ty : Com d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "cast",
"content": "def cast (h_eq : ty₁ = ty₂) : Γ.Var ty₁ → Γ.Var ty₂\n | ⟨i, h⟩ => ⟨i, h_eq ▸ h⟩"
},
{
"name": "cast",
"content": "def cast (h₁ : Γ = Γ') (h₂ : Δ = Δ') : Diff Γ Δ → Diff Γ' Δ'\n | ⟨n, h⟩ => ⟨n, by admit /- proof elided -/\n ⟩"
},
{
"name": "Com.castPureToEff",
"content": "def Com.castPureToEff (eff : EffectKind) : Com d Γ .pure t → Com d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
},
{
"name": "Com.changeEffect",
"content": "def Com.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Com d Γ eff₁ t → Com d Γ eff₂ t := fun com =>\n Com.rec' (motive := @fun Γ _ => eff₁ ≤ eff₂ → Com d Γ eff₂ t)\n (fun v _h => rets v)\n (fun e _body castBody h => var (e.changeEffect h) (castBody h))\n com h"
},
{
"name": "Expr.changeEffect",
"content": "def Expr.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Expr d Γ eff₁ t → Expr d Γ eff₂ t\n | Expr.mk op ty_eq eff_le args regArgs =>\n have heff : DialectSignature.effectKind op ≤ eff₂ := by admit /- proof elided -/"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "com",
"content": "def com := mkCom (d := InstCombine.MetaLLVM 0) bb0 |>.toOption |>.get (by admit /- proof elided -/\n)"
},
{
"name": "bb0",
"content": "def bb0 : Region 0 := [mlir_region|\n{\n ^bb0(%arg0: i32):\n %0 = llvm.mlir.constant(8) : i32\n %1 = llvm.mlir.constant(31) : i32\n %2 = llvm.ashr %arg0, %1 : i32\n %3 = llvm.and %2, %0 : i32\n %4 = llvm.add %3, %2 : i32\n llvm.return %4 : i32\n }]"
},
{
"name": "Region",
"content": "structure Region where\n (name: String)\n (args: List <| TypedSSAVal φ)\n (ops: List Op)"
},
{
"name": "MetaLLVM",
"content": "abbrev MetaLLVM (φ : Nat) : Dialect where\n Op := MOp φ\n Ty := MTy φ"
},
{
"name": "Ty",
"content": "@[deprecated \"Use `LLVM.Ty` instead\" (since:=\"2025-04-30\")] abbrev Ty := LLVM.Ty"
},
{
"name": "Op",
"content": "@[deprecated \"Use `LLVM.Op` instead\" (since:=\"2025-04-30\")] abbrev Op := LLVM.Op"
},
{
"name": "MOp",
"content": "inductive MOp (φ : Nat) : Type\n | unary (w : Width φ) (op : MOp.UnaryOp φ) : MOp φ\n | binary (w : Width φ) (op : MOp.BinaryOp) : MOp φ\n | select (w : Width φ) : MOp φ\n | icmp (c : IntPred) (w : Width φ) : MOp φ\n \n | const (w : Width φ) (val : ℤ) : MOp φ\nderiving Repr, DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "binary",
"content": "@[match_pattern] abbrev binary (w : Nat) (op : MOp.BinaryOp) : LLVM.Op :=\n MOp.binary (.concrete w) op"
},
{
"name": "MOp.BinaryOp",
"content": "inductive MOp.BinaryOp : Type\n | and\n | or (disjoint : DisjointFlag := {disjoint := false} )\n | xor\n | shl (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | lshr (exact : ExactFlag := {exact := false} )\n | ashr (exact : ExactFlag := {exact := false} )\n | urem\n | srem\n | add (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | mul (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | sub (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | sdiv (exact : ExactFlag := {exact := false} )\n | udiv (exact : ExactFlag := {exact := false} )\nderiving DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "LLVM",
"content": "def LLVM : Dialect where\n Op := MOp 0\n Ty := MTy 0"
},
{
"name": "MTy",
"content": "inductive MTy (φ : Nat)\n | bitvec (w : Width φ) : MTy φ\n deriving DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "Width",
"content": "abbrev Width φ := ConcreteOrMVar Nat φ"
},
{
"name": "ConcreteOrMVar",
"content": "inductive ConcreteOrMVar (α : Type u) (φ : Nat)\n | concrete (a : α)\n | mvar (i : Fin φ)\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "const",
"content": "@[match_pattern] abbrev const (w : Nat) (val : ℤ) : LLVM.Op := MOp.const (.concrete w) val"
},
{
"name": "MOp.UnaryOp",
"content": "inductive MOp.UnaryOp (φ : Nat) : Type\n | neg\n | not\n | copy\n | freeze\n | trunc (w' : Width φ) (noWrapFlags : NoWrapFlags := {nsw := false, nuw := false} )\n | zext (w' : Width φ) (nneg : NonNegFlag := {nneg := false} )\n | sext (w' : Width φ)\nderiving Repr, DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "select",
"content": "@[simp_llvm_option]\ndef select {w : Nat} (c? : IntW 1) (x? y? : IntW w ) : IntW w := do\n let c ← c?\n if c = 1#1 then x? else y?"
},
{
"name": "IntW",
"content": "def IntW w := PoisonOr <| BitVec w"
},
{
"name": "PoisonOr",
"content": "structure PoisonOr (α : Type) where\n val : α\n poisonous : Bool\nderiving Inhabited, DecidableEq"
},
{
"name": "icmp",
"content": "@[simp_llvm_option]\ndef icmp {w : Nat} (c : IntPred) (x y : IntW w) : IntW 1 := do\n let x' ← x\n let y' ← y\n icmp? c x' y'"
},
{
"name": "icmp?",
"content": "@[simp_llvm]\ndef icmp? {w : Nat} (c : IntPred) (x y : BitVec w) : IntW 1 :=\n .value ↑(icmp' c x y)"
},
{
"name": "IntPred",
"content": "inductive IntPred where\n | eq\n | ne\n | ugt\n | uge\n | ult\n | ule\n | sgt\n | sge\n | slt\n | sle\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "icmp'",
"content": "@[simp_llvm]\ndef icmp' {w : Nat} (c : IntPred) (x y : BitVec w) : Bool :=\n match c with\n | .eq => (x == y)\n | .ne => (x != y)\n | .sgt => (x >ₛ y)\n | .sge => (x ≥ₛ y)\n | .slt => (x <ₛ y)\n | .sle => (x ≤ₛ y)\n | .ugt => (x >ᵤ y)\n | .uge => (x ≥ᵤ y)\n | .ult => (x <ᵤ y)\n | .ule => (x ≤ᵤ y)"
},
{
"name": "mkCom",
"content": "def mkCom [TransformTy d φ] [TransformExpr d φ] [TransformReturn d φ]\n (reg : MLIR.AST.Region φ) :\n ExceptM d (Σ (Γ : Ctxt d.Ty) (eff : EffectKind) (ty : _), Com d Γ eff ty) :=\n match reg.ops with\n | [] => throw <| .generic \"Ill-formed region (empty)\"\n | coms => BuilderM.runWithEmptyMapping <| do\n let Γ ← declareBindings ∅ reg.args\n let com ← mkComHelper Γ coms\n return ⟨Γ, com⟩"
},
{
"name": "FlatCom.denoteLets",
"content": "def FlatCom.denoteLets (flatCom : FlatCom d Γ eff Γ_out t) (Γv : Γ.Valuation) :\n eff.toMonad d.m <| Γ_out.Valuation :=\n flatCom.lets.denote Γv"
},
{
"name": "Com.toLets",
"content": "def Com.toLets (com : Com d Γ eff t) : Lets d Γ eff com.outContext :=\n Lets.nil.addComToEnd com"
},
{
"name": "Lets.castPureToEff",
"content": "def Lets.castPureToEff (eff : EffectKind) : Lets d Γ_in .pure Γ_out → Lets d Γ_in eff Γ_out\n | .nil => .nil\n | .var body e => .var (body.castPureToEff eff) (e.castPureToEff eff)"
},
{
"name": "Expr.castPureToEff",
"content": "def Expr.castPureToEff (eff : EffectKind) : Expr d Γ .pure t → Expr d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
},
{
"name": "Expr.returnVars",
"content": "def Expr.returnVars (e : Expr d Γ eff tys) : HVector e.outContext.Var tys :=\n .ofFn _ _ <| fun i => (Var.ofFin i).appendInl"
},
{
"name": "ofFin",
"content": "def ofFin (i : Fin Γ.length) : Γ.Var (Γ[i]) :=\n ⟨i.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Com.returnVars",
"content": "def Com.returnVars : (com : Com d Γ eff ts) → HVector (Var com.outContext) ts\n | .rets vs => vs\n | .var _ body => body.returnVars"
},
{
"name": "Valuation.comap",
"content": "def Valuation.comap {Γi Γo : Ctxt Ty} (Γiv: Γi.Valuation) (hom : Ctxt.Hom Γo Γi) : Γo.Valuation :=\n fun _to vo => Γiv (hom vo)"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "HVectorLiteral",
"content": "structure HVectorLiteral where\n u : Level\n v : Level\n α : Q(Type $u)\n A : Q($α → Type $v)\n elems : Array ((a : Q($α)) × Q($A $a))"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "Com.denoteLets_eq",
"content": "theorem Com.denoteLets_eq {com : Com d Γ eff t} : com.denoteLets = com.toLets.denote"
},
{
"name": "Lets.denote_var",
"content": "@[simp] theorem Lets.denote_var {lets : Lets d Γ_in eff Γ_out} {e : Expr d Γ_out eff t} :\n (lets.var e).denote = fun V_in => lets.denote V_in >>= e.denote"
},
{
"name": "castCtxt_rfl",
"content": "@[simp, grind=] theorem castCtxt_rfl (h : Γ = Γ) : v.castCtxt h = v"
},
{
"name": "Com.returnVars_castPureToEff",
"content": "@[simp] theorem Com.returnVars_castPureToEff (eff : _) (com : Com d Γ .pure tys) :\n (com.castPureToEff eff).returnVars = com.returnVars.map (fun _ v => v.castCtxt (by simp))"
},
{
"name": "Valuation.comap_apply",
"content": "@[simp] theorem Valuation.comap_apply {Γi Γo : Ctxt Ty}\n (V : Γi.Valuation) (f : Ctxt.Hom Γo Γi) (v : Γo.Var t) :\n V.comap f v = V (f v)"
},
{
"name": "Com.denoteLets_castPureToEff",
"content": "@[simp] theorem Com.denoteLets_castPureToEff {com : Com d Γ .pure ty} :\n denoteLets (com.castPureToEff eff)\n = fun V => pure (com.denoteLets V |>.comap fun _ v => v.castCtxt (by simp))"
},
{
"name": "Com.denoteLets_returnVars",
"content": "@[simp] theorem Com.denoteLets_returnVars (c : Com d Γ .pure tys) (V : Valuation Γ) :\n c.returnVars.map (c.denoteLets V) = c.denote V"
},
{
"name": "Id.bind_eq'",
"content": "theorem Id.bind_eq' (x : Id α) (f : α → id β) : x >>= f = f x"
},
{
"name": "Id.pure_eq'",
"content": "theorem Id.pure_eq' (a : α) : (pure a : Id α) = a"
},
{
"name": "Ctxt.Valuation.comap_outContextHom_denoteLets",
"content": "@[simp] theorem Ctxt.Valuation.comap_outContextHom_denoteLets {com : Com d Γ .pure ty} {V} :\n Valuation.comap (com.denoteLets V) com.outContextHom = V"
},
{
"name": "Com.bvars_castPureToEff",
"content": "@[simp] theorem Com.bvars_castPureToEff {com : Com d Γ .pure ty} :\n (com.castPureToEff eff).bvars = com.bvars"
},
{
"name": "Valuation.comap_with",
"content": "@[simp] theorem Valuation.comap_with [DecidableEq Ty] {Γ Δ : Ctxt Ty}\n {V : Valuation Γ} {map : Δ.Hom Γ} {vs : HVector Δ.Var ty} {ws : HVector Γ.Var ty} :\n V.comap (map.with vs ws) = (V.comap map).reassignVars vs (ws.map V)"
},
{
"name": "map_map",
"content": "theorem map_map {A B C : α → Type*} {l : List α} (t : HVector A l)\n (f : ∀ a, A a → B a) (g : ∀ a, B a → C a) :\n (t.map f).map g = t.map (fun a v => g a (f a v))"
},
{
"name": "castCtxt_castCtxt",
"content": "@[simp, grind=] theorem castCtxt_castCtxt (h₁ : Γ = Δ) (h₂ : Δ = Ξ) :\n (v.castCtxt h₁).castCtxt h₂ = v.castCtxt (by simp [*])"
}
] | [
{
"name": "Zipper",
"content": "structure Zipper (Γ_in : Ctxt d.Ty) (eff : EffectKind) (tys : List d.Ty) where\n \n {Γ_mid : Ctxt d.Ty}\n \n top : Lets d Γ_in eff Γ_mid\n \n bot : Com d Γ_mid eff tys"
},
{
"name": "Zipper.denote",
"content": "def denote (zip : Zipper d Γ_in eff tys) (V_in : Valuation Γ_in) :\n eff.toMonad d.m (HVector toType tys) :=\n (zip.top.denote V_in) >>= zip.bot.denote"
},
{
"name": "Zipper.insertCom",
"content": "def insertCom (zip : Zipper d Γ_in eff ty)\n (vs : HVector zip.Γ_mid.Var newTy) (newCom : Com d zip.Γ_mid eff newTy) :\n Zipper d Γ_in eff ty :=\n let top := zip.top.addComToEnd newCom\n \n let bot := zip.bot.changeVars <| newCom.outContextHom.with vs newCom.returnVars\n \n \n { top, bot }"
},
{
"name": "Zipper.insertPureCom",
"content": "def insertPureCom (zip : Zipper d Γ_in eff ty)\n (vs : HVector zip.Γ_mid.Var newTy)\n (newCom : Com d zip.Γ_mid .pure newTy) : Zipper d Γ_in eff ty :=\n zip.insertCom vs (newCom.castPureToEff eff)"
}
] | [
{
"name": "Zipper.denote_insertCom",
"content": "theorem denote_insertCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]\n {newCom : Com d zip.Γ_mid eff newTys} {vs : HVector zip.Γ_mid.Var newTys} :\n (zip.insertCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do\n let V_mid ← zip.top.denote V_in\n let V_newMid ← newCom.denoteLets V_mid\n zip.bot.denote\n (V_newMid.comap <| newCom.outContextHom.with vs newCom.returnVars)\n )"
}
] | import LeanMLIR.Framework.Basic
import LeanMLIR.Transforms.Rewrite.Match
open Ctxt (Valuation Var Hom)
variable (d : Dialect) [DialectSignature d]
structure Zipper (Γ_in : Ctxt d.Ty) (eff : EffectKind) (tys : List d.Ty) where
{Γ_mid : Ctxt d.Ty}
top : Lets d Γ_in eff Γ_mid
bot : Com d Γ_mid eff tys
namespace Zipper
variable {d}
section Denote
variable [TyDenote d.Ty] [DialectDenote d] [Monad d.m]
def denote (zip : Zipper d Γ_in eff tys) (V_in : Valuation Γ_in) :
eff.toMonad d.m (HVector toType tys) :=
(zip.top.denote V_in) >>= zip.bot.denote
end Denote
section ToCom
variable {Γ_mid}
variable [TyDenote d.Ty] [DialectDenote d] [Monad d.m]
end ToCom
section InsertCom
variable [DecidableEq d.Ty]
def insertCom (zip : Zipper d Γ_in eff ty)
(vs : HVector zip.Γ_mid.Var newTy) (newCom : Com d zip.Γ_mid eff newTy) :
Zipper d Γ_in eff ty :=
let top := zip.top.addComToEnd newCom
let bot := zip.bot.changeVars <| newCom.outContextHom.with vs newCom.returnVars
{ top, bot }
def insertPureCom (zip : Zipper d Γ_in eff ty)
(vs : HVector zip.Γ_mid.Var newTy)
(newCom : Com d zip.Γ_mid .pure newTy) : Zipper d Γ_in eff ty :=
zip.insertCom vs (newCom.castPureToEff eff)
section Lemmas
variable [TyDenote d.Ty] [DialectDenote d] [Monad d.m] | theorem denote_insertPureCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]
{newCom : Com d zip.Γ_mid .pure newTys} {vs : HVector zip.Γ_mid.Var newTys} :
(zip.insertPureCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do
let V_mid ← zip.top.denote V_in
zip.bot.denote
((Com.denoteLets newCom V_mid).comap <| newCom.outContextHom.with vs newCom.returnVars)
) := | := by
have (V_mid) (h : Com.outContext (Com.castPureToEff eff newCom) = Com.outContext newCom) :
((Com.denoteLets newCom V_mid).comap fun x v => v.castCtxt h).comap
(newCom.castPureToEff eff).outContextHom
= (Com.denoteLets newCom V_mid).comap newCom.outContextHom := by
funext t' ⟨v', hv'⟩
simp only [Com.outContextHom, Com.outContextDiff, Com.bvars_castPureToEff]
rfl
funext V
simp only [insertPureCom, denote_insertCom, Com.denoteLets_castPureToEff,
Com.returnVars_castPureToEff, Valuation.comap_with, HVector.map_map, pure_bind, this,
Valuation.comap_outContextHom_denoteLets, Valuation.comap_apply, Var.castCtxt_castCtxt,
Var.castCtxt_rfl, Com.denoteLets_returnVars] | 11 | 133 | false | Compiler |
308 | autMsbSet_accepts | @[simp]
lemma autMsbSet_accepts : NFA'.autMsbSet.accepts = langMsb | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.Blase.AutoStructs.ForLean",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BitVec.ofFin",
"module": "Init.Prelude"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Function.RightInverse",
"module": "Init.Data.Function"
}
] | [
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "instFinEnumBV",
"content": "instance instFinEnumBV : FinEnum (BitVec w) where\n card := 2^w\n equiv := {\n toFun := fun x => x.toFin\n invFun := fun x => BitVec.ofFin x\n left_inv := by admit /- proof elided -/"
},
{
"name": "langMsb",
"content": "@[simp]\ndef langMsb : Set (BitVecs 1) := { bvs | bvs.bvs.get 0 |>.msb }"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "head",
"content": "def head (x : BitStream) : Bool := x 0"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
}
] | [
{
"name": "BitVec.eq_nil",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.getElem_one",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.getLsbD_eq_getElem",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.msb_eq_getLsbD_last",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.ofNat_eq_ofNat",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.getElem?_eq_getElem",
"module": "Init.GetElem"
},
{
"name": "List.getLast?_eq_getElem?",
"module": "Init.Data.List.Lemmas"
},
{
"name": "Set.mem_image",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "and_true",
"module": "Init.SimpLemmas"
},
{
"name": "decide_true",
"module": "Init.Core"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
},
{
"name": "dec_enc'",
"content": "@[simp]\nlemma dec_enc' : dec (enc bvs) = bvs"
},
{
"name": "dec_enc",
"content": "@[simp]\nlemma dec_enc : Function.RightInverse (α := BitVecs' n) enc dec"
},
{
"name": "dec_enc_w",
"content": "lemma dec_enc_w (bvs : BitVecs n) : (dec (enc bvs)).w = bvs.w"
},
{
"name": "BitVec.ofFn_getElem",
"content": "@[simp]\ntheorem BitVec.ofFn_getElem {w : Nat} (f : Fin w → Bool) {i : Nat} (hi : i < w) :\n (BitVec.ofFn f)[i] = f ⟨i, hi⟩"
},
{
"name": "BitVec.ofFn_getLsbD",
"content": "@[simp]\ntheorem BitVec.ofFn_getLsbD {w : Nat} {f : Fin w → Bool} {i : Nat} (hi : i < w) :\n (BitVec.ofFn f).getLsbD i = f ⟨i, hi⟩"
},
{
"name": "BitVec.ofFn_getLsbD_fin",
"content": "theorem BitVec.ofFn_getLsbD_fin {w : Nat} {f : Fin w → Bool} {i : Fin w} :\n (BitVec.ofFn f).getLsbD i = f i"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "NFA.msbState",
"content": "inductive NFA.msbState : Type where\n| i | f\nderiving DecidableEq, Fintype"
},
{
"name": "NFA.msbStep",
"content": "def NFA.msbStep (q : NFA.msbState) (a : BitVec 1) : List NFA.msbState :=\n match q, a with\n | .i, 0 => [.i]\n | .i, 1 => [.i, .f]\n | _, _ => []"
},
{
"name": "NFA.autMsbSet",
"content": "def NFA.autMsbSet : NFA (BitVec 1) msbState where\n step s a := { s' | s' ∈ msbStep s a }\n start := {.i}\n accept := {.f}"
},
{
"name": "NFA'.autMsbSet",
"content": "def NFA'.autMsbSet : NFA' 1 := ⟨_, NFA.autMsbSet⟩"
},
{
"name": "NFA.msbLang",
"content": "def NFA.msbLang : Language (BitVec 1) := { bvs | bvs.getLast? = some 1 }"
},
{
"name": "NFA.msbSA",
"content": "def NFA.msbSA (q : msbState) : Language (BitVec 1) :=\n match q with\n | .i => ⊤\n | .f => msbLang"
},
{
"name": "NFA.msbCorrect",
"content": "def NFA.msbCorrect : NFA.autMsbSet.correct msbSA msbLang :="
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
variable {arity : Type} [FinEnum arity]
open BitStream in
end fsm
section nfas_relations
inductive NFA.msbState : Type where
| i | f
deriving DecidableEq, Fintype
def NFA.msbStep (q : NFA.msbState) (a : BitVec 1) : List NFA.msbState :=
match q, a with
| .i, 0 => [.i]
| .i, 1 => [.i, .f]
| _, _ => []
def NFA.autMsbSet : NFA (BitVec 1) msbState where
step s a := { s' | s' ∈ msbStep s a }
start := {.i}
accept := {.f}
def NFA'.autMsbSet : NFA' 1 := ⟨_, NFA.autMsbSet⟩
def NFA.msbLang : Language (BitVec 1) := { bvs | bvs.getLast? = some 1 }
def NFA.msbSA (q : msbState) : Language (BitVec 1) :=
match q with
| .i => ⊤
| .f => msbLang
def NFA.msbCorrect : NFA.autMsbSet.correct msbSA msbLang := | @[simp]
lemma autMsbSet_accepts : NFA'.autMsbSet.accepts = langMsb := | := by
simp [NFA'.accepts, NFA'.accepts', NFA'.autMsbSet]
rw [NFA.correct_spec NFA.msbCorrect, NFA.msbLang]
ext bvs; simp only [BitVec.ofNat_eq_ofNat, Set.mem_image, Set.mem_setOf_eq]
constructor
· rintro ⟨bvs', hl, heq⟩
have _ : bvs'.length ≠ 0 := by cases bvs'; tauto; simp
rw [←heq]
simp [dec]
rw [BitVec.msb_eq_getLsbD_last]
rw [BitVec.ofFn_getLsbD (by omega)]
simp
rw [List.getLast?_eq_getElem?] at hl
rw [List.getElem?_eq_getElem (by omega)] at hl
injection hl
simp_all only [BitVec.getElem_one, decide_true]
· intros h; use enc bvs
simp only [dec_enc', and_true]
simp [enc]
have hw : bvs.w ≠ 0 := by
rcases bvs with ⟨w, bvs⟩; rintro rfl
simp_all [BitVec.eq_nil (bvs.head)]
use ⟨bvs.w - 1, by omega⟩
simp; rw [List.getLast?_eq_getElem?]
simp; constructor
· rw [List.getElem?_eq_getElem (by simp; omega)]; simp
· ext i hi; rw [BitVec.ofFn_getElem _ (by omega)]
rw [BitVec.msb_eq_getLsbD_last] at h
simp [←BitVec.getLsbD_eq_getElem]
obtain rfl : i = 0 := by omega
simp_all | 5 | 71 | false | Compiler |
309 | decideIfZerosAux_correct | theorem decideIfZerosAux_correct {arity : Type _} [DecidableEq arity]
(p : FSM arity) (c : Circuit p.α)
(hc : ∀ s, c.eval s = true →
∃ m y, (p.changeInitCarry s).eval y m = true)
(hc₂ : ∀ (x : arity → Bool) (s : p.α → Bool),
(FSM.nextBit p s x).snd = true → Circuit.eval c s = true) :
decideIfZerosAux p c = true ↔ ∀ n x, p.eval x n = false | lean-mlir | Blase/Blase/Fast/FiniteStateMachine.lean | [
"import Blase.Fast.Defs",
"import Mathlib.Data.Fintype.BigOperators",
"import Blase.Fast.Circuit",
"import Blase.Vars",
"import Blase.Blase.Fast.Circuit",
"import Mathlib.Data.Fintype.Pi",
"import Mathlib.Data.Fintype.Sum",
"import Mathlib.Data.Fintype.Card",
"import Mathlib.Data.Fintype.Sigma",
"import Mathlib.Tactic.Ring",
"import Mathlib.Data.FinEnum",
"import Blase.FinEnum",
"import Mathlib.Tactic.Zify"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.card",
"module": "Mathlib.Data.Finset.Card"
},
{
"name": "Finset.univ",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Bool.xor",
"module": "Init.Data.Bool"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "id",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"slt\" : MLIR.Pretty.uniform_op",
"content": "syntax \"slt\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "Term.eval",
"content": "def Term.eval (t : Term) (vars : List BitStream) : BitStream :=\n match t with\n | var n => vars.getD n default\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ => (t₁.eval vars) &&& (t₂.eval vars)\n | or t₁ t₂ => (t₁.eval vars) ||| (t₂.eval vars)\n | xor t₁ t₂ => (t₁.eval vars) ^^^ (t₂.eval vars)\n | not t => ~~~(t.eval vars)\n | add t₁ t₂ => (Term.eval t₁ vars) + (Term.eval t₂ vars)\n | sub t₁ t₂ => (Term.eval t₁ vars) - (Term.eval t₂ vars)\n | neg t => -(Term.eval t vars)\n\n\n | shiftL t n => BitStream.shiftLeft (Term.eval t vars) n"
},
{
"name": "Predicate.eval",
"content": "def Predicate.eval (p : Predicate) (vars : List BitStream) : BitStream :=\n match p with\n | .width .eq n => BitStream.falseIffEq n\n | .width .neq n => BitStream.falseIffNeq n\n | .width .lt n => BitStream.falseIffLt n\n | .width .le n => BitStream.falseIffLe n\n | .width .gt n => BitStream.falseIffGt n\n | .width .ge n => BitStream.falseIffGe n\n | lor p q => Predicate.evalLor (p.eval vars) (q.eval vars)\n | land p q => Predicate.evalLand (p.eval vars) (q.eval vars)\n | binary .eq t₁ t₂ => Predicate.evalEq (t₁.eval vars) (t₂.eval vars)\n \n | binary .neq t1 t2 => Predicate.evalNeq (t1.eval vars) (t2.eval vars)\n | binary .ult t₁ t₂ => Predicate.evalUlt (t₁.eval vars) (t₂.eval vars)\n | binary .ule t₁ t₂ =>\n Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalUlt (t₁.eval vars) (t₂.eval vars))\n | binary .slt t₁ t₂ => Predicate.evalSlt (t₁.eval vars) (t₂.eval vars)\n | binary .sle t₁ t₂ => Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalSlt (t₁.eval vars) (t₂.eval vars))"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "eval",
"content": "@[simp]\ndef eval : Circuit α → (α → Bool) → Bool\n | tru, _ => true\n | fals, _ => false\n | var b x, f => if b then f x else !(f x)\n | and c₁ c₂, f => (eval c₁ f) && (eval c₂ f)\n | or c₁ c₂, f => (eval c₁ f) || (eval c₂ f)\n | xor c₁ c₂, f => Bool.xor (eval c₁ f) (eval c₂ f)"
},
{
"name": "sumVarsRight",
"content": "def sumVarsRight [DecidableEq α] [DecidableEq β] : Circuit (α ⊕ β) → List β\n | tru => []\n | fals => []\n | var _ (Sum.inl _) => []\n | var _ (Sum.inr x) => [x]\n | and c₁ c₂ => (sumVarsRight c₁ ++ sumVarsRight c₂).dedup\n | or c₁ c₂ => (sumVarsRight c₁ ++ sumVarsRight c₂).dedup\n | xor c₁ c₂ => (sumVarsRight c₁ ++ sumVarsRight c₂).dedup"
},
{
"name": "fst",
"content": "def fst {α β : Type _} [DecidableEq α] [DecidableEq β]\n (c : Circuit (α ⊕ β)) : Circuit α :=\n Circuit.bOr (c.sumVarsRight.pi (λ _ => [true, false]))\n (λ x => Circuit.assignVars c\n (λ i => Sum.rec (λ i _ => Sum.inl i) (λ i hi => Sum.inr (x i (by admit /- proof elided -/\n ))) i))"
},
{
"name": "bOr",
"content": "def bOr : ∀ (_s : List α) (_f : α → Circuit β), Circuit β\n| [], _ => fals\n| a::l, f => l.foldl (λ c x => c ||| (f x)) (f a)"
},
{
"name": "assignVars",
"content": "def assignVars [DecidableEq α] :\n ∀ (c : Circuit α) (_f : ∀ (a : α) (_ha : a ∈ c.vars), β ⊕ Bool), Circuit β\n | tru, _ => tru\n | fals, _ => fals\n | var b x, f =>\n Sum.elim\n (var b)\n (λ c : Bool => if Bool.xor b c then fals else tru)\n (f x (by admit /- proof elided -/\n ))\n | and c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/\n ))) &&&\n (assignVars c₂ (λ x hx => f x (by admit /- proof elided -/\n )))\n | or c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/\n ))) |||\n (assignVars c₂ (λ x hx => f x (by admit /- proof elided -/\n )))\n | xor c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/\n ))) ^^^\n (assignVars c₂ (λ x hx => f x (by admit /- proof elided -/\n )))"
},
{
"name": "vars",
"content": "def vars [DecidableEq α] : Circuit α → List α\n | tru => []\n | fals => []\n | var _ x => [x]\n | and c₁ c₂ => (vars c₁ ++ vars c₂).dedup\n | or c₁ c₂ => (vars c₁ ++ vars c₂).dedup\n | xor c₁ c₂ => (vars c₁ ++ vars c₂).dedup"
},
{
"name": "evalv",
"content": "@[simp] def evalv [DecidableEq α] : ∀ (c : Circuit α), (∀ a ∈ vars c, Bool) → Bool\n | tru, _ => true\n | fals, _ => false\n | var b x, f => if b then f x (by admit /- proof elided -/\n ) else !(f x (by admit /- proof elided -/\n ))\n | and c₁ c₂, f => (evalv c₁ (fun i hi => f i (by admit /- proof elided -/\n ))) &&\n (evalv c₂ (fun i hi => f i (by admit /- proof elided -/\n )))\n | or c₁ c₂, f => (evalv c₁ (fun i hi => f i (by admit /- proof elided -/\n ))) ||\n (evalv c₂ (fun i hi => f i (by admit /- proof elided -/\n )))\n | xor c₁ c₂, f => Bool.xor (evalv c₁ (fun i hi => f i (by admit /- proof elided -/\n )))\n (evalv c₂ (fun i hi => f i (by admit /- proof elided -/\n )))"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "simplifyOr",
"content": "def simplifyOr : Circuit α → Circuit α → Circuit α\n | tru, _ => tru\n | _, tru => tru\n | fals, c => c\n | c, fals => c\n | c₁, c₂ => or c₁ c₂"
},
{
"name": "bind",
"content": "def bind : ∀ (_c : Circuit α) (_f : α → Circuit β), Circuit β\n | tru, _ => tru\n | fals, _ => fals\n | var b x, f => if b then f x else ~~~ (f x)\n | and c₁ c₂, f => (bind c₁ f) &&& (bind c₂ f)\n | or c₁ c₂, f => (bind c₁ f) ||| (bind c₂ f)\n | xor c₁ c₂, f => (bind c₁ f) ^^^ (bind c₂ f)"
}
] | [
{
"name": "Bool.not_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "Finset.card_lt_card",
"module": "Mathlib.Data.Finset.Card"
},
{
"name": "Finset.ssubset_iff",
"module": "Mathlib.Data.Finset.Insert"
},
{
"name": "Finset.subset_iff",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "not_imp_not",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Bool.or_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "Nat.rec_zero",
"module": "Mathlib.Data.Nat.Init"
},
{
"name": "or_true",
"module": "Init.SimpLemmas"
},
{
"name": "true_iff",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "le_def",
"content": "lemma le_def : ∀ (c₁ c₂ : Circuit α), c₁ ≤ c₂ ↔ ∀ f, eval c₁ f → eval c₂ f"
},
{
"name": "eval_fst",
"content": "theorem eval_fst {α β : Type _} [DecidableEq α] [DecidableEq β]\n (c : Circuit (α ⊕ β)) (g : α → Bool) :\n c.fst.eval g ↔ ∃ g' : β → Bool, c.eval (Sum.elim g g')"
},
{
"name": "eval_assignVars",
"content": "lemma eval_assignVars [DecidableEq α] : ∀ {c : Circuit α}\n {f : ∀ (a : α) (_ha : a ∈ c.vars), β ⊕ Bool} {g : β → Bool},\n eval (assignVars c f) g = evalv c (λ a ha => Sum.elim g id (f a ha))"
},
{
"name": "eval_bOr",
"content": "@[simp] lemma eval_bOr :\n ∀ {s : List α} {f : α → Circuit β} {g : β → Bool},\n eval (bOr s f) g = ∃ a ∈ s, eval (f a) g"
},
{
"name": "eval_foldl_or",
"content": "@[simp] lemma eval_foldl_or :\n ∀ (s : List α) (f : α → Circuit β) (c : Circuit β) (g : β → Bool),\n (eval (s.foldl (λ c x => c ||| (f x)) c) g : Prop) ↔\n eval c g ∨ (∃ a ∈ s, eval (f a) g)"
},
{
"name": "eval_or",
"content": "@[simp] lemma eval_or : ∀ (c₁ c₂ : Circuit α) (f : α → Bool),\n (eval (c₁ ||| c₂) f) = ((eval c₁ f) || (eval c₂ f))"
},
{
"name": "eval_eq_evalv",
"content": "lemma eval_eq_evalv [DecidableEq α] : ∀ (c : Circuit α) (f : α → Bool),\n eval c f = evalv c (λ x _ => f x)"
},
{
"name": "eval_bind",
"content": "lemma eval_bind : ∀ (c : Circuit α) (f : α → Circuit β) (g : β → Bool),\n eval (bind c f) g = eval c (λ a => eval (f a) g)"
}
] | [
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "FSM.State",
"content": "abbrev State : Type := p.α → Bool"
},
{
"name": "FSM.nextBit",
"content": "def nextBit : p.State → (arity → Bool) → p.State × Bool :=\n fun carry inputBits =>\n let input := Sum.elim carry inputBits\n let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input\n let outBit : Bool := (p.outputCirc).eval input\n (newState, outBit)"
},
{
"name": "FSM.carry",
"content": "def carry (x : arity → BitStream) : ℕ → p.State\n | 0 => p.initCarry\n | n+1 => (p.nextBit (carry x n) (fun i => x i n)).1"
},
{
"name": "FSM.eval",
"content": "def eval (x : arity → BitStream) : BitStream :=\n fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2"
},
{
"name": "FSM.changeInitCarry",
"content": "def changeInitCarry (p : FSM arity) (c : p.α → Bool) : FSM arity :=\n { p with initCarry := c }"
},
{
"name": "card_compl",
"content": "def card_compl [Fintype α] [DecidableEq α] (c : Circuit α) : ℕ :=\n Finset.card $ (@Finset.univ (α → Bool) _).filter (fun a => c.eval a = false)"
},
{
"name": "decideIfZerosAux",
"content": "def decideIfZerosAux {arity : Type _} [DecidableEq arity]\n (p : FSM arity) (c : Circuit p.α) : Bool :=\n \n if c.eval p.initCarry \n then false \n else\n \n \n have c' := (c.bind (p.nextStateCirc)).fst\n if h : c' ≤ c then true\n else\n have _wf : card_compl (c' ||| c) < card_compl c :=\n decideIfZeroAux_wf h\n decideIfZerosAux p (c' ||| c)\n termination_by card_compl c"
}
] | [
{
"name": "FSM.carry_changeInitCarry_succ",
"content": "theorem carry_changeInitCarry_succ\n (p : FSM arity) (c : p.α → Bool) (x : arity → BitStream) : ∀ n,\n (p.changeInitCarry c).carry x (n+1) =\n (p.changeInitCarry (p.nextBit c (fun a => x a 0)).1).carry\n (fun a i => x a (i+1)) n\n | 0 => by simp [carry, changeInitCarry, nextBit]\n | n+1 => by\n rw [carry, carry_changeInitCarry_succ p _ _ n]\n simp [nextBit, carry, changeInitCarry]"
},
{
"name": "FSM.eval_changeInitCarry_succ",
"content": "theorem eval_changeInitCarry_succ\n (p : FSM arity) (c : p.α → Bool) (x : arity → BitStream) (n : ℕ) :\n (p.changeInitCarry c).eval x (n+1) =\n (p.changeInitCarry (p.nextBit c (fun a => x a 0)).1).eval\n (fun a i => x a (i+1)) n"
},
{
"name": "FSM.evalAux_eq_zero_of_set",
"content": "theorem evalAux_eq_zero_of_set {arity : Type _} (p : FSM arity)\n (R : Set (p.α → Bool)) (hR : ∀ x s, (p.nextBit s x).1 ∈ R → s ∈ R)\n (hi : p.initCarry ∉ R) (hr1 : ∀ x s, (p.nextBit s x).2 = true → s ∈ R)\n (x : arity → BitStream) (n : ℕ) : p.eval x n = false ∧ p.carry x n ∉ R"
},
{
"name": "FSM.eval_eq_zero_of_set",
"content": "theorem eval_eq_zero_of_set {arity : Type _} (p : FSM arity)\n (R : Set (p.α → Bool)) (hR : ∀ x s, (p.nextBit s x).1 ∈ R → s ∈ R)\n (hi : p.initCarry ∉ R) (hr1 : ∀ x s, (p.nextBit s x).2 = true → s ∈ R) :\n p.eval = fun _ _ => false"
},
{
"name": "decideIfZeroAux_wf",
"content": "theorem decideIfZeroAux_wf {α : Type _} [Fintype α] [DecidableEq α]\n {c c' : Circuit α} (h : ¬c' ≤ c) : card_compl (c' ||| c) < card_compl c"
}
] | import Mathlib.Data.FinEnum
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Fintype.Sum
import Mathlib.Data.Fintype.Sigma
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Tactic.Zify
import Mathlib.Tactic.Ring
import Blase.FinEnum
import Blase.Fast.Defs
import Blase.Fast.Circuit
import Blase.Vars
open Sum
section FSM
variable {α β α' β' : Type} {γ : β → Type}
structure FSM (arity : Type) : Type 1 where
( α : Type )
[ i : FinEnum α ]
[ h : Hashable α ]
[ dec_eq : DecidableEq α ]
( initCarry : α → Bool )
outputCirc : Circuit (α ⊕ arity)
nextStateCirc : α → Circuit (α ⊕ arity)
open Lean in
open Lean in
open Lean in
open Lean in
namespace FSM
variable {arity : Type} (p : FSM arity)
abbrev State : Type := p.α → Bool
def nextBit : p.State → (arity → Bool) → p.State × Bool :=
fun carry inputBits =>
let input := Sum.elim carry inputBits
let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input
let outBit : Bool := (p.outputCirc).eval input
(newState, outBit)
def carry (x : arity → BitStream) : ℕ → p.State
| 0 => p.initCarry
| n+1 => (p.nextBit (carry x n) (fun i => x i n)).1
def eval (x : arity → BitStream) : BitStream :=
fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2
def changeInitCarry (p : FSM arity) (c : p.α → Bool) : FSM arity :=
{ p with initCarry := c }
section EvalInduction
end EvalInduction
end FSM
namespace FSM
end FSM
open Term
def card_compl [Fintype α] [DecidableEq α] (c : Circuit α) : ℕ :=
Finset.card $ (@Finset.univ (α → Bool) _).filter (fun a => c.eval a = false)
def decideIfZerosAux {arity : Type _} [DecidableEq arity]
(p : FSM arity) (c : Circuit p.α) : Bool :=
if c.eval p.initCarry
then false
else
have c' := (c.bind (p.nextStateCirc)).fst
if h : c' ≤ c then true
else
have _wf : card_compl (c' ||| c) < card_compl c :=
decideIfZeroAux_wf h
decideIfZerosAux p (c' ||| c)
termination_by card_compl c | theorem decideIfZerosAux_correct {arity : Type _} [DecidableEq arity]
(p : FSM arity) (c : Circuit p.α)
(hc : ∀ s, c.eval s = true →
∃ m y, (p.changeInitCarry s).eval y m = true)
(hc₂ : ∀ (x : arity → Bool) (s : p.α → Bool),
(FSM.nextBit p s x).snd = true → Circuit.eval c s = true) :
decideIfZerosAux p c = true ↔ ∀ n x, p.eval x n = false := | := by
rw [decideIfZerosAux]
split_ifs with h
· simp
exact hc p.initCarry h
· dsimp
split_ifs with h'
· simp only [true_iff]
intro n x
rw [p.eval_eq_zero_of_set {x | c.eval x = true}]
· intro y s
simp [Circuit.le_def, Circuit.eval_fst, Circuit.eval_bind] at h'
simp [FSM.nextBit]
apply h'
· assumption
· exact hc₂
· let c' := (c.bind (p.nextStateCirc)).fst
have _wf : card_compl (c' ||| c) < card_compl c :=
decideIfZeroAux_wf h'
apply decideIfZerosAux_correct p (c' ||| c)
simp [c', Circuit.eval_fst, Circuit.eval_bind]
intro s hs
rcases hs with ⟨x, hx⟩ | h
· rcases hc _ hx with ⟨m, y, hmy⟩
use (m+1)
use fun a i => Nat.casesOn i x (fun i a => y a i) a
rw [FSM.eval_changeInitCarry_succ]
rw [← hmy]
simp only [FSM.nextBit, Nat.rec_zero]
· exact hc _ h
· intro x s h
have := hc₂ _ _ h
simp only [Bool.or_eq_true, Circuit.eval_or, this, or_true]
termination_by card_compl c | 7 | 97 | false | Compiler |
310 | MultiWidth.eval_fsmTermSlt_eq_decide_slt | theorem eval_fsmTermSlt_eq_decide_slt {wcard tcard : Nat}
(tctx : Term.Ctx wcard tcard)
{wenv : WidthExpr.Env wcard}
(tenv : tctx.Env wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(w : WidthExpr wcard)
(a : Term bcard ncard icard pcard tctx (.bv w))
(b : Term bcard ncard icard pcard tctx (.bv w))
(wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
(hwfsm : HNatFSMToBitstream wfsm)
(afsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm a))
(hafsm : HTermFSMToBitStream afsm)
(bfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm b))
(hbfsm : HTermFSMToBitStream bfsm)
(fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)
(henv : HTermEnv fsmEnv tenv benv)
:
((fsmTermSlt
wfsm
afsm
bfsm)).eval fsmEnv i =
decide (((a.toBV benv nenv ienv penv tenv).signExtend i).slt
((b.toBV benv nenv ienv penv tenv).signExtend i)) | lean-mlir | Blase/Blase/MultiWidth/GoodFSM.lean | [
"import Blase.MultiWidth.Defs",
"import Blase.Vars",
"import Blase.KInduction.KInduction",
"import Lean",
"import Blase.Blase.Fast.BitStream",
"import Blase.Fast.FiniteStateMachine"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat.max",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.min",
"module": "Init.Data.Nat.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofBool",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.signExtend",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "BitVec.carry",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Bool.atLeastTwo",
"module": "Init.Data.BitVec.Bitblast"
}
] | [
{
"name": "syntax \"min\" : MLIR.Pretty.uniform_op",
"content": "syntax \"min\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "composeBinaryAux'",
"content": "def composeBinaryAux'\n (p : FSM Bool)\n (qtrue : FSM α)\n (qfalse : FSM α) :\n FSM α :=\n p.compose (α)\n (λ _ => α)\n (λ _ i => i)\n (λ b => match b with\n | true => qtrue\n | false => qfalse)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "xor",
"content": "def xor : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ^^^ Circuit.var true (inr false),\n nextStateCirc := Empty.elim\n }"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "latchImmediate",
"content": "def latchImmediate (initVal : Bool) : FSM Bool where\n α := Unit\n initCarry := fun _ => initVal\n outputCirc :=\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state\n nextStateCirc := fun () =>\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state"
},
{
"name": "ite",
"content": "def ite (cond t f : Circuit α) : Circuit α :=\n (cond &&& t) ||| (~~~ cond &&& f)"
},
{
"name": "TermFSM",
"content": "structure TermFSM (wcard tcard bcard ncard icard pcard : Nat) (t : Nondep.Term) where\n toFsmZext : FSM (StateSpace wcard tcard bcard ncard icard pcard)\n width : NatFSM wcard tcard bcard ncard icard pcard t.width"
},
{
"name": "NatFSM",
"content": "structure NatFSM (wcard tcard bcard ncard icard pcard : Nat) (v : Nondep.WidthExpr) where\n toFsm : FSM (StateSpace wcard tcard bcard ncard icard pcard)"
},
{
"name": "StateSpace",
"content": "inductive StateSpace (wcard tcard bcard ncard icard pcard : Nat)\n| widthVar (v : Fin wcard)\n| termVar (v : Fin tcard)\n| predVar (v : Fin pcard)\n| boolVar (v : Fin bcard)\nderiving DecidableEq, Repr, Hashable"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| bvOfBool (b : Term) : Term\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr) : Term\n| binRel (k : BinaryRelationKind) (w : WidthExpr)\n (a : Term) (b : Term) : Term\n| or (p1 p2 : Term) : Term\n| and (p1 p2 : Term) : Term\n| pvar (v : Nat) : Term\n| boolBinRel (k : BoolBinaryRelationKind)\n (a b : Term) : Term\nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : Nat → WidthExpr → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : (k : Nat) → (v : WidthExpr) → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "HNatFSMToBitstream",
"content": "structure HNatFSMToBitstream {wcard : Nat} {v : WidthExpr wcard} {tcard : Nat} {bcard : Nat} {pcard : Nat}\n (fsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v)) : Prop where\n heq :\n ∀ (wenv : Fin wcard → Nat)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HWidthEnv fsmEnv wenv) →\n fsm.toFsm.eval fsmEnv =\n BitStream.ofNatUnary (v.toNat wenv)"
},
{
"name": "WidthExpr.toNat",
"content": "def WidthExpr.toNat (e : WidthExpr wcard) (env : WidthExpr.Env wcard) : Nat :=\n match e with\n | .const n => n\n | .var v => env v\n | .min v w => Nat.min (v.toNat env) (w.toNat env)\n | .max v w => Nat.max (v.toNat env) (w.toNat env)\n | .addK v k => v.toNat env + k\n | .kadd k v => k + v.toNat env"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr (wcard : Nat) : Type\n| const (n : Nat) : WidthExpr wcard\n| var : (v : Fin wcard) → WidthExpr wcard\n| min : (v w : WidthExpr wcard) → WidthExpr wcard\n| max : (v w : WidthExpr wcard) → WidthExpr wcard\n| addK : (v : WidthExpr wcard) → (k : Nat) → WidthExpr wcard\n| kadd : (k : Nat) → (v : WidthExpr wcard) → WidthExpr wcard"
},
{
"name": "WidthExpr.Env",
"content": "abbrev WidthExpr.Env (wcard : Nat) : Type :=\n Fin wcard → Nat"
},
{
"name": "HWidthEnv",
"content": "structure HWidthEnv {wcard tcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (wenv : Fin wcard → Nat) : Prop where\n heq_width : ∀ (v : Fin wcard),\n fsmEnv (StateSpace.widthVar v) = BitStream.ofNatUnary (wenv v)"
},
{
"name": "HPredicateEnv",
"content": "structure HPredicateEnv {wcard tcard bcard ncard icard pcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (penv : Fin pcard → Prop) : Prop where\n heq_width : ∀ (v : Fin pcard),\n fsmEnv (StateSpace.predVar v) = BitStream.ofProp (penv v)"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "ofNatUnary",
"content": "abbrev ofNatUnary (n : Nat) : BitStream :=\n fun i => decide (i < n)"
},
{
"name": "HPredFSMToBitStream",
"content": "structure HPredFSMToBitStream {pcard : Nat}\n {tctx : Term.Ctx wcard tcard}\n {p : Term bcard ncard icard pcard tctx .prop}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard\n (.ofDepTerm p)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (htenv : HTermEnv fsmEnv tenv benv) →\n (hpenv : HPredicateEnv fsmEnv penv) →\n p.toBV benv nenv ienv penv tenv ↔ (fsm.toFsmZext.eval fsmEnv = .negOne)"
},
{
"name": "Term.Ctx",
"content": "abbrev Term.Ctx (wcard : Nat) (tcard : Nat) : Type :=\n Fin tcard → WidthExpr wcard"
},
{
"name": "Term.BoolEnv",
"content": "def Term.BoolEnv (bcard : Nat) : Type := Fin bcard → Bool"
},
{
"name": "Term.IntEnv",
"content": "def Term.IntEnv (icard : Nat) : Type := Fin icard → Nat"
},
{
"name": "HTermFSMToBitStream",
"content": "structure HTermFSMToBitStream {w : WidthExpr wcard}\n {tctx : Term.Ctx wcard tcard}\n {t : Term bcard ncard icard pcard tctx (.bv w)}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm t)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HTermEnv fsmEnv tenv benv) →\n fsm.toFsmZext.eval fsmEnv =\n BitStream.ofBitVecZext (t.toBV benv nenv ienv penv tenv)"
},
{
"name": "Predicate.Env",
"content": "def Predicate.Env (pcard : Nat) : Type :=\n Fin pcard → Prop"
},
{
"name": "TermKind",
"content": "inductive TermKind (wcard : Nat) : Type\n| bool\n| bv (w : WidthExpr wcard) : TermKind wcard\n| prop\n| nat\n| int"
},
{
"name": "HTermEnv",
"content": "structure HTermEnv {wcard tcard bcard : Nat}\n {wenv : Fin wcard → Nat} {tctx : Term.Ctx wcard tcard}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (tenv : tctx.Env wenv)\n (benv : Term.BoolEnv bcard) : Prop\n extends HWidthEnv fsmEnv wenv where\n heq_term : ∀ (v : Fin tcard),\n fsmEnv (StateSpace.termVar v) = BitStream.ofBitVecZext (tenv v)\n heq_bool : ∀ (v : Fin bcard),\n fsmEnv (StateSpace.boolVar v) = BitStream.ofBool (benv v)"
},
{
"name": "BitStream.ofBool",
"content": "noncomputable def BitStream.ofBool (b : Bool) : BitStream := fun _i => b"
},
{
"name": "Term.Ctx.Env",
"content": "abbrev Term.Ctx.Env\n (tctx : Term.Ctx wcard tcard)\n (wenv : WidthExpr.Env wcard) :=\n (v : Fin tcard) → BitVec ((tctx v).toNat wenv)"
},
{
"name": "ofBitVecZext",
"content": "abbrev ofBitVecZext {w} (x : BitVec w) : BitStream :=\n fun i => x.getLsbD i"
},
{
"name": "Term.NatEnv",
"content": "def Term.NatEnv (ncard : Nat) : Type := Fin ncard → Nat"
},
{
"name": "Term.toBV",
"content": "def Term.toBV {wenv : WidthExpr.Env wcard}\n {tctx : Term.Ctx wcard tcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard)\n (tenv : tctx.Env wenv)\n (t : Term bcard ncard icard pcard tctx k) : k.denote wenv :=\nmatch t with\n| .ofNat w n => BitVec.ofNat (w.toNat wenv) n\n| .boolConst b => b\n| .var v => tenv.get v.1 v.2\n| .add (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a + b\n| .zext a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .setWidth a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .sext a v => (a.toBV benv nenv ienv penv tenv).signExtend (v.toNat wenv)\n| .bor a b (w := w) =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ||| b\n| .band (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a &&& b\n| .bxor (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ^^^ b\n| .bnot (w := w) a =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n ~~~ a\n| .boolVar v => benv v\n| .shiftl (w := w) a k =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n a <<< k\n| .bvOfBool b => BitVec.ofBool (b.toBV benv nenv ienv penv tenv)\n\n| .binWidthRel rel wa wb =>\n match rel with\n | .eq => wa.toNat wenv = wb.toNat wenv\n | .le => wa.toNat wenv ≤ wb.toNat wenv\n| .binRel rel _w a b =>\n match rel with\n | .eq => a.toBV benv nenv ienv penv tenv = b.toBV benv nenv ienv penv tenv\n | .ne => a.toBV benv nenv ienv penv tenv ≠ b.toBV benv nenv ienv penv tenv\n | .ult => (a.toBV benv nenv ienv penv tenv).ult (b.toBV benv nenv ienv penv tenv) = true\n | .ule => (a.toBV benv nenv ienv penv tenv).ule (b.toBV benv nenv ienv penv tenv) = true\n | .slt => (a.toBV benv nenv ienv penv tenv).slt (b.toBV benv nenv ienv penv tenv) = true\n | .sle => (a.toBV benv nenv ienv penv tenv).sle (b.toBV benv nenv ienv penv tenv) = true\n| .and p1 p2 => p1.toBV benv nenv ienv penv tenv ∧ p2.toBV benv nenv ienv penv tenv\n| .or p1 p2 => p1.toBV benv nenv ienv penv tenv ∨ p2.toBV benv nenv ienv penv tenv\n| .boolBinRel rel a b =>\n match rel with\n \n | .eq => (a.toBV benv nenv ienv penv tenv) = (b.toBV benv nenv ienv penv tenv)\n| .pvar v => penv v"
},
{
"name": "Term",
"content": "inductive Term {wcard tcard : Nat} (bcard : Nat) (ncard : Nat) (icard : Nat) (pcard : Nat)\n (tctx : Term.Ctx wcard tcard) : TermKind wcard → Type\n\n \n| ofNat (w : WidthExpr wcard) (n : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| var (v : Fin tcard) : Term bcard ncard icard pcard tctx (.bv (tctx v))\n \n| add (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| shiftl (a : Term bcard ncard icard pcard tctx (.bv w)) (k : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| band (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bxor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bnot (a : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| zext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| setWidth (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| sext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| bvOfBool (b : Term bcard ncard icard pcard tctx .bool) : Term bcard ncard icard pcard tctx (.bv (.const 1))\n\n| boolConst (b : Bool) : Term bcard ncard icard pcard tctx .bool\n| boolVar (v : Fin bcard) : Term bcard ncard icard pcard tctx .bool\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr wcard) :\n Term bcard ncard icard pcard tctx .prop\n| binRel\n (k : BinaryRelationKind)\n (w : WidthExpr wcard)\n (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) :\n Term bcard ncard icard pcard tctx .prop\n| and (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| or (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| pvar (v : Fin pcard) : Term bcard ncard icard pcard tctx (.prop) \n\n\n| boolBinRel\n (k : BoolBinaryRelationKind)\n (a b : Term bcard ncard icard pcard tctx .bool) :\n Term bcard ncard icard pcard tctx (.prop)"
},
{
"name": "Term.Ctx.Env.get",
"content": "def Term.Ctx.Env.get {tcard : Nat}\n {wcard : Nat} {wenv : Fin wcard → Nat}\n {tctx : Term.Ctx wcard tcard}\n (tenv : tctx.Env wenv) (i : Nat) (hi : i < tcard) :\n BitVec ((tctx ⟨i, hi⟩).toNat wenv) :=\n tenv ⟨i, hi⟩"
},
{
"name": "BinaryRelationKind",
"content": "inductive BinaryRelationKind\n| eq\n| ne\n| ule\n| slt\n| sle\n| ult \nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "WidthBinaryRelationKind",
"content": "inductive WidthBinaryRelationKind\n| eq\n| le\n\n\nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "carry'",
"content": "def carry' (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n =>\n match n with\n | 0 => initCarry\n | n + 1 => (addAux' initCarry x y n).2"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
}
] | [
{
"name": "BitVec.msb_eq_getLsbD_last",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.getElem_signExtend",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.of_length_zero",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.slt_eq_not_carry",
"module": "Init.Data.BitVec.Bitblast"
}
] | [
{
"name": "carry'_eq_carry",
"content": "protected theorem carry'_eq_carry (x y : BitStream) (c : Bool)\n (x' y' : BitVec w)\n (hx : ∀ i, i < n → x'.getLsbD i = x i)\n (hy : ∀ i, i < n → y'.getLsbD i = y i) :\n carry' c x y n = (BitVec.carry n x' y' c)"
},
{
"name": "carry'_succ",
"content": "@[simp] theorem carry'_succ (initCarry : Bool) (x y : BitStream) :\n (carry' initCarry x y (i + 1)) =\n let out"
}
] | [
{
"name": "MultiWidth.fsmMsb",
"content": "def fsmMsb (x w : FSM α) : FSM α :=\n composeBinaryAux'\n (FSM.latchImmediate false)\n (qfalse := x)\n (qtrue := w)"
},
{
"name": "MultiWidth.fsmCarry''",
"content": "def fsmCarry'' (initialCarryVal : Bool): FSM Bool :=\n let outputCirc :=\n let carry := Circuit.var true (Sum.inl ())\n let a := Circuit.var true (Sum.inr true)\n let b := Circuit.var true (Sum.inr false)\n \n ((a &&& b) ||| (a &&& carry) ||| (b &&& carry))\n { α := Unit,\n \n \n initCarry := fun () => initialCarryVal, \n outputCirc := Circuit.var true (Sum.inl ()) ,\n nextStateCirc := fun () => outputCirc\n }"
},
{
"name": "MultiWidth.fsmMsbEq",
"content": "def fsmMsbEq (a : FSM α) (b : FSM α) : FSM α :=\n composeUnaryAux (FSM.ls false) <|\n composeBinaryAux' FSM.xor a b"
},
{
"name": "MultiWidth.fsmTermSlt",
"content": "def fsmTermSlt\n {wcard tcard : Nat}\n {w : Nondep.WidthExpr}\n {a b : Nondep.Term}\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard w)\n (afsm : TermFSM wcard tcard bcard ncard icard pcard a)\n (bfsm : TermFSM wcard tcard bcard ncard icard pcard b)\n : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n let afsm := afsm.toFsmZext\n let bfsm := bfsm.toFsmZext\n let afsm := fsmMsb afsm wfsm.toFsm\n let bfsm := fsmMsb bfsm wfsm.toFsm\n let carryFsm :=\n (~~~ (composeBinaryAux' (fsmCarry'' true) afsm (~~~ bfsm)))\n let xorFsm := fsmMsbEq afsm bfsm\n let val := xorFsm ^^^ carryFsm\n val"
}
] | [
{
"name": "MultiWidth.eval_fsmMsb_eq",
"content": "@[simp]\ntheorem eval_fsmMsb_eq {wcard bcard tcard : Nat}\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n {tctx : Term.Ctx wcard tcard}\n (tenv : Term.Ctx.Env tctx wenv)\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (w : WidthExpr wcard)\n (x : Term bcard ncard icard pcard tctx (.bv w))\n (xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))\n (hxfsm : HTermFSMToBitStream xfsm)\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n (hwfsm : HNatFSMToBitstream wfsm)\n (htenv : HTermEnv fsmEnv tenv benv) :\n (fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv = (fun i =>\n BitStream.ofBitVecZext (x.toBV benv nenv ienv penv tenv) (min i (w.toNat wenv - 1)))"
},
{
"name": "MultiWidth.eval_fsmMsb_eq_BitStream_ofBitVecSext",
"content": "theorem eval_fsmMsb_eq_BitStream_ofBitVecSext {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n {tctx : Term.Ctx wcard tcard}\n (tenv : Term.Ctx.Env tctx wenv)\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (w : WidthExpr wcard)\n (x : Term bcard ncard icard pcard tctx (.bv w))\n (xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))\n (hxfsm : HTermFSMToBitStream xfsm)\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n (hwfsm : HNatFSMToBitstream wfsm)\n (htenv : HTermEnv fsmEnv tenv benv) :\n (fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv =\n BitStream.ofBitVecSext (x.toBV benv nenv ienv penv tenv)"
}
] | import Blase.Fast.FiniteStateMachine
import Blase.Vars
import Blase.MultiWidth.Defs
import Blase.KInduction.KInduction
import Lean
namespace MultiWidth
def fsmMsb (x w : FSM α) : FSM α :=
composeBinaryAux'
(FSM.latchImmediate false)
(qfalse := x)
(qtrue := w)
def fsmCarry'' (initialCarryVal : Bool): FSM Bool :=
let outputCirc :=
let carry := Circuit.var true (Sum.inl ())
let a := Circuit.var true (Sum.inr true)
let b := Circuit.var true (Sum.inr false)
((a &&& b) ||| (a &&& carry) ||| (b &&& carry))
{ α := Unit,
initCarry := fun () => initialCarryVal,
outputCirc := Circuit.var true (Sum.inl ()) ,
nextStateCirc := fun () => outputCirc
}
def fsmMsbEq (a : FSM α) (b : FSM α) : FSM α :=
composeUnaryAux (FSM.ls false) <|
composeBinaryAux' FSM.xor a b
def fsmTermSlt
{wcard tcard : Nat}
{w : Nondep.WidthExpr}
{a b : Nondep.Term}
(wfsm : NatFSM wcard tcard bcard ncard icard pcard w)
(afsm : TermFSM wcard tcard bcard ncard icard pcard a)
(bfsm : TermFSM wcard tcard bcard ncard icard pcard b)
: FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
let afsm := afsm.toFsmZext
let bfsm := bfsm.toFsmZext
let afsm := fsmMsb afsm wfsm.toFsm
let bfsm := fsmMsb bfsm wfsm.toFsm
let carryFsm :=
(~~~ (composeBinaryAux' (fsmCarry'' true) afsm (~~~ bfsm)))
let xorFsm := fsmMsbEq afsm bfsm
let val := xorFsm ^^^ carryFsm
val | theorem eval_fsmTermSlt_eq_decide_slt {wcard tcard : Nat}
(tctx : Term.Ctx wcard tcard)
{wenv : WidthExpr.Env wcard}
(tenv : tctx.Env wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(w : WidthExpr wcard)
(a : Term bcard ncard icard pcard tctx (.bv w))
(b : Term bcard ncard icard pcard tctx (.bv w))
(wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
(hwfsm : HNatFSMToBitstream wfsm)
(afsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm a))
(hafsm : HTermFSMToBitStream afsm)
(bfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm b))
(hbfsm : HTermFSMToBitStream bfsm)
(fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)
(henv : HTermEnv fsmEnv tenv benv)
:
((fsmTermSlt
wfsm
afsm
bfsm)).eval fsmEnv i =
decide (((a.toBV benv nenv ienv penv tenv).signExtend i).slt
((b.toBV benv nenv ienv penv tenv).signExtend i)) := | := by
simp [fsmTermSlt]
have := BitVec.slt_eq_not_carry
(x := (a.toBV benv nenv ienv penv tenv).signExtend i)
(y := (b.toBV benv nenv ienv penv tenv).signExtend i)
rw [this]
clear this
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext
(hxfsm := hafsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv)
(tenv := tenv) (htenv := henv)]
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext (hxfsm := hbfsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv)
(tenv := tenv) (htenv := henv)]
rw [BitStream.carry'_eq_carry
(x' := BitVec.signExtend i (Term.toBV benv nenv ienv penv tenv a))
(y' := ~~~ BitVec.signExtend i (Term.toBV benv nenv ienv penv tenv b))]
-- simp [fsmMsbEq]
· rcases i with rfl | i
· simp
simp [BitVec.of_length_zero]
simp [fsmMsbEq]
· simp [fsmMsbEq]
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext
(hxfsm := hafsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv)
(tenv := tenv) (htenv := henv)]
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext (hxfsm := hbfsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv)
(tenv := tenv) (htenv := henv)]
simp [BitStream.ofBitVecSext]
by_cases hi : i < w.toNat wenv
· simp [BitVec.msb_eq_getLsbD_last, BitVec.getElem_signExtend]
simp [hi]
grind [Bool]
· simp [BitVec.msb_eq_getLsbD_last, BitVec.getElem_signExtend]
simp [hi]
grind [Bool]
· intros j
intros hj
simp [hj]
simp [BitVec.getElem_signExtend]
simp [BitStream.ofBitVecSext]
by_cases hw : j < w.toNat wenv
· simp [hw]
· simp [hw]
· intros j
simp
intros hj
simp [hj]
simp [BitVec.getElem_signExtend]
simp [BitStream.ofBitVecSext]
by_cases hw : j < w.toNat wenv
· simp [hw]
· simp [hw] | 5 | 89 | false | Compiler |
311 | MultiWidth.eval_fsmTermSle_eq_decide_sle | theorem eval_fsmTermSle_eq_decide_sle {wcard tcard bcard : Nat}
(tctx : Term.Ctx wcard tcard)
{wenv : WidthExpr.Env wcard}
(tenv : tctx.Env wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(w : WidthExpr wcard)
(wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
(hwfsm : HNatFSMToBitstream wfsm)
(a : Term bcard ncard icard pcard tctx (.bv w))
(b : Term bcard ncard icard pcard tctx (.bv w))
(afsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm a))
(hafsm : HTermFSMToBitStream afsm)
(bfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm b))
(hbfsm : HTermFSMToBitStream bfsm)
(fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)
(henv : HTermEnv fsmEnv tenv benv)
:
((fsmTermSle
wfsm
afsm
bfsm)).eval fsmEnv i =
decide (((a.toBV benv nenv ienv penv tenv).signExtend i).sle
((b.toBV benv nenv ienv penv tenv).signExtend i)) | lean-mlir | Blase/Blase/MultiWidth/GoodFSM.lean | [
"import Blase.MultiWidth.Defs",
"import Blase.Vars",
"import Blase.KInduction.KInduction",
"import Lean",
"import Blase.Blase.Fast.BitStream",
"import Blase.Fast.FiniteStateMachine"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat.max",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.min",
"module": "Init.Data.Nat.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofBool",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.signExtend",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "BitVec.carry",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Bool.atLeastTwo",
"module": "Init.Data.BitVec.Bitblast"
}
] | [
{
"name": "syntax \"min\" : MLIR.Pretty.uniform_op",
"content": "syntax \"min\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "composeBinaryAux'",
"content": "def composeBinaryAux'\n (p : FSM Bool)\n (qtrue : FSM α)\n (qfalse : FSM α) :\n FSM α :=\n p.compose (α)\n (λ _ => α)\n (λ _ i => i)\n (λ b => match b with\n | true => qtrue\n | false => qfalse)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "xor",
"content": "def xor : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ^^^ Circuit.var true (inr false),\n nextStateCirc := Empty.elim\n }"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "latchImmediate",
"content": "def latchImmediate (initVal : Bool) : FSM Bool where\n α := Unit\n initCarry := fun _ => initVal\n outputCirc :=\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state\n nextStateCirc := fun () =>\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state"
},
{
"name": "ite",
"content": "def ite (cond t f : Circuit α) : Circuit α :=\n (cond &&& t) ||| (~~~ cond &&& f)"
},
{
"name": "TermFSM",
"content": "structure TermFSM (wcard tcard bcard ncard icard pcard : Nat) (t : Nondep.Term) where\n toFsmZext : FSM (StateSpace wcard tcard bcard ncard icard pcard)\n width : NatFSM wcard tcard bcard ncard icard pcard t.width"
},
{
"name": "NatFSM",
"content": "structure NatFSM (wcard tcard bcard ncard icard pcard : Nat) (v : Nondep.WidthExpr) where\n toFsm : FSM (StateSpace wcard tcard bcard ncard icard pcard)"
},
{
"name": "StateSpace",
"content": "inductive StateSpace (wcard tcard bcard ncard icard pcard : Nat)\n| widthVar (v : Fin wcard)\n| termVar (v : Fin tcard)\n| predVar (v : Fin pcard)\n| boolVar (v : Fin bcard)\nderiving DecidableEq, Repr, Hashable"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| bvOfBool (b : Term) : Term\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr) : Term\n| binRel (k : BinaryRelationKind) (w : WidthExpr)\n (a : Term) (b : Term) : Term\n| or (p1 p2 : Term) : Term\n| and (p1 p2 : Term) : Term\n| pvar (v : Nat) : Term\n| boolBinRel (k : BoolBinaryRelationKind)\n (a b : Term) : Term\nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : Nat → WidthExpr → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : (k : Nat) → (v : WidthExpr) → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "HNatFSMToBitstream",
"content": "structure HNatFSMToBitstream {wcard : Nat} {v : WidthExpr wcard} {tcard : Nat} {bcard : Nat} {pcard : Nat}\n (fsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v)) : Prop where\n heq :\n ∀ (wenv : Fin wcard → Nat)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HWidthEnv fsmEnv wenv) →\n fsm.toFsm.eval fsmEnv =\n BitStream.ofNatUnary (v.toNat wenv)"
},
{
"name": "WidthExpr.toNat",
"content": "def WidthExpr.toNat (e : WidthExpr wcard) (env : WidthExpr.Env wcard) : Nat :=\n match e with\n | .const n => n\n | .var v => env v\n | .min v w => Nat.min (v.toNat env) (w.toNat env)\n | .max v w => Nat.max (v.toNat env) (w.toNat env)\n | .addK v k => v.toNat env + k\n | .kadd k v => k + v.toNat env"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr (wcard : Nat) : Type\n| const (n : Nat) : WidthExpr wcard\n| var : (v : Fin wcard) → WidthExpr wcard\n| min : (v w : WidthExpr wcard) → WidthExpr wcard\n| max : (v w : WidthExpr wcard) → WidthExpr wcard\n| addK : (v : WidthExpr wcard) → (k : Nat) → WidthExpr wcard\n| kadd : (k : Nat) → (v : WidthExpr wcard) → WidthExpr wcard"
},
{
"name": "WidthExpr.Env",
"content": "abbrev WidthExpr.Env (wcard : Nat) : Type :=\n Fin wcard → Nat"
},
{
"name": "HWidthEnv",
"content": "structure HWidthEnv {wcard tcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (wenv : Fin wcard → Nat) : Prop where\n heq_width : ∀ (v : Fin wcard),\n fsmEnv (StateSpace.widthVar v) = BitStream.ofNatUnary (wenv v)"
},
{
"name": "HPredicateEnv",
"content": "structure HPredicateEnv {wcard tcard bcard ncard icard pcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (penv : Fin pcard → Prop) : Prop where\n heq_width : ∀ (v : Fin pcard),\n fsmEnv (StateSpace.predVar v) = BitStream.ofProp (penv v)"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "ofNatUnary",
"content": "abbrev ofNatUnary (n : Nat) : BitStream :=\n fun i => decide (i < n)"
},
{
"name": "HPredFSMToBitStream",
"content": "structure HPredFSMToBitStream {pcard : Nat}\n {tctx : Term.Ctx wcard tcard}\n {p : Term bcard ncard icard pcard tctx .prop}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard\n (.ofDepTerm p)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (htenv : HTermEnv fsmEnv tenv benv) →\n (hpenv : HPredicateEnv fsmEnv penv) →\n p.toBV benv nenv ienv penv tenv ↔ (fsm.toFsmZext.eval fsmEnv = .negOne)"
},
{
"name": "Term.Ctx",
"content": "abbrev Term.Ctx (wcard : Nat) (tcard : Nat) : Type :=\n Fin tcard → WidthExpr wcard"
},
{
"name": "Term.BoolEnv",
"content": "def Term.BoolEnv (bcard : Nat) : Type := Fin bcard → Bool"
},
{
"name": "Term.IntEnv",
"content": "def Term.IntEnv (icard : Nat) : Type := Fin icard → Nat"
},
{
"name": "HTermFSMToBitStream",
"content": "structure HTermFSMToBitStream {w : WidthExpr wcard}\n {tctx : Term.Ctx wcard tcard}\n {t : Term bcard ncard icard pcard tctx (.bv w)}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm t)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HTermEnv fsmEnv tenv benv) →\n fsm.toFsmZext.eval fsmEnv =\n BitStream.ofBitVecZext (t.toBV benv nenv ienv penv tenv)"
},
{
"name": "Predicate.Env",
"content": "def Predicate.Env (pcard : Nat) : Type :=\n Fin pcard → Prop"
},
{
"name": "TermKind",
"content": "inductive TermKind (wcard : Nat) : Type\n| bool\n| bv (w : WidthExpr wcard) : TermKind wcard\n| prop\n| nat\n| int"
},
{
"name": "HTermEnv",
"content": "structure HTermEnv {wcard tcard bcard : Nat}\n {wenv : Fin wcard → Nat} {tctx : Term.Ctx wcard tcard}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (tenv : tctx.Env wenv)\n (benv : Term.BoolEnv bcard) : Prop\n extends HWidthEnv fsmEnv wenv where\n heq_term : ∀ (v : Fin tcard),\n fsmEnv (StateSpace.termVar v) = BitStream.ofBitVecZext (tenv v)\n heq_bool : ∀ (v : Fin bcard),\n fsmEnv (StateSpace.boolVar v) = BitStream.ofBool (benv v)"
},
{
"name": "BitStream.ofBool",
"content": "noncomputable def BitStream.ofBool (b : Bool) : BitStream := fun _i => b"
},
{
"name": "Term.Ctx.Env",
"content": "abbrev Term.Ctx.Env\n (tctx : Term.Ctx wcard tcard)\n (wenv : WidthExpr.Env wcard) :=\n (v : Fin tcard) → BitVec ((tctx v).toNat wenv)"
},
{
"name": "ofBitVecZext",
"content": "abbrev ofBitVecZext {w} (x : BitVec w) : BitStream :=\n fun i => x.getLsbD i"
},
{
"name": "Term.NatEnv",
"content": "def Term.NatEnv (ncard : Nat) : Type := Fin ncard → Nat"
},
{
"name": "Term.toBV",
"content": "def Term.toBV {wenv : WidthExpr.Env wcard}\n {tctx : Term.Ctx wcard tcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard)\n (tenv : tctx.Env wenv)\n (t : Term bcard ncard icard pcard tctx k) : k.denote wenv :=\nmatch t with\n| .ofNat w n => BitVec.ofNat (w.toNat wenv) n\n| .boolConst b => b\n| .var v => tenv.get v.1 v.2\n| .add (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a + b\n| .zext a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .setWidth a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .sext a v => (a.toBV benv nenv ienv penv tenv).signExtend (v.toNat wenv)\n| .bor a b (w := w) =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ||| b\n| .band (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a &&& b\n| .bxor (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ^^^ b\n| .bnot (w := w) a =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n ~~~ a\n| .boolVar v => benv v\n| .shiftl (w := w) a k =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n a <<< k\n| .bvOfBool b => BitVec.ofBool (b.toBV benv nenv ienv penv tenv)\n\n| .binWidthRel rel wa wb =>\n match rel with\n | .eq => wa.toNat wenv = wb.toNat wenv\n | .le => wa.toNat wenv ≤ wb.toNat wenv\n| .binRel rel _w a b =>\n match rel with\n | .eq => a.toBV benv nenv ienv penv tenv = b.toBV benv nenv ienv penv tenv\n | .ne => a.toBV benv nenv ienv penv tenv ≠ b.toBV benv nenv ienv penv tenv\n | .ult => (a.toBV benv nenv ienv penv tenv).ult (b.toBV benv nenv ienv penv tenv) = true\n | .ule => (a.toBV benv nenv ienv penv tenv).ule (b.toBV benv nenv ienv penv tenv) = true\n | .slt => (a.toBV benv nenv ienv penv tenv).slt (b.toBV benv nenv ienv penv tenv) = true\n | .sle => (a.toBV benv nenv ienv penv tenv).sle (b.toBV benv nenv ienv penv tenv) = true\n| .and p1 p2 => p1.toBV benv nenv ienv penv tenv ∧ p2.toBV benv nenv ienv penv tenv\n| .or p1 p2 => p1.toBV benv nenv ienv penv tenv ∨ p2.toBV benv nenv ienv penv tenv\n| .boolBinRel rel a b =>\n match rel with\n \n | .eq => (a.toBV benv nenv ienv penv tenv) = (b.toBV benv nenv ienv penv tenv)\n| .pvar v => penv v"
},
{
"name": "Term",
"content": "inductive Term {wcard tcard : Nat} (bcard : Nat) (ncard : Nat) (icard : Nat) (pcard : Nat)\n (tctx : Term.Ctx wcard tcard) : TermKind wcard → Type\n\n \n| ofNat (w : WidthExpr wcard) (n : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| var (v : Fin tcard) : Term bcard ncard icard pcard tctx (.bv (tctx v))\n \n| add (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| shiftl (a : Term bcard ncard icard pcard tctx (.bv w)) (k : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| band (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bxor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bnot (a : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| zext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| setWidth (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| sext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| bvOfBool (b : Term bcard ncard icard pcard tctx .bool) : Term bcard ncard icard pcard tctx (.bv (.const 1))\n\n| boolConst (b : Bool) : Term bcard ncard icard pcard tctx .bool\n| boolVar (v : Fin bcard) : Term bcard ncard icard pcard tctx .bool\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr wcard) :\n Term bcard ncard icard pcard tctx .prop\n| binRel\n (k : BinaryRelationKind)\n (w : WidthExpr wcard)\n (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) :\n Term bcard ncard icard pcard tctx .prop\n| and (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| or (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| pvar (v : Fin pcard) : Term bcard ncard icard pcard tctx (.prop) \n\n\n| boolBinRel\n (k : BoolBinaryRelationKind)\n (a b : Term bcard ncard icard pcard tctx .bool) :\n Term bcard ncard icard pcard tctx (.prop)"
},
{
"name": "Term.Ctx.Env.get",
"content": "def Term.Ctx.Env.get {tcard : Nat}\n {wcard : Nat} {wenv : Fin wcard → Nat}\n {tctx : Term.Ctx wcard tcard}\n (tenv : tctx.Env wenv) (i : Nat) (hi : i < tcard) :\n BitVec ((tctx ⟨i, hi⟩).toNat wenv) :=\n tenv ⟨i, hi⟩"
},
{
"name": "BinaryRelationKind",
"content": "inductive BinaryRelationKind\n| eq\n| ne\n| ule\n| slt\n| sle\n| ult \nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "WidthBinaryRelationKind",
"content": "inductive WidthBinaryRelationKind\n| eq\n| le\n\n\nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "carry'",
"content": "def carry' (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n =>\n match n with\n | 0 => initCarry\n | n + 1 => (addAux' initCarry x y n).2"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
}
] | [
{
"name": "BitVec.msb_eq_getLsbD_last",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.getElem_signExtend",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.of_length_zero",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.sle_eq_carry",
"module": "Init.Data.BitVec.Bitblast"
}
] | [
{
"name": "carry'_eq_carry",
"content": "protected theorem carry'_eq_carry (x y : BitStream) (c : Bool)\n (x' y' : BitVec w)\n (hx : ∀ i, i < n → x'.getLsbD i = x i)\n (hy : ∀ i, i < n → y'.getLsbD i = y i) :\n carry' c x y n = (BitVec.carry n x' y' c)"
},
{
"name": "carry'_succ",
"content": "@[simp] theorem carry'_succ (initCarry : Bool) (x y : BitStream) :\n (carry' initCarry x y (i + 1)) =\n let out"
}
] | [
{
"name": "MultiWidth.fsmMsb",
"content": "def fsmMsb (x w : FSM α) : FSM α :=\n composeBinaryAux'\n (FSM.latchImmediate false)\n (qfalse := x)\n (qtrue := w)"
},
{
"name": "MultiWidth.fsmCarry''",
"content": "def fsmCarry'' (initialCarryVal : Bool): FSM Bool :=\n let outputCirc :=\n let carry := Circuit.var true (Sum.inl ())\n let a := Circuit.var true (Sum.inr true)\n let b := Circuit.var true (Sum.inr false)\n \n ((a &&& b) ||| (a &&& carry) ||| (b &&& carry))\n { α := Unit,\n \n \n initCarry := fun () => initialCarryVal, \n outputCirc := Circuit.var true (Sum.inl ()) ,\n nextStateCirc := fun () => outputCirc\n }"
},
{
"name": "MultiWidth.fsmMsbEq",
"content": "def fsmMsbEq (a : FSM α) (b : FSM α) : FSM α :=\n composeUnaryAux (FSM.ls false) <|\n composeBinaryAux' FSM.xor a b"
},
{
"name": "MultiWidth.fsmTermSle",
"content": "def fsmTermSle\n {wcard tcard : Nat}\n {w : Nondep.WidthExpr}\n {a b : Nondep.Term}\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard w)\n (afsm : TermFSM wcard tcard bcard ncard icard pcard a)\n (bfsm : TermFSM wcard tcard bcard ncard icard pcard b)\n : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n let afsm := afsm.toFsmZext\n let bfsm := bfsm.toFsmZext\n let afsm := fsmMsb afsm wfsm.toFsm\n let bfsm := fsmMsb bfsm wfsm.toFsm\n let carryFsm :=\n ((composeBinaryAux' (fsmCarry'' true) bfsm (~~~ afsm)))\n let xorFsm := fsmMsbEq afsm bfsm\n ~~~ ((~~~ xorFsm) ^^^ carryFsm)"
}
] | [
{
"name": "MultiWidth.eval_fsmMsb_eq",
"content": "@[simp]\ntheorem eval_fsmMsb_eq {wcard bcard tcard : Nat}\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n {tctx : Term.Ctx wcard tcard}\n (tenv : Term.Ctx.Env tctx wenv)\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (w : WidthExpr wcard)\n (x : Term bcard ncard icard pcard tctx (.bv w))\n (xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))\n (hxfsm : HTermFSMToBitStream xfsm)\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n (hwfsm : HNatFSMToBitstream wfsm)\n (htenv : HTermEnv fsmEnv tenv benv) :\n (fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv = (fun i =>\n BitStream.ofBitVecZext (x.toBV benv nenv ienv penv tenv) (min i (w.toNat wenv - 1)))"
},
{
"name": "MultiWidth.eval_fsmMsb_eq_BitStream_ofBitVecSext",
"content": "theorem eval_fsmMsb_eq_BitStream_ofBitVecSext {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n {tctx : Term.Ctx wcard tcard}\n (tenv : Term.Ctx.Env tctx wenv)\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (w : WidthExpr wcard)\n (x : Term bcard ncard icard pcard tctx (.bv w))\n (xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))\n (hxfsm : HTermFSMToBitStream xfsm)\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n (hwfsm : HNatFSMToBitstream wfsm)\n (htenv : HTermEnv fsmEnv tenv benv) :\n (fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv =\n BitStream.ofBitVecSext (x.toBV benv nenv ienv penv tenv)"
}
] | import Blase.Fast.FiniteStateMachine
import Blase.Vars
import Blase.MultiWidth.Defs
import Blase.KInduction.KInduction
import Lean
namespace MultiWidth
def fsmMsb (x w : FSM α) : FSM α :=
composeBinaryAux'
(FSM.latchImmediate false)
(qfalse := x)
(qtrue := w)
def fsmCarry'' (initialCarryVal : Bool): FSM Bool :=
let outputCirc :=
let carry := Circuit.var true (Sum.inl ())
let a := Circuit.var true (Sum.inr true)
let b := Circuit.var true (Sum.inr false)
((a &&& b) ||| (a &&& carry) ||| (b &&& carry))
{ α := Unit,
initCarry := fun () => initialCarryVal,
outputCirc := Circuit.var true (Sum.inl ()) ,
nextStateCirc := fun () => outputCirc
}
def fsmMsbEq (a : FSM α) (b : FSM α) : FSM α :=
composeUnaryAux (FSM.ls false) <|
composeBinaryAux' FSM.xor a b
def fsmTermSle
{wcard tcard : Nat}
{w : Nondep.WidthExpr}
{a b : Nondep.Term}
(wfsm : NatFSM wcard tcard bcard ncard icard pcard w)
(afsm : TermFSM wcard tcard bcard ncard icard pcard a)
(bfsm : TermFSM wcard tcard bcard ncard icard pcard b)
: FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
let afsm := afsm.toFsmZext
let bfsm := bfsm.toFsmZext
let afsm := fsmMsb afsm wfsm.toFsm
let bfsm := fsmMsb bfsm wfsm.toFsm
let carryFsm :=
((composeBinaryAux' (fsmCarry'' true) bfsm (~~~ afsm)))
let xorFsm := fsmMsbEq afsm bfsm
~~~ ((~~~ xorFsm) ^^^ carryFsm) | theorem eval_fsmTermSle_eq_decide_sle {wcard tcard bcard : Nat}
(tctx : Term.Ctx wcard tcard)
{wenv : WidthExpr.Env wcard}
(tenv : tctx.Env wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(w : WidthExpr wcard)
(wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
(hwfsm : HNatFSMToBitstream wfsm)
(a : Term bcard ncard icard pcard tctx (.bv w))
(b : Term bcard ncard icard pcard tctx (.bv w))
(afsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm a))
(hafsm : HTermFSMToBitStream afsm)
(bfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm b))
(hbfsm : HTermFSMToBitStream bfsm)
(fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)
(henv : HTermEnv fsmEnv tenv benv)
:
((fsmTermSle
wfsm
afsm
bfsm)).eval fsmEnv i =
decide (((a.toBV benv nenv ienv penv tenv).signExtend i).sle
((b.toBV benv nenv ienv penv tenv).signExtend i)) := | := by
have := BitVec.sle_eq_carry
(x := (a.toBV benv nenv ienv penv tenv).signExtend i)
(y := (b.toBV benv nenv ienv penv tenv).signExtend i)
rw [this]
clear this
simp [fsmTermSle]
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext (hxfsm := hafsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv) (tenv := tenv) (htenv := henv)]
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext (hxfsm := hbfsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv) (tenv := tenv) (htenv := henv)]
rw [BitStream.carry'_eq_carry
(x' := BitVec.signExtend i (Term.toBV benv nenv ienv penv tenv b))
(y' := ~~~ BitVec.signExtend i (Term.toBV benv nenv ienv penv tenv a))]
simp [fsmMsbEq]
· rcases i with rfl | i
· simp
simp [BitVec.of_length_zero]
· simp [eval_fsmMsb_eq_BitStream_ofBitVecSext (hxfsm := hafsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv) (tenv := tenv) (htenv := henv)]
simp [eval_fsmMsb_eq_BitStream_ofBitVecSext (hxfsm := hbfsm) (hwfsm := hwfsm)
(benv := benv) (nenv := nenv) (ienv := ienv) (penv := penv) (tenv := tenv) (htenv := henv)]
simp [BitStream.ofBitVecSext]
by_cases hi : i < w.toNat wenv
· simp [BitVec.msb_eq_getLsbD_last, BitVec.getElem_signExtend]
simp [hi]
grind [Bool]
· simp [BitVec.msb_eq_getLsbD_last, BitVec.getElem_signExtend]
simp [hi]
grind [Bool]
· intros j
intros hj
simp [hj]
simp [BitVec.getElem_signExtend]
simp [BitStream.ofBitVecSext]
by_cases hw : j < w.toNat wenv
· simp [hw]
· simp [hw]
· intros j
simp
intros hj
simp [hj]
simp [BitVec.getElem_signExtend]
simp [BitStream.ofBitVecSext]
by_cases hw : j < w.toNat wenv
· simp [hw]
· simp [hw] | 5 | 89 | false | Compiler |
312 | MultiWidth.fsmSext_eval_eq | theorem fsmSext_eval_eq
(woldFsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep wold))
(wnewFsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep wnew))
{wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
(hwnew : HNatFSMToBitstream wnewFsm)
(hwold : HNatFSMToBitstream woldFsm)
{tctx : Term.Ctx wcard tcard}
(tenv : Term.Ctx.Env tctx wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(t : Term bcard ncard icard pcard tctx (.bv wold))
(tFsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm t))
(htfsm : HTermFSMToBitStream tFsm)
(htenv : HTermEnv fsmEnv tenv benv) :
(fsmSext tFsm.toFsmZext woldFsm.toFsm wnewFsm.toFsm).eval fsmEnv = fun i =>
((BitStream.ofBitVecZext ((Term.sext t wnew).toBV benv nenv ienv penv tenv))) i | lean-mlir | Blase/Blase/MultiWidth/GoodFSM.lean | [
"import Blase.MultiWidth.Defs",
"import Blase.Vars",
"import Blase.KInduction.KInduction",
"import Lean",
"import Blase.Blase.Fast.FiniteStateMachine",
"import Blase.Blase.Fast.BitStream",
"import Blase.Fast.FiniteStateMachine"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat.max",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.min",
"module": "Init.Data.Nat.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofBool",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
}
] | [
{
"name": "syntax \"min\" : MLIR.Pretty.uniform_op",
"content": "syntax \"min\" : MLIR.Pretty.uniform_op\n\nsyntax \"slt\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "composeBinaryAux'",
"content": "def composeBinaryAux'\n (p : FSM Bool)\n (qtrue : FSM α)\n (qfalse : FSM α) :\n FSM α :=\n p.compose (α)\n (λ _ => α)\n (λ _ i => i)\n (λ b => match b with\n | true => qtrue\n | false => qfalse)"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "latchImmediate",
"content": "def latchImmediate (initVal : Bool) : FSM Bool where\n α := Unit\n initCarry := fun _ => initVal\n outputCirc :=\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state\n nextStateCirc := fun () =>\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state"
},
{
"name": "ite",
"content": "def ite (cond t f : Circuit α) : Circuit α :=\n (cond &&& t) ||| (~~~ cond &&& f)"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| mul (w : WidthExpr) (a b : Term) : Term\n| udiv (w : WidthExpr) (a b : Term) : Term\n| umod (w : WidthExpr) (a b : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| junk (s : String) : Term \nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "TermFSM",
"content": "structure TermFSM (wcard tcard bcard ncard icard pcard : Nat) (t : Nondep.Term) where\n toFsmZext : FSM (StateSpace wcard tcard bcard ncard icard pcard)\n width : NatFSM wcard tcard bcard ncard icard pcard t.width"
},
{
"name": "NatFSM",
"content": "structure NatFSM (wcard tcard bcard ncard icard pcard : Nat) (v : Nondep.WidthExpr) where\n toFsm : FSM (StateSpace wcard tcard bcard ncard icard pcard)"
},
{
"name": "StateSpace",
"content": "inductive StateSpace (wcard tcard bcard ncard icard pcard : Nat)\n| widthVar (v : Fin wcard)\n| termVar (v : Fin tcard)\n| predVar (v : Fin pcard)\n| boolVar (v : Fin bcard)\nderiving DecidableEq, Repr, Hashable"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| bvOfBool (b : Term) : Term\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr) : Term\n| binRel (k : BinaryRelationKind) (w : WidthExpr)\n (a : Term) (b : Term) : Term\n| or (p1 p2 : Term) : Term\n| and (p1 p2 : Term) : Term\n| pvar (v : Nat) : Term\n| boolBinRel (k : BoolBinaryRelationKind)\n (a b : Term) : Term\nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : Nat → WidthExpr → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : (k : Nat) → (v : WidthExpr) → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "HNatFSMToBitstream",
"content": "structure HNatFSMToBitstream {wcard : Nat} {v : WidthExpr wcard} {tcard : Nat} {bcard : Nat} {pcard : Nat}\n (fsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v)) : Prop where\n heq :\n ∀ (wenv : Fin wcard → Nat)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HWidthEnv fsmEnv wenv) →\n fsm.toFsm.eval fsmEnv =\n BitStream.ofNatUnary (v.toNat wenv)"
},
{
"name": "WidthExpr.toNat",
"content": "def WidthExpr.toNat (e : WidthExpr wcard) (env : WidthExpr.Env wcard) : Nat :=\n match e with\n | .const n => n\n | .var v => env v\n | .min v w => Nat.min (v.toNat env) (w.toNat env)\n | .max v w => Nat.max (v.toNat env) (w.toNat env)\n | .addK v k => v.toNat env + k\n | .kadd k v => k + v.toNat env"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr (wcard : Nat) : Type\n| const (n : Nat) : WidthExpr wcard\n| var : (v : Fin wcard) → WidthExpr wcard\n| min : (v w : WidthExpr wcard) → WidthExpr wcard\n| max : (v w : WidthExpr wcard) → WidthExpr wcard\n| addK : (v : WidthExpr wcard) → (k : Nat) → WidthExpr wcard\n| kadd : (k : Nat) → (v : WidthExpr wcard) → WidthExpr wcard"
},
{
"name": "WidthExpr.Env",
"content": "abbrev WidthExpr.Env (wcard : Nat) : Type :=\n Fin wcard → Nat"
},
{
"name": "HWidthEnv",
"content": "structure HWidthEnv {wcard tcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (wenv : Fin wcard → Nat) : Prop where\n heq_width : ∀ (v : Fin wcard),\n fsmEnv (StateSpace.widthVar v) = BitStream.ofNatUnary (wenv v)"
},
{
"name": "HPredicateEnv",
"content": "structure HPredicateEnv {wcard tcard bcard ncard icard pcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (penv : Fin pcard → Prop) : Prop where\n heq_width : ∀ (v : Fin pcard),\n fsmEnv (StateSpace.predVar v) = BitStream.ofProp (penv v)"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "ofNatUnary",
"content": "abbrev ofNatUnary (n : Nat) : BitStream :=\n fun i => decide (i < n)"
},
{
"name": "HPredFSMToBitStream",
"content": "structure HPredFSMToBitStream {pcard : Nat}\n {tctx : Term.Ctx wcard tcard}\n {p : Term bcard ncard icard pcard tctx .prop}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard\n (.ofDepTerm p)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (htenv : HTermEnv fsmEnv tenv benv) →\n (hpenv : HPredicateEnv fsmEnv penv) →\n p.toBV benv nenv ienv penv tenv ↔ (fsm.toFsmZext.eval fsmEnv = .negOne)"
},
{
"name": "Term.Ctx",
"content": "abbrev Term.Ctx (wcard : Nat) (tcard : Nat) : Type :=\n Fin tcard → WidthExpr wcard"
},
{
"name": "Term.BoolEnv",
"content": "def Term.BoolEnv (bcard : Nat) : Type := Fin bcard → Bool"
},
{
"name": "Term.IntEnv",
"content": "def Term.IntEnv (icard : Nat) : Type := Fin icard → Nat"
},
{
"name": "ofBitVecZext",
"content": "abbrev ofBitVecZext {w} (x : BitVec w) : BitStream :=\n fun i => x.getLsbD i"
},
{
"name": "HTermFSMToBitStream",
"content": "structure HTermFSMToBitStream {w : WidthExpr wcard}\n {tctx : Term.Ctx wcard tcard}\n {t : Term bcard ncard icard pcard tctx (.bv w)}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm t)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HTermEnv fsmEnv tenv benv) →\n fsm.toFsmZext.eval fsmEnv =\n BitStream.ofBitVecZext (t.toBV benv nenv ienv penv tenv)"
},
{
"name": "Predicate.Env",
"content": "def Predicate.Env (pcard : Nat) : Type :=\n Fin pcard → Prop"
},
{
"name": "TermKind",
"content": "inductive TermKind (wcard : Nat) : Type\n| bool\n| bv (w : WidthExpr wcard) : TermKind wcard\n| prop\n| nat\n| int"
},
{
"name": "HTermEnv",
"content": "structure HTermEnv {wcard tcard bcard : Nat}\n {wenv : Fin wcard → Nat} {tctx : Term.Ctx wcard tcard}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (tenv : tctx.Env wenv)\n (benv : Term.BoolEnv bcard) : Prop\n extends HWidthEnv fsmEnv wenv where\n heq_term : ∀ (v : Fin tcard),\n fsmEnv (StateSpace.termVar v) = BitStream.ofBitVecZext (tenv v)\n heq_bool : ∀ (v : Fin bcard),\n fsmEnv (StateSpace.boolVar v) = BitStream.ofBool (benv v)"
},
{
"name": "BitStream.ofBool",
"content": "noncomputable def BitStream.ofBool (b : Bool) : BitStream := fun _i => b"
},
{
"name": "Term.Ctx.Env",
"content": "abbrev Term.Ctx.Env\n (tctx : Term.Ctx wcard tcard)\n (wenv : WidthExpr.Env wcard) :=\n (v : Fin tcard) → BitVec ((tctx v).toNat wenv)"
},
{
"name": "Term.NatEnv",
"content": "def Term.NatEnv (ncard : Nat) : Type := Fin ncard → Nat"
},
{
"name": "Term.toBV",
"content": "def Term.toBV {wenv : WidthExpr.Env wcard}\n {tctx : Term.Ctx wcard tcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard)\n (tenv : tctx.Env wenv)\n (t : Term bcard ncard icard pcard tctx k) : k.denote wenv :=\nmatch t with\n| .ofNat w n => BitVec.ofNat (w.toNat wenv) n\n| .boolConst b => b\n| .var v => tenv.get v.1 v.2\n| .add (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a + b\n| .zext a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .setWidth a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .sext a v => (a.toBV benv nenv ienv penv tenv).signExtend (v.toNat wenv)\n| .bor a b (w := w) =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ||| b\n| .band (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a &&& b\n| .bxor (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ^^^ b\n| .bnot (w := w) a =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n ~~~ a\n| .boolVar v => benv v\n| .shiftl (w := w) a k =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n a <<< k\n| .bvOfBool b => BitVec.ofBool (b.toBV benv nenv ienv penv tenv)\n\n| .binWidthRel rel wa wb =>\n match rel with\n | .eq => wa.toNat wenv = wb.toNat wenv\n | .le => wa.toNat wenv ≤ wb.toNat wenv\n| .binRel rel _w a b =>\n match rel with\n | .eq => a.toBV benv nenv ienv penv tenv = b.toBV benv nenv ienv penv tenv\n | .ne => a.toBV benv nenv ienv penv tenv ≠ b.toBV benv nenv ienv penv tenv\n | .ult => (a.toBV benv nenv ienv penv tenv).ult (b.toBV benv nenv ienv penv tenv) = true\n | .ule => (a.toBV benv nenv ienv penv tenv).ule (b.toBV benv nenv ienv penv tenv) = true\n | .slt => (a.toBV benv nenv ienv penv tenv).slt (b.toBV benv nenv ienv penv tenv) = true\n | .sle => (a.toBV benv nenv ienv penv tenv).sle (b.toBV benv nenv ienv penv tenv) = true\n| .and p1 p2 => p1.toBV benv nenv ienv penv tenv ∧ p2.toBV benv nenv ienv penv tenv\n| .or p1 p2 => p1.toBV benv nenv ienv penv tenv ∨ p2.toBV benv nenv ienv penv tenv\n| .boolBinRel rel a b =>\n match rel with\n \n | .eq => (a.toBV benv nenv ienv penv tenv) = (b.toBV benv nenv ienv penv tenv)\n| .pvar v => penv v"
},
{
"name": "Term",
"content": "inductive Term {wcard tcard : Nat} (bcard : Nat) (ncard : Nat) (icard : Nat) (pcard : Nat)\n (tctx : Term.Ctx wcard tcard) : TermKind wcard → Type\n\n \n| ofNat (w : WidthExpr wcard) (n : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| var (v : Fin tcard) : Term bcard ncard icard pcard tctx (.bv (tctx v))\n \n| add (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| shiftl (a : Term bcard ncard icard pcard tctx (.bv w)) (k : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| band (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bxor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bnot (a : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| zext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| setWidth (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| sext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| bvOfBool (b : Term bcard ncard icard pcard tctx .bool) : Term bcard ncard icard pcard tctx (.bv (.const 1))\n\n| boolConst (b : Bool) : Term bcard ncard icard pcard tctx .bool\n| boolVar (v : Fin bcard) : Term bcard ncard icard pcard tctx .bool\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr wcard) :\n Term bcard ncard icard pcard tctx .prop\n| binRel\n (k : BinaryRelationKind)\n (w : WidthExpr wcard)\n (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) :\n Term bcard ncard icard pcard tctx .prop\n| and (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| or (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| pvar (v : Fin pcard) : Term bcard ncard icard pcard tctx (.prop) \n\n\n| boolBinRel\n (k : BoolBinaryRelationKind)\n (a b : Term bcard ncard icard pcard tctx .bool) :\n Term bcard ncard icard pcard tctx (.prop)"
},
{
"name": "Term.Ctx.Env.get",
"content": "def Term.Ctx.Env.get {tcard : Nat}\n {wcard : Nat} {wenv : Fin wcard → Nat}\n {tctx : Term.Ctx wcard tcard}\n (tenv : tctx.Env wenv) (i : Nat) (hi : i < tcard) :\n BitVec ((tctx ⟨i, hi⟩).toNat wenv) :=\n tenv ⟨i, hi⟩"
},
{
"name": "BinaryRelationKind",
"content": "inductive BinaryRelationKind\n| eq\n| ne\n| ule\n| slt\n| sle\n| ult \nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "WidthBinaryRelationKind",
"content": "inductive WidthBinaryRelationKind\n| eq\n| le\n\n\nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "eval",
"content": "def eval (x : arity → BitStream) : BitStream :=\n fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2"
},
{
"name": "nextBit",
"content": "def nextBit : p.State → (arity → Bool) → p.State × Bool :=\n fun carry inputBits =>\n let input := Sum.elim carry inputBits\n let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input\n let outBit : Bool := (p.outputCirc).eval input\n (newState, outBit)"
},
{
"name": "State",
"content": "abbrev State : Type := p.α → Bool"
},
{
"name": "carry",
"content": "def carry (x : arity → BitStream) : ℕ → p.State\n | 0 => p.initCarry\n | n+1 => (p.nextBit (carry x n) (fun i => x i n)).1"
},
{
"name": "Term.eval",
"content": "def Term.eval (t : Term) (vars : List BitStream) : BitStream :=\n match t with\n | var n => vars.getD n default\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ => (t₁.eval vars) &&& (t₂.eval vars)\n | or t₁ t₂ => (t₁.eval vars) ||| (t₂.eval vars)\n | xor t₁ t₂ => (t₁.eval vars) ^^^ (t₂.eval vars)\n | not t => ~~~(t.eval vars)\n | add t₁ t₂ => (Term.eval t₁ vars) + (Term.eval t₂ vars)\n | sub t₁ t₂ => (Term.eval t₁ vars) - (Term.eval t₂ vars)\n | neg t => -(Term.eval t vars)\n\n\n | shiftL t n => BitStream.shiftLeft (Term.eval t vars) n"
},
{
"name": "Predicate.eval",
"content": "def Predicate.eval (p : Predicate) (vars : List BitStream) : BitStream :=\n match p with\n | .width .eq n => BitStream.falseIffEq n\n | .width .neq n => BitStream.falseIffNeq n\n | .width .lt n => BitStream.falseIffLt n\n | .width .le n => BitStream.falseIffLe n\n | .width .gt n => BitStream.falseIffGt n\n | .width .ge n => BitStream.falseIffGe n\n | lor p q => Predicate.evalLor (p.eval vars) (q.eval vars)\n | land p q => Predicate.evalLand (p.eval vars) (q.eval vars)\n | binary .eq t₁ t₂ => Predicate.evalEq (t₁.eval vars) (t₂.eval vars)\n \n | binary .neq t1 t2 => Predicate.evalNeq (t1.eval vars) (t2.eval vars)\n | binary .ult t₁ t₂ => Predicate.evalUlt (t₁.eval vars) (t₂.eval vars)\n | binary .ule t₁ t₂ =>\n Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalUlt (t₁.eval vars) (t₂.eval vars))\n | binary .slt t₁ t₂ => Predicate.evalSlt (t₁.eval vars) (t₂.eval vars)\n | binary .sle t₁ t₂ => Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalSlt (t₁.eval vars) (t₂.eval vars))"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "and",
"content": "def and : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := fun a => a.elim,\n outputCirc := Circuit.var true (inr true) &&& Circuit.var true (inr false),\n }"
}
] | [
{
"name": "BitVec.getElem_signExtend",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.getLsbD_signExtend",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.msb_eq_getLsbD_last",
"module": "Init.Data.BitVec.Lemmas"
}
] | [
{
"name": "and_eq",
"content": "@[simp] theorem and_eq : (x &&& y) i = (x i && y i)"
},
{
"name": "FSM.eval_and'",
"content": "@[simp]\ntheorem FSM.eval_and' (a b : FSM arity) : (a &&& b).eval env = a.eval env &&& b.eval env"
},
{
"name": "FSM.and_eq",
"content": "theorem FSM.and_eq (a b : FSM arity) : (a &&& b) = composeBinaryAux' FSM.and a b"
}
] | [
{
"name": "MultiWidth.fsmMsb",
"content": "def fsmMsb (x w : FSM α) : FSM α :=\n composeBinaryAux'\n (FSM.latchImmediate false)\n (qfalse := x)\n (qtrue := w)"
},
{
"name": "MultiWidth.fsmSext",
"content": "def fsmSext (x wold wnew : FSM α) : FSM α :=\n (fsmMsb x wold) &&& wnew"
}
] | [
{
"name": "MultiWidth.eval_fsmMsb_eq",
"content": "@[simp]\ntheorem eval_fsmMsb_eq {wcard bcard tcard : Nat}\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n {tctx : Term.Ctx wcard tcard}\n (tenv : Term.Ctx.Env tctx wenv)\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (w : WidthExpr wcard)\n (x : Term bcard ncard icard pcard tctx (.bv w))\n (xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))\n (hxfsm : HTermFSMToBitStream xfsm)\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n (hwfsm : HNatFSMToBitstream wfsm)\n (htenv : HTermEnv fsmEnv tenv benv) :\n (fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv = (fun i =>\n BitStream.ofBitVecZext (x.toBV benv nenv ienv penv tenv) (min i (w.toNat wenv - 1)))"
}
] | import Blase.Fast.FiniteStateMachine
import Blase.Vars
import Blase.MultiWidth.Defs
import Blase.KInduction.KInduction
import Lean
namespace MultiWidth
def fsmMsb (x w : FSM α) : FSM α :=
composeBinaryAux'
(FSM.latchImmediate false)
(qfalse := x)
(qtrue := w)
def fsmSext (x wold wnew : FSM α) : FSM α :=
(fsmMsb x wold) &&& wnew | theorem fsmSext_eval_eq
(woldFsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep wold))
(wnewFsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep wnew))
{wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
(hwnew : HNatFSMToBitstream wnewFsm)
(hwold : HNatFSMToBitstream woldFsm)
{tctx : Term.Ctx wcard tcard}
(tenv : Term.Ctx.Env tctx wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(t : Term bcard ncard icard pcard tctx (.bv wold))
(tFsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm t))
(htfsm : HTermFSMToBitStream tFsm)
(htenv : HTermEnv fsmEnv tenv benv) :
(fsmSext tFsm.toFsmZext woldFsm.toFsm wnewFsm.toFsm).eval fsmEnv = fun i =>
((BitStream.ofBitVecZext ((Term.sext t wnew).toBV benv nenv ienv penv tenv))) i := | := by
ext i
rw [fsmSext]
simp [FSM.eval_and', BitStream.and_eq]
rw [hwnew.heq (henv := htenv.toHWidthEnv)]
rw [eval_fsmMsb_eq
(xfsm := tFsm) (wfsm := woldFsm) (htenv := htenv)
(hxfsm := htfsm) (hwfsm := hwold)]
simp
by_cases hwold : i < wold.toNat wenv
· simp [hwold]
by_cases hwnew : i < wnew.toNat wenv
· simp [hwnew]
simp [BitVec.getElem_signExtend]
simp [hwold]
congr; omega
· simp [hwnew]
simp [BitVec.getLsbD_signExtend]
omega
· by_cases hwnew : i < wnew.toNat wenv
· simp [hwnew]
simp at hwold
rw [BitVec.getElem_signExtend]
simp [show min i (wold.toNat wenv - 1) = wold.toNat wenv - 1 by omega]
simp [show ¬ i < wold.toNat wenv by omega]
rw [BitVec.msb_eq_getLsbD_last]
· simp [hwnew]
rw [BitVec.getLsbD_signExtend]
simp; omega | 7 | 107 | false | Compiler |
313 | R.repLength_lt_n_plus_1 | theorem R.repLength_lt_n_plus_1 [Fact (q > 1)]: forall a : R q n, a.repLength < 2^n + 1 | lean-mlir | SSA/Projects/FullyHomomorphicEncryption/Basic.lean | [
"import Mathlib.Data.List.Basic",
"import Mathlib.Data.List.ToFinsupp",
"import Mathlib.RingTheory.Polynomial.Quotient",
"import Mathlib.Data.ZMod.Defs",
"import Mathlib.RingTheory.Ideal.Defs",
"import Mathlib.RingTheory.Ideal.Basic",
"import Mathlib.Data.ZMod.Basic",
"import Mathlib.Algebra.MonoidAlgebra.Basic",
"import LeanMLIR.Framework",
"import Mathlib.Tactic.Cases",
"import Mathlib.Algebra.Polynomial.RingDivision",
"import Mathlib.Data.Finset.Sort"
] | [
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Function.surjInv",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.degree",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Fact",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "WithBot",
"module": "Mathlib.Order.TypeTags"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "OfNat",
"module": "Init.Prelude"
},
{
"name": "OfNat.ofNat",
"module": "Init.Prelude"
},
{
"name": "Polynomial.Monic",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Fin.pos'",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.cast_ofNat",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.cast_pow",
"module": "Mathlib.Data.Nat.Cast.Basic"
},
{
"name": "Polynomial.degree_X_pow",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Polynomial.degree_add_eq_left_of_degree_lt",
"module": "Mathlib.Algebra.Polynomial.Degree.Operations"
},
{
"name": "Polynomial.degree_one",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Nat.one_le_two_pow",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.sub_add_cancel",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Polynomial.monic_X_pow_add",
"module": "Mathlib.Algebra.Polynomial.Monic"
},
{
"name": "Option.some_inj",
"module": "Init.Data.Option.Instances"
},
{
"name": "Polynomial.degree_modByMonic_lt",
"module": "Mathlib.Algebra.Polynomial.Div"
},
{
"name": "WithBot.lt_def",
"module": "Mathlib.Order.WithBot"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "R.representative'",
"content": "private noncomputable def R.representative' :\n R q n → (ZMod q)[X] := Function.surjInv (R.surjective_fromPoly q n)"
},
{
"name": "R.representative",
"content": "noncomputable def R.representative :\n R q n → (ZMod q)[X] := fun x => R.representative' q n x %ₘ (f q n)"
},
{
"name": "R.repLength",
"content": "noncomputable def R.repLength {q n} (a : R q n) : Nat := match\n Polynomial.degree a.representative with\n | none => 0\n | some d => d + 1"
}
] | [
{
"name": "f_deg_eq",
"content": "theorem f_deg_eq : (f q n).degree = 2^n"
},
{
"name": "f_monic",
"content": "theorem f_monic : Monic (f q n)"
}
] | import Mathlib.RingTheory.Polynomial.Quotient
import Mathlib.RingTheory.Ideal.Defs
import Mathlib.RingTheory.Ideal.Basic
import Mathlib.Data.ZMod.Defs
import Mathlib.Data.ZMod.Basic
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.Data.Finset.Sort
import Mathlib.Data.List.ToFinsupp
import Mathlib.Data.List.Basic
import Mathlib.Tactic.Cases
import LeanMLIR.Framework
open Polynomial -- for R[X] notation
section CommRing
variable (q t : Nat) [Fact (q > 1)] (n : Nat)
noncomputable def f : (ZMod q)[X] := X^(2^n) + 1
abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})
end CommRing
section Representative
variable (q t n : Nat)
private noncomputable def R.representative' :
R q n → (ZMod q)[X] := Function.surjInv (R.surjective_fromPoly q n)
noncomputable def R.representative :
R q n → (ZMod q)[X] := fun x => R.representative' q n x %ₘ (f q n)
variable [Fact (q > 1)]
end Representative
noncomputable def R.repLength {q n} (a : R q n) : Nat := match
Polynomial.degree a.representative with
| none => 0
| some d => d + 1 | theorem R.repLength_lt_n_plus_1 [Fact (q > 1)]: forall a : R q n, a.repLength < 2^n + 1 := | := by
intro a
simp only [R.repLength, representative]
have : Polynomial.degree ( R.representative' q n a %ₘ f q n) < 2^n := by
rw [← f_deg_eq q n]
apply (Polynomial.degree_modByMonic_lt)
apply f_monic
/- simp only [LT.lt] at this -/
/- let ⟨val, VAL, VAL_EQN⟩ := this -/
rcases H : degree (R.representative' q n a %ₘ f q n) <;> simp
case some val' =>
rw [H] at this
rw [WithBot.lt_def] at this
simp at this
obtain ⟨val'', twon, hval', heq1, heq2⟩ := this
rw [Option.some_inj.mp heq1]
have := Option.some_inj.mp heq2
subst this
simp_all | 4 | 31 | false | Compiler |
314 | Circuit.varsFinset_assignVars | lemma varsFinset_assignVars [DecidableEq α] [DecidableEq β] :
∀ (c : Circuit α) (f : ∀ (a : α) (_ha : a ∈ c.vars), β ⊕ Bool),
(c.assignVars f).varsFinset ⊆ c.varsFinset.biUnion
(fun a => if ha : a ∈ c.vars
then
match f a ha with
| Sum.inl b => {b}
| Sum.inr _ => ∅
else ∅)
| tru, _ => by simp [assignVars, varsFinset, vars]
| fals, _ => by simp [vars, assignVars, varsFinset]
| var c v, f => by
intro x
simp [assignVars, varsFinset, vars]
split <;>
simp [*, vars]
split_ifs <;> simp [vars]
| and c₁ c₂, f => by
intro x
simp only [assignVars, Finset.mem_biUnion]
intro hx
replace hx := varsFinset_and _ _ hx
simp only [Finset.mem_union] at hx
cases hx with
| inl hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| inr hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| or c₁ c₂, f => by
intro x
simp only [assignVars, Finset.mem_biUnion]
intro hx
replace hx := varsFinset_or _ _ hx
simp only [Finset.mem_union] at hx
cases hx with
| inl hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| inr hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| xor c₁ c₂, f => by
intro x
simp only [assignVars, Finset.mem_biUnion]
intro hx
replace hx := varsFinset_xor _ _ hx
simp only [Finset.mem_union] at hx
cases hx with
| inl hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| inr hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2 | lean-mlir | Blase/Blase/Fast/Circuit.lean | [
"import Mathlib.Data.Fin.Basic",
"import Mathlib.Data.Fintype.Basic",
"import Mathlib.Data.Finset.Union",
"import Mathlib.Data.Finset.Defs",
"import Mathlib.Data.Finset.Card",
"import Mathlib.Data.List.Pi",
"import Mathlib.Data.Finset.Basic"
] | [
{
"name": "BitVec.xor",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "HOr",
"module": "Init.Prelude"
},
{
"name": "HOr.hOr",
"module": "Init.Prelude"
},
{
"name": "OrOp",
"module": "Init.Prelude"
},
{
"name": "AndOp",
"module": "Init.Prelude"
},
{
"name": "HAnd",
"module": "Init.Prelude"
},
{
"name": "HAnd.hAnd",
"module": "Init.Prelude"
}
] | [
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
}
] | [
{
"name": "Finset.subset_iff",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "List.mem_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.mem_dedup",
"module": "Mathlib.Data.List.Dedup"
},
{
"name": "Finset.mem_union",
"module": "Mathlib.Data.Finset.Lattice.Basic"
},
{
"name": "List.subset_def",
"module": "Init.Data.List.Sublist"
},
{
"name": "Finset.mem_biUnion",
"module": "Mathlib.Data.Finset.Union"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Circuit.vars",
"content": "def vars [DecidableEq α] : Circuit α → List α\n | tru => []\n | fals => []\n | var _ x => [x]\n | and c₁ c₂ => (vars c₁ ++ vars c₂).dedup\n | or c₁ c₂ => (vars c₁ ++ vars c₂).dedup\n | xor c₁ c₂ => (vars c₁ ++ vars c₂).dedup"
},
{
"name": "Circuit.varsFinset",
"content": "def varsFinset [DecidableEq α] (c : Circuit α) : Finset α :=\n ⟨c.vars, nodup_vars c⟩"
},
{
"name": "Circuit.simplifyAnd",
"content": "def simplifyAnd : Circuit α → Circuit α → Circuit α\n | tru, c => c\n | c, tru => c\n | fals, _ => fals\n | _, fals => fals\n | c₁, c₂ => and c₁ c₂"
},
{
"name": "Circuit.simplifyOr",
"content": "def simplifyOr : Circuit α → Circuit α → Circuit α\n | tru, _ => tru\n | _, tru => tru\n | fals, c => c\n | c, fals => c\n | c₁, c₂ => or c₁ c₂"
},
{
"name": "Circuit.simplifyNot",
"content": "def simplifyNot : Circuit α → Circuit α\n | tru => fals\n | fals => tru\n | xor a b => xor (simplifyNot a) b\n | and a b => or (simplifyNot a) (simplifyNot b)\n | or a b => and (simplifyNot a) (simplifyNot b)\n | var b a => var (!b) a"
},
{
"name": "Circuit.simplifyXor",
"content": "@[simp]\ndef simplifyXor : Circuit α → Circuit α → Circuit α\n | fals, c => c\n | c, fals => c\n | tru, c => ~~~ c\n | c, tru => ~~~ c\n | c₁, c₂ => xor c₁ c₂"
},
{
"name": "Circuit.assignVars",
"content": "def assignVars [DecidableEq α] :\n ∀ (c : Circuit α) (_f : ∀ (a : α) (_ha : a ∈ c.vars), β ⊕ Bool), Circuit β\n | tru, _ => tru\n | fals, _ => fals\n | var b x, f =>\n Sum.elim\n (var b)\n (λ c : Bool => if Bool.xor b c then fals else tru)\n (f x (by admit /- proof elided -/\n ))\n | and c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/\n ))) &&&\n (assignVars c₂ (λ x hx => f x (by admit /- proof elided -/\n )))\n | or c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/\n ))) |||\n (assignVars c₂ (λ x hx => f x (by admit /- proof elided -/\n )))\n | xor c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/\n ))) ^^^\n (assignVars c₂ (λ x hx => f x (by admit /- proof elided -/\n )))"
}
] | [
{
"name": "Circuit.mem_varsFinset",
"content": "lemma mem_varsFinset [DecidableEq α] {c : Circuit α} :\n ∀ {x : α}, x ∈ c.varsFinset ↔ x ∈ c.vars"
},
{
"name": "Circuit.varsFinset_and",
"content": "theorem varsFinset_and [DecidableEq α] (c₁ c₂ : Circuit α) :\n (varsFinset (c₁ &&& c₂)) ⊆ (varsFinset c₁ ∪ varsFinset c₂)"
},
{
"name": "Circuit.varsFinset_or",
"content": "theorem varsFinset_or [DecidableEq α] (c₁ c₂ : Circuit α) :\n (varsFinset (c₁ ||| c₂)) ⊆ (varsFinset c₁ ∪ varsFinset c₂)"
},
{
"name": "Circuit.simplifyNot_eq_complement",
"content": "@[simp]\ntheorem simplifyNot_eq_complement (c : Circuit α) :\n simplifyNot c = ~~~ c"
},
{
"name": "Circuit.vars_simplifyXor",
"content": "theorem vars_simplifyXor [DecidableEq α] (c₁ c₂ : Circuit α) :\n (vars (simplifyXor c₁ c₂)) ⊆ (vars c₁ ++ vars c₂).dedup"
},
{
"name": "Circuit.varsFinset_simplifyXor",
"content": "theorem varsFinset_simplifyXor [DecidableEq α] (c₁ c₂ : Circuit α) :\n (varsFinset (simplifyXor c₁ c₂)) ⊆ (varsFinset c₁ ∪ varsFinset c₂)"
},
{
"name": "Circuit.varsFinset_xor",
"content": "theorem varsFinset_xor [DecidableEq α] (c₁ c₂ : Circuit α) :\n (varsFinset (c₁ ^^^ c₂)) ⊆ (varsFinset c₁ ∪ varsFinset c₂)"
}
] | import Mathlib.Data.Finset.Card
import Mathlib.Data.List.Pi
import Mathlib.Data.Finset.Union
import Mathlib.Data.Fin.Basic
import Mathlib.Data.Finset.Basic
import Mathlib.Data.Finset.Defs
import Mathlib.Data.Fintype.Basic
open Std Sat AIG
inductive Circuit (α : Type u) : Type u
| tru : Circuit α
| fals : Circuit α
| var : (positive: Bool) → α → Circuit α
| and : Circuit α → Circuit α → Circuit α
| or : Circuit α → Circuit α → Circuit α
| xor : Circuit α → Circuit α → Circuit α
deriving Repr, DecidableEq
open Lean in
namespace Circuit
variable {α : Type u} {β : Type v}
def vars [DecidableEq α] : Circuit α → List α
| tru => []
| fals => []
| var _ x => [x]
| and c₁ c₂ => (vars c₁ ++ vars c₂).dedup
| or c₁ c₂ => (vars c₁ ++ vars c₂).dedup
| xor c₁ c₂ => (vars c₁ ++ vars c₂).dedup
def varsFinset [DecidableEq α] (c : Circuit α) : Finset α :=
⟨c.vars, nodup_vars c⟩
def simplifyAnd : Circuit α → Circuit α → Circuit α
| tru, c => c
| c, tru => c
| fals, _ => fals
| _, fals => fals
| c₁, c₂ => and c₁ c₂
def simplifyOr : Circuit α → Circuit α → Circuit α
| tru, _ => tru
| _, tru => tru
| fals, c => c
| c, fals => c
| c₁, c₂ => or c₁ c₂
def simplifyNot : Circuit α → Circuit α
| tru => fals
| fals => tru
| xor a b => xor (simplifyNot a) b
| and a b => or (simplifyNot a) (simplifyNot b)
| or a b => and (simplifyNot a) (simplifyNot b)
| var b a => var (!b) a
@[simp]
def simplifyXor : Circuit α → Circuit α → Circuit α
| fals, c => c
| c, fals => c
| tru, c => ~~~ c
| c, tru => ~~~ c
| c₁, c₂ => xor c₁ c₂
def assignVars [DecidableEq α] :
∀ (c : Circuit α) (_f : ∀ (a : α) (_ha : a ∈ c.vars), β ⊕ Bool), Circuit β
| tru, _ => tru
| fals, _ => fals
| var b x, f =>
Sum.elim
(var b)
(λ c : Bool => if Bool.xor b c then fals else tru)
(f x (by admit /- proof elided -/
))
| and c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/
))) &&&
(assignVars c₂ (λ x hx => f x (by admit /- proof elided -/
)))
| or c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/
))) |||
(assignVars c₂ (λ x hx => f x (by admit /- proof elided -/
)))
| xor c₁ c₂, f => (assignVars c₁ (λ x hx => f x (by admit /- proof elided -/
))) ^^^
(assignVars c₂ (λ x hx => f x (by admit /- proof elided -/
))) | lemma varsFinset_assignVars [DecidableEq α] [DecidableEq β] :
∀ (c : Circuit α) (f : ∀ (a : α) (_ha : a ∈ c.vars), β ⊕ Bool),
(c.assignVars f).varsFinset ⊆ c.varsFinset.biUnion
(fun a => if ha : a ∈ c.vars
then
match f a ha with
| Sum.inl b => {b}
| Sum.inr _ => ∅
else ∅) := | := varsFinset_and _ _ hx
simp only [Finset.mem_union] at hx
cases hx with
| inl hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| inr hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| or c₁ c₂, f => by
intro x
simp only [assignVars, Finset.mem_biUnion]
intro hx
replace hx := varsFinset_or _ _ hx
simp only [Finset.mem_union] at hx
cases hx with
| inl hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| inr hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| xor c₁ c₂, f => by
intro x
simp only [assignVars, Finset.mem_biUnion]
intro hx
replace hx := varsFinset_xor _ _ hx
simp only [Finset.mem_union] at hx
cases hx with
| inl hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2
| inr hx =>
have := varsFinset_assignVars _ _ hx
simp only [Finset.mem_biUnion] at this
rcases this with ⟨a, ha⟩
use a
simp only [mem_varsFinset] at ha
simpa [ha.1, mem_varsFinset, vars] using ha.2 | 4 | 40 | false | Compiler |
315 | NFA'.autUnsignedCmp_correct | lemma NFA'.autUnsignedCmp_correct cmp : autUnsignedCmp cmp |>.correct2 autUnsignedCmpSA cmp.urel | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BitVec.ofFin",
"module": "Init.Prelude"
},
{
"name": "cmp",
"module": "Mathlib.Data.Ordering.Basic"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "BitVec.ule",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ult",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
}
] | [
{
"name": "bv2",
"content": "def bv2 : BitVec 4 := BitVec.ofNat 4 1 "
},
{
"name": "bv1",
"content": "def bv1 : BitVec 4 := BitVec.ofNat 4 5 "
},
{
"name": "RelationOrdering",
"content": "inductive RelationOrdering\n| lt | le | gt | ge\nderiving Repr, Fintype"
},
{
"name": "instFinEnumBV",
"content": "instance instFinEnumBV : FinEnum (BitVec w) where\n card := 2^w\n equiv := {\n toFun := fun x => x.toFin\n invFun := fun x => BitVec.ofFin x\n left_inv := by admit /- proof elided -/"
}
] | [
{
"name": "BitVec.toNat_eq",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "le_iff_lt_or_eq",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "Nat.le_antisymm",
"module": "Init.Prelude"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVRel",
"content": "abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop"
},
{
"name": "NFA'.sa2",
"content": "def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "NFA.unsignedCmpState",
"content": "inductive NFA.unsignedCmpState : Type where\n| eq | gt | lt\nderiving Fintype, DecidableEq"
},
{
"name": "NFA.unsignedCmpStep",
"content": "def NFA.unsignedCmpStep (q : NFA.unsignedCmpState) (a : BitVec 2) : List NFA.unsignedCmpState :=\n match q, a with\n | .eq, 0 => [ .eq ] | .eq, 3 => [ .eq ] | .eq, 1 => [ .gt ] | .eq, 2 => [ .lt ]\n | .gt, 0 => [ .gt ] | .gt, 1 => [ .gt ] | .gt, 3 => [ .gt ] | .gt, 2 => [ .lt ]\n | .lt, 0 => [ .lt ] | .lt, 1 => [ .gt ] | .lt, 2 => [ .lt ] | .lt, 3 => [ .lt ]"
},
{
"name": "NFA.autUnsignedCmp",
"content": "def NFA.autUnsignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) unsignedCmpState where\n step s a := { s' | s' ∈ unsignedCmpStep s a }\n start := {s | s = .eq }\n accept := { s | s ∈ match cmp with | .lt => [unsignedCmpState.lt] | .le => [.lt, .eq] | .gt => [.gt] | .ge => [.gt, .eq] }"
},
{
"name": "NFA'.autUnsignedCmp",
"content": "def NFA'.autUnsignedCmp (cmp: RelationOrdering) : NFA' 2 :=\n ⟨_, NFA.autUnsignedCmp cmp⟩"
},
{
"name": "RelationOrdering.urel",
"content": "def RelationOrdering.urel (cmp : RelationOrdering) : BVRel :=\n match cmp with\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .le => fun _ bv1 bv2 => bv1.ule bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1\n | .ge => fun _ bv1 bv2 => bv2.ule bv1"
},
{
"name": "NFA'.autUnsignedCmpSA",
"content": "def NFA'.autUnsignedCmpSA (q : NFA.unsignedCmpState) : BVRel :=\n match q with\n | .eq => fun _ bv1 bv2 => bv1 = bv2\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1"
}
] | [
{
"name": "BitVec.ule_iff_ult_or_eq",
"content": "lemma BitVec.ule_iff_ult_or_eq {w : ℕ} (bv1 bv2 : BitVec w):\n (bv1.ule bv2) = true ↔ (bv1.ult bv2) = true ∨ bv1 = bv2"
},
{
"name": "ucmp_tricho",
"content": "@[simp]\nlemma ucmp_tricho {bv1 bv2 : BitVec w} : (bv2.ult bv1) = false → (bv1.ult bv2) = false → bv1 = bv2"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop
def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
variable {arity : Type} [FinEnum arity]
open BitStream in
end fsm
section nfas_relations
inductive NFA.unsignedCmpState : Type where
| eq | gt | lt
deriving Fintype, DecidableEq
def NFA.unsignedCmpStep (q : NFA.unsignedCmpState) (a : BitVec 2) : List NFA.unsignedCmpState :=
match q, a with
| .eq, 0 => [ .eq ] | .eq, 3 => [ .eq ] | .eq, 1 => [ .gt ] | .eq, 2 => [ .lt ]
| .gt, 0 => [ .gt ] | .gt, 1 => [ .gt ] | .gt, 3 => [ .gt ] | .gt, 2 => [ .lt ]
| .lt, 0 => [ .lt ] | .lt, 1 => [ .gt ] | .lt, 2 => [ .lt ] | .lt, 3 => [ .lt ]
def NFA.autUnsignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) unsignedCmpState where
step s a := { s' | s' ∈ unsignedCmpStep s a }
start := {s | s = .eq }
accept := { s | s ∈ match cmp with | .lt => [unsignedCmpState.lt] | .le => [.lt, .eq] | .gt => [.gt] | .ge => [.gt, .eq] }
def NFA'.autUnsignedCmp (cmp: RelationOrdering) : NFA' 2 :=
⟨_, NFA.autUnsignedCmp cmp⟩
def RelationOrdering.urel (cmp : RelationOrdering) : BVRel :=
match cmp with
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .le => fun _ bv1 bv2 => bv1.ule bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
| .ge => fun _ bv1 bv2 => bv2.ule bv1
def NFA'.autUnsignedCmpSA (q : NFA.unsignedCmpState) : BVRel :=
match q with
| .eq => fun _ bv1 bv2 => bv1 = bv2
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1 | lemma NFA'.autUnsignedCmp_correct cmp : autUnsignedCmp cmp |>.correct2 autUnsignedCmpSA cmp.urel := | := by
let getState {w} (bv1 bv2 : BitVec w) : NFA.unsignedCmpState :=
if bv2.ult bv1 then .gt else if bv1.ult bv2 then .lt else .eq
constructor <;> simp [NFA.autUnsignedCmp, autUnsignedCmp, autUnsignedCmpSA, RelationOrdering.urel]
· rintro _ _ _; cases cmp <;> simp [BitVec.ule_iff_ult_or_eq]; tauto
· rintro (_ | _ | _) <;> simp
· rintro (_ | _ | _) a w bv1 bv2 <;> simp [NFA.stepSet, NFA.unsignedCmpStep]
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [instFinEnumBV]
· rintro ⟨_, _⟩; use .eq; simp; fin_cases a <;> simp [instFinEnumBV] at * <;> tauto
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [instFinEnumBV]
· rintro _; fin_cases a <;> simp [instFinEnumBV] at *
· use .gt; simp_all
· use (getState bv1 bv2); simp [getState]; split_ifs <;> simp_all; apply ucmp_tricho <;> assumption
· use .gt; simp_all
· constructor
· rintro ⟨i, hi⟩; cases i <;> fin_cases a <;> simp_all [instFinEnumBV]
· rintro _; fin_cases a <;> simp [instFinEnumBV] at *
· use .lt; simp_all
· use (getState bv1 bv2); simp [getState]; split_ifs <;> simp_all; apply ucmp_tricho <;> assumption
· use .lt; simp_all | 3 | 37 | false | Compiler |
316 | AngelicChoice.ExtractNonDet.extract_refines_wp_weak | omit [MAlgDet m l] in
lemma ExtractNonDet.extract_refines_wp_weak (s : NonDetT m α) (inst : ExtractNonDet WeakFindable s) :
wp s.extractWeak post <= wp s post | loom | Loom/MonadAlgebras/NonDetT'/Extract.lean | [
"import Loom.MonadAlgebras.WP.Gen",
"import Loom.MonadAlgebras.WP.Liberal",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Mathlib.Data.W.Basic",
"import Loom.MonadAlgebras.NonDetT'.Basic",
"import Loom.MonadAlgebras.WP.Basic",
"import Mathlib.Order.Lattice",
"import Mathlib.Data.FinEnum",
"import Mathlib.Order.Basic"
] | [
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "inline",
"module": "Init.Core"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Encodable",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Encodable.decode",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "Nonempty",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadEnv",
"module": "Lean.Environment"
},
{
"name": "Lean.SimpleScopedEnvExtension",
"module": "Lean.ScopedEnvExtension"
},
{
"name": "Lean.SimplePersistentEnvExtension",
"module": "Lean.EnvExtension"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "Lean.Order.bot",
"module": "Init.Internal.Order.Basic"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "MonadNonDet",
"content": "class MonadNonDet (m : Type u → Type v) where\n pick : (τ : Type u) → [Inhabited τ] → m τ\n \n pickSuchThat : (τ : Type u) → (p : τ → Prop) → [Findable p] → m τ\n assume : (as : Prop) → [Decidable as] → m PUnit.{u+1}\n \n rep {α : Type u} : α → (α → m (ForInStep α)) → m α"
},
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "CCPOBot",
"content": "class CCPOBot (m : Type u -> Type v) where\n compBot {α} : m α"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "MAlgDet",
"content": "class MAlgDet (l : outParam (Type v)) [Monad m] [CompleteLattice l] [MAlgOrdered m l] where\n \n demonic {α ι : Type v} (c : m α) (p : ι -> α -> l) [Nonempty ι] :\n ⨅ i, MAlg.lift c (p i) ≤ MAlg.lift c (fun x => ⨅ i, p i x)\n \n angelic {α ι : Type v} (c : m α) (p : ι -> α -> l) [Nonempty ι] :\n ⨆ i, MAlg.lift c (p i) ≥ MAlg.lift c (fun x => ⨆ i, p i x)"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "CCPOBotLawful",
"content": "class CCPOBotLawful (m : Type u -> Type v) [∀ α, Lean.Order.CCPO (m α)] [CCPOBot m] where\n prop {α} : CCPOBot.compBot (m := m) (α := α) = Lean.Order.bot"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} {α : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m α -> Cont l α\n | .pure ret => pure ret\n | .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | .pickCont τ p f => fun post => let p : Set τ := p; ⨅ a ∈ (p : Set τ), wp (f a) post"
},
{
"name": "NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
},
{
"name": "NonDetT.bind",
"content": "def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=\n match x with\n | pure ret => f ret\n | vis x f' => vis x fun y => bind (f' y) f\n | pickCont τ p f' => pickCont τ p fun t => bind (f' t) f\n | repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f"
},
{
"name": "WPGen.bind",
"content": "def WPGen.bind {x : m α} {f : α -> m β} (wpg : WPGen x) (wpgf : ∀ a, WPGen (f a)) :\n WPGen (x >>= f) where\n get := fun post => wpg.get (fun a => (wpgf a).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "_root_.Lean.SimpleScopedEnvExtension.get",
"content": "private def _root_.Lean.SimpleScopedEnvExtension.get [Inhabited σ] (ext : SimpleScopedEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "_root_.Lean.SimplePersistentEnvExtension.get",
"content": "private def _root_.Lean.SimplePersistentEnvExtension.get [Inhabited σ] (ext : SimplePersistentEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "WPGen",
"content": "structure WPGen (x : m α) where\n get : Cont l α\n \n prop : ∀ post, get post <= wp x post"
},
{
"name": "_root_.Lean.EnvExtension.get",
"content": "private def _root_.Lean.EnvExtension.get [Inhabited σ] (ext : EnvExtension σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "MAlgTotal",
"content": "class MAlgTotal (m : Type u -> Type v) [Monad m] [∀ α, Lean.Order.CCPO (m α)]\n [CompleteLattice l] [MAlgOrdered m l] where\n bot_lift {α : Type u} (post : α -> l) :\n MAlg.lift (Lean.Order.bot : m α) post <= ⊥"
}
] | [
{
"name": "ge_iff_le",
"module": "Init.Core"
},
{
"name": "iSup_const",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "inf_comm",
"module": "Mathlib.Order.Lattice"
},
{
"name": "le_iSup_of_le",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "monadLift_self",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "NonDetT.wp_vis",
"content": "@[simp]\nlemma NonDetT.wp_vis {β : Type u} (x : m β) (f : β → NonDetT m α) post :\n _root_.wp (NonDetT.vis x f) post = _root_.wp x fun a => _root_.wp (f a) post"
},
{
"name": "NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
},
{
"name": "NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α β : Type u} (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
},
{
"name": "NonDetT.wp_pickCont",
"content": "@[simp]\nlemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) post :\n _root_.wp (NonDetT.pickCont τ p f) post = ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post"
},
{
"name": "NonDetT.wp_pickCont",
"content": "@[simp]\nlemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) post :\n _root_.wp (NonDetT.pickCont τ p f) post = ⨆ a, ⌜p a⌝ ⊓ _root_.wp (f a) post"
},
{
"name": "wp_bot",
"content": "@[simp]\nlemma wp_bot :\n wp (bot : m α) = fun _ => (⊥ : l)"
},
{
"name": "wp_bind",
"content": "lemma wp_bind {β} (x : m α) (f : α -> m β) (post : β -> l) :\n wp (x >>= f) post = wp x (fun x => wp (f x) post)"
}
] | [
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
},
{
"name": "find",
"content": "def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=\n findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode"
},
{
"name": "WeakFindable",
"content": "class WeakFindable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_some_p : find () = some x -> p x"
},
{
"name": "WeakFindable",
"content": "instance WeakFindable.of_Findable {α : Type u} (p : α -> Prop) [Findable p] : WeakFindable p where\n find := Findable.find p\n find_some_p := Findable.find_some_p"
},
{
"name": "ExtractNonDet",
"content": "inductive ExtractNonDet (findable : {τ : Type u} -> (τ -> Prop) -> Type u) {m} : {α : Type u} -> NonDetT m α -> Type _ where\n | pure {α} : ∀ (x : α), ExtractNonDet findable (NonDetT.pure x)\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) :\n (∀ y, ExtractNonDet findable (f y)) → ExtractNonDet findable (.vis x f)\n | pickSuchThat {α} (τ : Type u) (p : τ -> Prop) (f : τ → NonDetT m α)\n {_ : findable p}\n : (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont τ p f)\n | assume {α} (p : PUnit -> Prop) (f : PUnit → NonDetT m α) {_ : Decidable (p .unit)} :\n (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont PUnit p f)"
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pure' : ExtractNonDet findable (Pure.pure (f := NonDetT m) x) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.liftM (x : m α) :\n ExtractNonDet findable (liftM (n := NonDetT m) x) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.assume' {p : Prop} [Decidable p] : ExtractNonDet findable (MonadNonDet.assume (m := NonDetT m) p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pickSuchThat' {τ : Type u} (p : τ -> Prop) [Findable p] :\n ExtractNonDet Findable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pickSuchThat_weak {τ : Type u} (p : τ -> Prop) [WeakFindable p] :\n ExtractNonDet WeakFindable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.if {p : Prop} {dec : Decidable p} {x y : NonDetT m α}\n (_ : ExtractNonDet findable x) (_ : ExtractNonDet findable y) :\n ExtractNonDet findable (if p then x else y) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}\n (_ : ∀ a b, ExtractNonDet findable (f a b)) :\n ExtractNonDet findable (forIn xs init f) :="
},
{
"name": "NonDetT.extractGen",
"content": "@[simp, inline]\ndef NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}\n (findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)\n : (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/\n ) -> m α\n | .pure x, _ => Pure.pure x\n | .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))\n | .pickCont _ p f, .pickSuchThat _ _ _ _ =>\n match findOf p ‹_› () with\n | none => CCPOBot.compBot\n | some x => extractGen findOf (f x)\n | .pickCont _ p f, .assume _ _ _ =>\n if p .unit then\n extractGen findOf (f .unit)\n else CCPOBot.compBot"
},
{
"name": "NonDetT.extractWeak",
"content": "def NonDetT.extractWeak {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet WeakFindable s := by admit /- proof elided -/\n) : m α :=\n NonDetT.extractGen WeakFindable.find s"
}
] | [] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Mathlib.Data.W.Basic
import Mathlib.Data.FinEnum
import Loom.MonadAlgebras.WP.Gen
import Loom.MonadAlgebras.WP.Liberal
import Loom.MonadAlgebras.NonDetT'.Basic
open Lean.Order
def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=
let rec aux i :=
if p i then
some i
else
aux (i + 1)
partial_fixpoint
aux 0
def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=
findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode
class WeakFindable {α : Type u} (p : α -> Prop) where
find : Unit -> Option α
find_some_p : find () = some x -> p x
instance WeakFindable.of_Findable {α : Type u} (p : α -> Prop) [Findable p] : WeakFindable p where
find := Findable.find p
find_some_p := Findable.find_some_p
inductive ExtractNonDet (findable : {τ : Type u} -> (τ -> Prop) -> Type u) {m} : {α : Type u} -> NonDetT m α -> Type _ where
| pure {α} : ∀ (x : α), ExtractNonDet findable (NonDetT.pure x)
| vis {α} {β} (x : m β) (f : β → NonDetT m α) :
(∀ y, ExtractNonDet findable (f y)) → ExtractNonDet findable (.vis x f)
| pickSuchThat {α} (τ : Type u) (p : τ -> Prop) (f : τ → NonDetT m α)
{_ : findable p}
: (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont τ p f)
| assume {α} (p : PUnit -> Prop) (f : PUnit → NonDetT m α) {_ : Decidable (p .unit)} :
(∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont PUnit p f)
instance ExtractNonDet.pure' : ExtractNonDet findable (Pure.pure (f := NonDetT m) x) :=
instance ExtractNonDet.liftM (x : m α) :
ExtractNonDet findable (liftM (n := NonDetT m) x) :=
instance ExtractNonDet.assume' {p : Prop} [Decidable p] : ExtractNonDet findable (MonadNonDet.assume (m := NonDetT m) p) :=
instance ExtractNonDet.pickSuchThat' {τ : Type u} (p : τ -> Prop) [Findable p] :
ExtractNonDet Findable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :=
instance ExtractNonDet.pickSuchThat_weak {τ : Type u} (p : τ -> Prop) [WeakFindable p] :
ExtractNonDet WeakFindable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :=
instance ExtractNonDet.if {p : Prop} {dec : Decidable p} {x y : NonDetT m α}
(_ : ExtractNonDet findable x) (_ : ExtractNonDet findable y) :
ExtractNonDet findable (if p then x else y) :=
instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}
(_ : ∀ a b, ExtractNonDet findable (f a b)) :
ExtractNonDet findable (forIn xs init f) :=
variable [Monad m] [CCPOBot m] [CompleteBooleanAlgebra l] [MAlgOrdered m l] [MAlgDet m l] [LawfulMonad m]
@[simp, inline]
def NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}
(findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)
: (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/
) -> m α
| .pure x, _ => Pure.pure x
| .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))
| .pickCont _ p f, .pickSuchThat _ _ _ _ =>
match findOf p ‹_› () with
| none => CCPOBot.compBot
| some x => extractGen findOf (f x)
| .pickCont _ p f, .assume _ _ _ =>
if p .unit then
extractGen findOf (f .unit)
else CCPOBot.compBot
def NonDetT.extractWeak {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet WeakFindable s := by admit /- proof elided -/
) : m α :=
NonDetT.extractGen WeakFindable.find s
namespace DemonicChoice
end DemonicChoice
namespace AngelicChoice
variable [∀ α, CCPO (m α)] [CCPOBotLawful m] [MAlgTotal m] | omit [MAlgDet m l] in
lemma ExtractNonDet.extract_refines_wp_weak (s : NonDetT m α) (inst : ExtractNonDet WeakFindable s) :
wp s.extractWeak post <= wp s post := | := by
unhygienic induction inst
{ simp [wp_pure, NonDetT.extractWeak] }
{ simp only [NonDetT.extractWeak, NonDetT.extractGen, monadLift_self, wp_bind, NonDetT.wp_vis];
apply wp_cons; aesop (add norm inf_comm) }
{ simp only [NonDetT.extractWeak, NonDetT.extractGen, NonDetT.wp_pickCont]; split
{ simp [*, CCPOBotLawful.prop, TotalCorrectness.wp_bot] }
apply le_iSup_of_le; simp; constructor; rotate_left
apply a_ih; rename_i h; simp [x.find_some_p h] }
simp only [NonDetT.extractWeak, NonDetT.extractGen, NonDetT.wp_pickCont]
have : ∀ a : PUnit.{u_1 + 1}, a = .unit := by simp
simp only [this, ge_iff_le]; split_ifs <;> simp [*, iSup_const, CCPOBotLawful.prop, TotalCorrectness.wp_bot]
apply a_ih | 5 | 67 | false | Framework |
317 | denote_matchVar | theorem denote_matchVar
{v w : Var _ t}
(mapOut : MatchVarResult lets v matchLets w mapIn)
(V : lets.ValidDenotation) :
(matchLets.denote (mapOut.val.mapValuation V.val) w)
= V.val v | lean-mlir | LeanMLIR/LeanMLIR/Transforms/Rewrite/Match.lean | [
"import LeanMLIR.Framework",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Transforms.Rewrite.Mapping",
"import LeanMLIR.LeanMLIR.ErasedContext"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "AList",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "AList.insert",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Valuation.map",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "Exists",
"module": "Init.Core"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Sigma",
"module": "Init.Core"
},
{
"name": "Sigma.mk",
"module": "Init.Core"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Iff",
"module": "Init.Core"
},
{
"name": "IsEmpty",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "HEq",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"neg\" : MLIR.Pretty.uniform_op",
"content": "syntax \"neg\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Mapping",
"content": "abbrev Mapping (Γ Δ : Ctxt Ty) : Type :=\n @AList (Σ t, Var Γ t) (fun x => Var Δ x.1)"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "last",
"content": "@[match_pattern]\ndef last (Γ : Ctxt Ty) (t : Ty) : Ctxt.Var (Ctxt.cons t Γ) t :=\n ⟨0, by admit /- proof elided -/\n ⟩"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "cons",
"content": "@[match_pattern]\ndef cons (hd : Ty) : Ctxt Ty → Ctxt Ty\n| ⟨tl⟩ => ⟨hd :: tl⟩"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "Expr.ty",
"content": "def Expr.ty : Expr d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Lets.denote",
"content": "def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}\n (lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=\n match lets with\n | .nil => return V\n | .var lets' e => lets'.denote V >>= e.denote"
},
{
"name": "regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "HVector.denote",
"content": "def HVector.denote :\n {l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →\n HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l\n | _, .nil => HVector.nil\n | _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)"
},
{
"name": "FlatCom.denote",
"content": "@[simp] abbrev FlatCom.denote [DialectDenote d]\n (flatCom : FlatCom d Γ eff Γ_out ts)\n (V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=\n flatCom.lets.denote V >>= (return flatCom.rets.map ·)"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "RegionSignature.map",
"content": "def RegionSignature.map (f : Ty → Ty') : RegionSignature Ty → RegionSignature Ty' :=\n List.map fun ⟨Γ, ty⟩ => (Γ.map f, ty.map f)"
},
{
"name": "Signature.map",
"content": "def Signature.map (f : Ty → Ty') : Signature Ty → Signature Ty' :=\n fun sig => {\n sig := sig.sig.map f\n regSig := sig.regSig.map f\n returnTypes := sig.returnTypes.map f\n }"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "Expr.denote",
"content": "def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :\n eff.toMonad d.m (e.outContext.Valuation) :=\n match e with\n | ⟨op, ty_eq, heff, args, regArgs⟩ => do\n let argsDenote := args.map V\n let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote\n return (val ++ V).cast (by admit /- proof elided -/\n )"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "liftEffect",
"content": "def liftEffect [Pure m] {e1 e2 : EffectKind} {α : Type}\n (hle : e1 ≤ e2) (v1 : e1.toMonad m α) : e2.toMonad m α :=\n match e1, e2, hle with\n | .pure, .pure, _ | .impure, .impure, _ => v1\n | .pure, .impure, _ => Pure.pure v1"
},
{
"name": "toMonad",
"content": "def toMonad (e : EffectKind) (m : Type → Type) : Type → Type :=\n match e with\n | pure => Id\n | impure => m"
},
{
"name": "Com.denote",
"content": "def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →\n eff.toMonad d.m (HVector toType ty)\n | .rets vs, Γv => pure (vs.map Γv)\n | .var e body, V => e.denote V >>= body.denote"
},
{
"name": "Com.ty",
"content": "def Com.ty : Com d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "Expr.denoteOp",
"content": "def Expr.denoteOp (e : Expr d Γ eff ty) (V : Γ.Valuation) :\n eff.toMonad d.m (HVector toType ty) :=\n EffectKind.liftEffect e.eff_le <| cast (by admit /- proof elided -/\n ) <|\n DialectDenote.denote e.op (e.args.map V) e.regArgs.denote"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Bool.false_eq_true",
"module": "Init.Data.Bool"
},
{
"name": "IsEmpty.exists_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "Option.isSome_none",
"module": "Init.Data.Option.Basic"
},
{
"name": "iff_false",
"module": "Init.SimpLemmas"
},
{
"name": "Option.get_some",
"module": "Init.Data.Option.Basic"
},
{
"name": "Option.isSome_iff_exists",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "forall_exists_index",
"module": "Init.PropLemmas"
},
{
"name": "Exists.choose_spec",
"module": "Init.Classical"
}
] | [
{
"name": "map_cons",
"content": "@[simp] theorem map_cons : (Γ.cons a).map f = (Γ.map f).cons (f a)"
},
{
"name": "eq.ty_eq",
"content": "theorem eq.ty_eq {v : Γ.Var t} {w : Γ.Var u} (h : v.eq w) : t = u"
},
{
"name": "Expr.op_mk",
"content": "@[simp]\ntheorem Expr.op_mk {Γ : Ctxt d.Ty} {ty} {eff : EffectKind} (op : d.Op)\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op))\n (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).op = op"
},
{
"name": "Expr.regArgs_mk",
"content": "@[simp]\ntheorem Expr.regArgs_mk {Γ : Ctxt d.Ty} {ty eff op}\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op)) (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).regArgs = regArgs"
},
{
"name": "appendCases_appendInl",
"content": "@[simp] theorem appendCases_appendInl (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInl = (left v)"
},
{
"name": "Expr.args_mk",
"content": "@[simp]\ntheorem Expr.args_mk {Γ : Ctxt d.Ty} {ty eff op}\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op)) (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).args = args"
},
{
"name": "Id.bind_eq'",
"content": "theorem Id.bind_eq' (x : Id α) (f : α → id β) : x >>= f = f x"
},
{
"name": "Expr.denoteOp_eq_denoteOp_of",
"content": "@[simp] theorem Expr.denoteOp_eq_denoteOp_of {e₁ : Expr d Γ eff ty} {e₂ : Expr d Δ eff ty}\n {Γv : Valuation Γ} {Δv : Valuation Δ}\n (op_eq : e₁.op = e₂.op)\n (h_args : HVector.map Γv (op_eq ▸ e₁.args)\n = HVector.map Δv e₂.args)\n (h_regArgs : HEq e₁.regArgs.denote e₂.regArgs.denote) :\n e₁.denoteOp Γv = e₂.denoteOp Δv"
},
{
"name": "Id.pure_eq'",
"content": "theorem Id.pure_eq' (a : α) : (pure a : Id α) = a"
}
] | [
{
"name": "MatchVarM",
"content": "abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)"
},
{
"name": "MatchVar",
"content": "abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit"
},
{
"name": "MatchVarM.unifyVars",
"content": "def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=\n fun ma =>\n match ma.lookup ⟨_, v⟩ with\n | some v =>\n if v = w then\n some ((), ma)\n else\n none\n | none =>\n some ((), AList.insert ⟨_, v⟩ w ma)"
},
{
"name": "matchArg",
"content": "def matchArg [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :\n {l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →\n MatchVar Δ_in Γ_out\n | _, .nil, .nil => return\n | t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do\n matchVar (t := t) lets vₗ matchLets vᵣ\n matchArg lets matchLets vsₗ vsᵣ\n termination_by l => (sizeOf matchLets, l.length + 1)"
},
{
"name": "matchVar",
"content": "def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :\n (matchLets : Lets d Δ_in .pure Δ_out) →\n (w : Var Δ_out t) →\n MatchVar Δ_in Γ_out\n \n | @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/\n | right w =>\n exact matchVar lets v matchLets w\n | left w => exact do\n let ⟨ts', w', ie⟩ ← lets.getPureExpr v\n if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then\n have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/"
},
{
"name": "MatchVarResult",
"content": "def MatchVarResult := { mapOut : Mapping _ _ //\n ∃ (mapIn' mapOut' : Mapping _ _),\n mapIn.entries ⊆ mapIn'.entries\n ∧ mapOut'.entries ⊆ mapOut.entries\n ∧ matchVar lets v matchLets w mapIn' = some ((), mapOut') }"
},
{
"name": "MatchArgResult",
"content": "def MatchArgResult := { mapOut : Mapping _ _ //\n ∃ (mapIn' mapOut' : Mapping _ _),\n mapIn.entries ⊆ mapIn'.entries\n ∧ mapOut'.entries ⊆ mapOut.entries\n ∧ matchArg lets matchLets vs ws mapIn' = some ((), mapOut') }"
},
{
"name": "MatchVarResult.eqvVarLeft",
"content": "def eqvVarLeft :\n MatchVarResult lets v (.var matchLets matchExpr) w.appendInr ma\n ≃ MatchVarResult lets v matchLets w ma where\n toFun := fun ⟨x, h⟩ => ⟨x, by admit /- proof elided -/\n ⟩\n invFun := fun ⟨x, h⟩ => ⟨x, by admit /- proof elided -/\n ⟩"
},
{
"name": "MatchVarResult.toArgResult",
"content": "noncomputable def toArgResult\n (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInl mapIn) :\n let args := mapOut.getPureExpr_eq_some.choose\n MatchArgResult lets matchLets args matchExpr.args mapIn :=\n ⟨mapOut.1, by admit /- proof elided -/\n ⟩"
}
] | [
{
"name": "MatchVar.liftM_bind_eq_some_iff",
"content": "@[simp]\ntheorem MatchVar.liftM_bind_eq_some_iff (x? : Option α)\n (f : α → MatchVarM Δ Γ β) :\n ((liftM x? >>= f) mapIn = some mapOut)\n ↔ ( ∃ h : x?.isSome,\n f (x?.get h) mapIn = some mapOut )"
},
{
"name": "matchVar_appendInl",
"content": "theorem matchVar_appendInl {w : Var ⟨te⟩ t} :\n matchVar lets v (.var matchLets matchExpr) w.appendInl ma = some ma' →\n ∃ args,\n lets.getPureExpr v\n = some ⟨_, w, matchExpr.op, matchExpr.ty_eq, matchExpr.eff_le, args, matchExpr.regArgs⟩\n ∧ matchArg lets matchLets args matchExpr.args ma = some ma'"
},
{
"name": "MatchVarResult.getPureExpr_eq_some",
"content": "theorem getPureExpr_eq_some\n (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInl mapIn) :\n ∃ args, lets.getPureExpr v = some ⟨te, w, ⟨\n matchExpr.op,\n matchExpr.ty_eq,\n matchExpr.eff_le,\n args,\n matchExpr.regArgs\n ⟩⟩"
},
{
"name": "HVector.map_eq_map_of_matchArg",
"content": "theorem HVector.map_eq_map_of_matchArg\n {lets : Lets d Γ_in eff Γ_out}\n {matchLets : Lets d Δ_in .pure Δ_out}\n {ma : Mapping Δ_in Γ_out}\n {l : List d.Ty} {args₁ : HVector _ l} {args₂ : HVector _ l}\n (mapOut : MatchArgResult lets matchLets args₁ args₂ ma)\n (f₁ f₂ : (t : d.Ty) → Var _ t → ⟦t⟧)\n (hf : ∀ {t v₁ v₂},\n (mapOut' : MatchVarResult lets v₁ matchLets v₂ ma)\n → mapOut'.val = mapOut.val\n → f₂ t v₂ = f₁ t v₁) :\n HVector.map f₂ args₂ = HVector.map f₁ args₁"
}
] | import LeanMLIR.Framework
import LeanMLIR.Transforms.Rewrite.Mapping
open Ctxt (Var VarSet Valuation Hom)
variable {d} [DialectSignature d] [DecidableEq d.Ty]
variable {Γ : Ctxt d.Ty} {ty : d.Ty}
abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)
abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit
def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=
fun ma =>
match ma.lookup ⟨_, v⟩ with
| some v =>
if v = w then
some ((), ma)
else
none
| none =>
some ((), AList.insert ⟨_, v⟩ w ma)
open MatchVarM
variable [DecidableEq d.Op]
def matchArg [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :
{l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →
MatchVar Δ_in Γ_out
| _, .nil, .nil => return
| t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do
matchVar (t := t) lets vₗ matchLets vᵣ
matchArg lets matchLets vsₗ vsᵣ
termination_by l => (sizeOf matchLets, l.length + 1)
def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :
(matchLets : Lets d Δ_in .pure Δ_out) →
(w : Var Δ_out t) →
MatchVar Δ_in Γ_out
| @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/
| right w =>
exact matchVar lets v matchLets w
| left w => exact do
let ⟨ts', w', ie⟩ ← lets.getPureExpr v
if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then
have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/
end
section MatchVar
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out t te}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
variable (lets v matchLets w) (mapIn : Mapping _ _) in
def MatchVarResult := { mapOut : Mapping _ _ //
∃ (mapIn' mapOut' : Mapping _ _),
mapIn.entries ⊆ mapIn'.entries
∧ mapOut'.entries ⊆ mapOut.entries
∧ matchVar lets v matchLets w mapIn' = some ((), mapOut') }
variable (lets matchLets) {tys} (vs ws : HVector _ tys) (mapIn : Mapping _ _) in
def MatchArgResult := { mapOut : Mapping _ _ //
∃ (mapIn' mapOut' : Mapping _ _),
mapIn.entries ⊆ mapIn'.entries
∧ mapOut'.entries ⊆ mapOut.entries
∧ matchArg lets matchLets vs ws mapIn' = some ((), mapOut') }
namespace MatchVarResult
variable [TyDenote d.Ty] [∀ (t : d.Ty), Inhabited ⟦t⟧] in
section Left
variable {w : Δ_out.Var t}
def eqvVarLeft :
MatchVarResult lets v (.var matchLets matchExpr) w.appendInr ma
≃ MatchVarResult lets v matchLets w ma where
toFun := fun ⟨x, h⟩ => ⟨x, by admit /- proof elided -/
⟩
invFun := fun ⟨x, h⟩ => ⟨x, by admit /- proof elided -/
⟩
variable {mapIn} (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInr mapIn)
end Left
variable {w : Var ⟨te⟩ _} {mapIn}
noncomputable def toArgResult
(mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInl mapIn) :
let args := mapOut.getPureExpr_eq_some.choose
MatchArgResult lets matchLets args matchExpr.args mapIn :=
⟨mapOut.1, by admit /- proof elided -/
⟩
end MatchVarResult
end MatchVar
section SubsetEntries
open MatchVar
section UnifyVars
variable {Δ Γ : Ctxt d.Ty} {t} (w : Δ.Var t) (v : Γ.Var t)
end UnifyVars
variable [DecidableEq d.Op]
end SubsetEntries
namespace MatchArgResult
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out te}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
{u us}
{v : Γ_out.Var u} {vs : HVector Γ_out.Var us}
{w : Δ_out.Var u} {ws : HVector Δ_out.Var us}
{mapIn : Mapping _ _}
(mapOut : MatchArgResult lets matchLets (v ::ₕ vs) (w ::ₕ ws) mapIn)
end MatchArgResult
section DenoteLemmas
variable [TyDenote d.Ty] [DecidableEq d.Op]
variable [∀ (t : d.Ty), Inhabited ⟦t⟧]
variable [Monad d.m] [LawfulMonad d.m] [DialectDenote d]
section DenoteIntoSubtype
end DenoteIntoSubtype
variable {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out} | theorem denote_matchVar
{v w : Var _ t}
(mapOut : MatchVarResult lets v matchLets w mapIn)
(V : lets.ValidDenotation) :
(matchLets.denote (mapOut.val.mapValuation V.val) w)
= V.val v := | := by
induction matchLets generalizing v mapIn t
case nil => simp [Id.pure_eq']
case var t' matchLets matchExpr ih =>
cases w using Var.appendCases with
| right w =>
specialize ih mapOut.eqvVarLeft
simpa [Id.bind_eq'] using ih
| left w =>
let mapOut' := mapOut.toArgResult
have h := Exists.choose_spec mapOut.getPureExpr_eq_some
rw [← V.prop h]
simp
congr 1
apply Expr.denoteOp_eq_denoteOp_of (by rfl)
· simp only [Expr.op_mk, Expr.args_mk]
rw [HVector.map_eq_map_of_matchArg (f₁ := V.val) (mapOut := mapOut')]
· intro t v₁ v₂ mapOut'' mapOut_eq
simp [← ih mapOut'', mapOut_eq, mapOut']
· rfl | 8 | 114 | false | Compiler |
318 | NFA.proj_eval | @[simp]
lemma proj_eval (M : NFA (BitVec m) σ) (f : Fin n → Fin m) :
(M.proj f).eval w =
⋃ w' ∈ BitVecs'.transport f ⁻¹' {w}, M.eval w' | lean-mlir | Blase/Blase/AutoStructs/ForMathlib.lean | [
"import Mathlib.Data.Rel",
"import Mathlib.Data.FinEnum",
"import Mathlib.Data.Vector.Basic",
"import Blase.AutoStructs.ForLean",
"import Mathlib.Computability.NFA"
] | [
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
},
{
"name": "List.getLast",
"module": "Init.Data.List.Basic"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
}
] | [
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "_root_.Set.proj",
"content": "@[simp]\ndef _root_.Set.proj (f : Fin n → Fin m) (bvs : Set (BitVecs m)) : Set (BitVecs n) :=\n BitVecs.transport f '' bvs"
}
] | [
{
"name": "List.append_inj_left'",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.append_inj_right'",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.dropLast_concat_getLast",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.map_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.map_cons",
"module": "Init.Data.List.Basic"
},
{
"name": "List.map_dropLast",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.map_nil",
"module": "Init.Data.List.Basic"
},
{
"name": "Set.ext",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.mem_iUnion",
"module": "Mathlib.Order.SetNotation"
},
{
"name": "exists_prop",
"module": "Init.PropLemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "NFA.Deterministic",
"content": "structure Deterministic (M : NFA α σ) : Prop where\n start : M.start.Subsingleton\n step : ∀ q a, M.step q a |>.Subsingleton"
},
{
"name": "NFA.proj",
"content": "@[simps]\ndef proj (M: NFA (BitVec n1) σ) (f : Fin n2 → Fin n1) : NFA (BitVec n2) σ where\n start := M.start\n accept := M.accept\n step q a := { q' | ∃ a', a'.transport f = a ∧ q' ∈ M.step q a' }"
}
] | [] | import Mathlib.Computability.NFA
import Mathlib.Data.FinEnum
import Mathlib.Data.Rel
import Mathlib.Data.Vector.Basic
import Blase.AutoStructs.ForLean
open Set
open Mathlib
open SetRel
def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=
Vector.ofFn fun i => v.get (f i)
def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=
BitVec.ofFn fun i => bv.getLsbD (f i)
structure BitVecs (n : Nat) where
w : Nat
bvs : List.Vector (BitVec w) n
abbrev BitVecs' (n : Nat) := List (BitVec n)
def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=
{ w := bvs.w, bvs := bvs.bvs.transport f }
def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=
bvs'.map fun bv => bv.transport f
namespace NFA
structure Deterministic (M : NFA α σ) : Prop where
start : M.start.Subsingleton
step : ∀ q a, M.step q a |>.Subsingleton
@[simps]
def proj (M: NFA (BitVec n1) σ) (f : Fin n2 → Fin n1) : NFA (BitVec n2) σ where
start := M.start
accept := M.accept
step q a := { q' | ∃ a', a'.transport f = a ∧ q' ∈ M.step q a' } | @[simp]
lemma proj_eval (M : NFA (BitVec m) σ) (f : Fin n → Fin m) :
(M.proj f).eval w =
⋃ w' ∈ BitVecs'.transport f ⁻¹' {w}, M.eval w' := | := by
induction w using List.reverseRecOn
case nil => simp [proj, BitVecs'.transport]
case append_singleton w a ih =>
ext q; simp [BitVecs'.transport]; constructor
· rintro ⟨a', htr, S, hrS, hqS⟩
rcases hrS with ⟨q', rfl⟩
simp [ih] at hqS
rcases hqS with ⟨⟨w', htr', he⟩, hs⟩
use w' ++ [a']; constructor
· simp_all; exact htr'
· simp; use M.step q' a'; constructor
on_goal 2 => assumption
use q'; simp_all
· rintro ⟨wa', heq, he⟩
by_cases hemp : wa' = []
· simp_all
have hdl := List.dropLast_concat_getLast hemp
rw [←hdl] at heq he
simp only [List.map_append, List.map_dropLast, List.map_cons, List.map_nil] at heq
use List.getLast wa' hemp; constructor
· apply List.append_inj_right' at heq; simp_all
· obtain rfl := List.append_inj_left' heq (by simp)
simp at he; rcases he with ⟨S, ⟨q', rfl⟩, hqS⟩
simp at hqS; rcases hqS with ⟨he, hs⟩
simp only [stepSet, mem_iUnion, exists_prop]
use q'
simp [ih]; constructor
on_goal 2 => assumption
use wa'.dropLast
simp_all [BitVecs'.transport] | 4 | 36 | false | Compiler |
319 | nfaOfFormula_bv_language | theorem nfaOfFormula_bv_language φ :
(nfaOfFormula φ).bv_recognizes φ.language | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.Blase.AutoStructs.Basic",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.Blase.AutoStructs.Constructions",
"import Blase.Blase.AutoStructs.ForLean",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.card",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Array.foldl",
"module": "Init.Data.Array.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Array.size",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "cond",
"module": "Init.Prelude"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Array.emptyWithCapacity",
"module": "Init.Prelude"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
},
{
"name": "Array.empty",
"module": "Init.Prelude"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "impl",
"module": "Mathlib.Deprecated.MLList.BestFirst"
},
{
"name": "atom",
"module": "Leanwuzla.Sexp.Basic"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "FinEnum.equiv",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Subsingleton",
"module": "Init.Core"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "SetRel",
"module": "Mathlib.Data.Rel"
},
{
"name": "Array.back?",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.isEmpty",
"module": "Init.Data.Array.Basic"
},
{
"name": "List.next",
"module": "Mathlib.Data.List.Cycle"
},
{
"name": "L",
"module": "Archive.Hairer"
},
{
"name": "Fin.mk",
"module": "Init.Prelude"
},
{
"name": "Fin.cast",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.castLT",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.subNat",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List.Vector.get",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "DFA",
"module": "Mathlib.Computability.DFA"
},
{
"name": "NFA.toDFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
},
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "Fin.natAdd",
"module": "Init.Data.Fin.Basic"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
},
{
"name": "cmp",
"module": "Mathlib.Data.Ordering.Basic"
},
{
"name": "BitVec.ofFin",
"module": "Init.Prelude"
},
{
"name": "BitVec.ule",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ult",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.sle",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.slt",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
},
{
"name": "Classical.propDecidable",
"module": "Init.Classical"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "Function.RightInverse",
"module": "Init.Data.Function"
}
] | [
{
"name": "syntax \"max\" : MLIR.Pretty.uniform_op",
"content": "syntax \"max\" : MLIR.Pretty.uniform_op\n\nsyntax \"slt\" : MLIR.Pretty.uniform_op\n\nsyntax \"xor\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "carry",
"content": "def carry (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n => (addAux' initCarry x y n).2"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "worklistRun",
"content": "def worklistRun (final : S → Bool) (inits : Array S)\n (hinits : inits.toList.Nodup) (f : S → Array (BitVec n × S)) : CNFA n :=\n ⟨worklistRun' _ S final inits hinits f, worklistRun'_wf (BitVec n) S⟩"
},
{
"name": "worklistRun'",
"content": "def worklistRun' (final : S → Bool) (inits : Array S) (hinits : inits.toList.Nodup) (f : S → Array (A × S)) : RawCNFA A :=\n let st0 := worklist.initState _ _ inits hinits final\n go st0\nwhere go (st0 : worklist.St A S) : RawCNFA A :=\n if hemp : st0.worklist.isEmpty then st0.m else\n let sa? := st0.worklist.back?\n match heq : sa? with\n | some sa =>\n let wl := st0.worklist.pop\n let st1 := { st0 with worklist := wl,\n worklist_nodup := by admit /- proof elided -/"
},
{
"name": "worklist.St",
"content": "structure worklist.St where\n m : RawCNFA A\n map : Std.HashMap S State := ∅\n worklist : Array S := ∅\n worklist_nodup : worklist.toList.Nodup\n worklist_incl : ∀ sa ∈ worklist, sa ∈ map"
},
{
"name": "worklist.initState",
"content": "def worklist.initState (inits : Array S) (hinits : inits.toList.Nodup) (final? : S → Bool) : worklist.St A S :=\n let m := RawCNFA.empty (A := A)\n let mapm := inits.foldl (init := (Std.HashMap.emptyWithCapacity, m)) fun (map, m) sa =>\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := if final? sa then m.addFinal s else m\n (map.insert sa s, m)\n let map := mapm.1\n let m := mapm.2\n let worklist_incl : ∀ sa ∈ inits, sa ∈ map :="
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.empty",
"content": "def RawCNFA.empty : RawCNFA A := {\n stateMax := 0\n initials := ∅\n finals := ∅\n trans := ∅\n}"
},
{
"name": "processOneElem",
"content": "def processOneElem (final : S → Bool) (s : State) (st : worklist.St A S) : A × S → worklist.St A S :=\n fun (a', sa') =>\n let (s', st') := st.addOrCreateState _ _ (final sa') sa'\n let m := st'.m.addTrans a' s s'\n { st' with m }"
},
{
"name": "worklist.St.addOrCreateState",
"content": "def worklist.St.addOrCreateState (st : worklist.St A S) (final? : Bool) (sa : S) : State × worklist.St A S :=\n match heq : st.map[sa]? with\n | some s => (s, st)\n | none =>\n let (s, m) := st.m.newState\n let m := if final? then m.addFinal s else m\n let map := st.map.insert sa s\n let worklist := st.worklist.push sa\n have worklist_nodup : worklist.toList.Nodup := by admit /- proof elided -/"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "sub",
"content": "def sub (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).1"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "ofTerm",
"content": "abbrev ofTerm (t : Term) : FSM (Fin t.arity) := termEvalEqFSM t |>.toFSM"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "termEvalEqFSM",
"content": "def termEvalEqFSM : ∀ (t : Term), FSMTermSolution t\n | ofNat n =>\n { toFSM := FSM.ofNat n,\n good := by admit /- proof elided -/"
},
{
"name": "or",
"content": "def or : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ||| Circuit.var true (inr false),\n nextStateCirc := fun a => a.elim\n }"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (n : Nat) : FSM Unit :=\n match n with\n | 0 => FSM.id\n | n + 1 => composeUnaryAux (FSM.ls false) (shiftLeft n)"
},
{
"name": "id",
"content": "def id : FSM Unit := {\n α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr ()),\n nextStateCirc := Empty.elim\n}"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "and",
"content": "def and : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := fun a => a.elim,\n outputCirc := Circuit.var true (inr true) &&& Circuit.var true (inr false),\n }"
},
{
"name": "xor",
"content": "def xor : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ^^^ Circuit.var true (inr false),\n nextStateCirc := Empty.elim\n }"
},
{
"name": "neg",
"content": "def neg : FSM Unit :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "composeBinary",
"content": "def composeBinary\n (p : FSM Bool)\n {t₁ t₂ : Term}\n (q₁ : FSMTermSolution t₁)\n (q₂ : FSMTermSolution t₂) :\n FSM (Fin (max t₁.arity t₂.arity)) := composeBinaryAux p q₁.toFSM q₂.toFSM"
},
{
"name": "composeBinaryAux",
"content": "def composeBinaryAux\n (p : FSM Bool)\n (q₁ : FSM (Fin a₁))\n (q₂ : FSM (Fin a₂)) :\n FSM (Fin (max a₁ a₂)) :=\n p.compose (Fin (max a₁ a₂))\n (λ b => Fin (cond b a₁ a₂))\n (λ b i => Fin.castLE (by admit /- proof elided -/\n ) i)\n (λ b => match b with\n | true => q₁\n | false => q₂)"
},
{
"name": "FSMTermSolution",
"content": "structure FSMTermSolution (t : Term) extends FSM (Fin t.arity) where\n ( good : t.evalFin = toFSM.eval )"
},
{
"name": "Term.evalFin",
"content": "@[simp] def Term.evalFin (t : Term) (vars : Fin (arity t) → BitStream) : BitStream :=\n match t with\n | var n => vars (Fin.last n)\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | or t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | xor t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | not t => ~~~(t.evalFin vars)\n | add t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | sub t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | neg t => -(Term.evalFin t vars)\n \n \n | shiftL t n => BitStream.shiftLeft (Term.evalFin t vars) n"
},
{
"name": "Predicate.evalFin",
"content": "@[simp] def Predicate.evalFin (p : Predicate) (vars : Fin (arity p) → BitStream) : BitStream :=\nmatch p with\n| .width .eq n => BitStream.falseIffEq n\n| .width .neq n => BitStream.falseIffNeq n\n| .width .lt n => BitStream.falseIffLt n\n| .width .le n => BitStream.falseIffLe n\n| .width .gt n => BitStream.falseIffGt n\n| .width .ge n => BitStream.falseIffGe n\n| .binary .eq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalEq x₁ x₂\n| .binary .neq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalNeq x₁ x₂\n| .land p q =>\n \n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLand x₁ x₂\n| .lor p q =>\n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor x₁ x₂\n| .binary .slt p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalSlt x₁ x₂\n| .binary .sle p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalSlt x₁ x₂) (Predicate.evalEq x₁ x₂)\n| .binary .ult p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n (Predicate.evalUlt x₁ x₂)\n| .binary .ule p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalUlt x₁ x₂) (Predicate.evalEq x₁ x₂)"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "Predicate",
"content": "inductive Predicate : Type where\n \n| width (wp : WidthPredicate) (n : Nat) : Predicate\n| binary (p : BinaryPredicate) (t₁ t₂ : Term)\n| land (p q : Predicate) : Predicate\n| lor (p q : Predicate) : Predicate\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "ofNat",
"content": "def ofNat (n : Nat) : FSM (Fin 0) :=\n match hn : n with\n | 0 => FSM.zero\n\n | n' + 1 =>\n let bit := n.testBit 0\n let m := n / 2\n have h : m < n := by admit /- proof elided -/"
},
{
"name": "zero",
"content": "def zero : FSM (Fin 0) :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.fals\n }"
},
{
"name": "composeUnary",
"content": "def composeUnary\n (p : FSM Unit)\n {t : Term}\n (q : FSMTermSolution t) :\n FSM (Fin t.arity) := composeUnaryAux p q.toFSM"
},
{
"name": "one",
"content": "def one : FSM (Fin 0) :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "var",
"content": "def var (n : ℕ) : FSM (Fin (n+1)) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "add",
"content": "def add : FSM Bool :=\n { α := Unit,\n initCarry := λ _ => false,\n nextStateCirc := fun () =>\n Circuit.var true (inr true) &&& Circuit.var true (inr false) |||\n Circuit.var true (inr true) &&& Circuit.var true (inl ()) |||\n Circuit.var true (inr false) &&& Circuit.var true (inl ()),\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n }"
},
{
"name": "negOne",
"content": "def negOne : FSM (Fin 0) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "sub",
"content": "def sub : FSM Bool :=\n { α := Unit,\n initCarry := fun _ => false,\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n nextStateCirc := fun _ =>\n (Circuit.var false (inr true) &&& Circuit.var true (inr false)) |||\n (Circuit.var false (inr true) ^^^ Circuit.var true (inr false)) &&&\n (Circuit.var true (inl ()))\n }"
},
{
"name": "not",
"content": "def not : FSM Unit :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.var false (inr ())\n }"
},
{
"name": "add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "neg",
"content": "def neg (x : BitStream) : BitStream :=\n fun n => (negAux x n).1"
},
{
"name": "negAux",
"content": "def negAux (x : BitStream) : Nat → Bool × Bool\n | 0 => (x 0, !(x 0))\n | n+1 =>\n let borrow := (negAux x n).2\n let a := x (n + 1)\n (xor (!a) borrow, !a && borrow)"
},
{
"name": "CNFA.inter",
"content": "def CNFA.inter (m1 m2 : CNFA n) : CNFA n := product (fun b1 b2 => b1 && b2) m1 m2"
},
{
"name": "product",
"content": "def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=\n worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)\n (by admit /- proof elided -/\n ) f\nwhere final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)\n f (ss : m₁.m.states × m₂.m.states) :=\n let (s1, s2) := ss\n (FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>\n product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))\n (fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as"
},
{
"name": "product.prodArray'",
"content": "@[inline]\ndef product.prodArray' (a : Array γ) :=\n m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>\n m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s1 s2)"
},
{
"name": "product.inits_nodup",
"content": "def product.inits_nodup : inits m₁ m₂ |>.toList.Nodup :="
},
{
"name": "product.inits",
"content": "def product.inits (m₁ m₂ : CNFA n) :=\n product.prodArray Prod.mk @m₁.wf.initials_lt @m₂.wf.initials_lt"
},
{
"name": "product.prodArray",
"content": "@[inline]\ndef product.prodArray := prodArray' f hm₁ hm₂ (Array.emptyWithCapacity <| m₁.size * m₂.size)"
},
{
"name": "liftMaxSuccSucc2",
"content": "def liftMaxSuccSucc2 (n m : Nat) : Fin (m + 1) → Fin (max n m + 3) :=\n fun k => if _ : k = Fin.last m then max n m + 1 else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMaxSuccSucc1",
"content": "def liftMaxSuccSucc1 (n m : Nat) : Fin (n + 1) → Fin (max n m + 3) :=\n fun k => if _ : k = Fin.last n then (max n m).cast else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftLast3",
"content": "def liftLast3 n : Fin 3 → Fin (n + 3)\n| 0 => n\n| 1 => n + 1\n| 2 => Fin.last (n + 2)"
},
{
"name": "Unop",
"content": "inductive Unop\n| neg\nderiving Repr"
},
{
"name": "RelationOrdering",
"content": "inductive RelationOrdering\n| lt | le | gt | ge\nderiving Repr, Fintype"
},
{
"name": "Relation",
"content": "inductive Relation\n| eq\n| signed (ord : RelationOrdering)\n| unsigned (ord : RelationOrdering)\nderiving Repr"
},
{
"name": "WidthPredicate",
"content": "inductive WidthPredicate\n| eq\n| neq\n| lt\n| le\n| gt\n| ge\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "Binop",
"content": "inductive Binop\n| and | or | impl | equiv\nderiving Repr"
},
{
"name": "liftLast2",
"content": "def liftLast2 n : Fin 2 → Fin (n + 2)\n| 0 => n\n| 1 => Fin.last (n + 1)"
},
{
"name": "liftMaxSucc2",
"content": "def liftMaxSucc2 (n m : Nat) : Fin (m + 1) → Fin (max n m + 2) :=\n fun k => if _ : k = m then Fin.last (max n m + 1) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMaxSucc1",
"content": "def liftMaxSucc1 (n m : Nat) : Fin (n + 1) → Fin (max n m + 2) :=\n fun k => if _ : k = n then Fin.last (max n m) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMax2",
"content": "def liftMax2 (n m : Nat) : Fin m → Fin (max n m) :=\n fun k => k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftExcept2",
"content": "def liftExcept2 n : Fin n → Fin (n + 2) :=\n fun k => Fin.castLE (by admit /- proof elided -/\n ) k"
},
{
"name": "Formula.arity",
"content": "@[simp]\ndef Formula.arity : Formula → Nat\n| width _ _ => 0\n| atom _ t1 t2 => max t1.arity t2.arity\n| msbSet t => t.arity\n| unop _ φ => φ.arity\n| binop _ φ1 φ2 => max φ1.arity φ2.arity"
},
{
"name": "liftMax1",
"content": "def liftMax1 (n m : Nat) : Fin n → Fin (max n m) :=\n fun k => k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "Formula",
"content": "inductive Formula : Type\n| width : WidthPredicate → Nat → Formula\n| atom : Relation → Term → Term → Formula\n| msbSet : Term → Formula\n| unop : Unop → Formula → Formula\n| binop : Binop → Formula → Formula → Formula\nderiving Repr"
},
{
"name": "CNFA.inter_bv_language",
"content": "def CNFA.inter_bv_language (m₁ m₂ : CNFA n) :\n m₁.bv_recognizes L₁ →\n m₂.bv_recognizes L₂ →\n (m₁.inter m₂).bv_recognizes (L₁ ∩ L₂) :="
},
{
"name": "HashSet.inter",
"content": "def HashSet.inter [BEq A] [Hashable A] (m1 m2 : Std.HashSet A) : Std.HashSet A :=\n m1.fold (init := ∅) fun mi x => if m2.contains x then mi.insert x else mi"
},
{
"name": "Formula.language",
"content": "@[simp]\ndef Formula.language (φ : Formula) : Set (BitVecs φ.arity) :=\n match φ with\n | .width wp n => { bvs | wp.sat bvs.w n }\n | .atom rel t1 t2 =>\n let l1 := t1.language.lift (liftMaxSucc1 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity))\n let l2 := t2.language.lift (liftMaxSucc2 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity))\n let lrel := rel.language.lift $ liftLast2 (max (FinEnum.card (Fin t1.arity)) (FinEnum.card (Fin t2.arity)))\n let l := lrel ∩ l1 ∩ l2\n l.proj (liftExcept2 _)\n | .unop .neg φ => φ.languageᶜ\n | .binop op φ1 φ2 =>\n let l1 := φ1.language.lift $ liftMax1 φ1.arity φ2.arity\n let l2 := φ2.language.lift $ liftMax2 φ1.arity φ2.arity\n langBinop op l1 l2\n | .msbSet t =>\n let lmsb := langMsb.lift $ fun _ => Fin.last t.arity\n let l' := t.language ∩ lmsb\n l'.proj fun n => n.castLE (by admit /- proof elided -/\n )"
},
{
"name": "WidthPredicate.sat",
"content": "@[simp]\ndef WidthPredicate.sat (wp : WidthPredicate) (w n : Nat) : Bool :=\n match wp with\n | .eq => w = n\n | .neq => w ≠ n\n | .lt => w < n\n | .le => w ≤ n\n | .gt => w > n\n | .ge => w ≥ n"
},
{
"name": "_root_.Set.proj",
"content": "@[simp]\ndef _root_.Set.proj (f : Fin n → Fin m) (bvs : Set (BitVecs m)) : Set (BitVecs n) :=\n BitVecs.transport f '' bvs"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "Term.language",
"content": "def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=\n { bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }"
},
{
"name": "Term.evalFinBV",
"content": "@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=\n match t with\n | .var n => vars (Fin.last n)\n | .zero => BitVec.zero w\n | .one => 1\n | .negOne => -1\n | .ofNat n => BitVec.ofNat _ n\n | .and t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | .or t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | .xor t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | .not t => ~~~(t.evalFinBV vars)\n \n | .add t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | .sub t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | .neg t => -(t.evalFinBV vars)\n | .shiftL a n => (a.evalFinBV vars) <<< n"
},
{
"name": "_root_.Set.lift",
"content": "@[simp]\ndef _root_.Set.lift (f : Fin n → Fin m) (bvs : Set (BitVecs n)) : Set (BitVecs m) :=\n BitVecs.transport f ⁻¹' bvs"
},
{
"name": "Formula.sat",
"content": "@[simp]\ndef Formula.sat {w : Nat} (φ : Formula) (ρ : Fin φ.arity → BitVec w) : Prop :=\n match φ with\n | .width wp n => wp.sat w n\n | .atom rel t1 t2 =>\n let bv1 := t1.evalFinBV (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n let bv2 := t2.evalFinBV (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n evalRelation rel bv1 bv2\n | .unop .neg φ => ¬ φ.sat ρ\n | .binop op φ1 φ2 =>\n let b1 := φ1.sat (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n let b2 := φ2.sat (fun n => ρ $ Fin.castLE (by admit /- proof elided -/\n ) n)\n evalBinop op b1 b2\n | .msbSet t => (t.evalFinBV ρ).msb"
},
{
"name": "evalBinop",
"content": "def evalBinop (op : Binop) (b1 b2 : Prop) : Prop :=\n match op with\n | .and => b1 ∧ b2\n | .or => b1 ∨ b2\n | .impl => b1 → b2\n | .equiv => b1 ↔ b2"
},
{
"name": "evalRelation",
"content": "def evalRelation (rel : Relation) {w} (bv1 bv2 : BitVec w) : Prop :=\n match rel with\n | .eq => bv1 = bv2\n | .signed .lt => bv1.slt bv2\n | .signed .le => bv1.sle bv2\n | .signed .gt => bv2.slt bv1\n | .signed .ge => bv2.sle bv1\n | .unsigned .lt => bv1.ult bv2\n | .unsigned .le => bv1.ule bv2\n | .unsigned .gt => bv2.ult bv1\n | .unsigned .ge => bv2.ule bv1"
},
{
"name": "langBinop",
"content": "def langBinop (op : Binop) (l1 l2 : Set (BitVecs n)) : Set (BitVecs n) :=\n match op with\n | .and => l1 ∩ l2\n | .or => l1 ∪ l2\n | .impl => l1ᶜ ∪ l2\n | .equiv => (l1ᶜ ∪ l2) ∩ (l2ᶜ ∪ l1)"
},
{
"name": "Relation.language",
"content": "@[simp]\ndef Relation.language (rel : Relation) : Set (BitVecs 2) :=\n { bvs | evalRelation rel (bvs.bvs.get 0) (bvs.bvs.get 1) }"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "eval",
"content": "def eval (x : arity → BitStream) : BitStream :=\n fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2"
},
{
"name": "nextBit",
"content": "def nextBit : p.State → (arity → Bool) → p.State × Bool :=\n fun carry inputBits =>\n let input := Sum.elim carry inputBits\n let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input\n let outBit : Bool := (p.outputCirc).eval input\n (newState, outBit)"
},
{
"name": "State",
"content": "abbrev State : Type := p.α → Bool"
},
{
"name": "carry",
"content": "def carry (x : arity → BitStream) : ℕ → p.State\n | 0 => p.initCarry\n | n+1 => (p.nextBit (carry x n) (fun i => x i n)).1"
},
{
"name": "carryBV",
"content": "def carryBV (x : ar → BitVec w) : p.State :=\n p.carry (fun ar => .ofBitVecSext (x ar)) w"
},
{
"name": "evalBV",
"content": "def evalBV {w} (x : ar → BitVec w) : BitVec w :=\n BitVec.ofFn fun k => p.eval (fun ar => .ofBitVecSext (x ar)) k"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
},
{
"name": "worklistRun_spec",
"content": "def worklistRun_spec : (worklistRun S final inits hinits f |>.Sim $ nfa' inits final f) :=\n worklistRun'_spec inits final f"
},
{
"name": "nfa'",
"content": "def nfa' : NFA' n :=\n { σ := _, M := nfa inits final f }"
},
{
"name": "nfa",
"content": "def nfa : NFA A S where\n start := { sa | sa ∈ inits }\n accept := { sa | final sa }\n step sa a := { sa' | (a, sa') ∈ f sa }"
},
{
"name": "worklistRun'_spec",
"content": "def worklistRun'_spec :\n (worklistRun' A S final inits hinits f |>.Sim $ nfa inits final f) :="
},
{
"name": "StInv",
"content": "structure StInv (m : RawCNFA A) (map : Std.HashMap S State) where\n wf : m.WF\n map_states : ∀ (sa : S) s, map[sa]? = some s → s ∈ m.states\n map_surj : ∀ s : m.states, ∃ (sa : S), map[sa]? = some s.val\n map_inj : ∀ {s} {sa sa' : S}, map[sa]? = some s → map[sa']? = some s → sa = sa'"
},
{
"name": "worklist.St.D",
"content": "def worklist.St.D (st : worklist.St A S) : Set S := st.visited"
},
{
"name": "worklist.St.visited",
"content": "def worklist.St.visited (st : worklist.St A S) : Set S := { s : S | s ∈ st.map ∧ s ∉ st.worklist }"
},
{
"name": "worklistGo_spec",
"content": "def worklistGo_spec {st : worklist.St A S} (inv : StInv A S st.m st.map) :\n st.sim inits final f ∅ →\n (worklistRun'.go A S final f st |>.Sim $ nfa inits final f) :="
},
{
"name": "worklist.St.rel",
"content": "def worklist.St.rel (st : worklist.St A S) : SetRel State S := {(s, sa) | st.map[sa]? = some s }"
},
{
"name": "processOneElem_mot",
"content": "def processOneElem_mot (s : State) (sa : S) (n : ℕ) (st : worklist.St A S) : Prop :=\n st.map[sa]? = some s ∧\n sa ∈ st.visited ∧\n StInv A S st.m st.map ∧\n st.sim inits final f {(sa1, a, sa') | sa1 = sa ∧ ∃ k ≥ n, (f sa)[k]? = some (a, sa') }"
},
{
"name": "worklist.St.sim",
"content": "abbrev worklist.St.sim {st : worklist.St A S} (T : Set (S × A × S)) :=\n st.m.Simul (nfa inits final f) st.rel st.D T"
},
{
"name": "RawCNFA.Sim",
"content": "def RawCNFA.Sim (m : RawCNFA A) (A : NFA A S) := ∃ R, RawCNFA.Simul m A R ⊤ ∅"
},
{
"name": "RawCNFA.Simul",
"content": "structure RawCNFA.Simul (m : RawCNFA A) (M : NFA A Q) (R : SetRel State Q) (D : Set Q) (T : Set (Q × A × Q)) where\n accept {s q} : s ~[R] q → (s ∈ m.finals ↔ q ∈ M.accept)\n initial₁ {s} : s ∈ m.initials → ∃ q ∈ M.start, s ~[R] q\n initial₂ {q} : q ∈ M.start → ∃ s ∈ m.initials, s ~[R] q\n trans_match₁ {s s' a q} : s ~[R] q → s' ∈ m.tr s a → ∃ q', q' ∈ M.step q a ∧ s' ~[R] q'\n trans_match₂ {s a q q'} : s ~[R] q → q' ∈ M.step q a → q ∈ D → (q, a, q') ∉ T → ∃ s', s' ∈ m.tr s a ∧ s' ~[R] q'"
},
{
"name": "RawCNFA.SimulFun",
"content": "structure RawCNFA.SimulFun (m : RawCNFA A) (M : NFA A Q) (f : m.states ≃ Q) where\n accept {q} : ((f.invFun q).val ∈ m.finals ↔ q ∈ M.accept)\n initial {q} : q ∈ M.start ↔ (f.invFun q).val ∈ m.initials\n trans_match {a q q'} : q' ∈ M.step q a ↔ (f.invFun q').val ∈ m.tr (f.invFun q) a"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "CNFA.Sim",
"content": "def CNFA.Sim (m : CNFA n) (M : NFA' n) :=\n m.m.Sim M.M"
},
{
"name": "CNFA.bv_recognizes",
"content": "def CNFA.bv_recognizes (m : CNFA n) (L : Set (BitVecs n)) :=\n ∃ L', m.recognizes L' ∧ L = dec '' L'"
},
{
"name": "RawCNFA.recognizes",
"content": "def RawCNFA.recognizes (m : RawCNFA A) (L : Language A) :=\n ∃ (σ : Type) (M : NFA A σ), m.Sim M ∧ M.accepts = L"
},
{
"name": "CNFA.recognizes",
"content": "def CNFA.recognizes (m : CNFA n) (L : Language (BitVec n)) :=\n ∃ (M : NFA' n), m.Sim M ∧ M.M.accepts = L"
},
{
"name": "BitVecs.cast",
"content": "def BitVecs.cast (bvs : BitVecs n) (h : n = n') : BitVecs n' :=\n { w := bvs.w, bvs := h ▸ bvs.bvs }"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "CNFA.minimize",
"content": "def CNFA.minimize (m : CNFA n) : CNFA n :=\n let mᵣ := m.reverse.determinize\n mᵣ.reverse.determinize"
},
{
"name": "CNFA.determinize",
"content": "def CNFA.determinize (m : CNFA n) : CNFA n :=\n worklistRun (BitVec m.m.stateMax)\n (fun ss => ss.any fun n b => b == true && n ∈ m.m.finals)\n (determinize.inits m)\n (by admit /- proof elided -/\n )\n f\nwhere\n f := fun (ss : BitVec m.m.stateMax) =>\n (FinEnum.toList (BitVec n)).foldl (init := Array.empty) fun ts a =>\n let ss' := m.m.transSetBV ss a\n ts.push (a, ss')"
},
{
"name": "CNFA.determinize.inits",
"content": "def CNFA.determinize.inits (m : CNFA n) : Array (BitVec m.m.stateMax) :=\n #[BitVec.ofFn (fun n => n ∈ m.m.initials)]"
},
{
"name": "CNFA.reverse",
"content": "def CNFA.reverse (m : CNFA n) : CNFA n :=\n ⟨m.m.reverse, RawCNFA.reverse_spec m.wf |>.1⟩"
},
{
"name": "RawCNFA.reverse",
"content": "def RawCNFA.reverse (m : RawCNFA A) : RawCNFA A :=\n let m' := { stateMax := m.stateMax, trans := Std.HashMap.emptyWithCapacity m.trans.size, initials := m.finals, finals := m.initials}\n m.trans.fold (init := m') processState\nwhere\n processState := fun m' (s, a) ss' =>\n ss'.fold (init := m') fun m' s' => m'.addTrans a s' s"
},
{
"name": "CNFA.toNFA'",
"content": "def CNFA.toNFA' (m : CNFA n) : NFA' n := ⟨_, m.toNFA⟩"
},
{
"name": "CNFA.toNFA",
"content": "def CNFA.toNFA (m : CNFA n) : NFA (BitVec n) m.m.states where\n start := { s | s.val ∈ m.m.initials }\n accept := { s | s.val ∈ m.m.finals }\n step s₁ a := { s₂ | s₂.val ∈ m.m.tr s₁.val a }"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "reverse",
"content": "def reverse (M : NFA' n) : NFA' n where\n σ := _\n M := M.M.reverse"
},
{
"name": "CNFA.determinize_spec",
"content": "def CNFA.determinize_spec (m : CNFA n)\n {M : NFA' n} (hsim : m.Sim M) :\n m.determinize.Sim M.determinize :="
},
{
"name": "bv_to_set",
"content": "private def bv_to_set (bv : BitVec w) : Set State :=\n { s | bv.getLsbD s }"
},
{
"name": "_root_.SetRel.set_eq",
"content": "structure _root_.SetRel.set_eq (R : SetRel α β) (A : Set α) (B : Set β) where\n fwd : a ∈ A → ∃ b ∈ B, a ~[R] b\n bwd : b ∈ B → ∃ a ∈ A, a ~[R] b"
},
{
"name": "RawCNFA.lift",
"content": "@[inline]\ndef RawCNFA.lift (m₁: RawCNFA (BitVec n1)) (f : Fin n1 → Fin n2) : RawCNFA (BitVec n2) :=\n let trans := (List.range m₁.stateMax).foldl (init := ∅) fun m2 s => processState m2 s\n { m₁ with trans }\nwhere"
},
{
"name": "CNFA.lift",
"content": "@[inline]\ndef CNFA.lift (m: CNFA n1) (f : Fin n1 → Fin n2) : CNFA n2 :=\n ⟨m.m.lift f, m.m.lift_wf m.wf⟩"
},
{
"name": "RawCNFA.proj",
"content": "@[inline]\ndef RawCNFA.proj (m1: RawCNFA (BitVec n1)) (f : Fin n2 → Fin n1) : RawCNFA (BitVec n2) :=\n let trans := m1.trans.keysArray.foldl (init := Std.HashMap.emptyWithCapacity) process\n { m1 with trans }\nwhere"
},
{
"name": "CNFA.proj_spec",
"content": "def CNFA.proj_spec (m : CNFA n2) (f : Fin n1 → Fin n2) {M : NFA' n2} :\n m.Sim M → (m.proj f |>.Sim (M.proj f)) :="
},
{
"name": "CNFA.proj",
"content": "@[inline]\ndef CNFA.proj (m: CNFA n2) (f : Fin n1 → Fin n2) : CNFA n1 :=\n ⟨m.m.proj f, m.m.proj_wf m.wf⟩"
},
{
"name": "CNFA.neg_spec",
"content": "def CNFA.neg_spec (m : CNFA n) {M : NFA' n} (hsim : m.Sim M) :\n m.neg.Sim M.neg :="
},
{
"name": "CNFA.neg",
"content": "def CNFA.neg (m : CNFA n) : CNFA n := m.determinize.flipFinals"
},
{
"name": "CNFA.flipFinals",
"content": "def CNFA.flipFinals (m : CNFA n) : CNFA n := ⟨m.m.flipFinals, m.m.flipFinals_wf m.wf⟩"
},
{
"name": "RawCNFA.flipFinals",
"content": "def RawCNFA.flipFinals (m : RawCNFA A) : RawCNFA A :=\n let oldFinals := m.finals\n let newFinals := (List.range m.stateMax).foldl (init := ∅) fun fins s =>\n if oldFinals.contains s then fins else fins.insert s\n { m with finals := newFinals }"
},
{
"name": "bv2",
"content": "def bv2 : BitVec 4 := BitVec.ofNat 4 1 "
},
{
"name": "bv1",
"content": "def bv1 : BitVec 4 := BitVec.ofNat 4 5 "
},
{
"name": "instFinEnumBV",
"content": "instance instFinEnumBV : FinEnum (BitVec w) where\n card := 2^w\n equiv := {\n toFun := fun x => x.toFin\n invFun := fun x => BitVec.ofFin x\n left_inv := by admit /- proof elided -/"
},
{
"name": "RawCNFA.WF",
"content": "structure RawCNFA.WF (m : RawCNFA A) where\n initials_lt : ∀ {s}, s ∈ m.initials → s ∈ m.states\n finals_lt : ∀ {s}, s ∈ m.finals → s ∈ m.states\n trans_src_lt : ∀ s_a ∈ m.trans, s_a.1 ∈ m.states\n trans_tgt_lt : s' ∈ m.tr s a → s' ∈ m.states"
},
{
"name": "CNFA.product_spec",
"content": "def CNFA.product_spec (final? : Bool → Bool → Bool) (m1 m2 : CNFA n)\n {M1 : NFA' n} {M2 : NFA' n} :\n m1.Sim M1 →\n m2.Sim M2 →\n (product final? m1 m2).Sim (NFA'.product (to_prop final?) M1 M2) :="
},
{
"name": "to_prop",
"content": "noncomputable def to_prop (f : Bool → Bool → Bool) (p1 p2 : Prop) : Prop :=\n f (@Decidable.decide p1 (Classical.propDecidable _)) (@Decidable.decide p2 (Classical.propDecidable _))"
},
{
"name": "CNFA.union",
"content": "def CNFA.union (m1 m2 : CNFA n) : CNFA n :=\n product (fun b1 b2 => b1 || b2) m1.addSink m2.addSink"
},
{
"name": "CNFA.addSink",
"content": "@[inline]\ndef CNFA.addSink (m : CNFA n) : CNFA n := ⟨m.m.addSink, wf_createSink m.wf⟩"
},
{
"name": "RawCNFA.addSink",
"content": "@[inline]\ndef RawCNFA.addSink (m : RawCNFA A) : RawCNFA A := m.createSink.2"
},
{
"name": "complete",
"content": "noncomputable def complete (M : NFA' n) : NFA' n where\n σ := _\n M := M.M.complete"
},
{
"name": "RawCNFA.addTrans",
"content": "def RawCNFA.addTrans (m : RawCNFA A) (a : A) (s s' : State) : RawCNFA A :=\n let ns := m.trans.getD (s, a) ∅\n let ns := ns.insert s'\n { m with trans := m.trans.insert (s, a) ns }"
},
{
"name": "RawCNFA.newState",
"content": "def RawCNFA.newState (m : RawCNFA A) : State × RawCNFA A :=\n let old := m.stateMax\n let m := { m with stateMax := old + 1 }\n (old, m)"
},
{
"name": "RawCNFA.addInitial",
"content": "def RawCNFA.addInitial (m : RawCNFA A) (s : State) : RawCNFA A :=\n { m with initials := m.initials.insert s }"
},
{
"name": "langMsb",
"content": "@[simp]\ndef langMsb : Set (BitVecs 1) := { bvs | bvs.bvs.get 0 |>.msb }"
},
{
"name": "head",
"content": "def head (x : BitStream) : Bool := x 0"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "List.nodup_singleton",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "NFA.eval_append_singleton",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.eval_nil",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Fin.add_def",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fin.castLE_castLE",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.le_of_eq",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Fin.ext_iff",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.mod_le",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "eq_iff_iff",
"module": "Init.Core"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "ite_cond_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "BitVec.toNat_eq",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "le_iff_lt_or_eq",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "Nat.le_antisymm",
"module": "Init.Prelude"
},
{
"name": "BitVec.toInt_inj",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.zero_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Finset.mem_range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Function.iterate_add",
"module": "Mathlib.Logic.Function.Iterate"
},
{
"name": "eq_of_forall_lt_iff",
"module": "Mathlib.Order.Basic"
},
{
"name": "gt_iff_lt",
"module": "Init.Core"
},
{
"name": "Fin.val_one",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "eq_iff_eq_of_cmp_eq_cmp",
"module": "Mathlib.Order.Compare"
},
{
"name": "BitVec.eq_nil",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.getElem_one",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.getLsbD_eq_getElem",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.msb_eq_getLsbD_last",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.ofNat_eq_ofNat",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.getElem?_eq_getElem",
"module": "Init.GetElem"
},
{
"name": "List.getLast?_eq_getElem?",
"module": "Init.Data.List.Lemmas"
},
{
"name": "Set.mem_image",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "and_true",
"module": "Init.SimpLemmas"
},
{
"name": "decide_true",
"module": "Init.Core"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
},
{
"name": "bisim_comp",
"content": "lemma bisim_comp (m : RawCNFA A) :\n m.Sim M₁ → M₁.Bisim M₂ → m.Sim M₂"
},
{
"name": "bisimul_comp",
"content": "lemma bisimul_comp {m : RawCNFA A} :\n m.Simul M₁ R₁ ⊤ ∅ → M₁.Bisimul R₂ M₂ →\n m.Simul M₂ (R₁.comp R₂) ⊤ ∅"
},
{
"name": "CNFA.bv_recognizes_equiv",
"content": "lemma CNFA.bv_recognizes_equiv {m : CNFA n} :\n m.bv_recognizes L ↔ ∃ (M : NFA' n), m.Sim M ∧ M.accepts = L"
},
{
"name": "List.Vector.append_get_ge",
"content": "@[simp]\nlemma List.Vector.append_get_ge {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: n ≤ i) :\n (x ++ y).get i = y.get ((i.cast (Nat.add_comm n m) |>.subNat n hlt))"
},
{
"name": "List.Vector.append_get_lt",
"content": "@[simp]\nlemma List.Vector.append_get_lt {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: i < n) :\n (x ++ y).get i = x.get (i.castLT hlt)"
},
{
"name": "CNFA.minimize_bv_language",
"content": "lemma CNFA.minimize_bv_language {m : CNFA n} :\n m.bv_recognizes L → m.minimize.bv_recognizes L"
},
{
"name": "CNFA.minimize_language",
"content": "lemma CNFA.minimize_language {m : CNFA n} :\n m.recognizes L → m.minimize.recognizes L"
},
{
"name": "CNFA.reverse_language",
"content": "lemma CNFA.reverse_language {m : CNFA n} (hl : m.recognizes L) : m.reverse.recognizes L.reverse"
},
{
"name": "CNFA.reverse_spec",
"content": "lemma CNFA.reverse_spec {m : CNFA n} : m.reverse.Sim m.toNFA'.reverse"
},
{
"name": "RawCNFA.reverse_spec",
"content": "lemma RawCNFA.reverse_spec {m : RawCNFA A} (hwf : m.WF) :\n let m'"
},
{
"name": "RawCNFA.reverse_spec_procesState",
"content": "lemma RawCNFA.reverse_spec_procesState {m : RawCNFA A} (hwf : m.WF) s₀ a₀ ss' (hs₀ : s₀ ∈ m.states) :\n let motive m' ss'"
},
{
"name": "CNFA.determinize_language",
"content": "lemma CNFA.determinize_language {m : CNFA n} :\n m.recognizes L → m.determinize.recognizes L"
},
{
"name": "CNFA.lift_bv_language",
"content": "@[simp]\nlemma CNFA.lift_bv_language {m : CNFA n1} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.lift f |>.bv_recognizes (BitVecs.transport f ⁻¹' L))"
},
{
"name": "CNFA.lift_spec",
"content": "lemma CNFA.lift_spec (m : CNFA n1) (f : Fin n1 → Fin n2) {M : NFA' n1} :\n m.Sim M → (m.lift f |>.Sim (M.lift f))"
},
{
"name": "CNFA.proj_bv_language",
"content": "lemma CNFA.proj_bv_language {m : CNFA n2} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.proj f |>.bv_recognizes (BitVecs.transport f '' L))"
},
{
"name": "BitVecs.transport_getElem",
"content": "@[simp]\nlemma BitVecs.transport_getElem {bvs : BitVecs m} (f : Fin n → Fin m) (i : Fin n) :\n (bvs.transport f).bvs.get i = bvs.bvs.get (f i)"
},
{
"name": "simulFun_sim",
"content": "lemma simulFun_sim {m : CNFA n} f :\n m.m.SimulFun M.M f → m.Sim M"
},
{
"name": "simulFun_sim_raw",
"content": "lemma simulFun_sim_raw [LawfulBEq A] {m : RawCNFA A} (hwf : m.WF) f :\n m.SimulFun M f → m.Sim M"
},
{
"name": "RawCNFA.Simul.initial",
"content": "@[simp]\nlemma RawCNFA.Simul.initial {m : RawCNFA A} {M : NFA A Q} (hsim : m.Simul M R ⊤ ∅) :\n R.set_eq m.initials.toSet M.start"
},
{
"name": "CNFA.inter_spec",
"content": "lemma CNFA.inter_spec (m1 m2 : CNFA n)\n {M1 : NFA' n} {M2 : NFA' n} :\n m1.Sim M1 →\n m2.Sim M2 →\n (m1.inter m2).Sim (M1.inter M2)"
},
{
"name": "CNFA.union_spec",
"content": "lemma CNFA.union_spec (m1 m2 : CNFA n)\n {M1 : NFA' n} {M2 : NFA' n} :\n m1.Sim M1 →\n m2.Sim M2 →\n (m1.union m2).Sim (M1.union M2)"
},
{
"name": "CNFA.addSink_spec",
"content": "lemma CNFA.addSink_spec (m : CNFA n) (M : NFA' n) :\n m.Sim M →\n m.addSink.Sim M.complete"
},
{
"name": "wf_addTrans",
"content": "@[grind ., simp, aesop 50% unsafe]\nlemma wf_addTrans [LawfulBEq A] (m : RawCNFA A) (hwf : m.WF) s a s' (hin : s ∈ m.states) (hin' : s' ∈ m.states) :\n (m.addTrans a s s').WF"
},
{
"name": "RawCNFA.same_stateMax",
"content": "@[grind =, simp]\nlemma RawCNFA.same_stateMax (m : RawCNFA A) x y (z : Std.HashMap (State × A) (Std.HashSet State)) :\n (RawCNFA.mk m.stateMax x y z).states = m.states"
},
{
"name": "newState_eq",
"content": "@[grind =, simp, aesop 50% unsafe]\nlemma newState_eq (m : RawCNFA A) :\n m.newState.1 = m.stateMax"
},
{
"name": "addInitial_stateMax",
"content": "@[grind =, simp]\nlemma addInitial_stateMax {m : RawCNFA A} : (m.addInitial s).stateMax = m.stateMax"
},
{
"name": "addTrans_stateMax",
"content": "@[grind =, simp]\nlemma addTrans_stateMax {m : RawCNFA A} : (m.addTrans a s s').stateMax = m.stateMax"
},
{
"name": "dec_enc'",
"content": "@[simp]\nlemma dec_enc' : dec (enc bvs) = bvs"
},
{
"name": "dec_enc",
"content": "@[simp]\nlemma dec_enc : Function.RightInverse (α := BitVecs' n) enc dec"
},
{
"name": "dec_enc_w",
"content": "lemma dec_enc_w (bvs : BitVecs n) : (dec (enc bvs)).w = bvs.w"
},
{
"name": "BitVec.ofFn_getElem",
"content": "@[simp]\ntheorem BitVec.ofFn_getElem {w : Nat} (f : Fin w → Bool) {i : Nat} (hi : i < w) :\n (BitVec.ofFn f)[i] = f ⟨i, hi⟩"
},
{
"name": "BitVec.ofFn_getLsbD",
"content": "@[simp]\ntheorem BitVec.ofFn_getLsbD {w : Nat} {f : Fin w → Bool} {i : Nat} (hi : i < w) :\n (BitVec.ofFn f).getLsbD i = f ⟨i, hi⟩"
},
{
"name": "BitVec.ofFn_getLsbD_fin",
"content": "theorem BitVec.ofFn_getLsbD_fin {w : Nat} {f : Fin w → Bool} {i : Fin w} :\n (BitVec.ofFn f).getLsbD i = f i"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVRel",
"content": "abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "NFA'.sa2",
"content": "def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel"
},
{
"name": "langRel",
"content": "def langRel (R : BVNRel n) : Set (BitVecs n) :=\n { bvs | R bvs.bvs }"
},
{
"name": "langRel2",
"content": "def langRel2 (R : BVRel) : Set (BitVecs 2) :=\n { bvs | R (bvs.bvs.get 0) (bvs.bvs.get 1) }"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "Alphabet",
"content": "abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)"
},
{
"name": "finFunToBitVec",
"content": "def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=\n BitVec.ofFn fun i => c (fe.equiv.invFun i)"
},
{
"name": "bitVecToFinFun",
"content": "def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=\n fun c => bv[FinEnum.equiv.toFun c]"
},
{
"name": "NFA.ofFSM",
"content": "def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where\n start := { q | q = p.initCarry }\n accept := ⊤\n step s a := {s' |\n let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))\n s' = s'' ∧ a.msb = b }"
},
{
"name": "inFSMRel",
"content": "@[simp]\nabbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=\n bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_sa",
"content": "def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>\n inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_correct",
"content": "def NFA'.ofFSM_correct (p : FSM arity) :\n (NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :="
},
{
"name": "CNFA.ofFSM",
"content": "def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=\n worklistRun (BitVec (FinEnum.card p.α))\n (fun _ => true)\n #[finFunToBitVec p.initCarry]\n (by admit /- proof elided -/\n )\n f\n where"
},
{
"name": "RawCNFA.autEq",
"content": "def RawCNFA.autEq : RawCNFA (BitVec 2) :=\n let m := RawCNFA.empty\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := m.addFinal s\n let m := m.addTrans 0 s s\n let m := m.addTrans 3 s s\n m"
},
{
"name": "CNFA.autEq",
"content": "def CNFA.autEq : CNFA 2 :=\n ⟨RawCNFA.autEq, by admit /- proof elided -/\n ⟩"
},
{
"name": "NFA.autEq",
"content": "def NFA.autEq : NFA (BitVec 2) Unit :=\n { start := ⊤, accept := ⊤, step _ a := { _s' | if a = 0 ∨ a = 3 then true else false }}"
},
{
"name": "NFA'.autEq",
"content": "def NFA'.autEq : NFA' 2 :=\n ⟨Unit, NFA.autEq⟩"
},
{
"name": "NFA'.eqRel",
"content": "def NFA'.eqRel : BVRel := fun _ x y => x = y"
},
{
"name": "autEq_equiv",
"content": "def autEq_equiv : CNFA.autEq.m.states ≃ NFA'.autEq.σ where\n toFun := fun ⟨s, hs⟩ =>\n match s with\n | _ => ()\n invFun q :=\n match q with\n | () => ⟨0, by admit /- proof elided -/\n ⟩\n left_inv := by admit /- proof elided -/"
},
{
"name": "RawCNFA.autUnsignedCmp",
"content": "def RawCNFA.autUnsignedCmp (cmp: RelationOrdering) : RawCNFA (BitVec 2) :=\n let m := RawCNFA.empty\n let (seq, m) := m.newState\n let (sgt, m) := m.newState\n let (slt, m) := m.newState\n let m := m.addInitial seq\n let m := m.addManyTrans [0#2, 3#2] seq seq\n let m := m.addTrans 1#2 seq sgt\n let m := m.addTrans 2#2 seq slt\n let m := m.addManyTrans [0#2, 1#2, 3#2] sgt sgt\n let m := m.addTrans 2#2 sgt slt\n let m := m.addManyTrans [0#2, 2#2, 3#2] slt slt\n let mf := m.addTrans 1#2 slt sgt\n match cmp with\n | .lt => mf.addFinal slt\n | .le => (mf.addFinal slt).addFinal seq\n | .gt => mf.addFinal sgt\n | .ge => (mf.addFinal sgt).addFinal seq"
},
{
"name": "CNFA.autUnsignedCmp",
"content": "def CNFA.autUnsignedCmp (cmp: RelationOrdering) : CNFA 2 :=\n ⟨RawCNFA.autUnsignedCmp cmp, RawCNFA.autoUnsignedCmp_wf⟩"
},
{
"name": "NFA.unsignedCmpState",
"content": "inductive NFA.unsignedCmpState : Type where\n| eq | gt | lt\nderiving Fintype, DecidableEq"
},
{
"name": "NFA.unsignedCmpStep",
"content": "def NFA.unsignedCmpStep (q : NFA.unsignedCmpState) (a : BitVec 2) : List NFA.unsignedCmpState :=\n match q, a with\n | .eq, 0 => [ .eq ] | .eq, 3 => [ .eq ] | .eq, 1 => [ .gt ] | .eq, 2 => [ .lt ]\n | .gt, 0 => [ .gt ] | .gt, 1 => [ .gt ] | .gt, 3 => [ .gt ] | .gt, 2 => [ .lt ]\n | .lt, 0 => [ .lt ] | .lt, 1 => [ .gt ] | .lt, 2 => [ .lt ] | .lt, 3 => [ .lt ]"
},
{
"name": "NFA.autUnsignedCmp",
"content": "def NFA.autUnsignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) unsignedCmpState where\n step s a := { s' | s' ∈ unsignedCmpStep s a }\n start := {s | s = .eq }\n accept := { s | s ∈ match cmp with | .lt => [unsignedCmpState.lt] | .le => [.lt, .eq] | .gt => [.gt] | .ge => [.gt, .eq] }"
},
{
"name": "NFA'.autUnsignedCmp",
"content": "def NFA'.autUnsignedCmp (cmp: RelationOrdering) : NFA' 2 :=\n ⟨_, NFA.autUnsignedCmp cmp⟩"
},
{
"name": "RelationOrdering.urel",
"content": "def RelationOrdering.urel (cmp : RelationOrdering) : BVRel :=\n match cmp with\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .le => fun _ bv1 bv2 => bv1.ule bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1\n | .ge => fun _ bv1 bv2 => bv2.ule bv1"
},
{
"name": "NFA'.autUnsignedCmpSA",
"content": "def NFA'.autUnsignedCmpSA (q : NFA.unsignedCmpState) : BVRel :=\n match q with\n | .eq => fun _ bv1 bv2 => bv1 = bv2\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1"
},
{
"name": "RawCNFA.autSignedCmp",
"content": "def RawCNFA.autSignedCmp (cmp: RelationOrdering) : RawCNFA (BitVec 2) :=\n let (m, sltfin, sgtfin, seq) := m\n match cmp with\n | .lt => m.addFinal sltfin\n | .le => (m.addFinal sltfin).addFinal seq\n | .gt => m.addFinal sgtfin\n | .ge => (m.addFinal sgtfin).addFinal seq\nwhere"
},
{
"name": "CNFA.autSignedCmp",
"content": "def CNFA.autSignedCmp (cmp: RelationOrdering) : CNFA 2 :=\n ⟨RawCNFA.autSignedCmp cmp, RawCNFA.autSignedCmp_wf⟩"
},
{
"name": "NFA.signedCmpState",
"content": "inductive NFA.signedCmpState : Type where\n| eq | gt | lt | ltfin | gtfin\nderiving DecidableEq, Fintype"
},
{
"name": "NFA.signedCmpStep",
"content": "def NFA.signedCmpStep (q : NFA.signedCmpState) (a : BitVec 2) : List NFA.signedCmpState :=\n match q, a with\n | .eq, 0 => [ .eq ] | .eq, 3 => [.eq] | .eq, 1 => [.gt, .ltfin] | .eq, 2 => [ .lt, .gtfin ]\n | .gt, 0 => [ .gt, .gtfin ] | .gt, 1 => [ .gt, .ltfin ] | .gt, 3 => [ .gt, .gtfin ] | .gt, 2 => [ .lt, .gtfin ]\n | .lt, 0 => [ .lt, .ltfin ] | .lt, 1 => [ .gt, .ltfin ] | .lt, 2 => [ .lt, .gtfin ] | .lt, 3 => [ .lt, .ltfin ]\n | .gtfin, _ => ∅\n | .ltfin, _ => ∅"
},
{
"name": "NFA.autSignedCmp",
"content": "def NFA.autSignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) signedCmpState where\n step s a := { s' | s' ∈ signedCmpStep s a }\n start := { s | s = signedCmpState.eq }\n accept := { s | s ∈ match cmp with | .lt => [NFA.signedCmpState.ltfin] | .le => [.ltfin, .eq] | .gt => [.gtfin] | .ge => [.gtfin, .eq] }"
},
{
"name": "NFA'.autSignedCmp",
"content": "def NFA'.autSignedCmp (cmp: RelationOrdering) : NFA' 2 :=\n ⟨_, NFA.autSignedCmp cmp⟩"
},
{
"name": "RelationOrdering.srel",
"content": "def RelationOrdering.srel (cmp : RelationOrdering) : BVRel :=\n match cmp with\n | .lt => fun _ bv1 bv2 => bv1.slt bv2\n | .le => fun _ bv1 bv2 => bv1.sle bv2\n | .gt => fun _ bv1 bv2 => bv2.slt bv1\n | .ge => fun _ bv1 bv2 => bv2.sle bv1"
},
{
"name": "NFA'.autSignedCmpSA",
"content": "def NFA'.autSignedCmpSA (q : NFA.signedCmpState) : BVRel :=\n match q with\n | .eq => fun _ bv1 bv2 => bv1 = bv2\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1\n | .ltfin => fun _ bv1 bv2 => bv1.slt bv2\n | .gtfin => fun _ bv1 bv2 => bv2.slt bv1"
},
{
"name": "unsigned_equiv",
"content": "def unsigned_equiv cmp : (CNFA.autUnsignedCmp cmp).m.states ≃ (NFA'.autUnsignedCmp cmp).σ where\n toFun := fun ⟨s, hs⟩ =>\n match s with\n | 0 => .eq\n | 1 => .gt\n | _ => .lt\n invFun q :=\n match q with\n | .eq => ⟨0, by admit /- proof elided -/\n ⟩\n | .gt => ⟨1, by admit /- proof elided -/\n ⟩\n | .lt => ⟨2, by admit /- proof elided -/\n ⟩\n left_inv := by admit /- proof elided -/"
},
{
"name": "signed_equiv",
"content": "def signed_equiv cmp : (CNFA.autSignedCmp cmp).m.states ≃ (NFA'.autSignedCmp cmp).σ where\n toFun := fun ⟨s, hs⟩ =>\n match s with\n | 0 => .eq\n | 1 => .gt\n | 2 => .lt\n | 3 => .gtfin\n | _ => .ltfin\n invFun q :=\n match q with\n | .eq => ⟨0, by admit /- proof elided -/\n ⟩\n | .gt => ⟨1, by admit /- proof elided -/\n ⟩\n | .lt => ⟨2, by admit /- proof elided -/\n ⟩\n | .gtfin => ⟨3, by admit /- proof elided -/\n ⟩\n | .ltfin => ⟨4, by admit /- proof elided -/\n ⟩\n left_inv := by admit /- proof elided -/"
},
{
"name": "RawCNFA.autMsbSet",
"content": "def RawCNFA.autMsbSet : RawCNFA (BitVec 1) :=\n let m := RawCNFA.empty\n let (si, m) := m.newState\n let (sf, m) := m.newState\n let m := m.addInitial si\n let m := m.addFinal sf\n let m := m.addTrans 1 si sf\n let m := m.addManyTrans [0, 1] si si\n m"
},
{
"name": "CNFA.autMsbSet",
"content": "@[inline]\ndef CNFA.autMsbSet : CNFA 1 :=\n ⟨RawCNFA.autMsbSet, RawCNFA.autMsbSet_wf⟩"
},
{
"name": "NFA.msbState",
"content": "inductive NFA.msbState : Type where\n| i | f\nderiving DecidableEq, Fintype"
},
{
"name": "NFA.msbStep",
"content": "def NFA.msbStep (q : NFA.msbState) (a : BitVec 1) : List NFA.msbState :=\n match q, a with\n | .i, 0 => [.i]\n | .i, 1 => [.i, .f]\n | _, _ => []"
},
{
"name": "NFA.autMsbSet",
"content": "def NFA.autMsbSet : NFA (BitVec 1) msbState where\n step s a := { s' | s' ∈ msbStep s a }\n start := {.i}\n accept := {.f}"
},
{
"name": "NFA'.autMsbSet",
"content": "def NFA'.autMsbSet : NFA' 1 := ⟨_, NFA.autMsbSet⟩"
},
{
"name": "NFA.msbLang",
"content": "def NFA.msbLang : Language (BitVec 1) := { bvs | bvs.getLast? = some 1 }"
},
{
"name": "NFA.msbSA",
"content": "def NFA.msbSA (q : msbState) : Language (BitVec 1) :=\n match q with\n | .i => ⊤\n | .f => msbLang"
},
{
"name": "NFA.msbCorrect",
"content": "def NFA.msbCorrect : NFA.autMsbSet.correct msbSA msbLang :="
},
{
"name": "autMsb_equiv",
"content": "def autMsb_equiv : CNFA.autMsbSet.m.states ≃ NFA'.autMsbSet.σ where\n toFun := fun ⟨s, hs⟩ =>\n match s with\n | 0 => .i\n | 1 => .f\n | _ => .i\n invFun q :=\n match q with\n | .i => ⟨0, by admit /- proof elided -/\n ⟩\n | .f => ⟨1, by admit /- proof elided -/\n ⟩\n left_inv := by admit /- proof elided -/"
},
{
"name": "WidthPredicate.final?",
"content": "def WidthPredicate.final? (wp : WidthPredicate) (n : Nat) (s : State) : Bool :=\n decide (wp.sat s n)"
},
{
"name": "RawCNFA.autWidth",
"content": "def RawCNFA.autWidth (wp : WidthPredicate) (n : Nat) : RawCNFA (BitVec 0) :=\n let m := (n+2).iterate f empty\n let m := m.addInitial 0\n m.addTrans (BitVec.zero 0) (n + 1) (n + 1)\nwhere\n f m :=\n let (s, m) := m.newState\n let m := if wp.final? n s then m.addFinal s else m\n if s > 0 then m.addTrans (BitVec.zero 0) (s-1) s else m"
},
{
"name": "CNFA.autWidth",
"content": "def CNFA.autWidth (wp : WidthPredicate) (n : Nat) : CNFA 0 :=\n ⟨RawCNFA.autWidth wp n, RawCNFA.autWidth_wf⟩"
},
{
"name": "NFA.autWidth",
"content": "def NFA.autWidth (wp : WidthPredicate) (n : Nat) : NFA (BitVec 0) (Fin (n+2)) where\n start := { 0 }\n accept := { s | wp.final? n s }\n step s₁ _ := { s₂ | if s₁ = Fin.last (n+1) then s₁ = s₂ else s₂ = s₁ + 1 }"
},
{
"name": "NFA'.autWidth",
"content": "def NFA'.autWidth (wp : WidthPredicate) (n : Nat) : NFA' 0 := ⟨_, NFA.autWidth wp n⟩"
},
{
"name": "NFA'.autWidth_spec",
"content": "@[simp]\ndef NFA'.autWidth_spec : (autWidth wp n).accepts = { bv | wp.sat bv.w n } :="
},
{
"name": "autWidth_equiv",
"content": "def autWidth_equiv : (CNFA.autWidth wp n).m.states ≃ (NFA'.autWidth wp n).σ where\n toFun := fun ⟨s, hs⟩ =>\n Fin.mk s (by admit /- proof elided -/\n )\n invFun q := ⟨q.val, by admit /- proof elided -/\n ⟩\n left_inv := by admit /- proof elided -/"
},
{
"name": "Relation.autOfRelation",
"content": "def Relation.autOfRelation : Relation → CNFA 2\n| .eq => CNFA.autEq\n| .signed ord => CNFA.autSignedCmp ord\n| .unsigned ord => CNFA.autUnsignedCmp ord"
},
{
"name": "Relation.absAutOfRelation",
"content": "def Relation.absAutOfRelation (rel : Relation) : NFA' 2 :=\n match rel with\n | .eq => NFA'.autEq\n | .unsigned cmp => NFA'.autUnsignedCmp cmp\n | .signed cmp => NFA'.autSignedCmp cmp"
},
{
"name": "unopNfa",
"content": "def unopNfa (op : Unop) (m : CNFA n) : CNFA n :=\n match op with\n | .neg => m.neg"
},
{
"name": "unopAbsNfa",
"content": "def unopAbsNfa (op : Unop) (M : NFA' n) : NFA' n :=\n match op with\n | .neg => M.neg"
},
{
"name": "binopNfa",
"content": "def binopNfa (op : Binop) (m1 m2 : CNFA n) : CNFA n :=\n match op with\n | .and => m1.inter m2\n | .or => m1.union m2\n | .impl => m1.neg.union m2\n | .equiv => (m1.neg.union m2).inter (m2.neg.union m1)"
},
{
"name": "binopAbsNfa",
"content": "def binopAbsNfa (op : Binop) (M1 M2: NFA' n) : NFA' n :=\n match op with\n | .and => M1.inter M2\n | .or => M1.union M2\n | .impl => M1.neg.union M2\n | .equiv => (M1.neg.union M2).inter (M2.neg.union M1)"
},
{
"name": "liftOp",
"content": "def liftOp n : Fin (n + 1) → Fin (n + 3) :=\n fun k =>\n if k = n then Fin.last (n+2) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftOp_unchanged",
"content": "@[simp]\ndef liftOp_unchanged (k : Fin n) : liftOp n k.castSucc = k.castLE (by simp) :="
},
{
"name": "liftUnop",
"content": "def liftUnop n : Fin (n + 1) → Fin (n + 2) :=\n fun k =>\n if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "TermBinop",
"content": "inductive TermBinop where\n| and | or | xor | add | sub"
},
{
"name": "TermBinop.subst",
"content": "def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=\n match op with\n | .and => .and t₁ t₂\n | .or => .or t₁ t₂\n | .xor => .xor t₁ t₂\n | .add => .add t₁ t₂\n | .sub => .sub t₁ t₂"
},
{
"name": "TermBinop.openTerm",
"content": "def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)"
},
{
"name": "TermBinop.openTerm_arity",
"content": "@[simp]\ndef TermBinop.openTerm_arity (op : TermBinop) : op.openTerm.arity + 1 = 3 :="
},
{
"name": "TermBinop.termGadget",
"content": "def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=\n match t with\n | .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM\n | .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM\n | .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM\n | .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM\n | .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM"
},
{
"name": "autOfTermBinop",
"content": "def autOfTermBinop (op : TermBinop) (m₁ : CNFA (n + 1)) (m₂ : CNFA (m + 1)) : CNFA ((n ⊔ m) + 1 ) :=\n let mop : CNFA 3 := op.termGadget\n let f₁ := liftMaxSuccSucc1 n m\n let m1' := m₁.lift f₁\n let f₂ := liftMaxSuccSucc2 n m\n let m2' := m₂.lift f₂\n let mop := mop.lift $ liftLast3 (max (FinEnum.card (Fin n)) (FinEnum.card (Fin m)))\n let m := CNFA.inter m1' m2' |> CNFA.inter mop\n let mfinal := m.proj (liftOp _)\n mfinal.minimize"
},
{
"name": "swapLastTwoBlock",
"content": "def swapLastTwoBlock (x : Fin (n + 3)) : Fin (n + 3) :=\n if x = Fin.last (n+2) then n\n else if x = n+1 then Fin.last (n + 2)\n else if x = n then n + 1\n else x"
},
{
"name": "TermUnop",
"content": "inductive TermUnop where\n| neg | not | shiftL (k : Nat)"
},
{
"name": "TermUnop.openTerm",
"content": "def TermUnop.openTerm (op : TermUnop) : Term :=\n match op with\n | .neg => .neg (.var 0)\n | .not => .not (.var 0)\n | .shiftL k => .shiftL (.var 0) k"
},
{
"name": "TermUnop.openTerm_arity",
"content": "def TermUnop.openTerm_arity (op : TermUnop) : op.openTerm.arity = 1 :="
},
{
"name": "TermUnop.openTerm_arity'",
"content": "@[simp]\ndef TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :="
},
{
"name": "TermUnop.subst",
"content": "def TermUnop.subst (op : TermUnop) (t : Term) : Term :=\n match op with\n | .neg => .neg t\n | .not => .not t\n | .shiftL k => .shiftL t k"
},
{
"name": "TermUnop.termGadget",
"content": "def TermUnop.termGadget (t : TermUnop) : CNFA 2 :=\n match t with\n | .neg => FSM.ofTerm (.neg (.var 0)) |> CNFA.ofFSM\n | .not => FSM.ofTerm (.not (.var 0)) |> CNFA.ofFSM\n | .shiftL k => FSM.ofTerm (.shiftL (.var 0) k) |> CNFA.ofFSM"
},
{
"name": "autOfTermUnop",
"content": "def autOfTermUnop (op : TermUnop) (m : CNFA (n + 1)) : CNFA (n + 1) :=\n let mop : CNFA 2 := op.termGadget\n let mop : CNFA (n + 2) := mop.lift (λ i ↦ i.natAdd n)\n let m : CNFA (n + 2) := m.lift (λ i ↦ i.castLE (by admit /- proof elided -/\n ))\n let m := CNFA.inter m mop\n let mfinal := m.proj (liftUnop n)\n mfinal.minimize"
},
{
"name": "nfaOfTerm",
"content": "def nfaOfTerm (t : Term) : CNFA (t.arity + 1) :=\n match t with\n | .var n => FSM.ofTerm (.var n) |> CNFA.ofFSM\n | .zero => FSM.ofTerm .zero |> CNFA.ofFSM\n | .negOne => FSM.ofTerm .negOne |> CNFA.ofFSM\n | .one => FSM.ofTerm .one |> CNFA.ofFSM\n | .ofNat n => FSM.ofTerm (.ofNat n) |> CNFA.ofFSM\n | .and t₁ t₂ => autOfTermBinop .and (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .or t₁ t₂ => autOfTermBinop .or (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .xor t₁ t₂ => autOfTermBinop .xor (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .add t₁ t₂ => autOfTermBinop .add (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .sub t₁ t₂ => autOfTermBinop .sub (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .neg t => autOfTermUnop .neg (nfaOfTerm t)\n | .not t => autOfTermUnop .not (nfaOfTerm t)\n | .shiftL t k => autOfTermUnop (.shiftL k) (nfaOfTerm t)"
},
{
"name": "swapLastTwo",
"content": "def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=\n if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x"
},
{
"name": "nfaOfFormula",
"content": "def nfaOfFormula (φ : Formula) : CNFA φ.arity :=\n match φ with\n | .width wp n => CNFA.autWidth wp n\n | .atom rel t1 t2 =>\n let m1 := nfaOfTerm t1\n let m2 := nfaOfTerm t2\n let f1 := liftMaxSucc1 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity)\n let m1' := m1.lift f1\n let f2 := liftMaxSucc2 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity)\n let m2' := m2.lift f2\n let meq := rel.autOfRelation.lift $ liftLast2 (max (FinEnum.card (Fin t1.arity)) (FinEnum.card (Fin t2.arity)))\n let m := CNFA.inter m1' m2' |> CNFA.inter meq\n let mfinal := m.proj (liftExcept2 _)\n mfinal\n | .msbSet t =>\n let m := (termEvalEqFSM t).toFSM |> CNFA.ofFSM\n let mMsb := CNFA.autMsbSet.lift $ fun _ => Fin.last t.arity\n let res := m.inter mMsb\n res.proj $ fun n => n.castLE (by admit /- proof elided -/\n )\n | .unop op φ => unopNfa op (nfaOfFormula φ)\n | .binop op φ1 φ2 =>\n let m1 := (nfaOfFormula φ1).lift $ liftMax1 φ1.arity φ2.arity\n let m2 := (nfaOfFormula φ2).lift $ liftMax2 φ1.arity φ2.arity\n binopNfa op m1 m2"
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
},
{
"name": "in_enc",
"content": "@[simp]\nlemma in_enc : x ∈ enc '' S ↔ dec x ∈ S"
},
{
"name": "dec_snoc_in_langRel",
"content": "@[simp]\nlemma dec_snoc_in_langRel {n} {R : BVNRel n} {w : BitVecs' n} {a : BitVec n} :\n dec (w ++ [a]) ∈ langRel R ↔\n R (List.Vector.ofFn fun k => .cons (a.getLsbD k) ((dec w).bvs.get k))"
},
{
"name": "NFA'.correct_spec",
"content": "lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :\n M.correct ζ L → M.accepts = langRel L"
},
{
"name": "NFA'.correct2_spec",
"content": "lemma NFA'.correct2_spec {M : NFA' 2} {ζ : M.sa2} {L : BVRel} :\n M.correct2 ζ L → M.accepts = langRel2 L"
},
{
"name": "NFA'.ofFSM_spec",
"content": "@[simp]\nlemma NFA'.ofFSM_spec (t : Term) :\n (ofFSM (FSM.ofTerm t)).accepts = t.language"
},
{
"name": "CNFA.ofFSM_spec",
"content": "lemma CNFA.ofFSM_spec (p : FSM arity) :\n (CNFA.ofFSM p).Sim (NFA'.ofFSM p)"
},
{
"name": "CNFA.ofFSM_bv_language",
"content": "lemma CNFA.ofFSM_bv_language :\n (CNFA.ofFSM (FSM.ofTerm t)).bv_recognizes t.language"
},
{
"name": "NFA'.autEq_correct",
"content": "lemma NFA'.autEq_correct : autEq.correct2 (fun _ => eqRel) eqRel"
},
{
"name": "CNFA.autEq_spec",
"content": "lemma CNFA.autEq_spec : autEq.Sim NFA'.autEq"
},
{
"name": "BitVec.ule_iff_ult_or_eq",
"content": "lemma BitVec.ule_iff_ult_or_eq {w : ℕ} (bv1 bv2 : BitVec w):\n (bv1.ule bv2) = true ↔ (bv1.ult bv2) = true ∨ bv1 = bv2"
},
{
"name": "ucmp_tricho",
"content": "@[simp]\nlemma ucmp_tricho {bv1 bv2 : BitVec w} : (bv2.ult bv1) = false → (bv1.ult bv2) = false → bv1 = bv2"
},
{
"name": "NFA'.autUnsignedCmp_correct",
"content": "lemma NFA'.autUnsignedCmp_correct cmp : autUnsignedCmp cmp |>.correct2 autUnsignedCmpSA cmp.urel"
},
{
"name": "BitVec.sle_iff_slt_or_eq",
"content": "private lemma BitVec.sle_iff_slt_or_eq {w : ℕ} (bv1 bv2 : BitVec w):\n (bv1.sle bv2) = true ↔ (bv1.slt bv2) = true ∨ bv1 = bv2"
},
{
"name": "NFA'.autSignedCmp_correct",
"content": "lemma NFA'.autSignedCmp_correct cmp : autSignedCmp cmp |>.correct2 autSignedCmpSA cmp.srel"
},
{
"name": "CNFA.autUnsignedCmp_spec",
"content": "lemma CNFA.autUnsignedCmp_spec {cmp} : (CNFA.autUnsignedCmp cmp).Sim (NFA'.autUnsignedCmp cmp)"
},
{
"name": "CNFA.autSignedCmp_spec",
"content": "lemma CNFA.autSignedCmp_spec {cmp} : (CNFA.autSignedCmp cmp).Sim (NFA'.autSignedCmp cmp)"
},
{
"name": "CNFA.autMsbSet_spec",
"content": "lemma CNFA.autMsbSet_spec : CNFA.autMsbSet.Sim NFA'.autMsbSet"
},
{
"name": "autMsbSet_accepts",
"content": "@[simp]\nlemma autMsbSet_accepts : NFA'.autMsbSet.accepts = langMsb"
},
{
"name": "CNFA.autMsbSet_bv_language",
"content": "lemma CNFA.autMsbSet_bv_language : autMsbSet.bv_recognizes langMsb"
},
{
"name": "RawCNFA.autWidth_spec",
"content": "lemma RawCNFA.autWidth_spec {wp : WidthPredicate} :\n let m := RawCNFA.autWidth wp n\n m.WF ∧ m.stateMax = n+2 ∧\n (∀ s, s ∈ m.states → (s ∈ m.initials ↔ s = 0) ∧ (s ∈ m.finals ↔ wp.final? n s)) ∧\n (∀ s s', s ∈ m.states → s' ∈ m.states → (s' ∈ m.tr s 0 ↔ if s = n+1 then s = s' else s' = s + 1))"
},
{
"name": "CNFA.autWidth_states",
"content": "@[simp]\nlemma CNFA.autWidth_states: s ∈ (autWidth wp n).m.states ↔ s < n+2"
},
{
"name": "CNFA.autWidth_initials",
"content": "lemma CNFA.autWidth_initials : s ∈ (autWidth wp n).m.initials ↔ s = 0"
},
{
"name": "CNFA.autWidth_finals",
"content": "lemma CNFA.autWidth_finals (hn : s < n + 2) : s ∈ (autWidth wp n).m.finals ↔ wp.final? n s"
},
{
"name": "CNFA.autWidth_tr",
"content": "lemma CNFA.autWidth_tr (hs : s < n + 2) (hs' : s' < n + 2) : s' ∈ (autWidth wp n).m.tr s 0 ↔ if s = n+1 then s = s' else s' = s + 1"
},
{
"name": "CNFA.autWidth_spec",
"content": "lemma CNFA.autWidth_spec : autWidth wp n |>.Sim (NFA'.autWidth wp n)"
},
{
"name": "CNFA.autWidth_bv_language",
"content": "lemma CNFA.autWidth_bv_language :\n (autWidth wp n).bv_recognizes { bv | wp.sat bv.w n }"
},
{
"name": "autOfRelation_spec",
"content": "lemma autOfRelation_spec (r : Relation) :\n r.autOfRelation.Sim r.absAutOfRelation"
},
{
"name": "autOfRelation_accepts",
"content": "@[simp]\nlemma autOfRelation_accepts (r : Relation) :\n r.absAutOfRelation.accepts = r.language"
},
{
"name": "CNFA.autOfRelation_bv_language",
"content": "lemma CNFA.autOfRelation_bv_language (r : Relation) :\n (r.autOfRelation).bv_recognizes r.language"
},
{
"name": "unopNfa_spec",
"content": "lemma unopNfa_spec (op : Unop) (m : CNFA n) (M : NFA' n) :\n m.Sim M → (unopNfa op m).Sim (unopAbsNfa op M)"
},
{
"name": "unopNfa_accepts",
"content": "lemma unopNfa_accepts (op : Unop) (M : NFA' n) :\n (unopAbsNfa op M).accepts = M.acceptsᶜ"
},
{
"name": "unopNfa_bv_language",
"content": "lemma unopNfa_bv_language (op : Unop) :\n m.bv_recognizes L → (unopNfa op m).bv_recognizes Lᶜ"
},
{
"name": "binopNfa_bv_language",
"content": "lemma binopNfa_bv_language (op : Binop) {m₁ m₂ : CNFA n} :\n m₁.bv_recognizes L₁ → m₂.bv_recognizes L₂ →\n (binopNfa op m₁ m₂).bv_recognizes (langBinop op L₁ L₂)"
},
{
"name": "TermBinop.subst_arity'",
"content": "lemma TermBinop.subst_arity' {op : TermBinop} : (op.subst t₁ t₂).arity + 1= t₁.arity ⊔ t₂.arity + 1"
},
{
"name": "BitVecs.cast_eq",
"content": "@[simp]\nlemma BitVecs.cast_eq (x : BitVecs n) (h : n = n') : h ▸ x = x.cast h"
},
{
"name": "Fin.natAdd_zero'",
"content": "lemma Fin.natAdd_zero' [h : NeZero m] : Fin.natAdd (m := m) n 0 = n"
},
{
"name": "TermBinop.alt_lang",
"content": "lemma TermBinop.alt_lang {t₁ t₂ : Term} (op : TermBinop) :\n (op.subst_arity' ▸ (op.subst t₁ t₂).language) =\n let lop : Set (BitVecs 3) := op.openTerm_arity ▸ op.openTerm.language\n let lop' : Set (BitVecs ((t₁.arity ⊔ t₂.arity) + 3)) := lop.lift (liftLast3 (max t₁.arity t₂.arity))\n let l₁ := t₁.language.lift (liftMaxSuccSucc1 t₁.arity t₂.arity)\n let l₂ := t₂.language.lift (liftMaxSuccSucc2 t₁.arity t₂.arity)\n let l := l₁ ∩ l₂ ∩ lop'\n l.proj (liftOp _)"
},
{
"name": "TermUnop.subst_arity'",
"content": "@[simp]\nlemma TermUnop.subst_arity' {op : TermUnop} : (op.subst t).arity + 1 = t.arity + 1"
},
{
"name": "autOfTermBinop_bv_language",
"content": "lemma autOfTermBinop_bv_language op {t₁ t₂ : Term} (m₁ : CNFA (t₁.arity + 1)) (m₂ : CNFA (t₂.arity + 1)) :\n m₁.bv_recognizes t₁.language →\n m₂.bv_recognizes t₂.language →\n (autOfTermBinop op m₁ m₂ |>.bv_recognizes (op.subst_arity' ▸ (op.subst t₁ t₂).language))"
},
{
"name": "TermUnop.alt_lang",
"content": "lemma TermUnop.alt_lang {t : Term} (op : TermUnop) :\n (op.subst_arity' ▸ (op.subst t).language) =\n let lop : Set (BitVecs 2) := op.openTerm_arity' ▸ op.openTerm.language\n let lop' : Set (BitVecs (t.arity + 2)) := lop.lift (λ i ↦ i.natAdd t.arity)\n let lt : Set (BitVecs (t.arity + 2)) := t.language.lift (λ i ↦ i.castLE (by omega))\n let l := lt ∩ lop'\n l.proj (liftUnop t.arity)"
},
{
"name": "autOfTermUnop_bv_language",
"content": "lemma autOfTermUnop_bv_language op {t : Term} (m : CNFA (t.arity + 1)) :\n m.bv_recognizes t.language →\n (autOfTermUnop op m |>.bv_recognizes (op.subst_arity' ▸ (op.subst t).language))"
},
{
"name": "nfaOfTerm_bv_language",
"content": "lemma nfaOfTerm_bv_language (t : Term) :\n nfaOfTerm t |>.bv_recognizes t.language"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel
def langRel (R : BVNRel n) : Set (BitVecs n) :=
{ bvs | R bvs.bvs }
def langRel2 (R : BVRel) : Set (BitVecs 2) :=
{ bvs | R (bvs.bvs.get 0) (bvs.bvs.get 1) }
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)
variable {arity : Type} [FinEnum arity]
def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=
BitVec.ofFn fun i => c (fe.equiv.invFun i)
def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=
fun c => bv[FinEnum.equiv.toFun c]
def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where
start := { q | q = p.initCarry }
accept := ⊤
step s a := {s' |
let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))
s' = s'' ∧ a.msb = b }
@[simp]
abbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=
bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>
inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_correct (p : FSM arity) :
(NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :=
open BitStream in
def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=
worklistRun (BitVec (FinEnum.card p.α))
(fun _ => true)
#[finFunToBitVec p.initCarry]
(by admit /- proof elided -/
)
f
where
end fsm
section nfas_relations
def RawCNFA.autEq : RawCNFA (BitVec 2) :=
let m := RawCNFA.empty
let (s, m) := m.newState
let m := m.addInitial s
let m := m.addFinal s
let m := m.addTrans 0 s s
let m := m.addTrans 3 s s
m
def CNFA.autEq : CNFA 2 :=
⟨RawCNFA.autEq, by admit /- proof elided -/
⟩
def NFA.autEq : NFA (BitVec 2) Unit :=
{ start := ⊤, accept := ⊤, step _ a := { _s' | if a = 0 ∨ a = 3 then true else false }}
def NFA'.autEq : NFA' 2 :=
⟨Unit, NFA.autEq⟩
def NFA'.eqRel : BVRel := fun _ x y => x = y
def autEq_equiv : CNFA.autEq.m.states ≃ NFA'.autEq.σ where
toFun := fun ⟨s, hs⟩ =>
match s with
| _ => ()
invFun q :=
match q with
| () => ⟨0, by admit /- proof elided -/
⟩
left_inv := by admit /- proof elided -/
def RawCNFA.autUnsignedCmp (cmp: RelationOrdering) : RawCNFA (BitVec 2) :=
let m := RawCNFA.empty
let (seq, m) := m.newState
let (sgt, m) := m.newState
let (slt, m) := m.newState
let m := m.addInitial seq
let m := m.addManyTrans [0#2, 3#2] seq seq
let m := m.addTrans 1#2 seq sgt
let m := m.addTrans 2#2 seq slt
let m := m.addManyTrans [0#2, 1#2, 3#2] sgt sgt
let m := m.addTrans 2#2 sgt slt
let m := m.addManyTrans [0#2, 2#2, 3#2] slt slt
let mf := m.addTrans 1#2 slt sgt
match cmp with
| .lt => mf.addFinal slt
| .le => (mf.addFinal slt).addFinal seq
| .gt => mf.addFinal sgt
| .ge => (mf.addFinal sgt).addFinal seq
def CNFA.autUnsignedCmp (cmp: RelationOrdering) : CNFA 2 :=
⟨RawCNFA.autUnsignedCmp cmp, RawCNFA.autoUnsignedCmp_wf⟩
inductive NFA.unsignedCmpState : Type where
| eq | gt | lt
deriving Fintype, DecidableEq
def NFA.unsignedCmpStep (q : NFA.unsignedCmpState) (a : BitVec 2) : List NFA.unsignedCmpState :=
match q, a with
| .eq, 0 => [ .eq ] | .eq, 3 => [ .eq ] | .eq, 1 => [ .gt ] | .eq, 2 => [ .lt ]
| .gt, 0 => [ .gt ] | .gt, 1 => [ .gt ] | .gt, 3 => [ .gt ] | .gt, 2 => [ .lt ]
| .lt, 0 => [ .lt ] | .lt, 1 => [ .gt ] | .lt, 2 => [ .lt ] | .lt, 3 => [ .lt ]
def NFA.autUnsignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) unsignedCmpState where
step s a := { s' | s' ∈ unsignedCmpStep s a }
start := {s | s = .eq }
accept := { s | s ∈ match cmp with | .lt => [unsignedCmpState.lt] | .le => [.lt, .eq] | .gt => [.gt] | .ge => [.gt, .eq] }
def NFA'.autUnsignedCmp (cmp: RelationOrdering) : NFA' 2 :=
⟨_, NFA.autUnsignedCmp cmp⟩
def RelationOrdering.urel (cmp : RelationOrdering) : BVRel :=
match cmp with
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .le => fun _ bv1 bv2 => bv1.ule bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
| .ge => fun _ bv1 bv2 => bv2.ule bv1
def NFA'.autUnsignedCmpSA (q : NFA.unsignedCmpState) : BVRel :=
match q with
| .eq => fun _ bv1 bv2 => bv1 = bv2
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
def RawCNFA.autSignedCmp (cmp: RelationOrdering) : RawCNFA (BitVec 2) :=
let (m, sltfin, sgtfin, seq) := m
match cmp with
| .lt => m.addFinal sltfin
| .le => (m.addFinal sltfin).addFinal seq
| .gt => m.addFinal sgtfin
| .ge => (m.addFinal sgtfin).addFinal seq
where
def CNFA.autSignedCmp (cmp: RelationOrdering) : CNFA 2 :=
⟨RawCNFA.autSignedCmp cmp, RawCNFA.autSignedCmp_wf⟩
inductive NFA.signedCmpState : Type where
| eq | gt | lt | ltfin | gtfin
deriving DecidableEq, Fintype
def NFA.signedCmpStep (q : NFA.signedCmpState) (a : BitVec 2) : List NFA.signedCmpState :=
match q, a with
| .eq, 0 => [ .eq ] | .eq, 3 => [.eq] | .eq, 1 => [.gt, .ltfin] | .eq, 2 => [ .lt, .gtfin ]
| .gt, 0 => [ .gt, .gtfin ] | .gt, 1 => [ .gt, .ltfin ] | .gt, 3 => [ .gt, .gtfin ] | .gt, 2 => [ .lt, .gtfin ]
| .lt, 0 => [ .lt, .ltfin ] | .lt, 1 => [ .gt, .ltfin ] | .lt, 2 => [ .lt, .gtfin ] | .lt, 3 => [ .lt, .ltfin ]
| .gtfin, _ => ∅
| .ltfin, _ => ∅
def NFA.autSignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) signedCmpState where
step s a := { s' | s' ∈ signedCmpStep s a }
start := { s | s = signedCmpState.eq }
accept := { s | s ∈ match cmp with | .lt => [NFA.signedCmpState.ltfin] | .le => [.ltfin, .eq] | .gt => [.gtfin] | .ge => [.gtfin, .eq] }
def NFA'.autSignedCmp (cmp: RelationOrdering) : NFA' 2 :=
⟨_, NFA.autSignedCmp cmp⟩
def RelationOrdering.srel (cmp : RelationOrdering) : BVRel :=
match cmp with
| .lt => fun _ bv1 bv2 => bv1.slt bv2
| .le => fun _ bv1 bv2 => bv1.sle bv2
| .gt => fun _ bv1 bv2 => bv2.slt bv1
| .ge => fun _ bv1 bv2 => bv2.sle bv1
def NFA'.autSignedCmpSA (q : NFA.signedCmpState) : BVRel :=
match q with
| .eq => fun _ bv1 bv2 => bv1 = bv2
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
| .ltfin => fun _ bv1 bv2 => bv1.slt bv2
| .gtfin => fun _ bv1 bv2 => bv2.slt bv1
def unsigned_equiv cmp : (CNFA.autUnsignedCmp cmp).m.states ≃ (NFA'.autUnsignedCmp cmp).σ where
toFun := fun ⟨s, hs⟩ =>
match s with
| 0 => .eq
| 1 => .gt
| _ => .lt
invFun q :=
match q with
| .eq => ⟨0, by admit /- proof elided -/
⟩
| .gt => ⟨1, by admit /- proof elided -/
⟩
| .lt => ⟨2, by admit /- proof elided -/
⟩
left_inv := by admit /- proof elided -/
def signed_equiv cmp : (CNFA.autSignedCmp cmp).m.states ≃ (NFA'.autSignedCmp cmp).σ where
toFun := fun ⟨s, hs⟩ =>
match s with
| 0 => .eq
| 1 => .gt
| 2 => .lt
| 3 => .gtfin
| _ => .ltfin
invFun q :=
match q with
| .eq => ⟨0, by admit /- proof elided -/
⟩
| .gt => ⟨1, by admit /- proof elided -/
⟩
| .lt => ⟨2, by admit /- proof elided -/
⟩
| .gtfin => ⟨3, by admit /- proof elided -/
⟩
| .ltfin => ⟨4, by admit /- proof elided -/
⟩
left_inv := by admit /- proof elided -/
def RawCNFA.autMsbSet : RawCNFA (BitVec 1) :=
let m := RawCNFA.empty
let (si, m) := m.newState
let (sf, m) := m.newState
let m := m.addInitial si
let m := m.addFinal sf
let m := m.addTrans 1 si sf
let m := m.addManyTrans [0, 1] si si
m
@[inline]
def CNFA.autMsbSet : CNFA 1 :=
⟨RawCNFA.autMsbSet, RawCNFA.autMsbSet_wf⟩
inductive NFA.msbState : Type where
| i | f
deriving DecidableEq, Fintype
def NFA.msbStep (q : NFA.msbState) (a : BitVec 1) : List NFA.msbState :=
match q, a with
| .i, 0 => [.i]
| .i, 1 => [.i, .f]
| _, _ => []
def NFA.autMsbSet : NFA (BitVec 1) msbState where
step s a := { s' | s' ∈ msbStep s a }
start := {.i}
accept := {.f}
def NFA'.autMsbSet : NFA' 1 := ⟨_, NFA.autMsbSet⟩
def NFA.msbLang : Language (BitVec 1) := { bvs | bvs.getLast? = some 1 }
def NFA.msbSA (q : msbState) : Language (BitVec 1) :=
match q with
| .i => ⊤
| .f => msbLang
def NFA.msbCorrect : NFA.autMsbSet.correct msbSA msbLang :=
def autMsb_equiv : CNFA.autMsbSet.m.states ≃ NFA'.autMsbSet.σ where
toFun := fun ⟨s, hs⟩ =>
match s with
| 0 => .i
| 1 => .f
| _ => .i
invFun q :=
match q with
| .i => ⟨0, by admit /- proof elided -/
⟩
| .f => ⟨1, by admit /- proof elided -/
⟩
left_inv := by admit /- proof elided -/
def WidthPredicate.final? (wp : WidthPredicate) (n : Nat) (s : State) : Bool :=
decide (wp.sat s n)
def RawCNFA.autWidth (wp : WidthPredicate) (n : Nat) : RawCNFA (BitVec 0) :=
let m := (n+2).iterate f empty
let m := m.addInitial 0
m.addTrans (BitVec.zero 0) (n + 1) (n + 1)
where
f m :=
let (s, m) := m.newState
let m := if wp.final? n s then m.addFinal s else m
if s > 0 then m.addTrans (BitVec.zero 0) (s-1) s else m
def CNFA.autWidth (wp : WidthPredicate) (n : Nat) : CNFA 0 :=
⟨RawCNFA.autWidth wp n, RawCNFA.autWidth_wf⟩
def NFA.autWidth (wp : WidthPredicate) (n : Nat) : NFA (BitVec 0) (Fin (n+2)) where
start := { 0 }
accept := { s | wp.final? n s }
step s₁ _ := { s₂ | if s₁ = Fin.last (n+1) then s₁ = s₂ else s₂ = s₁ + 1 }
def NFA'.autWidth (wp : WidthPredicate) (n : Nat) : NFA' 0 := ⟨_, NFA.autWidth wp n⟩
@[simp]
def NFA'.autWidth_spec : (autWidth wp n).accepts = { bv | wp.sat bv.w n } :=
def autWidth_equiv : (CNFA.autWidth wp n).m.states ≃ (NFA'.autWidth wp n).σ where
toFun := fun ⟨s, hs⟩ =>
Fin.mk s (by admit /- proof elided -/
)
invFun q := ⟨q.val, by admit /- proof elided -/
⟩
left_inv := by admit /- proof elided -/
end nfas_relations
def Relation.autOfRelation : Relation → CNFA 2
| .eq => CNFA.autEq
| .signed ord => CNFA.autSignedCmp ord
| .unsigned ord => CNFA.autUnsignedCmp ord
def Relation.absAutOfRelation (rel : Relation) : NFA' 2 :=
match rel with
| .eq => NFA'.autEq
| .unsigned cmp => NFA'.autUnsignedCmp cmp
| .signed cmp => NFA'.autSignedCmp cmp
def unopNfa (op : Unop) (m : CNFA n) : CNFA n :=
match op with
| .neg => m.neg
def unopAbsNfa (op : Unop) (M : NFA' n) : NFA' n :=
match op with
| .neg => M.neg
def binopNfa (op : Binop) (m1 m2 : CNFA n) : CNFA n :=
match op with
| .and => m1.inter m2
| .or => m1.union m2
| .impl => m1.neg.union m2
| .equiv => (m1.neg.union m2).inter (m2.neg.union m1)
def binopAbsNfa (op : Binop) (M1 M2: NFA' n) : NFA' n :=
match op with
| .and => M1.inter M2
| .or => M1.union M2
| .impl => M1.neg.union M2
| .equiv => (M1.neg.union M2).inter (M2.neg.union M1)
def liftOp n : Fin (n + 1) → Fin (n + 3) :=
fun k =>
if k = n then Fin.last (n+2) else k.castLE (by admit /- proof elided -/
)
@[simp]
def liftOp_unchanged (k : Fin n) : liftOp n k.castSucc = k.castLE (by simp) :=
def liftUnop n : Fin (n + 1) → Fin (n + 2) :=
fun k =>
if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/
)
inductive TermBinop where
| and | or | xor | add | sub
def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=
match op with
| .and => .and t₁ t₂
| .or => .or t₁ t₂
| .xor => .xor t₁ t₂
| .add => .add t₁ t₂
| .sub => .sub t₁ t₂
def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)
@[simp]
def TermBinop.openTerm_arity (op : TermBinop) : op.openTerm.arity + 1 = 3 :=
def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=
match t with
| .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM
| .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM
| .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM
| .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM
| .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM
def autOfTermBinop (op : TermBinop) (m₁ : CNFA (n + 1)) (m₂ : CNFA (m + 1)) : CNFA ((n ⊔ m) + 1 ) :=
let mop : CNFA 3 := op.termGadget
let f₁ := liftMaxSuccSucc1 n m
let m1' := m₁.lift f₁
let f₂ := liftMaxSuccSucc2 n m
let m2' := m₂.lift f₂
let mop := mop.lift $ liftLast3 (max (FinEnum.card (Fin n)) (FinEnum.card (Fin m)))
let m := CNFA.inter m1' m2' |> CNFA.inter mop
let mfinal := m.proj (liftOp _)
mfinal.minimize
def swapLastTwoBlock (x : Fin (n + 3)) : Fin (n + 3) :=
if x = Fin.last (n+2) then n
else if x = n+1 then Fin.last (n + 2)
else if x = n then n + 1
else x
inductive TermUnop where
| neg | not | shiftL (k : Nat)
def TermUnop.openTerm (op : TermUnop) : Term :=
match op with
| .neg => .neg (.var 0)
| .not => .not (.var 0)
| .shiftL k => .shiftL (.var 0) k
def TermUnop.openTerm_arity (op : TermUnop) : op.openTerm.arity = 1 :=
@[simp]
def TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :=
def TermUnop.subst (op : TermUnop) (t : Term) : Term :=
match op with
| .neg => .neg t
| .not => .not t
| .shiftL k => .shiftL t k
def TermUnop.termGadget (t : TermUnop) : CNFA 2 :=
match t with
| .neg => FSM.ofTerm (.neg (.var 0)) |> CNFA.ofFSM
| .not => FSM.ofTerm (.not (.var 0)) |> CNFA.ofFSM
| .shiftL k => FSM.ofTerm (.shiftL (.var 0) k) |> CNFA.ofFSM
def autOfTermUnop (op : TermUnop) (m : CNFA (n + 1)) : CNFA (n + 1) :=
let mop : CNFA 2 := op.termGadget
let mop : CNFA (n + 2) := mop.lift (λ i ↦ i.natAdd n)
let m : CNFA (n + 2) := m.lift (λ i ↦ i.castLE (by admit /- proof elided -/
))
let m := CNFA.inter m mop
let mfinal := m.proj (liftUnop n)
mfinal.minimize
def nfaOfTerm (t : Term) : CNFA (t.arity + 1) :=
match t with
| .var n => FSM.ofTerm (.var n) |> CNFA.ofFSM
| .zero => FSM.ofTerm .zero |> CNFA.ofFSM
| .negOne => FSM.ofTerm .negOne |> CNFA.ofFSM
| .one => FSM.ofTerm .one |> CNFA.ofFSM
| .ofNat n => FSM.ofTerm (.ofNat n) |> CNFA.ofFSM
| .and t₁ t₂ => autOfTermBinop .and (nfaOfTerm t₁) (nfaOfTerm t₂)
| .or t₁ t₂ => autOfTermBinop .or (nfaOfTerm t₁) (nfaOfTerm t₂)
| .xor t₁ t₂ => autOfTermBinop .xor (nfaOfTerm t₁) (nfaOfTerm t₂)
| .add t₁ t₂ => autOfTermBinop .add (nfaOfTerm t₁) (nfaOfTerm t₂)
| .sub t₁ t₂ => autOfTermBinop .sub (nfaOfTerm t₁) (nfaOfTerm t₂)
| .neg t => autOfTermUnop .neg (nfaOfTerm t)
| .not t => autOfTermUnop .not (nfaOfTerm t)
| .shiftL t k => autOfTermUnop (.shiftL k) (nfaOfTerm t)
def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=
if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x
def nfaOfFormula (φ : Formula) : CNFA φ.arity :=
match φ with
| .width wp n => CNFA.autWidth wp n
| .atom rel t1 t2 =>
let m1 := nfaOfTerm t1
let m2 := nfaOfTerm t2
let f1 := liftMaxSucc1 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity)
let m1' := m1.lift f1
let f2 := liftMaxSucc2 (FinEnum.card $ Fin t1.arity) (FinEnum.card $ Fin t2.arity)
let m2' := m2.lift f2
let meq := rel.autOfRelation.lift $ liftLast2 (max (FinEnum.card (Fin t1.arity)) (FinEnum.card (Fin t2.arity)))
let m := CNFA.inter m1' m2' |> CNFA.inter meq
let mfinal := m.proj (liftExcept2 _)
mfinal
| .msbSet t =>
let m := (termEvalEqFSM t).toFSM |> CNFA.ofFSM
let mMsb := CNFA.autMsbSet.lift $ fun _ => Fin.last t.arity
let res := m.inter mMsb
res.proj $ fun n => n.castLE (by admit /- proof elided -/
)
| .unop op φ => unopNfa op (nfaOfFormula φ)
| .binop op φ1 φ2 =>
let m1 := (nfaOfFormula φ1).lift $ liftMax1 φ1.arity φ2.arity
let m2 := (nfaOfFormula φ2).lift $ liftMax2 φ1.arity φ2.arity
binopNfa op m1 m2 | theorem nfaOfFormula_bv_language φ :
(nfaOfFormula φ).bv_recognizes φ.language := | := by
induction φ
case width rel n =>
simp only [nfaOfFormula]
apply CNFA.autWidth_bv_language
case atom rel t1 t2 =>
simp only [nfaOfFormula, Formula.language]
apply CNFA.proj_bv_language
ac_nf
apply CNFA.inter_bv_language
· apply CNFA.lift_bv_language
exact CNFA.autOfRelation_bv_language rel
· apply CNFA.inter_bv_language
· apply CNFA.lift_bv_language
exact nfaOfTerm_bv_language t1
· apply CNFA.lift_bv_language
exact nfaOfTerm_bv_language t2
case msbSet t =>
simp only [nfaOfFormula, Formula.language]
apply CNFA.proj_bv_language
apply CNFA.inter_bv_language
· exact CNFA.ofFSM_bv_language
· apply CNFA.lift_bv_language
apply CNFA.autMsbSet_bv_language
case unop op φ ih =>
simp only [nfaOfFormula, Formula.language]
exact unopNfa_bv_language op ih
case binop op φ₁ φ2 ih₁ ih₂ =>
simp only [nfaOfFormula, Formula.language]
apply binopNfa_bv_language op
· apply CNFA.lift_bv_language; assumption
· apply CNFA.lift_bv_language; assumption | 13 | 480 | false | Compiler |
320 | CNFA.ofFSM.f_spec | @[simp]
lemma CNFA.ofFSM.f_spec {p : FSM arity} {s s' : BitVec (FinEnum.card p.α)} :
(a, s') ∈ f p s ↔ bitVecToFinFun s' ∈ (NFA.ofFSM p).step (bitVecToFinFun s) a | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.card",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Array.foldl",
"module": "Init.Data.Array.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Array.size",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "FinEnum.equiv",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.cast",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Function.Injective",
"module": "Init.Data.Function"
},
{
"name": "Function.LeftInverse",
"module": "Init.Data.Function"
}
] | [
{
"name": "carry",
"content": "def carry (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n => (addAux' initCarry x y n).2"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "worklistRun",
"content": "def worklistRun (final : S → Bool) (inits : Array S)\n (hinits : inits.toList.Nodup) (f : S → Array (BitVec n × S)) : CNFA n :=\n ⟨worklistRun' _ S final inits hinits f, worklistRun'_wf (BitVec n) S⟩"
},
{
"name": "worklistRun'",
"content": "def worklistRun' (final : S → Bool) (inits : Array S) (hinits : inits.toList.Nodup) (f : S → Array (A × S)) : RawCNFA A :=\n let st0 := worklist.initState _ _ inits hinits final\n go st0\nwhere go (st0 : worklist.St A S) : RawCNFA A :=\n if hemp : st0.worklist.isEmpty then st0.m else\n let sa? := st0.worklist.back?\n match heq : sa? with\n | some sa =>\n let wl := st0.worklist.pop\n let st1 := { st0 with worklist := wl,\n worklist_nodup := by admit /- proof elided -/"
},
{
"name": "worklist.St",
"content": "structure worklist.St where\n m : RawCNFA A\n map : Std.HashMap S State := ∅\n worklist : Array S := ∅\n worklist_nodup : worklist.toList.Nodup\n worklist_incl : ∀ sa ∈ worklist, sa ∈ map"
},
{
"name": "worklist.initState",
"content": "def worklist.initState (inits : Array S) (hinits : inits.toList.Nodup) (final? : S → Bool) : worklist.St A S :=\n let m := RawCNFA.empty (A := A)\n let mapm := inits.foldl (init := (Std.HashMap.emptyWithCapacity, m)) fun (map, m) sa =>\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := if final? sa then m.addFinal s else m\n (map.insert sa s, m)\n let map := mapm.1\n let m := mapm.2\n let worklist_incl : ∀ sa ∈ inits, sa ∈ map :="
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.empty",
"content": "def RawCNFA.empty : RawCNFA A := {\n stateMax := 0\n initials := ∅\n finals := ∅\n trans := ∅\n}"
},
{
"name": "processOneElem",
"content": "def processOneElem (final : S → Bool) (s : State) (st : worklist.St A S) : A × S → worklist.St A S :=\n fun (a', sa') =>\n let (s', st') := st.addOrCreateState _ _ (final sa') sa'\n let m := st'.m.addTrans a' s s'\n { st' with m }"
},
{
"name": "worklist.St.addOrCreateState",
"content": "def worklist.St.addOrCreateState (st : worklist.St A S) (final? : Bool) (sa : S) : State × worklist.St A S :=\n match heq : st.map[sa]? with\n | some s => (s, st)\n | none =>\n let (s, m) := st.m.newState\n let m := if final? then m.addFinal s else m\n let map := st.map.insert sa s\n let worklist := st.worklist.push sa\n have worklist_nodup : worklist.toList.Nodup := by admit /- proof elided -/"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "bv2",
"content": "def bv2 : BitVec 4 := BitVec.ofNat 4 1 "
},
{
"name": "bv1",
"content": "def bv1 : BitVec 4 := BitVec.ofNat 4 5"
}
] | [
{
"name": "List.nodup_singleton",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "BitVec.eq_of_getLsbD_eq",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "BitVec.getLsbD_append",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.ofBool_eq_iff_eq",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Function.LeftInverse.injective",
"module": "Init.Data.Function"
},
{
"name": "BitVec.cons_msb_setWidth",
"module": "Init.Data.BitVec.Bootstrap"
},
{
"name": "BitVec.setWidth_cons",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "List.foldl_cons",
"module": "Init.Data.List.Basic"
},
{
"name": "and_self",
"module": "Init.SimpLemmas"
},
{
"name": "and_true",
"module": "Init.SimpLemmas"
},
{
"name": "or_true",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
}
] | [
{
"name": "Alphabet",
"content": "abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)"
},
{
"name": "finFunToBitVec",
"content": "def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=\n BitVec.ofFn fun i => c (fe.equiv.invFun i)"
},
{
"name": "bitVecToFinFun",
"content": "def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=\n fun c => bv[FinEnum.equiv.toFun c]"
},
{
"name": "NFA.ofFSM",
"content": "def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where\n start := { q | q = p.initCarry }\n accept := ⊤\n step s a := {s' |\n let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))\n s' = s'' ∧ a.msb = b }"
},
{
"name": "CNFA.ofFSM",
"content": "def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=\n worklistRun (BitVec (FinEnum.card p.α))\n (fun _ => true)\n #[finFunToBitVec p.initCarry]\n (by admit /- proof elided -/\n )\n f\n where"
}
] | [
{
"name": "BitVec.cast_inj",
"content": "@[simp]\ntheorem BitVec.cast_inj (h : w = w') {x y : BitVec w} : BitVec.cast h x = BitVec.cast h y ↔ x = y"
},
{
"name": "BitVec.append_inj",
"content": "@[simp]\ntheorem BitVec.append_inj {x1 x2 : BitVec w} {y1 y2 : BitVec w'} :\n x1 ++ y1 = x2 ++ y2 ↔ x1 = x2 ∧ y1 = y2"
},
{
"name": "BitVec.cons_inj",
"content": "@[simp]\nlemma BitVec.cons_inj : cons b1 bv1 = cons b2 bv2 ↔ (b1 = b2) ∧ bv1 = bv2"
},
{
"name": "bitVecToFinFun_rinv",
"content": "@[simp]\nlemma bitVecToFinFun_rinv (c : carry → Bool) [FinEnum carry]:\n bitVecToFinFun (finFunToBitVec c) = c"
},
{
"name": "bitVecToFinFun_linv",
"content": "@[simp]\nlemma bitVecToFinFun_linv [FinEnum ar] (bv : BitVec $ FinEnum.card ar) :\n finFunToBitVec (bitVecToFinFun bv) = bv"
},
{
"name": "bitVecToFinFun_inj",
"content": "@[simp]\nlemma bitVecToFinFun_inj [FinEnum ar] : Function.Injective (bitVecToFinFun (ar := ar))"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
section fsm
abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)
variable {arity : Type} [FinEnum arity]
def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=
BitVec.ofFn fun i => c (fe.equiv.invFun i)
def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=
fun c => bv[FinEnum.equiv.toFun c]
def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where
start := { q | q = p.initCarry }
accept := ⊤
step s a := {s' |
let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))
s' = s'' ∧ a.msb = b }
open BitStream in
def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=
worklistRun (BitVec (FinEnum.card p.α))
(fun _ => true)
#[finFunToBitVec p.initCarry]
(by admit /- proof elided -/
)
f
where | @[simp]
lemma CNFA.ofFSM.f_spec {p : FSM arity} {s s' : BitVec (FinEnum.card p.α)} :
(a, s') ∈ f p s ↔ bitVecToFinFun s' ∈ (NFA.ofFSM p).step (bitVecToFinFun s) a := | := by
let motive (as : List (BitVec (FinEnum.card arity))) := ∀ (acc : Array _) a s',
((a, s') ∈ as.foldl (init := acc) (process p s))
↔ (a, s') ∈ acc ∨ (a.setWidth (FinEnum.card arity) ∈ as) ∧
bitVecToFinFun s' ∈ (NFA.ofFSM p).step (bitVecToFinFun s) a
suffices h : motive (FinEnum.toList (BitVec (FinEnum.card arity))) by
specialize h #[]
simp at h
rw [←h]
rfl
generalize FinEnum.toList (BitVec (FinEnum.card arity)) = qs
induction qs
case nil => simp [motive]
case cons a as ih =>
rintro acc b s'
simp only [List.foldl_cons]; rw [ih]
simp [process]
constructor
· rintro ((hacc | ⟨rfl, rfl⟩) | ⟨hin₁, hin₂⟩)
· exact .inl hacc
· right; simp [NFA.ofFSM]; constructor <;> rfl
· right; simp_all only [or_true, and_self, motive]
· rintro (hacc | ⟨(rfl | hold), hst⟩)
· tauto
· simp [NFA.ofFSM] at hst; left; right
rcases hst with ⟨hs', hb⟩
constructor
· rw [←BitVec.cons_msb_setWidth b]
simp_all only [BitVec.setWidth_cons, BitVec.cons_inj, and_true]; rfl
· apply_fun bitVecToFinFun <;> simp only [hs', bitVecToFinFun_rinv, bitVecToFinFun_inj]
rfl
· tauto | 5 | 82 | false | Compiler |
321 | Predicate.evalFin_eq_eval | lemma Predicate.evalFin_eq_eval (p : Predicate)
(varsList : List BitStream) (varsFin : Fin p.arity → BitStream)
(hvars : ∀ (i : Fin p.arity), varsList.getD i default = (varsFin i)) :
Predicate.evalFin p varsFin = Predicate.eval p varsList | lean-mlir | Blase/Blase/Fast/Lemmas.lean | [
"import Blase.Fast.Defs",
"import Mathlib.Data.Fintype.BigOperators",
"import Blase.Fast.BitStream",
"import Mathlib.Data.Fintype.Sum",
"import Mathlib.Data.Fintype.Card",
"import Mathlib.Data.Fintype.Sigma",
"import Mathlib.Tactic.Ring",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Tactic.Zify"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"max\" : MLIR.Pretty.uniform_op",
"content": "syntax \"max\" : MLIR.Pretty.uniform_op\n\nsyntax \"slt\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "Predicate",
"content": "inductive Predicate : Type where\n \n| width (wp : WidthPredicate) (n : Nat) : Predicate\n| binary (p : BinaryPredicate) (t₁ t₂ : Term)\n| land (p q : Predicate) : Predicate\n| lor (p q : Predicate) : Predicate\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "Predicate.evalFin",
"content": "@[simp] def Predicate.evalFin (p : Predicate) (vars : Fin (arity p) → BitStream) : BitStream :=\nmatch p with\n| .width .eq n => BitStream.falseIffEq n\n| .width .neq n => BitStream.falseIffNeq n\n| .width .lt n => BitStream.falseIffLt n\n| .width .le n => BitStream.falseIffLe n\n| .width .gt n => BitStream.falseIffGt n\n| .width .ge n => BitStream.falseIffGe n\n| .binary .eq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalEq x₁ x₂\n| .binary .neq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalNeq x₁ x₂\n| .land p q =>\n \n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLand x₁ x₂\n| .lor p q =>\n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor x₁ x₂\n| .binary .slt p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalSlt x₁ x₂\n| .binary .sle p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalSlt x₁ x₂) (Predicate.evalEq x₁ x₂)\n| .binary .ult p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n (Predicate.evalUlt x₁ x₂)\n| .binary .ule p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalUlt x₁ x₂) (Predicate.evalEq x₁ x₂)"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Term.evalFin",
"content": "@[simp] def Term.evalFin (t : Term) (vars : Fin (arity t) → BitStream) : BitStream :=\n match t with\n | var n => vars (Fin.last n)\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | or t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | xor t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | not t => ~~~(t.evalFin vars)\n | add t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | sub t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | neg t => -(Term.evalFin t vars)\n \n \n | shiftL t n => BitStream.shiftLeft (Term.evalFin t vars) n"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "Predicate.arity",
"content": "@[simp] def Predicate.arity : Predicate → Nat\n| .width _ _ => 0\n| .binary .eq t1 t2 => max t1.arity t2.arity\n| .binary .neq t₁ t₂ => max t₁.arity t₂.arity\n| .binary .ult t₁ t₂ => max t₁.arity t₂.arity\n| .binary .ule t₁ t₂ => t₁.arity ⊔ t₂.arity ⊔ (t₁.arity ⊔ t₂.arity)\n| .binary .slt t₁ t₂ => (t₁.arity ⊔ t₂.arity ⊔ (t₁.arity ⊔ t₂.arity))\n| .binary .sle t₁ t₂ => (t₁.arity ⊔ t₂.arity ⊔ (t₁.arity ⊔ t₂.arity) ⊔ (t₁.arity ⊔ t₂.arity))\n| .lor p q => max p.arity q.arity\n| .land p q => max p.arity q.arity"
},
{
"name": "BinaryPredicate",
"content": "inductive BinaryPredicate\n| eq\n| neq\n| ult\n| ule\n| slt\n| sle\nderiving Repr, Lean.ToExpr"
},
{
"name": "WidthPredicate",
"content": "inductive WidthPredicate\n| eq\n| neq\n| lt\n| le\n| gt\n| ge\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "Predicate.eval",
"content": "def Predicate.eval (p : Predicate) (vars : List BitStream) : BitStream :=\n match p with\n | .width .eq n => BitStream.falseIffEq n\n | .width .neq n => BitStream.falseIffNeq n\n | .width .lt n => BitStream.falseIffLt n\n | .width .le n => BitStream.falseIffLe n\n | .width .gt n => BitStream.falseIffGt n\n | .width .ge n => BitStream.falseIffGe n\n | lor p q => Predicate.evalLor (p.eval vars) (q.eval vars)\n | land p q => Predicate.evalLand (p.eval vars) (q.eval vars)\n | binary .eq t₁ t₂ => Predicate.evalEq (t₁.eval vars) (t₂.eval vars)\n \n | binary .neq t1 t2 => Predicate.evalNeq (t1.eval vars) (t2.eval vars)\n | binary .ult t₁ t₂ => Predicate.evalUlt (t₁.eval vars) (t₂.eval vars)\n | binary .ule t₁ t₂ =>\n Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalUlt (t₁.eval vars) (t₂.eval vars))\n | binary .slt t₁ t₂ => Predicate.evalSlt (t₁.eval vars) (t₂.eval vars)\n | binary .sle t₁ t₂ => Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalSlt (t₁.eval vars) (t₂.eval vars))"
},
{
"name": "Term.eval",
"content": "def Term.eval (t : Term) (vars : List BitStream) : BitStream :=\n match t with\n | var n => vars.getD n default\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ => (t₁.eval vars) &&& (t₂.eval vars)\n | or t₁ t₂ => (t₁.eval vars) ||| (t₂.eval vars)\n | xor t₁ t₂ => (t₁.eval vars) ^^^ (t₂.eval vars)\n | not t => ~~~(t.eval vars)\n | add t₁ t₂ => (Term.eval t₁ vars) + (Term.eval t₂ vars)\n | sub t₁ t₂ => (Term.eval t₁ vars) - (Term.eval t₂ vars)\n | neg t => -(Term.eval t vars)\n\n\n | shiftL t n => BitStream.shiftLeft (Term.eval t vars) n"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "and_comm",
"content": "theorem and_comm (x y : BitStream) : x &&& y = y &&& x"
}
] | [] | [
{
"name": "Term.evalFin_eq_eval",
"content": "lemma Term.evalFin_eq_eval (t : Term)\n (varsList : List BitStream) (varsFin : Fin t.arity → BitStream)\n (hvars : ∀ (i : Fin t.arity), varsList.getD i default = (varsFin i)) :\n Term.evalFin t varsFin = Term.eval t varsList"
}
] | import Mathlib.Data.Fintype.Card
import Mathlib.Data.Fintype.Sum
import Mathlib.Data.Fintype.Sigma
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Tactic.Zify
import Mathlib.Tactic.Ring
import Blase.Fast.Defs
import Blase.Fast.BitStream
open Term | lemma Predicate.evalFin_eq_eval (p : Predicate)
(varsList : List BitStream) (varsFin : Fin p.arity → BitStream)
(hvars : ∀ (i : Fin p.arity), varsList.getD i default = (varsFin i)) :
Predicate.evalFin p varsFin = Predicate.eval p varsList := | := by
induction p generalizing varsList <;>
dsimp -failIfUnchanged [Predicate.evalFin, Predicate.eval, Predicate.arity] at *
case width rel n =>
rcases rel <;> dsimp -failIfUnchanged [Predicate.evalFin, Predicate.eval, Predicate.arity] at *
case binary ap t₁ t₂ =>
rcases ap <;>
· dsimp [Predicate.evalFin, Predicate.eval, Predicate.arity] at *
simp [evalEq, evalNeq, evalUlt, evalSlt, evalLor]
rw [Term.evalFin_eq_eval _ varsList]
· rw [Term.evalFin_eq_eval _ varsList]
try rw [BitStream.and_comm]
· intros i
rw [hvars ⟨i, by omega⟩]
rfl
· intros i
rw [hvars ⟨i, by omega⟩]
rfl
case land p q hp hq =>
simp [evalLand]
rw [hp varsList]
· rw [hq varsList]
· intros i
rw [hvars ⟨i, by omega⟩]
rfl
· intros i
rw [hvars ⟨i, by omega⟩]
rfl
case lor p q hp hq =>
simp [evalLor]
rw [hp varsList]
· rw [hq varsList]
· intros i
rw [hvars ⟨i, by omega⟩]
rfl
· intros i
rw [hvars ⟨i, by omega⟩]
rfl | 4 | 46 | false | Compiler |
322 | BitStream.ofBitVecZext_add_EqualUpTo | theorem ofBitVecZext_add_EqualUpTo :
ofBitVecZext (x + y) ≈ʷ (ofBitVecZext x) + (ofBitVecZext y) | lean-mlir | Blase/Blase/Fast/BitStream.lean | [
"import Mathlib.Logic.Function.Iterate",
"import Mathlib.Tactic.NormNum"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Add",
"module": "Init.Prelude"
},
{
"name": "Add.add",
"module": "Init.Prelude"
},
{
"name": "BitVec.carry",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "BitVec.getLsbD",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "HAdd",
"module": "Init.Prelude"
},
{
"name": "HAdd.hAdd",
"module": "Init.Prelude"
},
{
"name": "Int.succ",
"module": "Mathlib.Data.Int.Init"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Nat.add_mod",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.mod_two_eq_zero_or_one",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "BitVec.add_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.carry_succ",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "BitVec.getElem_add",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "BitVec.toNat_add",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "Bool.decide_and",
"module": "Init.Data.Bool"
},
{
"name": "Bool.decide_iff_dist",
"module": "Init.Data.Bool"
},
{
"name": "Bool.not_eq_eq_eq_not",
"module": "Init.SimpLemmas"
},
{
"name": "Bool.toNat_false",
"module": "Init.Data.Bool"
},
{
"name": "Nat.add_eq",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.mod_two_pos_mod_two_eq_one",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "Nat.testBit_zero",
"module": "Init.Data.Nat.Bitwise.Lemmas"
},
{
"name": "add_zero",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "and_true",
"module": "Init.SimpLemmas"
},
{
"name": "decide_not",
"module": "Init.SimpLemmas"
},
{
"name": "eq_iff_iff",
"module": "Init.Core"
},
{
"name": "ge_iff_le",
"module": "Init.Core"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "pow_one",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
},
{
"name": "zero_add",
"module": "Mathlib.Algebra.Group.Defs"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "BitStream.ofBitVecZext",
"content": "abbrev ofBitVecZext {w} (x : BitVec w) : BitStream :=\n fun i => x.getLsbD i"
},
{
"name": "BitStream.addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitStream.add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "BitStream.zero",
"content": "abbrev zero : BitStream := fun _ => false"
}
] | [
{
"name": "BitStream.ofBitVecZext_eq_getLsbD",
"content": "@[simp]\ntheorem ofBitVecZext_eq_getLsbD (x : BitVec w) (i : Nat) :\n ofBitVecZext x i = x.getLsbD i"
},
{
"name": "BitStream.addAux_zero",
"content": "@[simp] theorem addAux_zero (x y : BitStream) : (x.addAux y 0) =\n ((x 0) ^^ (y 0), (x 0) && (y 0))"
},
{
"name": "BitStream.two_le_add_iff_odd_and_odd",
"content": "private theorem two_le_add_iff_odd_and_odd (n m : Nat) :\n 2 ≤ n % 2 + m % 2 ↔ n % 2 = 1 ∧ m % 2 = 1"
},
{
"name": "BitStream.add_odd_iff_neq",
"content": "private theorem add_odd_iff_neq (n m : Nat) :\n (n + m) % 2 = 1 ↔ (n % 2 = 1) ≠ (m % 2 = 1)"
}
] | import Mathlib.Tactic.NormNum
import Mathlib.Logic.Function.Iterate
section UpStream
namespace Int
end Int
end UpStream
def BitStream : Type := Nat → Bool
namespace BitStream
section Basic
section Lemmas
end Lemmas
end Basic
section OfNat
end OfNat
section ToBitVec
abbrev ofBitVecZext {w} (x : BitVec w) : BitStream :=
fun i => x.getLsbD i
section Lemmas
end Lemmas
end ToBitVec
section BitwiseOps
section Lemmas
variable {w : Nat}
variable (x y : BitStream) (i : Nat)
variable (x y : BitVec (w+1))
end Lemmas
end BitwiseOps
section Scan
end Scan
section FindIndex
section Arith
def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=
let carryIn : Bool := match i with
| 0 => false
| i + 1 => (addAux x y i).2
Prod.swap (BitVec.adcb (x i) (y i) carryIn)
def add (x y : BitStream) : BitStream :=
fun n => (addAux x y n).1
abbrev zero : BitStream := fun _ => false
section Lemmas
variable {w : Nat} {x y : BitVec w} {a b a' b' : BitStream}
local infix:20 " ≈ʷ " => EqualUpTo w | theorem ofBitVecZext_add_EqualUpTo :
ofBitVecZext (x + y) ≈ʷ (ofBitVecZext x) + (ofBitVecZext y) := | := by
intros n a
have add_lemma : ⟨(x + y).getLsbD n, BitVec.carry (n + 1) x y false ⟩ = (ofBitVecZext x).addAux (ofBitVecZext y) n := by
induction n
case zero =>
simp only [zero_add, addAux_zero, ofBitVecZext_eq_getLsbD, Prod.mk.injEq]
simp only [BitVec.getLsbD, BitVec.toNat_add, Nat.testBit_zero, Nat.mod_two_pos_mod_two_eq_one,
a, true_and]
simp only [add_odd_iff_neq, ne_eq, eq_iff_iff, decide_not, Bool.decide_iff_dist,
Bool.not_eq_eq_eq_not, BitVec.carry, pow_one, Bool.toNat_false, add_zero, ge_iff_le,
two_le_add_iff_odd_and_odd, Bool.decide_and, and_true]
bv_decide
case succ i ih =>
simp [addAux, ← ih (by omega), BitVec.adcb, a, BitVec.carry_succ, BitVec.getElem_add];
simp [HAdd.hAdd, Add.add, BitStream.add, ← add_lemma, a, -BitVec.add_eq, -Nat.add_eq] | 3 | 43 | false | Compiler |
323 | product.sim | lemma product.sim {m1 m2 : CNFA n}:
m1.Sim M1 → m2.Sim M2 →
(nfa (product.inits m1 m2) (final final? m1 m2) (f m1 m2)).Bisim (M1.M.product (to_prop final?) M2.M) | lean-mlir | Blase/Blase/AutoStructs/Constructions.lean | [
"import Blase.AutoStructs.Worklist",
"import Mathlib.Tactic.ApplyFun",
"import Mathlib.Data.Fintype.Prod",
"import Blase.Blase.AutoStructs.ForLean",
"import Blase.Blase.AutoStructs.ForMathlib"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Array.emptyWithCapacity",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Classical.propDecidable",
"module": "Init.Classical"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "SetRel",
"module": "Mathlib.Data.Rel"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
},
{
"name": "Function.Injective2",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "List.Nodup",
"module": "Init.Data.List.Basic"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
}
] | [
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "product",
"content": "def product (final? : Prop → Prop → Prop) (M N : NFA' n) : NFA' n where\n σ := _\n M := M.M.product final? N.M"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "nfa",
"content": "def nfa : NFA A S where\n start := { sa | sa ∈ inits }\n accept := { sa | final sa }\n step sa a := { sa' | (a, sa') ∈ f sa }"
},
{
"name": "Std.HashSet.toSet",
"content": "def Std.HashSet.toSet [BEq α] [Hashable α] (m : HashSet α) : Set α := { x | x ∈ m }\n\naxiom hashMap_missing : ∀ {P : Prop}, P"
}
] | [
{
"name": "Array.mem_push",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "Array.mem_toList_iff",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "Array.toList_push",
"module": "Init.Data.Array.Bootstrap"
},
{
"name": "Function.Injective2.eq_iff",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "List.Nodup.append",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "List.append_assoc",
"module": "Init.Data.List.Basic"
},
{
"name": "List.disjoint_singleton",
"module": "Batteries.Data.List.Lemmas"
},
{
"name": "List.mem_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.mem_singleton",
"module": "Init.Data.List.Lemmas"
},
{
"name": "Set.mem_empty_iff_false",
"module": "Mathlib.Data.Set.Basic"
},
{
"name": "Set.mem_insert_iff",
"module": "Mathlib.Data.Set.Insert"
},
{
"name": "Set.union_singleton",
"module": "Mathlib.Data.Set.Insert"
},
{
"name": "and_false",
"module": "Init.SimpLemmas"
},
{
"name": "iff_and_self",
"module": "Init.SimpLemmas"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "or_false",
"module": "Init.SimpLemmas"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
},
{
"name": "ne_or_eq",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Array.emptyWithCapacity_eq",
"module": "Init.Data.Array.Basic"
},
{
"name": "and_self",
"module": "Init.SimpLemmas"
},
{
"name": "implies_true",
"module": "Init.SimpLemmas"
},
{
"name": "Array.mem_def",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.not_mem_empty",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "FinEnum.nodup_toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "List.Nodup.notMem",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "List.dedup_eq_self",
"module": "Mathlib.Data.List.Dedup"
},
{
"name": "List.foldl_nil",
"module": "Init.Data.List.Basic"
},
{
"name": "List.mem_cons",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.nodup_cons",
"module": "Init.Data.List.Pairwise"
},
{
"name": "List.not_mem_nil",
"module": "Init.Data.List.Lemmas"
},
{
"name": "false_and",
"module": "Init.SimpLemmas"
},
{
"name": "false_or",
"module": "Init.SimpLemmas"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
}
] | [
{
"name": "Std.HashSet.fold_induction",
"content": "theorem Std.HashSet.fold_induction [BEq α] [LawfulBEq α] [Hashable α]\n {f : β → α → β} {m : HashSet α} {motive : β → Set α → Prop} :\n motive b ∅ →\n (∀ b x s, x ∉ s → motive b s → motive (f b x) (s ∪ {x})) →\n motive (m.fold f b) m.toSet"
},
{
"name": "Std.HashSet.toSet_toList[BEq",
"content": "theorem Std.HashSet.toSet_toList[BEq α] [LawfulBEq α] [Hashable α] (m : HashSet α) : m.toSet = { x | x ∈ m.toList }"
},
{
"name": "Std.HashSet.mem_toSet",
"content": "@[simp]\nlemma Std.HashSet.mem_toSet [BEq α] [Hashable α] (m : HashSet α) : x ∈ m.toSet ↔ x ∈ m"
},
{
"name": "Std.HashSet.mem_attachWith_mem",
"content": "@[simp]\ntheorem Std.HashSet.mem_attachWith_mem [BEq α] [Hashable α] [LawfulBEq α] (m : HashSet α) {P H} (x : α) h :\n ⟨x, h⟩ ∈ m.attachWith P H ↔ x ∈ m"
}
] | [
{
"name": "product.prodArray'",
"content": "@[inline]\ndef product.prodArray' (a : Array γ) :=\n m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>\n m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s1 s2)"
},
{
"name": "product.prodArray",
"content": "@[inline]\ndef product.prodArray := prodArray' f hm₁ hm₂ (Array.emptyWithCapacity <| m₁.size * m₂.size)"
},
{
"name": "product.inits",
"content": "def product.inits (m₁ m₂ : CNFA n) :=\n product.prodArray Prod.mk @m₁.wf.initials_lt @m₂.wf.initials_lt"
},
{
"name": "product",
"content": "def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=\n worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)\n (by admit /- proof elided -/\n ) f\nwhere final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)\n f (ss : m₁.m.states × m₂.m.states) :=\n let (s1, s2) := ss\n (FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>\n product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))\n (fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as"
},
{
"name": "to_prop",
"content": "noncomputable def to_prop (f : Bool → Bool → Bool) (p1 p2 : Prop) : Prop :=\n f (@Decidable.decide p1 (Classical.propDecidable _)) (@Decidable.decide p2 (Classical.propDecidable _))"
}
] | [
{
"name": "product.prodArray_spec_helper",
"content": "include hinj in\nomit [BEq α] [Hashable α] [LawfulBEq α] in\nlemma product.prodArray_spec_helper\n (is : Array γ) (hnd : is.toList.Nodup)\n (s : S₁) (hnew : ∀ s₂, f s s₂ ∉ is):\n let motive (a : Array γ) (S : Set S₂) :=\n a.toList.Nodup ∧\n (∃ r, a.toList = is.toList ++ r ∧ (∀ z ∈ r, ∃ s₁ s₂, z = f s₁ s₂)) ∧\n ∀ s1 s2, f s1 s2 ∈ a ↔ s1 ≠ s ∧ f s1 s2 ∈ is ∨ s1 = s ∧ s2 ∈ S\n let body := m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s s2)\n motive body (m₂.attachWith _ hm₂).toSet"
},
{
"name": "product.prodArray'_spec_full",
"content": "include hinj in\nlemma product.prodArray'_spec_full {aᵢ : Array γ} (hnd: aᵢ.toList.Nodup) (hnin : ∀ s₁ s₂, f s₁ s₂ ∉ aᵢ) :\n (product.prodArray' f hm₁ hm₂ aᵢ).toList.Nodup ∧\n (∃ r, (product.prodArray' f hm₁ hm₂ aᵢ).toList = aᵢ.toList ++ r ∧ (∀ z ∈ r, ∃ s₁ s₂, z = f s₁ s₂)) ∧\n ∀ s₁ s₂, f s₁ s₂ ∈ product.prodArray' f hm₁ hm₂ aᵢ ↔ (s₁.val ∈ m₁ ∧ s₂.val ∈ m₂)"
},
{
"name": "product.prodArray_spec_full",
"content": "include hinj in\nlemma product.prodArray_spec_full :\n (product.prodArray f hm₁ hm₂).toList.Nodup ∧\n ∀ s₁ s₂, f s₁ s₂ ∈ product.prodArray f hm₁ hm₂ ↔ (s₁.val ∈ m₁ ∧ s₂.val ∈ m₂)"
},
{
"name": "product.prodArray_spec",
"content": "include hinj in\n@[simp]\nlemma product.prodArray_spec :\n ∀ s₁ s₂, f s₁ s₂ ∈ product.prodArray f hm₁ hm₂ ↔ (s₁.val ∈ m₁ ∧ s₂.val ∈ m₂)"
},
{
"name": "product.inits_spec",
"content": "@[simp]\nlemma product.inits_spec :\n ∀ s₁ s₂, (s₁, s₂) ∈ inits m₁ m₂ ↔ (s₁.val ∈ m₁.m.initials ∧ s₂.val ∈ m₂.m.initials)"
},
{
"name": "product.f_spec",
"content": "lemma product.f_spec {m₁ m₂ : CNFA n} {s₁ : m₁.m.states} {s₂ : m₂.m.states} :\n ∀ a s₁' s₂',\n (a, (s₁', s₂')) ∈ f m₁ m₂ (s₁, s₂) ↔ s₁'.val ∈ m₁.m.tr s₁ a ∧ s₂'.val ∈ m₂.m.tr s₂ a"
}
] | import Mathlib.Data.Fintype.Prod
import Blase.AutoStructs.Worklist
import Mathlib.Tactic.ApplyFun
open SetRel
section sink
variable {A : Type} [BEq A] [Hashable A] [DecidableEq A] [FinEnum A]
end sink
section generic_prod
variable {α} [BEq α] [Hashable α] [LawfulBEq α]
variable {β} [BEq β] [Hashable β] [LawfulBEq β]
variable {S₁ : Finset α} {S₂ : Finset β}
variable {γ} (f : S₁ → S₂ → γ) (hinj : Function.Injective2 f)
variable {m₁ : Std.HashSet α} (hm₁ : ∀ s₁ ∈ m₁, s₁ ∈ S₁)
variable {m₂ : Std.HashSet β} (hm₂ : ∀ s₂ ∈ m₂, s₂ ∈ S₂)
@[inline]
def product.prodArray' (a : Array γ) :=
m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>
m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>
is.push (f s1 s2)
@[inline]
def product.prodArray := prodArray' f hm₁ hm₂ (Array.emptyWithCapacity <| m₁.size * m₂.size)
end generic_prod
section product
variable {A : Type} [BEq A] [LawfulBEq A] [Hashable A] [DecidableEq A] [FinEnum A]
def product.inits (m₁ m₂ : CNFA n) :=
product.prodArray Prod.mk @m₁.wf.initials_lt @m₂.wf.initials_lt
def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=
worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)
(by admit /- proof elided -/
) f
where final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)
f (ss : m₁.m.states × m₂.m.states) :=
let (s1, s2) := ss
(FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>
product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))
(fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as
noncomputable def to_prop (f : Bool → Bool → Bool) (p1 p2 : Prop) : Prop :=
f (@Decidable.decide p1 (Classical.propDecidable _)) (@Decidable.decide p2 (Classical.propDecidable _)) | lemma product.sim {m1 m2 : CNFA n}:
m1.Sim M1 → m2.Sim M2 →
(nfa (product.inits m1 m2) (final final? m1 m2) (f m1 m2)).Bisim (M1.M.product (to_prop final?) M2.M) := | := by
rintro ⟨R₁, hsim₁⟩ ⟨R₂, hsim₂⟩
let R : SetRel (m1.m.states × m2.m.states) (M1.σ × M2.σ) :=
{((s₁, s₂), (q₁, q₂)) | s₁.val ~[R₁] q₁ ∧ s₂.val ~[R₂] q₂ }
use R; constructor
· rintro ⟨s₁, s₂⟩ ⟨q₁, q₂⟩ ⟨hR₁, hR₂⟩
simp [nfa, to_prop, final]
rw [←hsim₁.accept hR₁, ←hsim₂.accept hR₂]; congr
· constructor
· rintro ⟨s₁, s₂⟩ hstart
simp [nfa, inits_spec] at hstart; rcases hstart with ⟨h₁, h₂⟩
obtain ⟨q₁, hq₁, hR₁⟩ := hsim₁.initial₁ h₁
obtain ⟨q₂, hq₂, hR₂⟩ := hsim₂.initial₁ h₂
use (q₁, q₂); simp [NFA.product, R, *]
· rintro ⟨q₁, q₂⟩ ⟨hst₁, hst₂⟩
apply hsim₁.initial₂ at hst₁; obtain ⟨s₁, hi₁, hR₁⟩ := hst₁
apply hsim₂.initial₂ at hst₂; obtain ⟨s₂, hi₂, hR₂⟩ := hst₂
simp only [nfa, Set.mem_setOf_eq, Prod.exists, inits_spec]
have hin₁ : s₁ ∈ m1.m.states := by apply m1.wf.initials_lt hi₁
have hin₂ : s₂ ∈ m2.m.states := by apply m2.wf.initials_lt hi₂
use ⟨s₁, hin₁⟩, ⟨s₂, hin₂⟩
simp_all [R]
· rintro ⟨s₁, s₂⟩ ⟨q₁, q₂⟩ a ⟨s₁', s₂'⟩ ⟨hR₁, hR₂⟩ hst
simp [nfa, f_spec] at hst; rcases hst with ⟨hst₁, hst₂⟩
obtain ⟨q₁', hst₁, hR₁'⟩ := hsim₁.trans_match₁ hR₁ hst₁
obtain ⟨q₂', hst₂, hR₂'⟩ := hsim₂.trans_match₁ hR₂ hst₂
simp [NFA.product]
use q₁', q₂'
simp_all [R]
· rintro ⟨s₁, s₂⟩ ⟨q₁, q₂⟩ a ⟨q₁', q₂'⟩ ⟨hR₁, hR₂⟩ hst
simp [NFA.product] at hst; rcases hst with ⟨hst₁, hst₂⟩
obtain ⟨s₁', hst₁, hR₁'⟩ := hsim₁.trans_match₂ hR₁ hst₁ (by simp) (by simp)
obtain ⟨s₂', hst₂, hR₂'⟩ := hsim₂.trans_match₂ hR₂ hst₂ (by simp) (by simp)
have hin₁ : s₁' ∈ m1.m.states := by apply m1.wf.trans_tgt_lt hst₁;
have hin₂ : s₂' ∈ m2.m.states := by apply m2.wf.trans_tgt_lt hst₂
simp only [nfa, Set.mem_setOf_eq, Prod.exists, f_spec]
use ⟨s₁', hin₁⟩, ⟨s₂', hin₂⟩
simp_all [R] | 7 | 80 | false | Compiler |
324 | matchVar_appendInl | theorem matchVar_appendInl {w : Var ⟨te⟩ t} :
matchVar lets v (.var matchLets matchExpr) w.appendInl ma = some ma' →
∃ args,
lets.getPureExpr v
= some ⟨_, w, matchExpr.op, matchExpr.ty_eq, matchExpr.eff_le, args, matchExpr.regArgs⟩
∧ matchArg lets matchLets args matchExpr.args ma = some ma' | lean-mlir | LeanMLIR/LeanMLIR/Transforms/Rewrite/Match.lean | [
"import LeanMLIR.Framework",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Transforms.Rewrite.Mapping",
"import LeanMLIR.LeanMLIR.ErasedContext"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "AList",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "AList.insert",
"module": "Mathlib.Data.List.AList"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "Valuation.map",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "Sigma",
"module": "Init.Core"
},
{
"name": "Sigma.mk",
"module": "Init.Core"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Iff",
"module": "Init.Core"
},
{
"name": "IsEmpty",
"module": "Mathlib.Logic.IsEmpty"
}
] | [
{
"name": "syntax \"neg\" : MLIR.Pretty.uniform_op",
"content": "syntax \"neg\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Mapping",
"content": "abbrev Mapping (Γ Δ : Ctxt Ty) : Type :=\n @AList (Σ t, Var Γ t) (fun x => Var Δ x.1)"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "last",
"content": "@[match_pattern]\ndef last (Γ : Ctxt Ty) (t : Ty) : Ctxt.Var (Ctxt.cons t Γ) t :=\n ⟨0, by admit /- proof elided -/\n ⟩"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "Expr.ty",
"content": "def Expr.ty : Expr d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Bool.false_eq_true",
"module": "Init.Data.Bool"
},
{
"name": "IsEmpty.exists_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "Option.isSome_none",
"module": "Init.Data.Option.Basic"
},
{
"name": "iff_false",
"module": "Init.SimpLemmas"
},
{
"name": "Option.get_some",
"module": "Init.Data.Option.Basic"
},
{
"name": "Option.isSome_iff_exists",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "forall_exists_index",
"module": "Init.PropLemmas"
}
] | [
{
"name": "eq.ty_eq",
"content": "theorem eq.ty_eq {v : Γ.Var t} {w : Γ.Var u} (h : v.eq w) : t = u"
},
{
"name": "Expr.op_mk",
"content": "@[simp]\ntheorem Expr.op_mk {Γ : Ctxt d.Ty} {ty} {eff : EffectKind} (op : d.Op)\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op))\n (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).op = op"
},
{
"name": "Expr.regArgs_mk",
"content": "@[simp]\ntheorem Expr.regArgs_mk {Γ : Ctxt d.Ty} {ty eff op}\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op)) (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).regArgs = regArgs"
},
{
"name": "appendCases_appendInl",
"content": "@[simp] theorem appendCases_appendInl (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInl = (left v)"
},
{
"name": "Expr.args_mk",
"content": "@[simp]\ntheorem Expr.args_mk {Γ : Ctxt d.Ty} {ty eff op}\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op)) (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).args = args"
}
] | [
{
"name": "MatchVarM",
"content": "abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)"
},
{
"name": "MatchVar",
"content": "abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit"
},
{
"name": "MatchVarM.unifyVars",
"content": "def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=\n fun ma =>\n match ma.lookup ⟨_, v⟩ with\n | some v =>\n if v = w then\n some ((), ma)\n else\n none\n | none =>\n some ((), AList.insert ⟨_, v⟩ w ma)"
},
{
"name": "matchArg",
"content": "def matchArg [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :\n {l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →\n MatchVar Δ_in Γ_out\n | _, .nil, .nil => return\n | t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do\n matchVar (t := t) lets vₗ matchLets vᵣ\n matchArg lets matchLets vsₗ vsᵣ\n termination_by l => (sizeOf matchLets, l.length + 1)"
},
{
"name": "matchVar",
"content": "def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :\n (matchLets : Lets d Δ_in .pure Δ_out) →\n (w : Var Δ_out t) →\n MatchVar Δ_in Γ_out\n \n | @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/\n | right w =>\n exact matchVar lets v matchLets w\n | left w => exact do\n let ⟨ts', w', ie⟩ ← lets.getPureExpr v\n if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then\n have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/"
}
] | [
{
"name": "MatchVar.liftM_bind_eq_some_iff",
"content": "@[simp]\ntheorem MatchVar.liftM_bind_eq_some_iff (x? : Option α)\n (f : α → MatchVarM Δ Γ β) :\n ((liftM x? >>= f) mapIn = some mapOut)\n ↔ ( ∃ h : x?.isSome,\n f (x?.get h) mapIn = some mapOut )"
}
] | import LeanMLIR.Framework
import LeanMLIR.Transforms.Rewrite.Mapping
open Ctxt (Var VarSet Valuation Hom)
variable {d} [DialectSignature d] [DecidableEq d.Ty]
variable {Γ : Ctxt d.Ty} {ty : d.Ty}
abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)
abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit
def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=
fun ma =>
match ma.lookup ⟨_, v⟩ with
| some v =>
if v = w then
some ((), ma)
else
none
| none =>
some ((), AList.insert ⟨_, v⟩ w ma)
open MatchVarM
variable [DecidableEq d.Op]
def matchArg [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :
{l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →
MatchVar Δ_in Γ_out
| _, .nil, .nil => return
| t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do
matchVar (t := t) lets vₗ matchLets vᵣ
matchArg lets matchLets vsₗ vsᵣ
termination_by l => (sizeOf matchLets, l.length + 1)
def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :
(matchLets : Lets d Δ_in .pure Δ_out) →
(w : Var Δ_out t) →
MatchVar Δ_in Γ_out
| @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/
| right w =>
exact matchVar lets v matchLets w
| left w => exact do
let ⟨ts', w', ie⟩ ← lets.getPureExpr v
if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then
have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/
end
section MatchVar
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out t te}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te} | theorem matchVar_appendInl {w : Var ⟨te⟩ t} :
matchVar lets v (.var matchLets matchExpr) w.appendInl ma = some ma' →
∃ args,
lets.getPureExpr v
= some ⟨_, w, matchExpr.op, matchExpr.ty_eq, matchExpr.eff_le, args, matchExpr.regArgs⟩
∧ matchArg lets matchLets args matchExpr.args ma = some ma' := | := by
unfold matchVar
simp only [Var.appendCases_appendInl]
simp only [MatchVar.liftM_bind_eq_some_iff, forall_exists_index]
generalize h_e? : lets.getPureExpr v = e?
intro h_isSome h
split_ifs at h
case neg => contradiction
case neg => contradiction
case pos h_e? hw =>
rcases matchExpr with ⟨mOp, _, _, mArgs, mRegArgs⟩
rcases h_e? with ⟨(rfl : _ = mOp), (rfl : _ = mRegArgs)⟩
rcases Option.isSome_iff_exists.mp h_isSome with ⟨⟨tys', w', e'⟩, rfl⟩
simp only [Option.get_some, Expr.op_mk, Expr.regArgs_mk, Option.some.injEq, Sigma.mk.injEq,
Expr.args_mk]
obtain rfl : te = tys' := by
simpa [e'.ty_eq]
rcases e' with ⟨_op, _ty_eq, _eff_le, args, regArgs⟩
obtain rfl : w = w' := by
simp_all [Option.get_some]
exact ⟨args, ⟨rfl, by rfl⟩, h⟩ | 7 | 63 | false | Compiler |
325 | RawCNFA.reverse_spec | lemma RawCNFA.reverse_spec {m : RawCNFA A} (hwf : m.WF) :
let m' := m.reverse
m'.WF ∧ m'.stateMax = m.stateMax ∧ m'.initials = m.finals ∧ m'.finals = m.initials ∧
∀ s a s', s' ∈ m'.tr s a ↔ s ∈ m.tr s' a | lean-mlir | Blase/Blase/AutoStructs/Constructions.lean | [
"import Blase.AutoStructs.Worklist",
"import Mathlib.Tactic.ApplyFun",
"import Mathlib.Data.Fintype.Prod",
"import Blase.Blase.AutoStructs.ForLean",
"import Blase.Blase.AutoStructs.ForMathlib"
] | [
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
},
{
"name": "Function.update",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Prod.snd",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap.map",
"module": "Std.Data.HashMap.AdditionalOperations"
},
{
"name": "LawfulHashable",
"module": "Init.Data.LawfulHashable"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
}
] | [
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "Std.HashSet.toSet",
"content": "def Std.HashSet.toSet [BEq α] [Hashable α] (m : HashSet α) : Set α := { x | x ∈ m }"
},
{
"name": "Std.HashMap.toPFun",
"content": "def Std.HashMap.toPFun [BEq α] [Hashable α] (m : HashMap α β) (x : α) : Option β := m[x]?"
}
] | [
{
"name": "Function.update_apply",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "Std.HashSet.fold_induction",
"content": "theorem Std.HashSet.fold_induction [BEq α] [LawfulBEq α] [Hashable α]\n {f : β → α → β} {m : HashSet α} {motive : β → Set α → Prop} :\n motive b ∅ →\n (∀ b x s, x ∉ s → motive b s → motive (f b x) (s ∪ {x})) →\n motive (m.fold f b) m.toSet"
},
{
"name": "Std.HashSet.toSet_toList[BEq",
"content": "theorem Std.HashSet.toSet_toList[BEq α] [LawfulBEq α] [Hashable α] (m : HashSet α) : m.toSet = { x | x ∈ m.toList }"
},
{
"name": "Std.HashMap.fold_induction",
"content": "theorem Std.HashMap.fold_induction [BEq α] [LawfulBEq α] [DecidableEq α] [Hashable α]\n {f : γ → α → β → γ} {m : HashMap α β} {motive : γ → (α → Option β) → Prop} :\n motive b (λ _ ↦ none) →\n (∀ b x y m, m x = none → motive b m → motive (f b x y) (Function.update m x y)) →\n motive (m.fold f b) m.toPFun"
},
{
"name": "Std.HashMap.toPFun_toList[BEq",
"content": "theorem Std.HashMap.toPFun_toList[BEq α] [LawfulBEq α] [Hashable α] (m : HashMap α β) :\n m.toPFun = λ k ↦ m.toList.find? (λ x ↦ x.1 == k) |>.map Prod.snd"
},
{
"name": "Std.HashMap.mem_of_getElem?",
"content": "@[aesop 50% unsafe]\ntheorem Std.HashMap.mem_of_getElem? [BEq K] [LawfulBEq K] [Hashable K] [LawfulHashable K] {m : Std.HashMap K V} {k : K} :\n m[k]? = some v → k ∈ m"
},
{
"name": "Std.HashMap.mem_iff_getElem?",
"content": "theorem Std.HashMap.mem_iff_getElem? [BEq K] [LawfulBEq K] [Hashable K] [LawfulHashable K] [Inhabited V] {m : Std.HashMap K V} {k : K} :\n k ∈ m ↔ ∃ v, m[k]? = some v"
}
] | [
{
"name": "RawCNFA.reverse",
"content": "def RawCNFA.reverse (m : RawCNFA A) : RawCNFA A :=\n let m' := { stateMax := m.stateMax, trans := Std.HashMap.emptyWithCapacity m.trans.size, initials := m.finals, finals := m.initials}\n m.trans.fold (init := m') processState\nwhere\n processState := fun m' (s, a) ss' =>\n ss'.fold (init := m') fun m' s' => m'.addTrans a s' s"
}
] | [
{
"name": "RawCNFA.reverse_spec_procesState",
"content": "lemma RawCNFA.reverse_spec_procesState {m : RawCNFA A} (hwf : m.WF) s₀ a₀ ss' (hs₀ : s₀ ∈ m.states) :\n let motive m' ss' :=\n (∀ s ∈ ss', s ∈ m.states) →\n m'.WF ∧ m'.stateMax = m.stateMax ∧ m'.initials = m.initials ∧ m'.finals = m.finals ∧\n ∀ s a s', s' ∈ m'.tr s a ↔ (s' ∈ m.tr s a ∨ s' = s₀ ∧ a = a₀ ∧ s ∈ ss')\n motive (RawCNFA.reverse.processState m (s₀, a₀) ss') ss'.toSet"
}
] | import Mathlib.Data.Fintype.Prod
import Blase.AutoStructs.Worklist
import Mathlib.Tactic.ApplyFun
open SetRel
section sink
variable {A : Type} [BEq A] [Hashable A] [DecidableEq A] [FinEnum A]
end sink
section generic_prod
variable {α} [BEq α] [Hashable α] [LawfulBEq α]
variable {β} [BEq β] [Hashable β] [LawfulBEq β]
variable {S₁ : Finset α} {S₂ : Finset β}
variable {γ} (f : S₁ → S₂ → γ) (hinj : Function.Injective2 f)
variable {m₁ : Std.HashSet α} (hm₁ : ∀ s₁ ∈ m₁, s₁ ∈ S₁)
variable {m₂ : Std.HashSet β} (hm₂ : ∀ s₂ ∈ m₂, s₂ ∈ S₂)
end generic_prod
section product
variable {A : Type} [BEq A] [LawfulBEq A] [Hashable A] [DecidableEq A] [FinEnum A]
end product
section determinization
variable {A : Type} [BEq A] [LawfulBEq A] [Hashable A] [DecidableEq A] [FinEnum A]
def RawCNFA.reverse (m : RawCNFA A) : RawCNFA A :=
let m' := { stateMax := m.stateMax, trans := Std.HashMap.emptyWithCapacity m.trans.size, initials := m.finals, finals := m.initials}
m.trans.fold (init := m') processState
where
processState := fun m' (s, a) ss' =>
ss'.fold (init := m') fun m' s' => m'.addTrans a s' s | lemma RawCNFA.reverse_spec {m : RawCNFA A} (hwf : m.WF) :
let m' := | := m.reverse
m'.WF ∧ m'.stateMax = m.stateMax ∧ m'.initials = m.finals ∧ m'.finals = m.initials ∧
∀ s a s', s' ∈ m'.tr s a ↔ s ∈ m.tr s' a := by
let motive (m' : RawCNFA A) (trs : (State × A) → Option (Std.HashSet State)) :=
(∀ s a ss', trs (s, a) = some ss' → s ∈ m.states ∧ ∀ s' ∈ ss', s' ∈ m.states) →
m'.WF ∧ m'.stateMax = m.stateMax ∧ m'.initials = m.finals ∧ m'.finals = m.initials ∧
∀ s a s', s' ∈ m'.tr s a ↔ ∃ ss', trs (s', a) = some ss' ∧ s ∈ ss' -- s' -a-> s is a transition
suffices h : motive (m.reverse) (m.trans.toPFun) by
specialize h (by rintro s a ss' heq; exact ⟨hwf.trans_src_lt _ (Std.HashMap.mem_of_getElem? heq), fun s' hin => hwf.trans_tgt_lt_internal heq hin⟩)
simp_all
apply Std.HashMap.fold_induction
· simp [motive, tr]
constructor <;> simp_all [tr]
· rintro m' ⟨s, a⟩ ss' trs hnew ih
rintro hsts
specialize ih (by rintro s₀ a₀ ss₀ heq; apply hsts _ a₀; simp [Function.update_apply]; split <;> simp_all)
rcases ih with ⟨hwf', hm', his', hfs', htrs'⟩
specialize hsts s a ss' (by simp)
have hs : s ∈ m'.states := by simp_all [states]
have hss' : ∀ s ∈ ss'.toSet, s ∈ m'.states := by simp_all [states]
obtain ⟨hwf'', hm'', his'', hfs'', htrs''⟩ := reverse_spec_procesState hwf' s a ss' hs hss'
simp_all only [true_and]
rintro s₁ b s₂
by_cases hcond : s₂ = s ∧ b = a
· rcases hcond with ⟨rfl, rfl, hin⟩
simp_all
· simp_all | 3 | 37 | false | Compiler |
326 | denote_rewriteAt | theorem denote_rewriteAt [LawfulMonad d.m]
{lhs rhs : Com d Γ₁ .pure t₁}
(hl : lhs.denote = rhs.denote)
{hlhs : ∀ t (v : Var Γ₁ t), ⟨t, v⟩ ∈ lhs.vars}
{pos : ℕ} {target : Com d Γ₂ eff t₂}
{rew : Com d Γ₂ eff t₂}
(hrew : rew ∈ rewriteAt lhs rhs hlhs pos target) :
rew.denote = target.denote | lean-mlir | LeanMLIR/LeanMLIR/Transforms/Rewrite/Rewrite.lean | [
"import LeanMLIR.Transforms.Rewrite.Match",
"import LeanMLIR.Framework",
"import LeanMLIR.LeanMLIR.Transforms.Rewrite.Match",
"import LeanMLIR.LeanMLIR.Framework.Zipper",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Framework.Zipper"
] | [
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "AList",
"module": "Mathlib.Data.List.AList"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "AList.insert",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Valuation.map",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "Valuation.mk",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "cast",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"neg\" : MLIR.Pretty.uniform_op",
"content": "syntax \"neg\" : MLIR.Pretty.uniform_op\n\nsyntax \"llvm.and\" : MLIR.Pretty.uniform_op\n\nsyntax \"llvm.ashr\" : MLIR.Pretty.exact_op\n\nsyntax \"llvm.add\" : MLIR.Pretty.overflow_op\n\nsyntax \"llvm.return\" : MLIR.Pretty.uniform_op"
},
{
"name": "notation:50 x \" ≤ₛ \" y => BitVec.sle x y",
"content": "notation:50 x \" ≤ₛ \" y => BitVec.sle x y"
},
{
"name": "notation:50 x \" >ᵤ \" y => BitVec.ult y x",
"content": "notation:50 x \" >ᵤ \" y => BitVec.ult y x"
},
{
"name": "notation:50 x \" ≥ᵤ \" y => BitVec.ule y x",
"content": "notation:50 x \" ≥ᵤ \" y => BitVec.ule y x"
},
{
"name": "notation:50 x \" <ᵤ \" y => BitVec.ult x y",
"content": "notation:50 x \" <ᵤ \" y => BitVec.ult x y"
},
{
"name": "notation:50 x \" ≥ₛ \" y => BitVec.sle y x",
"content": "notation:50 x \" ≥ₛ \" y => BitVec.sle y x"
},
{
"name": "notation:50 x \" <ₛ \" y => BitVec.slt x y",
"content": "notation:50 x \" <ₛ \" y => BitVec.slt x y"
},
{
"name": "notation:50 x \" >ₛ \" y => BitVec.slt y x",
"content": "notation:50 x \" >ₛ \" y => BitVec.slt y x"
},
{
"name": "notation:50 x \" ≤ᵤ \" y => BitVec.ule x y",
"content": "notation:50 x \" ≤ᵤ \" y => BitVec.ule x y"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $resName:mlir_op_operand = $name:InstCombine.cmp_op_name $x, $y $[: $t]?) => do\n let some opName := extractOpName name.raw\n | Macro.throwUnsupported\n let t ← t.getDM `(mlir_type| _)\n `(mlir_op| $resName:mlir_op_operand = $opName ($x, $y) : ($t, $t) -> (i1) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $resName:mlir_op_operand = $name:InstCombine.int_cast_op $x : $t to $t') => do\n let some opName := extractOpName name.raw\n | Macro.throwUnsupported\n `(mlir_op| $resName:mlir_op_operand = $opName ($x) : ($t) -> $t')"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant( $x $[: $inner_type]?)\n $[: $outer_type]? ) => do\n \n let outer_type ← outer_type.getDM `(mlir_type| _)\n let inner_type := inner_type.getD outer_type\n `(mlir_op| $res:mlir_op_operand = \"llvm.mlir.constant\"()\n {value = $x:neg_num : $inner_type} : () -> ($outer_type) )\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant( ${ $x:term }) $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n let x ← `(MLIR.AST.AttrValue.int $x [mlir_type| $t])\n `(mlir_op| $res:mlir_op_operand = \"llvm.mlir.constant\"() {value = $$($x) } : () -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (true) $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (1 : i1) : i1)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (false) $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (0 : i1) : i1)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant $x $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant($x $[: $t]?) $[: $t]?)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant ${ $x:term } $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant($$($x) $[: $t]?) $[: $t]?)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.icmp $p $x, $y $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n match p.getString with\n | \"eq\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.eq\" ($x, $y) : ($t, $t) -> (i1))\n | \"ne\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ne\" ($x, $y) : ($t, $t) -> (i1))\n | \"slt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.slt\" ($x, $y) : ($t, $t) -> (i1))\n | \"sle\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sle\" ($x, $y) : ($t, $t) -> (i1))\n | \"sgt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sgt\" ($x, $y) : ($t, $t) -> (i1))\n | \"sge\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sge\" ($x, $y) : ($t, $t) -> (i1))\n | \"ult\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ult\" ($x, $y) : ($t, $t) -> (i1))\n | \"ule\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ule\" ($x, $y) : ($t, $t) -> (i1))\n | \"ugt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ugt\" ($x, $y) : ($t, $t) -> (i1))\n | \"uge\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.uge\" ($x, $y) : ($t, $t) -> (i1))\n | _ => Macro.throwErrorAt p s!\"unexpected predicate {p.getString}\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.select $c, $x, $y $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"llvm.select\" ($c, $x, $y) : (i1, $t, $t) -> ($t))"
},
{
"name": "Zipper",
"content": "structure Zipper (Γ_in : Ctxt d.Ty) (eff : EffectKind) (tys : List d.Ty) where\n \n {Γ_mid : Ctxt d.Ty}\n \n top : Lets d Γ_in eff Γ_mid\n \n bot : Com d Γ_mid eff tys"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "matchArgRes",
"content": "def matchArgRes (lets : Lets d Γ_in eff Γ_out)\n (matchLets : Lets d Δ_in .pure Δ_out)\n (vs : HVector Γ_out.Var ts)\n (ws : HVector Δ_out.Var ts) :\n Option (MatchArgResult lets matchLets vs ws ∅) := do\n (matchArg lets matchLets vs ws ∅).attach.map fun ⟨⟨_, _⟩, h⟩ => .mk h"
},
{
"name": "matchArg",
"content": "def matchArg [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :\n {l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →\n MatchVar Δ_in Γ_out\n | _, .nil, .nil => return\n | t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do\n matchVar (t := t) lets vₗ matchLets vᵣ\n matchArg lets matchLets vsₗ vsᵣ\n termination_by l => (sizeOf matchLets, l.length + 1)"
},
{
"name": "matchVar",
"content": "def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :\n (matchLets : Lets d Δ_in .pure Δ_out) →\n (w : Var Δ_out t) →\n MatchVar Δ_in Γ_out\n \n | @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/\n | right w =>\n exact matchVar lets v matchLets w\n | left w => exact do\n let ⟨ts', w', ie⟩ ← lets.getPureExpr v\n if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then\n have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/"
},
{
"name": "MatchVar",
"content": "abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit"
},
{
"name": "MatchVarM",
"content": "abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)"
},
{
"name": "Mapping",
"content": "abbrev Mapping (Γ Δ : Ctxt Ty) : Type :=\n @AList (Σ t, Var Γ t) (fun x => Var Δ x.1)"
},
{
"name": "MatchVarM.unifyVars",
"content": "def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=\n fun ma =>\n match ma.lookup ⟨_, v⟩ with\n | some v =>\n if v = w then\n some ((), ma)\n else\n none\n | none =>\n some ((), AList.insert ⟨_, v⟩ w ma)"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "last",
"content": "@[match_pattern]\ndef last (Γ : Ctxt Ty) (t : Ty) : Ctxt.Var (Ctxt.cons t Γ) t :=\n ⟨0, by admit /- proof elided -/\n ⟩"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "MatchArgResult",
"content": "def MatchArgResult := { mapOut : Mapping _ _ //\n ∃ (mapIn' mapOut' : Mapping _ _),\n mapIn.entries ⊆ mapIn'.entries\n ∧ mapOut'.entries ⊆ mapOut.entries\n ∧ matchArg lets matchLets vs ws mapIn' = some ((), mapOut') }"
},
{
"name": "toHom",
"content": "def toHom (d : Diff Γ₁ Γ₂) : Hom Γ₁ Γ₂ :=\n fun _ v => ⟨v.val + d.val, d.property v.property⟩"
},
{
"name": "Hom",
"content": "abbrev Hom (Γ Γ' : Ctxt Ty) := ⦃t : Ty⦄ → Γ.Var t → Γ'.Var t"
},
{
"name": "Diff",
"content": "def Diff (Γ₁ Γ₂ : Ctxt Ty) : Type :=\n {d : Nat // Diff.Valid Γ₁ Γ₂ d}"
},
{
"name": "Diff.Valid",
"content": "@[simp]\nabbrev Diff.Valid (Γ₁ Γ₂ : Ctxt Ty) (d : Nat) : Prop :=\n ∀ {i t}, Γ₁[i]? = some t → Γ₂[i+d]? = some t"
},
{
"name": "Expr.pdenoteOp",
"content": "@[simp] abbrev Expr.pdenoteOp :\n Expr d Γ .pure ty → Γ.Valuation → (HVector toType ty) :=\n Expr.denoteOp"
},
{
"name": "Expr.ty",
"content": "def Expr.ty : Expr d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Expr.denoteOp",
"content": "def Expr.denoteOp (e : Expr d Γ eff ty) (V : Γ.Valuation) :\n eff.toMonad d.m (HVector toType ty) :=\n EffectKind.liftEffect e.eff_le <| cast (by admit /- proof elided -/\n ) <|\n DialectDenote.denote e.op (e.args.map V) e.regArgs.denote"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Lets.denote",
"content": "def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}\n (lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=\n match lets with\n | .nil => return V\n | .var lets' e => lets'.denote V >>= e.denote"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "HVector.denote",
"content": "def HVector.denote :\n {l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →\n HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l\n | _, .nil => HVector.nil\n | _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)"
},
{
"name": "FlatCom.denote",
"content": "@[simp] abbrev FlatCom.denote [DialectDenote d]\n (flatCom : FlatCom d Γ eff Γ_out ts)\n (V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=\n flatCom.lets.denote V >>= (return flatCom.rets.map ·)"
},
{
"name": "RegionSignature.map",
"content": "def RegionSignature.map (f : Ty → Ty') : RegionSignature Ty → RegionSignature Ty' :=\n List.map fun ⟨Γ, ty⟩ => (Γ.map f, ty.map f)"
},
{
"name": "Signature.map",
"content": "def Signature.map (f : Ty → Ty') : Signature Ty → Signature Ty' :=\n fun sig => {\n sig := sig.sig.map f\n regSig := sig.regSig.map f\n returnTypes := sig.returnTypes.map f\n }"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "Expr.denote",
"content": "def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :\n eff.toMonad d.m (e.outContext.Valuation) :=\n match e with\n | ⟨op, ty_eq, heff, args, regArgs⟩ => do\n let argsDenote := args.map V\n let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote\n return (val ++ V).cast (by admit /- proof elided -/\n )"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "liftEffect",
"content": "def liftEffect [Pure m] {e1 e2 : EffectKind} {α : Type}\n (hle : e1 ≤ e2) (v1 : e1.toMonad m α) : e2.toMonad m α :=\n match e1, e2, hle with\n | .pure, .pure, _ | .impure, .impure, _ => v1\n | .pure, .impure, _ => Pure.pure v1"
},
{
"name": "toMonad",
"content": "def toMonad (e : EffectKind) (m : Type → Type) : Type → Type :=\n match e with\n | pure => Id\n | impure => m"
},
{
"name": "Com.denote",
"content": "def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →\n eff.toMonad d.m (HVector toType ty)\n | .rets vs, Γv => pure (vs.map Γv)\n | .var e body, V => e.denote V >>= body.denote"
},
{
"name": "Com.ty",
"content": "def Com.ty : Com d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "FlatCom.denoteLets",
"content": "def FlatCom.denoteLets (flatCom : FlatCom d Γ eff Γ_out t) (Γv : Γ.Valuation) :\n eff.toMonad d.m <| Γ_out.Valuation :=\n flatCom.lets.denote Γv"
},
{
"name": "Com.toLets",
"content": "def Com.toLets (com : Com d Γ eff t) : Lets d Γ eff com.outContext :=\n Lets.nil.addComToEnd com"
},
{
"name": "Com.denoteLets",
"content": "def Com.denoteLets : (com : Com d Γ eff ty) → (Γv : Valuation Γ) →\n eff.toMonad d.m (com.outContext.Valuation)\n | .rets _, V => pure V\n | .var e body, V =>\n e.denote V >>= body.denoteLets >>= fun V =>\n return V.cast (by admit /- proof elided -/\n )"
},
{
"name": "cast",
"content": "def cast (h_eq : ty₁ = ty₂) : Γ.Var ty₁ → Γ.Var ty₂\n | ⟨i, h⟩ => ⟨i, h_eq ▸ h⟩"
},
{
"name": "cast",
"content": "def cast (h₁ : Γ = Γ') (h₂ : Δ = Δ') : Diff Γ Δ → Diff Γ' Δ'\n | ⟨n, h⟩ => ⟨n, by admit /- proof elided -/\n ⟩"
},
{
"name": "toCom",
"content": "def toCom (zip : Zipper d Γ_in eff ty) : Com d Γ_in eff ty :=\n go zip.top zip.bot\n where\n go : {Γ_mid : _} → Lets d Γ_in eff Γ_mid → Com d Γ_mid eff ty → Com d Γ_in eff ty\n | _, .nil, com => com\n | _, .var body e, com => go body (.var e com)"
},
{
"name": "denote",
"content": "def denote (zip : Zipper d Γ_in eff tys) (V_in : Valuation Γ_in) :\n eff.toMonad d.m (HVector toType tys) :=\n (zip.top.denote V_in) >>= zip.bot.denote"
},
{
"name": "Expr.returnVars",
"content": "def Expr.returnVars (e : Expr d Γ eff tys) : HVector e.outContext.Var tys :=\n .ofFn _ _ <| fun i => (Var.ofFin i).appendInl"
},
{
"name": "ofFin",
"content": "def ofFin (i : Fin Γ.length) : Γ.Var (Γ[i]) :=\n ⟨i.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Com.returnVars",
"content": "def Com.returnVars : (com : Com d Γ eff ts) → HVector (Var com.outContext) ts\n | .rets vs => vs\n | .var _ body => body.returnVars"
},
{
"name": "MatchVarResult.toHom",
"content": "def MatchVarResult.toHom\n (map : MatchVarResult lets v matchLets w mapIn)\n (hvars : ∀ t (v : Var Δ_in t), ⟨t, v⟩ ∈ matchLets.vars w) :\n Δ_in.Hom Γ_out :=\n map.val.toHom <| map.isTotal_of hvars"
},
{
"name": "MatchVarResult.isTotal_of",
"content": "def MatchVarResult.isTotal_of\n (map : MatchVarResult lets v matchLets w mapIn)\n (hvars : ∀ t (v : Var Δ_in t), ⟨t, v⟩ ∈ matchLets.vars w) :\n map.val.IsTotal :="
},
{
"name": "MatchArgResult.isTotal_of",
"content": "def MatchArgResult.isTotal_of\n (map : MatchArgResult lets matchLets vs ws mapIn)\n (hvars : ∀ t (v : Var Δ_in t), ⟨t, v⟩ ∈ matchLets.varsOfVec ws) :\n map.val.IsTotal :="
},
{
"name": "MatchArgResult.toHom",
"content": "def MatchArgResult.toHom\n (map : MatchArgResult lets matchLets vs ws mapIn)\n (hvars : ∀ t (v : Var Δ_in t), ⟨t, v⟩ ∈ matchLets.varsOfVec ws) :\n Δ_in.Hom Γ_out :=\n map.val.toHom <| map.isTotal_of hvars\n\nvariable\n {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty}\n {lets : Lets d Γ_in eff Γ_out}\n {matchTy}\n {v : Var Γ_out matchTy}\n {matchLets : Lets d Δ_in .pure Δ_out}\n {w : Var Δ_out matchTy}\nin"
},
{
"name": "Valuation.comap",
"content": "def Valuation.comap {Γi Γo : Ctxt Ty} (Γiv: Γi.Valuation) (hom : Ctxt.Hom Γo Γi) : Γo.Valuation :=\n fun _to vo => Γiv (hom vo)"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "MatchVarResult",
"content": "def MatchVarResult := { mapOut : Mapping _ _ //\n ∃ (mapIn' mapOut' : Mapping _ _),\n mapIn.entries ⊆ mapIn'.entries\n ∧ mapOut'.entries ⊆ mapOut.entries\n ∧ matchVar lets v matchLets w mapIn' = some ((), mapOut') }"
},
{
"name": "toArgResult",
"content": "noncomputable def toArgResult\n (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInl mapIn) :\n let args := mapOut.getPureExpr_eq_some.choose\n MatchArgResult lets matchLets args matchExpr.args mapIn :=\n ⟨mapOut.1, by admit /- proof elided -/\n ⟩"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "eqvVarLeft",
"content": "def eqvVarLeft :\n MatchVarResult lets v (.var matchLets matchExpr) w.appendInr ma\n ≃ MatchVarResult lets v matchLets w ma where\n toFun := fun ⟨x, h⟩ => ⟨x, by admit /- proof elided -/\n ⟩\n invFun := fun ⟨x, h⟩ => ⟨x, by admit /- proof elided -/\n ⟩"
},
{
"name": "Expr.changeVars",
"content": "def Expr.changeVars (varsMap : Γ.Hom Γ') {ty} (e : Expr d Γ eff ty) :\n Expr d Γ' eff ty :=\n ⟨e.op, e.ty_eq, e.eff_le, e.args.map varsMap, e.regArgs⟩"
},
{
"name": "Com.changeVars",
"content": "def Com.changeVars : Com d Γ eff ty →\n (varsMap : Γ.Hom Γ') →\n Com d Γ' eff ty\n | .rets e => fun varsMap => .rets (e.map varsMap)\n | .var e body => fun varsMap => .var (e.changeVars varsMap)\n (body.changeVars (fun _ v => varsMap.append v))"
},
{
"name": "Hom.append",
"content": "def Hom.append {ζ : Ctxt Ty} (f : Γ.Hom Δ) : Hom (ζ ++ Γ) (ζ ++ Δ) :=\n fun _ => Var.appendCases\n (fun v => v.appendInl)\n (fun v => (f v).appendInr)"
},
{
"name": "append",
"content": "def append (d₁ : Diff Γ₁ Γ₂) (d₂ : Diff Γ₂ Γ₃) : Diff Γ₁ Γ₃ :=\n {val := d₁.val + d₂.val, property := append_valid d₁.property d₂.property}"
},
{
"name": "insertPureCom",
"content": "def insertPureCom (zip : Zipper d Γ_in eff ty)\n (vs : HVector zip.Γ_mid.Var newTy)\n (newCom : Com d zip.Γ_mid .pure newTy) : Zipper d Γ_in eff ty :=\n zip.insertCom vs (newCom.castPureToEff eff)"
},
{
"name": "insertCom",
"content": "def insertCom (zip : Zipper d Γ_in eff ty)\n (vs : HVector zip.Γ_mid.Var newTy) (newCom : Com d zip.Γ_mid eff newTy) :\n Zipper d Γ_in eff ty :=\n let top := zip.top.addComToEnd newCom\n \n let bot := zip.bot.changeVars <| newCom.outContextHom.with vs newCom.returnVars\n \n \n { top, bot }"
},
{
"name": "Hom.with",
"content": "def Hom.with [DecidableEq Ty] {Γ₁ Γ₂ : Ctxt Ty} (f : Γ₁.Hom Γ₂) {ts}\n (v₁ : HVector Γ₁.Var ts) (v₂ : HVector Γ₂.Var ts) : Γ₁.Hom Γ₂ :=\n fun _ w =>\n match v₁.idxOf? w with\n | none => f w\n | some ⟨i, h⟩ => (v₂.get i).cast h"
},
{
"name": "Com.outContextHom",
"content": "def Com.outContextHom (com : Com d Γ eff t) : Γ.Hom com.outContext :=\n com.outContextDiff.toHom"
},
{
"name": "Com.outContextDiff",
"content": "def Com.outContextDiff (com : Com d Γ eff ts) : Γ.Diff com.outContext :=\n ⟨com.bvars, by admit /- proof elided -/\n ⟩"
},
{
"name": "Expr.bvars",
"content": "@[simp, grind=] def Expr.bvars (e : Expr d Γ eff Δ) : Nat :=\n (DialectSignature.returnTypes e.op).length"
},
{
"name": "Com.bvars",
"content": "def Com.bvars : Com d Γ eff t → Nat :=\n Com.rec'\n (fun _ => 0)\n (fun e _body bodySize => e.bvars + bodySize)"
},
{
"name": "castCtxt",
"content": "def castCtxt (h_eq : Γ = Δ) : Γ.Var ty → Δ.Var ty\n | ⟨i, h⟩ => ⟨i, h_eq ▸ h⟩"
},
{
"name": "Com.castPureToEff",
"content": "def Com.castPureToEff (eff : EffectKind) : Com d Γ .pure t → Com d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
},
{
"name": "Com.changeEffect",
"content": "def Com.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Com d Γ eff₁ t → Com d Γ eff₂ t := fun com =>\n Com.rec' (motive := @fun Γ _ => eff₁ ≤ eff₂ → Com d Γ eff₂ t)\n (fun v _h => rets v)\n (fun e _body castBody h => var (e.changeEffect h) (castBody h))\n com h"
},
{
"name": "Expr.changeEffect",
"content": "def Expr.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Expr d Γ eff₁ t → Expr d Γ eff₂ t\n | Expr.mk op ty_eq eff_le args regArgs =>\n have heff : DialectSignature.effectKind op ≤ eff₂ := by admit /- proof elided -/"
},
{
"name": "com",
"content": "def com := mkCom (d := InstCombine.MetaLLVM 0) bb0 |>.toOption |>.get (by admit /- proof elided -/\n)"
},
{
"name": "bb0",
"content": "def bb0 : Region 0 := [mlir_region|\n{\n ^bb0(%arg0: i32):\n %0 = llvm.mlir.constant(8) : i32\n %1 = llvm.mlir.constant(31) : i32\n %2 = llvm.ashr %arg0, %1 : i32\n %3 = llvm.and %2, %0 : i32\n %4 = llvm.add %3, %2 : i32\n llvm.return %4 : i32\n }]"
},
{
"name": "Region",
"content": "structure Region where\n (name: String)\n (args: List <| TypedSSAVal φ)\n (ops: List Op)"
},
{
"name": "MetaLLVM",
"content": "abbrev MetaLLVM (φ : Nat) : Dialect where\n Op := MOp φ\n Ty := MTy φ"
},
{
"name": "Ty",
"content": "@[deprecated \"Use `LLVM.Ty` instead\" (since:=\"2025-04-30\")] abbrev Ty := LLVM.Ty"
},
{
"name": "Op",
"content": "@[deprecated \"Use `LLVM.Op` instead\" (since:=\"2025-04-30\")] abbrev Op := LLVM.Op"
},
{
"name": "MOp",
"content": "inductive MOp (φ : Nat) : Type\n | unary (w : Width φ) (op : MOp.UnaryOp φ) : MOp φ\n | binary (w : Width φ) (op : MOp.BinaryOp) : MOp φ\n | select (w : Width φ) : MOp φ\n | icmp (c : IntPred) (w : Width φ) : MOp φ\n \n | const (w : Width φ) (val : ℤ) : MOp φ\nderiving Repr, DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "binary",
"content": "@[match_pattern] abbrev binary (w : Nat) (op : MOp.BinaryOp) : LLVM.Op :=\n MOp.binary (.concrete w) op"
},
{
"name": "MOp.BinaryOp",
"content": "inductive MOp.BinaryOp : Type\n | and\n | or (disjoint : DisjointFlag := {disjoint := false} )\n | xor\n | shl (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | lshr (exact : ExactFlag := {exact := false} )\n | ashr (exact : ExactFlag := {exact := false} )\n | urem\n | srem\n | add (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | mul (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | sub (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | sdiv (exact : ExactFlag := {exact := false} )\n | udiv (exact : ExactFlag := {exact := false} )\nderiving DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "LLVM",
"content": "def LLVM : Dialect where\n Op := MOp 0\n Ty := MTy 0"
},
{
"name": "MTy",
"content": "inductive MTy (φ : Nat)\n | bitvec (w : Width φ) : MTy φ\n deriving DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "Width",
"content": "abbrev Width φ := ConcreteOrMVar Nat φ"
},
{
"name": "ConcreteOrMVar",
"content": "inductive ConcreteOrMVar (α : Type u) (φ : Nat)\n | concrete (a : α)\n | mvar (i : Fin φ)\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "const",
"content": "@[match_pattern] abbrev const (w : Nat) (val : ℤ) : LLVM.Op := MOp.const (.concrete w) val"
},
{
"name": "MOp.UnaryOp",
"content": "inductive MOp.UnaryOp (φ : Nat) : Type\n | neg\n | not\n | copy\n | freeze\n | trunc (w' : Width φ) (noWrapFlags : NoWrapFlags := {nsw := false, nuw := false} )\n | zext (w' : Width φ) (nneg : NonNegFlag := {nneg := false} )\n | sext (w' : Width φ)\nderiving Repr, DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "select",
"content": "@[simp_llvm_option]\ndef select {w : Nat} (c? : IntW 1) (x? y? : IntW w ) : IntW w := do\n let c ← c?\n if c = 1#1 then x? else y?"
},
{
"name": "IntW",
"content": "def IntW w := PoisonOr <| BitVec w"
},
{
"name": "PoisonOr",
"content": "structure PoisonOr (α : Type) where\n val : α\n poisonous : Bool\nderiving Inhabited, DecidableEq"
},
{
"name": "icmp",
"content": "@[simp_llvm_option]\ndef icmp {w : Nat} (c : IntPred) (x y : IntW w) : IntW 1 := do\n let x' ← x\n let y' ← y\n icmp? c x' y'"
},
{
"name": "icmp?",
"content": "@[simp_llvm]\ndef icmp? {w : Nat} (c : IntPred) (x y : BitVec w) : IntW 1 :=\n .value ↑(icmp' c x y)"
},
{
"name": "IntPred",
"content": "inductive IntPred where\n | eq\n | ne\n | ugt\n | uge\n | ult\n | ule\n | sgt\n | sge\n | slt\n | sle\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "icmp'",
"content": "@[simp_llvm]\ndef icmp' {w : Nat} (c : IntPred) (x y : BitVec w) : Bool :=\n match c with\n | .eq => (x == y)\n | .ne => (x != y)\n | .sgt => (x >ₛ y)\n | .sge => (x ≥ₛ y)\n | .slt => (x <ₛ y)\n | .sle => (x ≤ₛ y)\n | .ugt => (x >ᵤ y)\n | .uge => (x ≥ᵤ y)\n | .ult => (x <ᵤ y)\n | .ule => (x ≤ᵤ y)"
},
{
"name": "mkCom",
"content": "def mkCom [TransformTy d φ] [TransformExpr d φ] [TransformReturn d φ]\n (reg : MLIR.AST.Region φ) :\n ExceptM d (Σ (Γ : Ctxt d.Ty) (eff : EffectKind) (ty : _), Com d Γ eff ty) :=\n match reg.ops with\n | [] => throw <| .generic \"Ill-formed region (empty)\"\n | coms => BuilderM.runWithEmptyMapping <| do\n let Γ ← declareBindings ∅ reg.args\n let com ← mkComHelper Γ coms\n return ⟨Γ, com⟩"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Option.mem_def",
"module": "Init.Data.Option.Instances"
},
{
"name": "Option.bind_eq_bind",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Option.bind_eq_some_iff",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Option.dite_none_right_eq_some",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Option.pure_def",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "cast_eq",
"module": "Init.Core"
}
] | [
{
"name": "Com.denoteLets_eq",
"content": "theorem Com.denoteLets_eq {com : Com d Γ eff t} : com.denoteLets = com.toLets.denote"
},
{
"name": "Lets.denote_var",
"content": "@[simp] theorem Lets.denote_var {lets : Lets d Γ_in eff Γ_out} {e : Expr d Γ_out eff t} :\n (lets.var e).denote = fun V_in => lets.denote V_in >>= e.denote"
},
{
"name": "denote_toCom",
"content": "@[simp] theorem denote_toCom [LawfulMonad d.m] (zip : Zipper d Γ_in eff ty) :\n zip.toCom.denote = zip.denote"
},
{
"name": "Com.denoteLets_returnVars",
"content": "@[simp] theorem Com.denoteLets_returnVars (c : Com d Γ .pure tys) (V : Valuation Γ) :\n c.returnVars.map (c.denoteLets V) = c.denote V"
},
{
"name": "Id.bind_eq'",
"content": "theorem Id.bind_eq' (x : Id α) (f : α → id β) : x >>= f = f x"
},
{
"name": "Id.pure_eq'",
"content": "theorem Id.pure_eq' (a : α) : (pure a : Id α) = a"
},
{
"name": "denote_matchLets_of",
"content": "theorem denote_matchLets_of\n (map : MatchArgResult lets matchLets vs ws mapIn)\n (hvars : ∀ t (v : Var Δ_in t), ⟨t, v⟩ ∈ matchLets.varsOfVec ws)\n (V : lets.ValidDenotation) :\n ws.map (matchLets.denote (V.val.comap <| map.toHom h)) = vs.map V.val"
},
{
"name": "denote_matchArg",
"content": "theorem denote_matchArg\n {vs ws : HVector (Var _) ts}\n (mapOut : MatchArgResult lets matchLets vs ws mapIn)\n (V : lets.ValidDenotation) :\n HVector.map (matchLets.denote (mapOut.val.mapValuation V.val)) ws = HVector.map (V.val) vs"
},
{
"name": "HVector.map_eq_map_of_matchArg",
"content": "theorem HVector.map_eq_map_of_matchArg\n {lets : Lets d Γ_in eff Γ_out}\n {matchLets : Lets d Δ_in .pure Δ_out}\n {ma : Mapping Δ_in Γ_out}\n {l : List d.Ty} {args₁ : HVector _ l} {args₂ : HVector _ l}\n (mapOut : MatchArgResult lets matchLets args₁ args₂ ma)\n (f₁ f₂ : (t : d.Ty) → Var _ t → ⟦t⟧)\n (hf : ∀ {t v₁ v₂},\n (mapOut' : MatchVarResult lets v₁ matchLets v₂ ma)\n → mapOut'.val = mapOut.val\n → f₂ t v₂ = f₁ t v₁) :\n HVector.map f₂ args₂ = HVector.map f₁ args₁"
},
{
"name": "denote_matchVar",
"content": "theorem denote_matchVar\n {v w : Var _ t}\n (mapOut : MatchVarResult lets v matchLets w mapIn)\n (V : lets.ValidDenotation) :\n (matchLets.denote (mapOut.val.mapValuation V.val) w)\n = V.val v"
},
{
"name": "getPureExpr_eq_some",
"content": "theorem getPureExpr_eq_some\n (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInl mapIn) :\n ∃ args, lets.getPureExpr v = some ⟨te, w, ⟨\n matchExpr.op,\n matchExpr.ty_eq,\n matchExpr.eff_le,\n args,\n matchExpr.regArgs\n ⟩⟩"
},
{
"name": "matchVar_appendInl",
"content": "theorem matchVar_appendInl {w : Var ⟨te⟩ t} :\n matchVar lets v (.var matchLets matchExpr) w.appendInl ma = some ma' →\n ∃ args,\n lets.getPureExpr v\n = some ⟨_, w, matchExpr.op, matchExpr.ty_eq, matchExpr.eff_le, args, matchExpr.regArgs⟩\n ∧ matchArg lets matchLets args matchExpr.args ma = some ma'"
},
{
"name": "MatchVar.liftM_bind_eq_some_iff",
"content": "@[simp]\ntheorem MatchVar.liftM_bind_eq_some_iff (x? : Option α)\n (f : α → MatchVarM Δ Γ β) :\n ((liftM x? >>= f) mapIn = some mapOut)\n ↔ ( ∃ h : x?.isSome,\n f (x?.get h) mapIn = some mapOut )"
},
{
"name": "Com.denote_changeVars",
"content": "@[simp] theorem Com.denote_changeVars\n (varsMap : Γ.Hom Γ') (c : Com d Γ eff ty) :\n (c.changeVars varsMap).denote =\n fun V => c.denote (V.comap varsMap)"
},
{
"name": "denote_insertPureCom_eq_of",
"content": "theorem denote_insertPureCom_eq_of [LawfulMonad d.m]\n {zip : Zipper d Γ_in eff tys} {vs}\n {newCom : Com d zip.Γ_mid .pure newTys} {V_in : Valuation Γ_in}\n (h : ∀ V : zip.top.ValidDenotation,\n newCom.denote V.val = vs.map V.val) :\n (zip.insertPureCom vs newCom).denote V_in = zip.denote V_in"
},
{
"name": "denote_insertPureCom",
"content": "theorem denote_insertPureCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]\n {newCom : Com d zip.Γ_mid .pure newTys} {vs : HVector zip.Γ_mid.Var newTys} :\n (zip.insertPureCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do\n let V_mid ← zip.top.denote V_in\n zip.bot.denote\n ((Com.denoteLets newCom V_mid).comap <| newCom.outContextHom.with vs newCom.returnVars)\n )"
},
{
"name": "denote_insertCom",
"content": "theorem denote_insertCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]\n {newCom : Com d zip.Γ_mid eff newTys} {vs : HVector zip.Γ_mid.Var newTys} :\n (zip.insertCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do\n let V_mid ← zip.top.denote V_in\n let V_newMid ← newCom.denoteLets V_mid\n zip.bot.denote\n (V_newMid.comap <| newCom.outContextHom.with vs newCom.returnVars)\n )"
}
] | [
{
"name": "SplitProgramResult",
"content": "structure SplitProgramResult extends Zipper d Γ eff t where\n {midTypes : List d.Ty}\n midRet : HVector toZipper.Γ_mid.Var midTypes"
},
{
"name": "splitProgramAtAux",
"content": "def splitProgramAtAux : (pos : ℕ) → (lets : Lets d Γ₁ eff Γ₂) →\n (prog : Com d Γ₂ eff t) →\n Option (SplitProgramResult d Γ₁ eff t)\n | 0, lets, .var e body => some {\n top := lets.var e\n bot := body\n midRet := e.returnVars\n }\n | _, _, .rets _ => none\n | n+1, lets, .var e body =>\n splitProgramAtAux n (lets.var e) body"
},
{
"name": "splitProgramAt",
"content": "def splitProgramAt (pos : ℕ) (prog : Com d Γ eff t) :\n Option (SplitProgramResult d Γ eff t) :=\n splitProgramAtAux pos .nil prog"
},
{
"name": "rewriteAt",
"content": "def rewriteAt\n (lhs rhs : Com d Γ₁ .pure ts₁)\n (hlhs : ∀ t (v : Var Γ₁ t), ⟨t, v⟩ ∈ lhs.vars)\n (pos : ℕ) (target : Com d Γ₂ eff t₂) :\n Option (Com d Γ₂ eff t₂) := do\n let splitRes ← splitProgramAt pos target\n if h : ts₁ = splitRes.midTypes then\n let m ← matchArgRes splitRes.top lhs.toLets splitRes.midRet (h ▸ lhs.returnVars)\n let m := m.toHom <| by\n subst h; exact hlhs\n let rhs := rhs.changeVars m\n let zip := splitRes.insertPureCom splitRes.midRet (cast (by admit /- proof elided -/\n ) rhs)\n return zip.toCom\n else none"
}
] | [
{
"name": "denote_splitProgramAtAux",
"content": "theorem denote_splitProgramAtAux [LawfulMonad d.m] :\n {pos : ℕ} → {lets : Lets d Γ₁ eff Γ₂} →\n {prog : Com d Γ₂ eff t} →\n {res : _} → (hres : res ∈ splitProgramAtAux pos lets prog) →\n (V : Valuation Γ₁) →\n res.denote V = (lets.denote V) >>= prog.denote\n | 0, lets, .var e body, res, hres, V => by\n obtain rfl"
},
{
"name": "denote_splitProgramAt",
"content": "@[simp]\ntheorem denote_splitProgramAt [LawfulMonad d.m] {pos : ℕ} {prog : Com d Γ eff t}\n {res : _} (hres : res ∈ splitProgramAt pos prog) :\n res.denote = prog.denote"
}
] | import LeanMLIR.Framework
import LeanMLIR.Framework.Zipper
import LeanMLIR.Transforms.Rewrite.Match
open Ctxt (Var VarSet Valuation)
variable {d} [DialectSignature d] [TyDenote d.Ty] [DialectDenote d] [Monad d.m]
variable [DecidableEq d.Ty] [DecidableEq d.Op]
variable [∀ (t : d.Ty), Inhabited (toType t)]
section SplitProgram
variable (d Γ eff t) in
structure SplitProgramResult extends Zipper d Γ eff t where
{midTypes : List d.Ty}
midRet : HVector toZipper.Γ_mid.Var midTypes
def splitProgramAtAux : (pos : ℕ) → (lets : Lets d Γ₁ eff Γ₂) →
(prog : Com d Γ₂ eff t) →
Option (SplitProgramResult d Γ₁ eff t)
| 0, lets, .var e body => some {
top := lets.var e
bot := body
midRet := e.returnVars
}
| _, _, .rets _ => none
| n+1, lets, .var e body =>
splitProgramAtAux n (lets.var e) body
def splitProgramAt (pos : ℕ) (prog : Com d Γ eff t) :
Option (SplitProgramResult d Γ eff t) :=
splitProgramAtAux pos .nil prog
end SplitProgram
def rewriteAt
(lhs rhs : Com d Γ₁ .pure ts₁)
(hlhs : ∀ t (v : Var Γ₁ t), ⟨t, v⟩ ∈ lhs.vars)
(pos : ℕ) (target : Com d Γ₂ eff t₂) :
Option (Com d Γ₂ eff t₂) := do
let splitRes ← splitProgramAt pos target
if h : ts₁ = splitRes.midTypes then
let m ← matchArgRes splitRes.top lhs.toLets splitRes.midRet (h ▸ lhs.returnVars)
let m := m.toHom <| by
subst h; exact hlhs
let rhs := rhs.changeVars m
let zip := splitRes.insertPureCom splitRes.midRet (cast (by admit /- proof elided -/
) rhs)
return zip.toCom
else none | theorem denote_rewriteAt [LawfulMonad d.m]
{lhs rhs : Com d Γ₁ .pure t₁}
(hl : lhs.denote = rhs.denote)
{hlhs : ∀ t (v : Var Γ₁ t), ⟨t, v⟩ ∈ lhs.vars}
{pos : ℕ} {target : Com d Γ₂ eff t₂}
{rew : Com d Γ₂ eff t₂}
(hrew : rew ∈ rewriteAt lhs rhs hlhs pos target) :
rew.denote = target.denote := | := by
funext V
simp only [rewriteAt, Option.pure_def, Option.bind_eq_bind, Option.mem_def,
Option.bind_eq_some_iff, Option.dite_none_right_eq_some, Option.some.injEq] at hrew
rcases hrew with ⟨res, h_split, rfl, varMap', -, rfl⟩
dsimp only at varMap'
simp only [cast_eq, Zipper.denote_toCom, ← denote_splitProgramAt h_split]
apply Zipper.denote_insertPureCom_eq_of
intro V
simp only [Expr.pdenoteOp, Com.denote_changeVars, ← hl]
rw [← Com.denoteLets_returnVars, Com.denoteLets_eq]
apply denote_matchLets_of varMap' hlhs | 13 | 179 | false | Compiler |
327 | nfaOfTerm_bv_language | lemma nfaOfTerm_bv_language (t : Term) :
nfaOfTerm t |>.bv_recognizes t.language | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.Blase.AutoStructs.Basic",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.Blase.AutoStructs.Constructions",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.card",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Array.foldl",
"module": "Init.Data.Array.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Array.size",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "cond",
"module": "Init.Prelude"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Array.emptyWithCapacity",
"module": "Init.Prelude"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
},
{
"name": "Array.empty",
"module": "Init.Prelude"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.equiv",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Subsingleton",
"module": "Init.Core"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "SetRel",
"module": "Mathlib.Data.Rel"
},
{
"name": "Array.back?",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.isEmpty",
"module": "Init.Data.Array.Basic"
},
{
"name": "List.next",
"module": "Mathlib.Data.List.Cycle"
},
{
"name": "L",
"module": "Archive.Hairer"
},
{
"name": "Fin.mk",
"module": "Init.Prelude"
},
{
"name": "Fin.cast",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.castLT",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.subNat",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List.Vector.get",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "DFA",
"module": "Mathlib.Computability.DFA"
},
{
"name": "NFA.toDFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "Fin.natAdd",
"module": "Init.Data.Fin.Basic"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
}
] | [
{
"name": "syntax \"max\" : MLIR.Pretty.uniform_op",
"content": "syntax \"max\" : MLIR.Pretty.uniform_op\n\nsyntax \"slt\" : MLIR.Pretty.uniform_op\n\nsyntax \"xor\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "carry",
"content": "def carry (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n => (addAux' initCarry x y n).2"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "worklistRun",
"content": "def worklistRun (final : S → Bool) (inits : Array S)\n (hinits : inits.toList.Nodup) (f : S → Array (BitVec n × S)) : CNFA n :=\n ⟨worklistRun' _ S final inits hinits f, worklistRun'_wf (BitVec n) S⟩"
},
{
"name": "worklistRun'",
"content": "def worklistRun' (final : S → Bool) (inits : Array S) (hinits : inits.toList.Nodup) (f : S → Array (A × S)) : RawCNFA A :=\n let st0 := worklist.initState _ _ inits hinits final\n go st0\nwhere go (st0 : worklist.St A S) : RawCNFA A :=\n if hemp : st0.worklist.isEmpty then st0.m else\n let sa? := st0.worklist.back?\n match heq : sa? with\n | some sa =>\n let wl := st0.worklist.pop\n let st1 := { st0 with worklist := wl,\n worklist_nodup := by admit /- proof elided -/"
},
{
"name": "worklist.St",
"content": "structure worklist.St where\n m : RawCNFA A\n map : Std.HashMap S State := ∅\n worklist : Array S := ∅\n worklist_nodup : worklist.toList.Nodup\n worklist_incl : ∀ sa ∈ worklist, sa ∈ map"
},
{
"name": "worklist.initState",
"content": "def worklist.initState (inits : Array S) (hinits : inits.toList.Nodup) (final? : S → Bool) : worklist.St A S :=\n let m := RawCNFA.empty (A := A)\n let mapm := inits.foldl (init := (Std.HashMap.emptyWithCapacity, m)) fun (map, m) sa =>\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := if final? sa then m.addFinal s else m\n (map.insert sa s, m)\n let map := mapm.1\n let m := mapm.2\n let worklist_incl : ∀ sa ∈ inits, sa ∈ map :="
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.empty",
"content": "def RawCNFA.empty : RawCNFA A := {\n stateMax := 0\n initials := ∅\n finals := ∅\n trans := ∅\n}"
},
{
"name": "processOneElem",
"content": "def processOneElem (final : S → Bool) (s : State) (st : worklist.St A S) : A × S → worklist.St A S :=\n fun (a', sa') =>\n let (s', st') := st.addOrCreateState _ _ (final sa') sa'\n let m := st'.m.addTrans a' s s'\n { st' with m }"
},
{
"name": "worklist.St.addOrCreateState",
"content": "def worklist.St.addOrCreateState (st : worklist.St A S) (final? : Bool) (sa : S) : State × worklist.St A S :=\n match heq : st.map[sa]? with\n | some s => (s, st)\n | none =>\n let (s, m) := st.m.newState\n let m := if final? then m.addFinal s else m\n let map := st.map.insert sa s\n let worklist := st.worklist.push sa\n have worklist_nodup : worklist.toList.Nodup := by admit /- proof elided -/"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "sub",
"content": "def sub (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).1"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "ofTerm",
"content": "abbrev ofTerm (t : Term) : FSM (Fin t.arity) := termEvalEqFSM t |>.toFSM"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "termEvalEqFSM",
"content": "def termEvalEqFSM : ∀ (t : Term), FSMTermSolution t\n | ofNat n =>\n { toFSM := FSM.ofNat n,\n good := by admit /- proof elided -/"
},
{
"name": "or",
"content": "def or : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ||| Circuit.var true (inr false),\n nextStateCirc := fun a => a.elim\n }"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (n : Nat) : FSM Unit :=\n match n with\n | 0 => FSM.id\n | n + 1 => composeUnaryAux (FSM.ls false) (shiftLeft n)"
},
{
"name": "id",
"content": "def id : FSM Unit := {\n α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr ()),\n nextStateCirc := Empty.elim\n}"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "and",
"content": "def and : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := fun a => a.elim,\n outputCirc := Circuit.var true (inr true) &&& Circuit.var true (inr false),\n }"
},
{
"name": "xor",
"content": "def xor : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ^^^ Circuit.var true (inr false),\n nextStateCirc := Empty.elim\n }"
},
{
"name": "neg",
"content": "def neg : FSM Unit :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "composeBinary",
"content": "def composeBinary\n (p : FSM Bool)\n {t₁ t₂ : Term}\n (q₁ : FSMTermSolution t₁)\n (q₂ : FSMTermSolution t₂) :\n FSM (Fin (max t₁.arity t₂.arity)) := composeBinaryAux p q₁.toFSM q₂.toFSM"
},
{
"name": "composeBinaryAux",
"content": "def composeBinaryAux\n (p : FSM Bool)\n (q₁ : FSM (Fin a₁))\n (q₂ : FSM (Fin a₂)) :\n FSM (Fin (max a₁ a₂)) :=\n p.compose (Fin (max a₁ a₂))\n (λ b => Fin (cond b a₁ a₂))\n (λ b i => Fin.castLE (by admit /- proof elided -/\n ) i)\n (λ b => match b with\n | true => q₁\n | false => q₂)"
},
{
"name": "FSMTermSolution",
"content": "structure FSMTermSolution (t : Term) extends FSM (Fin t.arity) where\n ( good : t.evalFin = toFSM.eval )"
},
{
"name": "Term.evalFin",
"content": "@[simp] def Term.evalFin (t : Term) (vars : Fin (arity t) → BitStream) : BitStream :=\n match t with\n | var n => vars (Fin.last n)\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | or t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | xor t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | not t => ~~~(t.evalFin vars)\n | add t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | sub t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | neg t => -(Term.evalFin t vars)\n \n \n | shiftL t n => BitStream.shiftLeft (Term.evalFin t vars) n"
},
{
"name": "Predicate.evalFin",
"content": "@[simp] def Predicate.evalFin (p : Predicate) (vars : Fin (arity p) → BitStream) : BitStream :=\nmatch p with\n| .width .eq n => BitStream.falseIffEq n\n| .width .neq n => BitStream.falseIffNeq n\n| .width .lt n => BitStream.falseIffLt n\n| .width .le n => BitStream.falseIffLe n\n| .width .gt n => BitStream.falseIffGt n\n| .width .ge n => BitStream.falseIffGe n\n| .binary .eq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalEq x₁ x₂\n| .binary .neq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalNeq x₁ x₂\n| .land p q =>\n \n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLand x₁ x₂\n| .lor p q =>\n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor x₁ x₂\n| .binary .slt p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalSlt x₁ x₂\n| .binary .sle p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalSlt x₁ x₂) (Predicate.evalEq x₁ x₂)\n| .binary .ult p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n (Predicate.evalUlt x₁ x₂)\n| .binary .ule p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalUlt x₁ x₂) (Predicate.evalEq x₁ x₂)"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "Predicate",
"content": "inductive Predicate : Type where\n \n| width (wp : WidthPredicate) (n : Nat) : Predicate\n| binary (p : BinaryPredicate) (t₁ t₂ : Term)\n| land (p q : Predicate) : Predicate\n| lor (p q : Predicate) : Predicate\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "ofNat",
"content": "def ofNat (n : Nat) : FSM (Fin 0) :=\n match hn : n with\n | 0 => FSM.zero\n\n | n' + 1 =>\n let bit := n.testBit 0\n let m := n / 2\n have h : m < n := by admit /- proof elided -/"
},
{
"name": "zero",
"content": "def zero : FSM (Fin 0) :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.fals\n }"
},
{
"name": "composeUnary",
"content": "def composeUnary\n (p : FSM Unit)\n {t : Term}\n (q : FSMTermSolution t) :\n FSM (Fin t.arity) := composeUnaryAux p q.toFSM"
},
{
"name": "one",
"content": "def one : FSM (Fin 0) :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "var",
"content": "def var (n : ℕ) : FSM (Fin (n+1)) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "add",
"content": "def add : FSM Bool :=\n { α := Unit,\n initCarry := λ _ => false,\n nextStateCirc := fun () =>\n Circuit.var true (inr true) &&& Circuit.var true (inr false) |||\n Circuit.var true (inr true) &&& Circuit.var true (inl ()) |||\n Circuit.var true (inr false) &&& Circuit.var true (inl ()),\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n }"
},
{
"name": "negOne",
"content": "def negOne : FSM (Fin 0) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "sub",
"content": "def sub : FSM Bool :=\n { α := Unit,\n initCarry := fun _ => false,\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n nextStateCirc := fun _ =>\n (Circuit.var false (inr true) &&& Circuit.var true (inr false)) |||\n (Circuit.var false (inr true) ^^^ Circuit.var true (inr false)) &&&\n (Circuit.var true (inl ()))\n }"
},
{
"name": "not",
"content": "def not : FSM Unit :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.var false (inr ())\n }"
},
{
"name": "add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "neg",
"content": "def neg (x : BitStream) : BitStream :=\n fun n => (negAux x n).1"
},
{
"name": "negAux",
"content": "def negAux (x : BitStream) : Nat → Bool × Bool\n | 0 => (x 0, !(x 0))\n | n+1 =>\n let borrow := (negAux x n).2\n let a := x (n + 1)\n (xor (!a) borrow, !a && borrow)"
},
{
"name": "CNFA.inter",
"content": "def CNFA.inter (m1 m2 : CNFA n) : CNFA n := product (fun b1 b2 => b1 && b2) m1 m2"
},
{
"name": "product",
"content": "def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=\n worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)\n (by admit /- proof elided -/\n ) f\nwhere final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)\n f (ss : m₁.m.states × m₂.m.states) :=\n let (s1, s2) := ss\n (FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>\n product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))\n (fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as"
},
{
"name": "product.prodArray'",
"content": "@[inline]\ndef product.prodArray' (a : Array γ) :=\n m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>\n m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s1 s2)"
},
{
"name": "product.inits_nodup",
"content": "def product.inits_nodup : inits m₁ m₂ |>.toList.Nodup :="
},
{
"name": "product.inits",
"content": "def product.inits (m₁ m₂ : CNFA n) :=\n product.prodArray Prod.mk @m₁.wf.initials_lt @m₂.wf.initials_lt"
},
{
"name": "product.prodArray",
"content": "@[inline]\ndef product.prodArray := prodArray' f hm₁ hm₂ (Array.emptyWithCapacity <| m₁.size * m₂.size)"
},
{
"name": "liftMaxSuccSucc2",
"content": "def liftMaxSuccSucc2 (n m : Nat) : Fin (m + 1) → Fin (max n m + 3) :=\n fun k => if _ : k = Fin.last m then max n m + 1 else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMaxSuccSucc1",
"content": "def liftMaxSuccSucc1 (n m : Nat) : Fin (n + 1) → Fin (max n m + 3) :=\n fun k => if _ : k = Fin.last n then (max n m).cast else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftLast3",
"content": "def liftLast3 n : Fin 3 → Fin (n + 3)\n| 0 => n\n| 1 => n + 1\n| 2 => Fin.last (n + 2)"
},
{
"name": "CNFA.inter_bv_language",
"content": "def CNFA.inter_bv_language (m₁ m₂ : CNFA n) :\n m₁.bv_recognizes L₁ →\n m₂.bv_recognizes L₂ →\n (m₁.inter m₂).bv_recognizes (L₁ ∩ L₂) :="
},
{
"name": "HashSet.inter",
"content": "def HashSet.inter [BEq A] [Hashable A] (m1 m2 : Std.HashSet A) : Std.HashSet A :=\n m1.fold (init := ∅) fun mi x => if m2.contains x then mi.insert x else mi"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "eval",
"content": "def eval (x : arity → BitStream) : BitStream :=\n fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2"
},
{
"name": "nextBit",
"content": "def nextBit : p.State → (arity → Bool) → p.State × Bool :=\n fun carry inputBits =>\n let input := Sum.elim carry inputBits\n let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input\n let outBit : Bool := (p.outputCirc).eval input\n (newState, outBit)"
},
{
"name": "State",
"content": "abbrev State : Type := p.α → Bool"
},
{
"name": "carry",
"content": "def carry (x : arity → BitStream) : ℕ → p.State\n | 0 => p.initCarry\n | n+1 => (p.nextBit (carry x n) (fun i => x i n)).1"
},
{
"name": "carryBV",
"content": "def carryBV (x : ar → BitVec w) : p.State :=\n p.carry (fun ar => .ofBitVecSext (x ar)) w"
},
{
"name": "evalBV",
"content": "def evalBV {w} (x : ar → BitVec w) : BitVec w :=\n BitVec.ofFn fun k => p.eval (fun ar => .ofBitVecSext (x ar)) k"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "Term.language",
"content": "def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=\n { bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }"
},
{
"name": "Formula.arity",
"content": "@[simp]\ndef Formula.arity : Formula → Nat\n| width _ _ => 0\n| atom _ t1 t2 => max t1.arity t2.arity\n| msbSet t => t.arity\n| unop _ φ => φ.arity\n| binop _ φ1 φ2 => max φ1.arity φ2.arity"
},
{
"name": "Term.evalFinBV",
"content": "@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=\n match t with\n | .var n => vars (Fin.last n)\n | .zero => BitVec.zero w\n | .one => 1\n | .negOne => -1\n | .ofNat n => BitVec.ofNat _ n\n | .and t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | .or t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | .xor t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | .not t => ~~~(t.evalFinBV vars)\n \n | .add t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | .sub t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | .neg t => -(t.evalFinBV vars)\n | .shiftL a n => (a.evalFinBV vars) <<< n"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
},
{
"name": "worklistRun_spec",
"content": "def worklistRun_spec : (worklistRun S final inits hinits f |>.Sim $ nfa' inits final f) :=\n worklistRun'_spec inits final f"
},
{
"name": "nfa'",
"content": "def nfa' : NFA' n :=\n { σ := _, M := nfa inits final f }"
},
{
"name": "nfa",
"content": "def nfa : NFA A S where\n start := { sa | sa ∈ inits }\n accept := { sa | final sa }\n step sa a := { sa' | (a, sa') ∈ f sa }"
},
{
"name": "worklistRun'_spec",
"content": "def worklistRun'_spec :\n (worklistRun' A S final inits hinits f |>.Sim $ nfa inits final f) :="
},
{
"name": "StInv",
"content": "structure StInv (m : RawCNFA A) (map : Std.HashMap S State) where\n wf : m.WF\n map_states : ∀ (sa : S) s, map[sa]? = some s → s ∈ m.states\n map_surj : ∀ s : m.states, ∃ (sa : S), map[sa]? = some s.val\n map_inj : ∀ {s} {sa sa' : S}, map[sa]? = some s → map[sa']? = some s → sa = sa'"
},
{
"name": "worklist.St.D",
"content": "def worklist.St.D (st : worklist.St A S) : Set S := st.visited"
},
{
"name": "worklist.St.visited",
"content": "def worklist.St.visited (st : worklist.St A S) : Set S := { s : S | s ∈ st.map ∧ s ∉ st.worklist }"
},
{
"name": "worklistGo_spec",
"content": "def worklistGo_spec {st : worklist.St A S} (inv : StInv A S st.m st.map) :\n st.sim inits final f ∅ →\n (worklistRun'.go A S final f st |>.Sim $ nfa inits final f) :="
},
{
"name": "worklist.St.rel",
"content": "def worklist.St.rel (st : worklist.St A S) : SetRel State S := {(s, sa) | st.map[sa]? = some s }"
},
{
"name": "processOneElem_mot",
"content": "def processOneElem_mot (s : State) (sa : S) (n : ℕ) (st : worklist.St A S) : Prop :=\n st.map[sa]? = some s ∧\n sa ∈ st.visited ∧\n StInv A S st.m st.map ∧\n st.sim inits final f {(sa1, a, sa') | sa1 = sa ∧ ∃ k ≥ n, (f sa)[k]? = some (a, sa') }"
},
{
"name": "worklist.St.sim",
"content": "abbrev worklist.St.sim {st : worklist.St A S} (T : Set (S × A × S)) :=\n st.m.Simul (nfa inits final f) st.rel st.D T"
},
{
"name": "RawCNFA.Sim",
"content": "def RawCNFA.Sim (m : RawCNFA A) (A : NFA A S) := ∃ R, RawCNFA.Simul m A R ⊤ ∅"
},
{
"name": "RawCNFA.Simul",
"content": "structure RawCNFA.Simul (m : RawCNFA A) (M : NFA A Q) (R : SetRel State Q) (D : Set Q) (T : Set (Q × A × Q)) where\n accept {s q} : s ~[R] q → (s ∈ m.finals ↔ q ∈ M.accept)\n initial₁ {s} : s ∈ m.initials → ∃ q ∈ M.start, s ~[R] q\n initial₂ {q} : q ∈ M.start → ∃ s ∈ m.initials, s ~[R] q\n trans_match₁ {s s' a q} : s ~[R] q → s' ∈ m.tr s a → ∃ q', q' ∈ M.step q a ∧ s' ~[R] q'\n trans_match₂ {s a q q'} : s ~[R] q → q' ∈ M.step q a → q ∈ D → (q, a, q') ∉ T → ∃ s', s' ∈ m.tr s a ∧ s' ~[R] q'"
},
{
"name": "RawCNFA.SimulFun",
"content": "structure RawCNFA.SimulFun (m : RawCNFA A) (M : NFA A Q) (f : m.states ≃ Q) where\n accept {q} : ((f.invFun q).val ∈ m.finals ↔ q ∈ M.accept)\n initial {q} : q ∈ M.start ↔ (f.invFun q).val ∈ m.initials\n trans_match {a q q'} : q' ∈ M.step q a ↔ (f.invFun q').val ∈ m.tr (f.invFun q) a"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "CNFA.Sim",
"content": "def CNFA.Sim (m : CNFA n) (M : NFA' n) :=\n m.m.Sim M.M"
},
{
"name": "CNFA.bv_recognizes",
"content": "def CNFA.bv_recognizes (m : CNFA n) (L : Set (BitVecs n)) :=\n ∃ L', m.recognizes L' ∧ L = dec '' L'"
},
{
"name": "RawCNFA.recognizes",
"content": "def RawCNFA.recognizes (m : RawCNFA A) (L : Language A) :=\n ∃ (σ : Type) (M : NFA A σ), m.Sim M ∧ M.accepts = L"
},
{
"name": "CNFA.recognizes",
"content": "def CNFA.recognizes (m : CNFA n) (L : Language (BitVec n)) :=\n ∃ (M : NFA' n), m.Sim M ∧ M.M.accepts = L"
},
{
"name": "BitVecs.cast",
"content": "def BitVecs.cast (bvs : BitVecs n) (h : n = n') : BitVecs n' :=\n { w := bvs.w, bvs := h ▸ bvs.bvs }"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "CNFA.minimize",
"content": "def CNFA.minimize (m : CNFA n) : CNFA n :=\n let mᵣ := m.reverse.determinize\n mᵣ.reverse.determinize"
},
{
"name": "CNFA.determinize",
"content": "def CNFA.determinize (m : CNFA n) : CNFA n :=\n worklistRun (BitVec m.m.stateMax)\n (fun ss => ss.any fun n b => b == true && n ∈ m.m.finals)\n (determinize.inits m)\n (by admit /- proof elided -/\n )\n f\nwhere\n f := fun (ss : BitVec m.m.stateMax) =>\n (FinEnum.toList (BitVec n)).foldl (init := Array.empty) fun ts a =>\n let ss' := m.m.transSetBV ss a\n ts.push (a, ss')"
},
{
"name": "CNFA.determinize.inits",
"content": "def CNFA.determinize.inits (m : CNFA n) : Array (BitVec m.m.stateMax) :=\n #[BitVec.ofFn (fun n => n ∈ m.m.initials)]"
},
{
"name": "CNFA.reverse",
"content": "def CNFA.reverse (m : CNFA n) : CNFA n :=\n ⟨m.m.reverse, RawCNFA.reverse_spec m.wf |>.1⟩"
},
{
"name": "RawCNFA.reverse",
"content": "def RawCNFA.reverse (m : RawCNFA A) : RawCNFA A :=\n let m' := { stateMax := m.stateMax, trans := Std.HashMap.emptyWithCapacity m.trans.size, initials := m.finals, finals := m.initials}\n m.trans.fold (init := m') processState\nwhere\n processState := fun m' (s, a) ss' =>\n ss'.fold (init := m') fun m' s' => m'.addTrans a s' s"
},
{
"name": "CNFA.toNFA'",
"content": "def CNFA.toNFA' (m : CNFA n) : NFA' n := ⟨_, m.toNFA⟩"
},
{
"name": "CNFA.toNFA",
"content": "def CNFA.toNFA (m : CNFA n) : NFA (BitVec n) m.m.states where\n start := { s | s.val ∈ m.m.initials }\n accept := { s | s.val ∈ m.m.finals }\n step s₁ a := { s₂ | s₂.val ∈ m.m.tr s₁.val a }"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "reverse",
"content": "def reverse (M : NFA' n) : NFA' n where\n σ := _\n M := M.M.reverse"
},
{
"name": "CNFA.determinize_spec",
"content": "def CNFA.determinize_spec (m : CNFA n)\n {M : NFA' n} (hsim : m.Sim M) :\n m.determinize.Sim M.determinize :="
},
{
"name": "bv_to_set",
"content": "private def bv_to_set (bv : BitVec w) : Set State :=\n { s | bv.getLsbD s }"
},
{
"name": "_root_.SetRel.set_eq",
"content": "structure _root_.SetRel.set_eq (R : SetRel α β) (A : Set α) (B : Set β) where\n fwd : a ∈ A → ∃ b ∈ B, a ~[R] b\n bwd : b ∈ B → ∃ a ∈ A, a ~[R] b"
},
{
"name": "RawCNFA.lift",
"content": "@[inline]\ndef RawCNFA.lift (m₁: RawCNFA (BitVec n1)) (f : Fin n1 → Fin n2) : RawCNFA (BitVec n2) :=\n let trans := (List.range m₁.stateMax).foldl (init := ∅) fun m2 s => processState m2 s\n { m₁ with trans }\nwhere"
},
{
"name": "CNFA.lift",
"content": "@[inline]\ndef CNFA.lift (m: CNFA n1) (f : Fin n1 → Fin n2) : CNFA n2 :=\n ⟨m.m.lift f, m.m.lift_wf m.wf⟩"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "RawCNFA.proj",
"content": "@[inline]\ndef RawCNFA.proj (m1: RawCNFA (BitVec n1)) (f : Fin n2 → Fin n1) : RawCNFA (BitVec n2) :=\n let trans := m1.trans.keysArray.foldl (init := Std.HashMap.emptyWithCapacity) process\n { m1 with trans }\nwhere"
},
{
"name": "CNFA.proj_spec",
"content": "def CNFA.proj_spec (m : CNFA n2) (f : Fin n1 → Fin n2) {M : NFA' n2} :\n m.Sim M → (m.proj f |>.Sim (M.proj f)) :="
},
{
"name": "CNFA.proj",
"content": "@[inline]\ndef CNFA.proj (m: CNFA n2) (f : Fin n1 → Fin n2) : CNFA n1 :=\n ⟨m.m.proj f, m.m.proj_wf m.wf⟩"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "List.nodup_singleton",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "NFA.eval_append_singleton",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.eval_nil",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Fin.add_def",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fin.castLE_castLE",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.le_of_eq",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Fin.ext_iff",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.mod_le",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "eq_iff_iff",
"module": "Init.Core"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "ite_cond_eq_true",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
},
{
"name": "bisim_comp",
"content": "lemma bisim_comp (m : RawCNFA A) :\n m.Sim M₁ → M₁.Bisim M₂ → m.Sim M₂"
},
{
"name": "bisimul_comp",
"content": "lemma bisimul_comp {m : RawCNFA A} :\n m.Simul M₁ R₁ ⊤ ∅ → M₁.Bisimul R₂ M₂ →\n m.Simul M₂ (R₁.comp R₂) ⊤ ∅"
},
{
"name": "CNFA.bv_recognizes_equiv",
"content": "lemma CNFA.bv_recognizes_equiv {m : CNFA n} :\n m.bv_recognizes L ↔ ∃ (M : NFA' n), m.Sim M ∧ M.accepts = L"
},
{
"name": "List.Vector.append_get_ge",
"content": "@[simp]\nlemma List.Vector.append_get_ge {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: n ≤ i) :\n (x ++ y).get i = y.get ((i.cast (Nat.add_comm n m) |>.subNat n hlt))"
},
{
"name": "List.Vector.append_get_lt",
"content": "@[simp]\nlemma List.Vector.append_get_lt {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: i < n) :\n (x ++ y).get i = x.get (i.castLT hlt)"
},
{
"name": "CNFA.minimize_bv_language",
"content": "lemma CNFA.minimize_bv_language {m : CNFA n} :\n m.bv_recognizes L → m.minimize.bv_recognizes L"
},
{
"name": "CNFA.minimize_language",
"content": "lemma CNFA.minimize_language {m : CNFA n} :\n m.recognizes L → m.minimize.recognizes L"
},
{
"name": "CNFA.reverse_language",
"content": "lemma CNFA.reverse_language {m : CNFA n} (hl : m.recognizes L) : m.reverse.recognizes L.reverse"
},
{
"name": "CNFA.reverse_spec",
"content": "lemma CNFA.reverse_spec {m : CNFA n} : m.reverse.Sim m.toNFA'.reverse"
},
{
"name": "RawCNFA.reverse_spec",
"content": "lemma RawCNFA.reverse_spec {m : RawCNFA A} (hwf : m.WF) :\n let m'"
},
{
"name": "RawCNFA.reverse_spec_procesState",
"content": "lemma RawCNFA.reverse_spec_procesState {m : RawCNFA A} (hwf : m.WF) s₀ a₀ ss' (hs₀ : s₀ ∈ m.states) :\n let motive m' ss'"
},
{
"name": "CNFA.determinize_language",
"content": "lemma CNFA.determinize_language {m : CNFA n} :\n m.recognizes L → m.determinize.recognizes L"
},
{
"name": "CNFA.lift_bv_language",
"content": "@[simp]\nlemma CNFA.lift_bv_language {m : CNFA n1} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.lift f |>.bv_recognizes (BitVecs.transport f ⁻¹' L))"
},
{
"name": "CNFA.lift_spec",
"content": "lemma CNFA.lift_spec (m : CNFA n1) (f : Fin n1 → Fin n2) {M : NFA' n1} :\n m.Sim M → (m.lift f |>.Sim (M.lift f))"
},
{
"name": "CNFA.proj_bv_language",
"content": "lemma CNFA.proj_bv_language {m : CNFA n2} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.proj f |>.bv_recognizes (BitVecs.transport f '' L))"
},
{
"name": "BitVecs.transport_getElem",
"content": "@[simp]\nlemma BitVecs.transport_getElem {bvs : BitVecs m} (f : Fin n → Fin m) (i : Fin n) :\n (bvs.transport f).bvs.get i = bvs.bvs.get (f i)"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "langRel",
"content": "def langRel (R : BVNRel n) : Set (BitVecs n) :=\n { bvs | R bvs.bvs }"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "Alphabet",
"content": "abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)"
},
{
"name": "finFunToBitVec",
"content": "def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=\n BitVec.ofFn fun i => c (fe.equiv.invFun i)"
},
{
"name": "bitVecToFinFun",
"content": "def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=\n fun c => bv[FinEnum.equiv.toFun c]"
},
{
"name": "NFA.ofFSM",
"content": "def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where\n start := { q | q = p.initCarry }\n accept := ⊤\n step s a := {s' |\n let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))\n s' = s'' ∧ a.msb = b }"
},
{
"name": "inFSMRel",
"content": "@[simp]\nabbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=\n bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_sa",
"content": "def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>\n inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_correct",
"content": "def NFA'.ofFSM_correct (p : FSM arity) :\n (NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :="
},
{
"name": "CNFA.ofFSM",
"content": "def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=\n worklistRun (BitVec (FinEnum.card p.α))\n (fun _ => true)\n #[finFunToBitVec p.initCarry]\n (by admit /- proof elided -/\n )\n f\n where"
},
{
"name": "NFA.msbState",
"content": "inductive NFA.msbState : Type where\n| i | f\nderiving DecidableEq, Fintype"
},
{
"name": "liftOp",
"content": "def liftOp n : Fin (n + 1) → Fin (n + 3) :=\n fun k =>\n if k = n then Fin.last (n+2) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftOp_unchanged",
"content": "@[simp]\ndef liftOp_unchanged (k : Fin n) : liftOp n k.castSucc = k.castLE (by simp) :="
},
{
"name": "liftUnop",
"content": "def liftUnop n : Fin (n + 1) → Fin (n + 2) :=\n fun k =>\n if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "TermBinop",
"content": "inductive TermBinop where\n| and | or | xor | add | sub"
},
{
"name": "TermBinop.subst",
"content": "def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=\n match op with\n | .and => .and t₁ t₂\n | .or => .or t₁ t₂\n | .xor => .xor t₁ t₂\n | .add => .add t₁ t₂\n | .sub => .sub t₁ t₂"
},
{
"name": "TermBinop.openTerm",
"content": "def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)"
},
{
"name": "TermBinop.openTerm_arity",
"content": "@[simp]\ndef TermBinop.openTerm_arity (op : TermBinop) : op.openTerm.arity + 1 = 3 :="
},
{
"name": "TermBinop.termGadget",
"content": "def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=\n match t with\n | .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM\n | .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM\n | .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM\n | .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM\n | .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM"
},
{
"name": "autOfTermBinop",
"content": "def autOfTermBinop (op : TermBinop) (m₁ : CNFA (n + 1)) (m₂ : CNFA (m + 1)) : CNFA ((n ⊔ m) + 1 ) :=\n let mop : CNFA 3 := op.termGadget\n let f₁ := liftMaxSuccSucc1 n m\n let m1' := m₁.lift f₁\n let f₂ := liftMaxSuccSucc2 n m\n let m2' := m₂.lift f₂\n let mop := mop.lift $ liftLast3 (max (FinEnum.card (Fin n)) (FinEnum.card (Fin m)))\n let m := CNFA.inter m1' m2' |> CNFA.inter mop\n let mfinal := m.proj (liftOp _)\n mfinal.minimize"
},
{
"name": "swapLastTwoBlock",
"content": "def swapLastTwoBlock (x : Fin (n + 3)) : Fin (n + 3) :=\n if x = Fin.last (n+2) then n\n else if x = n+1 then Fin.last (n + 2)\n else if x = n then n + 1\n else x"
},
{
"name": "TermUnop",
"content": "inductive TermUnop where\n| neg | not | shiftL (k : Nat)"
},
{
"name": "TermUnop.openTerm",
"content": "def TermUnop.openTerm (op : TermUnop) : Term :=\n match op with\n | .neg => .neg (.var 0)\n | .not => .not (.var 0)\n | .shiftL k => .shiftL (.var 0) k"
},
{
"name": "TermUnop.openTerm_arity",
"content": "def TermUnop.openTerm_arity (op : TermUnop) : op.openTerm.arity = 1 :="
},
{
"name": "TermUnop.openTerm_arity'",
"content": "@[simp]\ndef TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :="
},
{
"name": "TermUnop.subst",
"content": "def TermUnop.subst (op : TermUnop) (t : Term) : Term :=\n match op with\n | .neg => .neg t\n | .not => .not t\n | .shiftL k => .shiftL t k"
},
{
"name": "TermUnop.termGadget",
"content": "def TermUnop.termGadget (t : TermUnop) : CNFA 2 :=\n match t with\n | .neg => FSM.ofTerm (.neg (.var 0)) |> CNFA.ofFSM\n | .not => FSM.ofTerm (.not (.var 0)) |> CNFA.ofFSM\n | .shiftL k => FSM.ofTerm (.shiftL (.var 0) k) |> CNFA.ofFSM"
},
{
"name": "autOfTermUnop",
"content": "def autOfTermUnop (op : TermUnop) (m : CNFA (n + 1)) : CNFA (n + 1) :=\n let mop : CNFA 2 := op.termGadget\n let mop : CNFA (n + 2) := mop.lift (λ i ↦ i.natAdd n)\n let m : CNFA (n + 2) := m.lift (λ i ↦ i.castLE (by admit /- proof elided -/\n ))\n let m := CNFA.inter m mop\n let mfinal := m.proj (liftUnop n)\n mfinal.minimize"
},
{
"name": "nfaOfTerm",
"content": "def nfaOfTerm (t : Term) : CNFA (t.arity + 1) :=\n match t with\n | .var n => FSM.ofTerm (.var n) |> CNFA.ofFSM\n | .zero => FSM.ofTerm .zero |> CNFA.ofFSM\n | .negOne => FSM.ofTerm .negOne |> CNFA.ofFSM\n | .one => FSM.ofTerm .one |> CNFA.ofFSM\n | .ofNat n => FSM.ofTerm (.ofNat n) |> CNFA.ofFSM\n | .and t₁ t₂ => autOfTermBinop .and (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .or t₁ t₂ => autOfTermBinop .or (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .xor t₁ t₂ => autOfTermBinop .xor (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .add t₁ t₂ => autOfTermBinop .add (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .sub t₁ t₂ => autOfTermBinop .sub (nfaOfTerm t₁) (nfaOfTerm t₂)\n | .neg t => autOfTermUnop .neg (nfaOfTerm t)\n | .not t => autOfTermUnop .not (nfaOfTerm t)\n | .shiftL t k => autOfTermUnop (.shiftL k) (nfaOfTerm t)"
},
{
"name": "swapLastTwo",
"content": "def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=\n if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x"
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
},
{
"name": "in_enc",
"content": "@[simp]\nlemma in_enc : x ∈ enc '' S ↔ dec x ∈ S"
},
{
"name": "dec_snoc_in_langRel",
"content": "@[simp]\nlemma dec_snoc_in_langRel {n} {R : BVNRel n} {w : BitVecs' n} {a : BitVec n} :\n dec (w ++ [a]) ∈ langRel R ↔\n R (List.Vector.ofFn fun k => .cons (a.getLsbD k) ((dec w).bvs.get k))"
},
{
"name": "NFA'.correct_spec",
"content": "lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :\n M.correct ζ L → M.accepts = langRel L"
},
{
"name": "NFA'.ofFSM_spec",
"content": "@[simp]\nlemma NFA'.ofFSM_spec (t : Term) :\n (ofFSM (FSM.ofTerm t)).accepts = t.language"
},
{
"name": "CNFA.ofFSM_spec",
"content": "lemma CNFA.ofFSM_spec (p : FSM arity) :\n (CNFA.ofFSM p).Sim (NFA'.ofFSM p)"
},
{
"name": "CNFA.ofFSM_bv_language",
"content": "lemma CNFA.ofFSM_bv_language :\n (CNFA.ofFSM (FSM.ofTerm t)).bv_recognizes t.language"
},
{
"name": "TermBinop.subst_arity'",
"content": "lemma TermBinop.subst_arity' {op : TermBinop} : (op.subst t₁ t₂).arity + 1= t₁.arity ⊔ t₂.arity + 1"
},
{
"name": "BitVecs.cast_eq",
"content": "@[simp]\nlemma BitVecs.cast_eq (x : BitVecs n) (h : n = n') : h ▸ x = x.cast h"
},
{
"name": "Fin.natAdd_zero'",
"content": "lemma Fin.natAdd_zero' [h : NeZero m] : Fin.natAdd (m := m) n 0 = n"
},
{
"name": "TermBinop.alt_lang",
"content": "lemma TermBinop.alt_lang {t₁ t₂ : Term} (op : TermBinop) :\n (op.subst_arity' ▸ (op.subst t₁ t₂).language) =\n let lop : Set (BitVecs 3) := op.openTerm_arity ▸ op.openTerm.language\n let lop' : Set (BitVecs ((t₁.arity ⊔ t₂.arity) + 3)) := lop.lift (liftLast3 (max t₁.arity t₂.arity))\n let l₁ := t₁.language.lift (liftMaxSuccSucc1 t₁.arity t₂.arity)\n let l₂ := t₂.language.lift (liftMaxSuccSucc2 t₁.arity t₂.arity)\n let l := l₁ ∩ l₂ ∩ lop'\n l.proj (liftOp _)"
},
{
"name": "TermUnop.subst_arity'",
"content": "@[simp]\nlemma TermUnop.subst_arity' {op : TermUnop} : (op.subst t).arity + 1 = t.arity + 1"
},
{
"name": "autOfTermBinop_bv_language",
"content": "lemma autOfTermBinop_bv_language op {t₁ t₂ : Term} (m₁ : CNFA (t₁.arity + 1)) (m₂ : CNFA (t₂.arity + 1)) :\n m₁.bv_recognizes t₁.language →\n m₂.bv_recognizes t₂.language →\n (autOfTermBinop op m₁ m₂ |>.bv_recognizes (op.subst_arity' ▸ (op.subst t₁ t₂).language))"
},
{
"name": "TermUnop.alt_lang",
"content": "lemma TermUnop.alt_lang {t : Term} (op : TermUnop) :\n (op.subst_arity' ▸ (op.subst t).language) =\n let lop : Set (BitVecs 2) := op.openTerm_arity' ▸ op.openTerm.language\n let lop' : Set (BitVecs (t.arity + 2)) := lop.lift (λ i ↦ i.natAdd t.arity)\n let lt : Set (BitVecs (t.arity + 2)) := t.language.lift (λ i ↦ i.castLE (by omega))\n let l := lt ∩ lop'\n l.proj (liftUnop t.arity)"
},
{
"name": "autOfTermUnop_bv_language",
"content": "lemma autOfTermUnop_bv_language op {t : Term} (m : CNFA (t.arity + 1)) :\n m.bv_recognizes t.language →\n (autOfTermUnop op m |>.bv_recognizes (op.subst_arity' ▸ (op.subst t).language))"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
def langRel (R : BVNRel n) : Set (BitVecs n) :=
{ bvs | R bvs.bvs }
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)
variable {arity : Type} [FinEnum arity]
def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=
BitVec.ofFn fun i => c (fe.equiv.invFun i)
def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=
fun c => bv[FinEnum.equiv.toFun c]
def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where
start := { q | q = p.initCarry }
accept := ⊤
step s a := {s' |
let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))
s' = s'' ∧ a.msb = b }
@[simp]
abbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=
bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>
inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_correct (p : FSM arity) :
(NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :=
open BitStream in
def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=
worklistRun (BitVec (FinEnum.card p.α))
(fun _ => true)
#[finFunToBitVec p.initCarry]
(by admit /- proof elided -/
)
f
where
end fsm
section nfas_relations
inductive NFA.msbState : Type where
| i | f
deriving DecidableEq, Fintype
end nfas_relations
def liftOp n : Fin (n + 1) → Fin (n + 3) :=
fun k =>
if k = n then Fin.last (n+2) else k.castLE (by admit /- proof elided -/
)
@[simp]
def liftOp_unchanged (k : Fin n) : liftOp n k.castSucc = k.castLE (by simp) :=
def liftUnop n : Fin (n + 1) → Fin (n + 2) :=
fun k =>
if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/
)
inductive TermBinop where
| and | or | xor | add | sub
def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=
match op with
| .and => .and t₁ t₂
| .or => .or t₁ t₂
| .xor => .xor t₁ t₂
| .add => .add t₁ t₂
| .sub => .sub t₁ t₂
def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)
@[simp]
def TermBinop.openTerm_arity (op : TermBinop) : op.openTerm.arity + 1 = 3 :=
def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=
match t with
| .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM
| .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM
| .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM
| .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM
| .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM
def autOfTermBinop (op : TermBinop) (m₁ : CNFA (n + 1)) (m₂ : CNFA (m + 1)) : CNFA ((n ⊔ m) + 1 ) :=
let mop : CNFA 3 := op.termGadget
let f₁ := liftMaxSuccSucc1 n m
let m1' := m₁.lift f₁
let f₂ := liftMaxSuccSucc2 n m
let m2' := m₂.lift f₂
let mop := mop.lift $ liftLast3 (max (FinEnum.card (Fin n)) (FinEnum.card (Fin m)))
let m := CNFA.inter m1' m2' |> CNFA.inter mop
let mfinal := m.proj (liftOp _)
mfinal.minimize
def swapLastTwoBlock (x : Fin (n + 3)) : Fin (n + 3) :=
if x = Fin.last (n+2) then n
else if x = n+1 then Fin.last (n + 2)
else if x = n then n + 1
else x
inductive TermUnop where
| neg | not | shiftL (k : Nat)
def TermUnop.openTerm (op : TermUnop) : Term :=
match op with
| .neg => .neg (.var 0)
| .not => .not (.var 0)
| .shiftL k => .shiftL (.var 0) k
def TermUnop.openTerm_arity (op : TermUnop) : op.openTerm.arity = 1 :=
@[simp]
def TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :=
def TermUnop.subst (op : TermUnop) (t : Term) : Term :=
match op with
| .neg => .neg t
| .not => .not t
| .shiftL k => .shiftL t k
def TermUnop.termGadget (t : TermUnop) : CNFA 2 :=
match t with
| .neg => FSM.ofTerm (.neg (.var 0)) |> CNFA.ofFSM
| .not => FSM.ofTerm (.not (.var 0)) |> CNFA.ofFSM
| .shiftL k => FSM.ofTerm (.shiftL (.var 0) k) |> CNFA.ofFSM
def autOfTermUnop (op : TermUnop) (m : CNFA (n + 1)) : CNFA (n + 1) :=
let mop : CNFA 2 := op.termGadget
let mop : CNFA (n + 2) := mop.lift (λ i ↦ i.natAdd n)
let m : CNFA (n + 2) := m.lift (λ i ↦ i.castLE (by admit /- proof elided -/
))
let m := CNFA.inter m mop
let mfinal := m.proj (liftUnop n)
mfinal.minimize
def nfaOfTerm (t : Term) : CNFA (t.arity + 1) :=
match t with
| .var n => FSM.ofTerm (.var n) |> CNFA.ofFSM
| .zero => FSM.ofTerm .zero |> CNFA.ofFSM
| .negOne => FSM.ofTerm .negOne |> CNFA.ofFSM
| .one => FSM.ofTerm .one |> CNFA.ofFSM
| .ofNat n => FSM.ofTerm (.ofNat n) |> CNFA.ofFSM
| .and t₁ t₂ => autOfTermBinop .and (nfaOfTerm t₁) (nfaOfTerm t₂)
| .or t₁ t₂ => autOfTermBinop .or (nfaOfTerm t₁) (nfaOfTerm t₂)
| .xor t₁ t₂ => autOfTermBinop .xor (nfaOfTerm t₁) (nfaOfTerm t₂)
| .add t₁ t₂ => autOfTermBinop .add (nfaOfTerm t₁) (nfaOfTerm t₂)
| .sub t₁ t₂ => autOfTermBinop .sub (nfaOfTerm t₁) (nfaOfTerm t₂)
| .neg t => autOfTermUnop .neg (nfaOfTerm t)
| .not t => autOfTermUnop .not (nfaOfTerm t)
| .shiftL t k => autOfTermUnop (.shiftL k) (nfaOfTerm t)
def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=
if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x | lemma nfaOfTerm_bv_language (t : Term) :
nfaOfTerm t |>.bv_recognizes t.language := | := by
induction t
case var x =>
simp only [nfaOfTerm]
exact CNFA.ofFSM_bv_language
case zero =>
simp only [nfaOfTerm]
exact CNFA.ofFSM_bv_language
case one =>
simp only [nfaOfTerm]
exact CNFA.ofFSM_bv_language
case negOne =>
simp only [nfaOfTerm]
exact CNFA.ofFSM_bv_language
case ofNat k =>
simp only [nfaOfTerm]
exact CNFA.ofFSM_bv_language
case neg t ih =>
simp only [nfaOfTerm]
apply autOfTermUnop_bv_language; assumption
case not t ih =>
simp only [nfaOfTerm]
apply autOfTermUnop_bv_language; assumption
case shiftL k t ih =>
simp only [nfaOfTerm]
apply autOfTermUnop_bv_language; assumption
case and t₁ t₂ ih₁ ih₂ =>
simp only [nfaOfTerm]
apply autOfTermBinop_bv_language <;> assumption
case or t₁ t₂ ih₁ ih₂ =>
simp only [nfaOfTerm]
apply autOfTermBinop_bv_language <;> assumption
case xor t₁ t₂ ih₁ ih₂ =>
simp only [nfaOfTerm]
apply autOfTermBinop_bv_language <;> assumption
case add t₁ t₂ ih₁ ih₂ =>
simp only [nfaOfTerm]
apply autOfTermBinop_bv_language <;> assumption
case sub t₁ t₂ ih₁ ih₂ =>
simp only [nfaOfTerm]
apply autOfTermBinop_bv_language <;> assumption | 12 | 311 | false | Compiler |
328 | isMonotone_matchVarArg_aux | theorem isMonotone_matchVarArg_aux (lets : Lets d Γ_in eff Γ_out) :
(
∀ (Δ_out : Ctxt d.Ty)
(matchLets : Lets d Δ_in EffectKind.pure Δ_out) (l : List d.Ty)
(argsl : HVector Γ_out.Var l) (argsr : HVector Δ_out.Var l),
(matchArg lets matchLets argsl argsr).IsMonotone
)
∧ (
∀ (Δ_out : Ctxt d.Ty) (t : d.Ty) (v : Γ_out.Var t)
(matchLets : Lets d Δ_in EffectKind.pure Δ_out)
(w : Var Δ_out t),
(matchVar lets v matchLets w).IsMonotone
) | lean-mlir | LeanMLIR/LeanMLIR/Transforms/Rewrite/Match.lean | [
"import LeanMLIR.Framework",
"import LeanMLIR.Transforms.Rewrite.Mapping"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "AList",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "AList.insert",
"module": "Mathlib.Data.List.AList"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "Valuation.map",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.Subset",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "List.Subset",
"module": "Init.Data.List.Basic"
},
{
"name": "StateT.bind",
"module": "Init.Control.State"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Iff",
"module": "Init.Core"
},
{
"name": "IsEmpty",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "reduceCtorEq",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
}
] | [
{
"name": "Mapping",
"content": "abbrev Mapping (Γ Δ : Ctxt Ty) : Type :=\n @AList (Σ t, Var Γ t) (fun x => Var Δ x.1)"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "last",
"content": "@[match_pattern]\ndef last (Γ : Ctxt Ty) (t : Ty) : Ctxt.Var (Ctxt.cons t Γ) t :=\n ⟨0, by admit /- proof elided -/\n ⟩"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Option.bind_eq_some_iff",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "AList.entries_insert_of_notMem",
"module": "Mathlib.Data.List.AList"
},
{
"name": "AList.lookup_eq_none",
"module": "Mathlib.Data.List.AList"
},
{
"name": "List.subset_cons_of_subset",
"module": "Init.Data.List.Sublist"
},
{
"name": "Option.mem_def",
"module": "Init.Data.Option.Instances"
},
{
"name": "IsEmpty.forall_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "forall_eq'",
"module": "Init.PropLemmas"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "implies_true",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "appendCases_appendInl",
"content": "@[simp] theorem appendCases_appendInl (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInl = (left v)"
}
] | [
{
"name": "MatchVarM",
"content": "abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)"
},
{
"name": "MatchVar",
"content": "abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit"
},
{
"name": "MatchVarM.unifyVars",
"content": "def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=\n fun ma =>\n match ma.lookup ⟨_, v⟩ with\n | some v =>\n if v = w then\n some ((), ma)\n else\n none\n | none =>\n some ((), AList.insert ⟨_, v⟩ w ma)"
},
{
"name": "matchArg",
"content": "def matchArg [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :\n {l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →\n MatchVar Δ_in Γ_out\n | _, .nil, .nil => return\n | t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do\n matchVar (t := t) lets vₗ matchLets vᵣ\n matchArg lets matchLets vsₗ vsᵣ\n termination_by l => (sizeOf matchLets, l.length + 1)"
},
{
"name": "matchVar",
"content": "def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :\n (matchLets : Lets d Δ_in .pure Δ_out) →\n (w : Var Δ_out t) →\n MatchVar Δ_in Γ_out\n \n | @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/\n | right w =>\n exact matchVar lets v matchLets w\n | left w => exact do\n let ⟨ts', w', ie⟩ ← lets.getPureExpr v\n if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then\n have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/"
},
{
"name": "MatchVar.IsMonotone",
"content": "def MatchVar.IsMonotone (f : MatchVar Δ Γ) : Prop :=\n ∀ mapIn, ∀ mapOut ∈ f mapIn,\n mapIn.entries ⊆ mapOut.2.entries"
}
] | [
{
"name": "unifyVars_eq_some_iff",
"content": "@[simp]\ntheorem unifyVars_eq_some_iff :\n unifyVars w v mapIn = some ((), mapOut)\n ↔ ( mapIn.lookup ⟨t, w⟩ = none ∧ mapIn.insert ⟨t, w⟩ v = mapOut\n ∨ mapIn.lookup ⟨t, w⟩ = v ∧ mapIn = mapOut\n )"
},
{
"name": "MatchVar.isMonotone_bind",
"content": "@[simp]\ntheorem MatchVar.isMonotone_bind {f : MatchVar Δ Γ} {g : Unit → MatchVar Δ Γ} :\n f.IsMonotone → (g ()).IsMonotone → IsMonotone (f >>= g)"
},
{
"name": "MatchVar.isMonotone_bind_liftM",
"content": "@[simp]\ntheorem MatchVar.isMonotone_bind_liftM {x? : Option α} {g : α → MatchVar Δ Γ} :\n IsMonotone (liftM x? >>= g) ↔ (∀ x ∈ x?, (g x).IsMonotone)"
},
{
"name": "MatchVar.isMonotone_none",
"content": "@[simp] theorem MatchVar.isMonotone_none : IsMonotone (none : MatchVar Δ Γ)"
},
{
"name": "MatchVar.isMonotone_unifyVars",
"content": "theorem MatchVar.isMonotone_unifyVars : IsMonotone (unifyVars w v)"
}
] | import LeanMLIR.Framework
import LeanMLIR.Transforms.Rewrite.Mapping
open Ctxt (Var VarSet Valuation Hom)
variable {d} [DialectSignature d] [DecidableEq d.Ty]
variable {Γ : Ctxt d.Ty} {ty : d.Ty}
abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)
abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit
def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=
fun ma =>
match ma.lookup ⟨_, v⟩ with
| some v =>
if v = w then
some ((), ma)
else
none
| none =>
some ((), AList.insert ⟨_, v⟩ w ma)
open MatchVarM
variable [DecidableEq d.Op]
def matchArg [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :
{l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →
MatchVar Δ_in Γ_out
| _, .nil, .nil => return
| t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do
matchVar (t := t) lets vₗ matchLets vᵣ
matchArg lets matchLets vsₗ vsᵣ
termination_by l => (sizeOf matchLets, l.length + 1)
def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :
(matchLets : Lets d Δ_in .pure Δ_out) →
(w : Var Δ_out t) →
MatchVar Δ_in Γ_out
| @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/
| right w =>
exact matchVar lets v matchLets w
| left w => exact do
let ⟨ts', w', ie⟩ ← lets.getPureExpr v
if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then
have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/
end
section MatchVar
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out t te}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
variable (lets v matchLets w) (mapIn : Mapping _ _) in
variable (lets matchLets) {tys} (vs ws : HVector _ tys) (mapIn : Mapping _ _) in
namespace MatchVarResult
variable [TyDenote d.Ty] [∀ (t : d.Ty), Inhabited ⟦t⟧] in
section Left
variable {w : Δ_out.Var t}
variable {mapIn} (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInr mapIn)
end Left
variable {w : Var ⟨te⟩ _} {mapIn}
end MatchVarResult
end MatchVar
section SubsetEntries
def MatchVar.IsMonotone (f : MatchVar Δ Γ) : Prop :=
∀ mapIn, ∀ mapOut ∈ f mapIn,
mapIn.entries ⊆ mapOut.2.entries
open MatchVar
section UnifyVars
variable {Δ Γ : Ctxt d.Ty} {t} (w : Δ.Var t) (v : Γ.Var t)
end UnifyVars
variable [DecidableEq d.Op] | theorem isMonotone_matchVarArg_aux (lets : Lets d Γ_in eff Γ_out) :
(
∀ (Δ_out : Ctxt d.Ty)
(matchLets : Lets d Δ_in EffectKind.pure Δ_out) (l : List d.Ty)
(argsl : HVector Γ_out.Var l) (argsr : HVector Δ_out.Var l),
(matchArg lets matchLets argsl argsr).IsMonotone
)
∧ (
∀ (Δ_out : Ctxt d.Ty) (t : d.Ty) (v : Γ_out.Var t)
(matchLets : Lets d Δ_in EffectKind.pure Δ_out)
(w : Var Δ_out t),
(matchVar lets v matchLets w).IsMonotone
) := | := by
apply matchArg.mutual_induct (d:=d)
· intro _ _ mapIn ⟨(), mapOut⟩ hvarMap
obtain rfl : mapIn = mapOut := by
simp only [matchArg] at hvarMap
change some ((), _) = some ((), _) at hvarMap
simp_all
exact Set.Subset.refl _
· intros
simp only [matchArg]
apply isMonotone_bind <;> assumption
· intro _ _ Δ_out u matchLets matchExpr l h ih
cases l using Var.appendCases with
| right _ => simp [ih]
| left _ =>
simp only [matchVar, Var.appendCases_appendInl, isMonotone_bind_liftM,
Option.mem_def]
intro ⟨_, e⟩ h_getPureExpr
split_ifs
· apply h; assumption
· exact isMonotone_none
· exact isMonotone_none
· simp [isMonotone_unifyVars] | 7 | 61 | false | Compiler |
329 | Deleted.toHom_append | @[simp] lemma Deleted.toHom_append {Γ Γ' : Ctxt Ty} {vs : DeleteRange Γ}
(DEL : Deleted (⟨us⟩ ++ Γ) vs.appendInl (⟨us⟩ ++ Γ')) :
DEL.toHom
= have DEL' : Deleted Γ vs Γ' | lean-mlir | LeanMLIR/LeanMLIR/Transforms/DCE.lean | [
"import Mathlib.Tactic.DepRewrite",
"import LeanMLIR.Framework",
"import Mathlib.Tactic.Linarith",
"import LeanMLIR.LeanMLIR.ErasedContext"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "List.ofFn",
"module": "Init.Data.List.OfFn"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "List.length",
"module": "Init.Prelude"
}
] | [
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "length",
"content": "@[grind=]\ndef length (Γ : Ctxt Ty) : Nat := Γ.toList.length"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "Hom.append",
"content": "def Hom.append {ζ : Ctxt Ty} (f : Γ.Hom Δ) : Hom (ζ ++ Γ) (ζ ++ Δ) :=\n fun _ => Var.appendCases\n (fun v => v.appendInl)\n (fun v => (f v).appendInr)"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "toHom",
"content": "def toHom (d : Diff Γ₁ Γ₂) : Hom Γ₁ Γ₂ :=\n fun _ v => ⟨v.val + d.val, d.property v.property⟩"
},
{
"name": "Hom",
"content": "abbrev Hom (Γ Γ' : Ctxt Ty) := ⦃t : Ty⦄ → Γ.Var t → Γ'.Var t"
},
{
"name": "Diff",
"content": "def Diff (Γ₁ Γ₂ : Ctxt Ty) : Type :=\n {d : Nat // Diff.Valid Γ₁ Γ₂ d}"
},
{
"name": "Diff.Valid",
"content": "@[simp]\nabbrev Diff.Valid (Γ₁ Γ₂ : Ctxt Ty) (d : Nat) : Prop :=\n ∀ {i t}, Γ₁[i]? = some t → Γ₂[i+d]? = some t"
}
] | [
{
"name": "Fin.coe_cast",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "List.getElem?_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.getElem?_ofFn",
"module": "Init.Data.List.OfFn"
},
{
"name": "List.getElem_append_right",
"module": "Init.Data.List.BasicAux"
},
{
"name": "List.length_append",
"module": "Init.Data.List.Basic"
},
{
"name": "Nat.ge_of_not_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Option.dite_none_right_eq_some",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Valuation.ext",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "dite_eq_ite",
"module": "Init.ByCases"
}
] | [
{
"name": "ofList_append",
"content": "@[simp] theorem ofList_append {ts us : List Ty} :\n Ctxt.ofList ts ++ Ctxt.ofList us = Ctxt.ofList (ts ++ us)"
},
{
"name": "length_ofList",
"content": "@[simp, grind=] theorem length_ofList : (ofList ts).length = ts.length"
},
{
"name": "getElem?_ofList",
"content": "@[simp, grind=] theorem getElem?_ofList (i : Nat) : (ofList ts)[i]? = ts[i]?"
},
{
"name": "getElem_ofList",
"content": "@[simp, grind=] theorem getElem_ofList (i : Nat) (h : _) : (ofList ts)[i]'h = ts[i]'h"
},
{
"name": "val_lt",
"content": "theorem val_lt (v : Γ.Var t) : v.val < Γ.length"
},
{
"name": "castCtxt_rfl",
"content": "@[simp, grind=] theorem castCtxt_rfl (h : Γ = Γ) : v.castCtxt h = v"
},
{
"name": "val_castCtxt",
"content": "@[simp, grind=] theorem val_castCtxt : (castCtxt h v).val = v.val"
}
] | [
{
"name": "DCE.DeleteRange",
"content": "structure DeleteRange (Γ : Ctxt Ty) where\n \n start : Fin (Γ.length + 1)\n \n num : Fin (Γ.length + 1 - start.val)"
},
{
"name": "DCE.DeleteRange.appendInl",
"content": "def appendInl {Γ : Ctxt Ty} {ts : List Ty}\n (r : DeleteRange Γ) : DeleteRange (⟨ts⟩ ++ Γ) where\n start := ⟨r.start + ts.length, by admit /- proof elided -/\n ⟩\n num := ⟨r.num, by admit /- proof elided -/\n ⟩"
},
{
"name": "Ctxt.delete",
"content": "def Ctxt.delete (Γ : Ctxt Ty) (vs : DeleteRange Γ) : Ctxt Ty :=\n Ctxt.ofList <| List.ofFn (n := Γ.length - vs.num.val) fun i =>\n have := vs.start.prop\n if hi : i.val < vs.start then\n Γ[i.val]\n else\n Γ[i.val + vs.num]"
},
{
"name": "Hom.delete",
"content": "def Hom.delete {Γ : Ctxt Ty} (delv : DeleteRange Γ) : Hom (Γ.delete delv) Γ :=\n fun t' v =>\n let idx :=\n if v.val < delv.start then\n v.val\n else\n v.val + delv.num\n ⟨idx, by admit /- proof elided -/\n ⟩"
},
{
"name": "Deleted",
"content": "def Deleted (Γ: Ctxt Ty) (vs : DeleteRange Γ) (Γ' : Ctxt Ty) : Prop :=\n Γ' = Γ.delete vs"
},
{
"name": "Deleted.toHom",
"content": "def Deleted.toHom (h : Deleted Γ r Γ') : Γ'.Hom Γ :=\n fun _ v => Hom.delete r (v.castCtxt h)"
}
] | [
{
"name": "Ctxt.delete_append_appendInl",
"content": "@[simp] theorem Ctxt.delete_append_appendInl {Γ : Ctxt Ty} {us : List Ty}\n {r : DeleteRange Γ} :\n (⟨us⟩ ++ Γ).delete r.appendInl = ⟨us⟩ ++ (Γ.delete r)"
}
] | import LeanMLIR.Framework
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.DepRewrite
open Ctxt (Var Valuation Hom)
namespace DCE
structure DeleteRange (Γ : Ctxt Ty) where
start : Fin (Γ.length + 1)
num : Fin (Γ.length + 1 - start.val)
open DCE (DeleteRange)
namespace DeleteRange
def appendInl {Γ : Ctxt Ty} {ts : List Ty}
(r : DeleteRange Γ) : DeleteRange (⟨ts⟩ ++ Γ) where
start := ⟨r.start + ts.length, by admit /- proof elided -/
⟩
num := ⟨r.num, by admit /- proof elided -/
⟩
section Lemmas
end Lemmas
end DeleteRange
end DCE
open DCE (DeleteRange)
def Ctxt.delete (Γ : Ctxt Ty) (vs : DeleteRange Γ) : Ctxt Ty :=
Ctxt.ofList <| List.ofFn (n := Γ.length - vs.num.val) fun i =>
have := vs.start.prop
if hi : i.val < vs.start then
Γ[i.val]
else
Γ[i.val + vs.num]
section Lemmas
variable {Γ : Ctxt Ty}
end Lemmas
def Hom.delete {Γ : Ctxt Ty} (delv : DeleteRange Γ) : Hom (Γ.delete delv) Γ :=
fun t' v =>
let idx :=
if v.val < delv.start then
v.val
else
v.val + delv.num
⟨idx, by admit /- proof elided -/
⟩
def Deleted (Γ: Ctxt Ty) (vs : DeleteRange Γ) (Γ' : Ctxt Ty) : Prop :=
Γ' = Γ.delete vs
def Deleted.toHom (h : Deleted Γ r Γ') : Γ'.Hom Γ :=
fun _ v => Hom.delete r (v.castCtxt h) | @[simp] lemma Deleted.toHom_append {Γ Γ' : Ctxt Ty} {vs : DeleteRange Γ}
(DEL : Deleted (⟨us⟩ ++ Γ) vs.appendInl (⟨us⟩ ++ Γ')) :
DEL.toHom
= have DEL' : Deleted Γ vs Γ' := | := by
rcases Γ'
simp only [Deleted, Ctxt.delete_append_appendInl] at DEL ⊢
injection DEL
simp_all [Ctxt.delete]
DEL'.toHom.append := by
have DEL' : Deleted Γ vs Γ' := by
rcases Γ'
simp only [Deleted, Ctxt.delete_append_appendInl] at DEL ⊢
injection DEL
simp_all [Ctxt.delete]
subst DEL'
funext t v
apply Subtype.ext
simp only [toHom, Hom.delete, Var.val_castCtxt, DeleteRange.val_start_appendInl,
DeleteRange.val_num_appendInl, Hom.append, Var.castCtxt_rfl]
cases v using Var.appendCases with
| right _ => simp; grind
| left v =>
have := v.val_lt
simp; grind | 3 | 45 | false | Compiler |
330 | Poly.fromTensor_toTensor | theorem fromTensor_toTensor [hqgt1 : Fact (q > 1)] (a : R q n)
(adeg : (R.representative q n a).natDegree + 1 < 2^n) :
R.fromTensor a.toTensor = a | lean-mlir | SSA/Projects/FullyHomomorphicEncryption/Statements.lean | [
"import Mathlib.Data.List.Basic",
"import Batteries.Data.List.Lemmas",
"import SSA.Projects.FullyHomomorphicEncryption.Basic"
] | [
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Function.surjInv",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.degree",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Ideal",
"module": "Mathlib.RingTheory.Ideal.Defs"
},
{
"name": "Ideal.Quotient.mk",
"module": "Mathlib.RingTheory.Ideal.Quotient.Defs"
},
{
"name": "Ideal.span",
"module": "Mathlib.RingTheory.Ideal.Span"
},
{
"name": "Polynomial.monomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Polynomial.coeff",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
},
{
"name": "Polynomial.map",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "Fact",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Polynomial.Monic",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "ZMod.cast",
"module": "Mathlib.Data.ZMod.Basic"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "WithBot",
"module": "Mathlib.Order.TypeTags"
},
{
"name": "List.length",
"module": "Init.Prelude"
},
{
"name": "Int.cast",
"module": "Init.Data.Int.Basic"
},
{
"name": "IntCast",
"module": "Init.Data.Int.Basic"
},
{
"name": "IntCast.intCast",
"module": "Init.Data.Int.Basic"
},
{
"name": "List.toFinsupp",
"module": "Mathlib.Data.List.ToFinsupp"
},
{
"name": "Polynomial.ofFinsupp",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "List.getD",
"module": "Init.Data.List.BasicAux"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Polynomial.toFinsupp",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Semiring",
"module": "Mathlib.Algebra.Ring.Defs"
}
] | [
{
"name": "syntax \"neg\" : MLIR.Pretty.uniform_op",
"content": "syntax \"neg\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "R.repLength",
"content": "noncomputable def R.repLength {q n} (a : R q n) : Nat := match\n Polynomial.degree a.representative with\n | none => 0\n | some d => d + 1"
},
{
"name": "R.representative",
"content": "noncomputable def R.representative :\n R q n → (ZMod q)[X] := fun x => R.representative' q n x %ₘ (f q n)"
},
{
"name": "R.representative'",
"content": "private noncomputable def R.representative' :\n R q n → (ZMod q)[X] := Function.surjInv (R.surjective_fromPoly q n)"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "R.fromTensor",
"content": "noncomputable def R.fromTensor {q n} (coeffs : List Int) : R q n :=\n coeffs.zipIdx.foldl (init := 0) fun res (c, i) =>\n res + R.monomial ↑c i"
},
{
"name": "R.monomial",
"content": "noncomputable def R.monomial {q n : Nat} (c : ZMod q) (i : Nat): R q n :=\n R.fromPoly (Polynomial.monomial i c)"
},
{
"name": "R.fromPoly",
"content": "abbrev R.fromPoly {q n : Nat} : (ZMod q)[X] →+* R q n := Ideal.Quotient.mk (Ideal.span {f q n})"
},
{
"name": "R.toTensor",
"content": "noncomputable def R.toTensor {q n} (a : R q n) : List Int :=\n List.range a.repLength |>.map fun i =>\n a.coeff i |>.toInt"
},
{
"name": "R.coeff",
"content": "noncomputable def R.coeff {q n} (a : R q n) (i : Nat) : ZMod q :=\n Polynomial.coeff a.representative i"
},
{
"name": "ZMod.toInt",
"content": "def ZMod.toInt (x : ZMod q) : Int := ZMod.cast x"
},
{
"name": "R.fromTensorFinsupp",
"content": "noncomputable def R.fromTensorFinsupp (q : Nat) (coeffs : List Int) : (ZMod q)[X] :=\n Polynomial.ofFinsupp (List.toFinsupp (coeffs.map Int.cast))"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
}
] | [
{
"name": "List.getD_eq_default",
"module": "Mathlib.Data.List.GetD"
},
{
"name": "List.getD_eq_getElem",
"module": "Mathlib.Data.List.GetD"
},
{
"name": "Nat.not_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Polynomial.coeff_eq_zero_of_degree_lt",
"module": "Mathlib.Algebra.Polynomial.Degree.Operations"
},
{
"name": "WithBot.bot_lt_coe",
"module": "Mathlib.Order.WithBot"
},
{
"name": "WithBot.coe_lt_coe",
"module": "Mathlib.Order.WithBot"
},
{
"name": "ZMod.cast_zero",
"module": "Mathlib.Data.ZMod.Basic"
},
{
"name": "Fact.elim",
"module": "Mathlib.Logic.Basic"
},
{
"name": "Nat.cast_add",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.cast_one",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.succ_eq_add_one",
"module": "Init.Data.Nat.Basic"
},
{
"name": "ZMod.cast_eq_val",
"module": "Mathlib.Data.ZMod.Basic"
},
{
"name": "ZMod.natCast_val",
"module": "Mathlib.Data.ZMod.Basic"
},
{
"name": "ZMod.val_intCast",
"module": "Mathlib.Data.ZMod.Basic"
},
{
"name": "gt_iff_lt",
"module": "Init.Core"
},
{
"name": "not_lt_zero'",
"module": "Mathlib.Algebra.Order.GroupWithZero.Canonical"
},
{
"name": "Polynomial.coeff_inj",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.degree_eq_bot",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "ZMod.coe_intCast",
"module": "Mathlib.Data.ZMod.Basic"
}
] | [
{
"name": "R.fromPoly_kernel_eq_zero",
"content": "@[simp]\ntheorem R.fromPoly_kernel_eq_zero (x : (ZMod q)[X]) : R.fromPoly (n := n) (f q n * x) = 0"
},
{
"name": "R.representative_fromPoly",
"content": "theorem R.representative_fromPoly :\n forall a : (ZMod q)[X], (R.fromPoly (n:=n) a).representative = a %ₘ (f q n)"
},
{
"name": "R.fromPoly_rep'_eq_ideal",
"content": "theorem R.fromPoly_rep'_eq_ideal :\n forall a : (ZMod q)[X],\n ∃ i ∈ Ideal.span {f q n}, (R.fromPoly (n:=n) a).representative' = a + i"
},
{
"name": "f_monic",
"content": "theorem f_monic : Monic (f q n)"
},
{
"name": "R.coeff_fromTensor",
"content": "theorem R.coeff_fromTensor (tensor : List Int)\n (htensorlen : tensor.length < 2^n) :\n (R.fromTensor (q := q) (n := n) tensor).coeff i = (tensor.getD i 0)"
},
{
"name": "R.fromTensorFinsupp_coeffs",
"content": "theorem R.fromTensorFinsupp_coeffs (coeffs : List Int) :\n Polynomial.coeff (fromTensorFinsupp q coeffs) i = ↑(List.getD coeffs i 0)"
},
{
"name": "R.fromTensorFinsupp_degree",
"content": "theorem R.fromTensorFinsupp_degree (q : Nat) (coeffs : List Int):\n (R.fromTensorFinsupp q coeffs).degree ≤ coeffs.length"
},
{
"name": "Polynomial.degree_toFinsupp",
"content": "theorem Polynomial.degree_toFinsupp [Semiring M] [DecidableEq M]\n (xs : List M) :\n degree { toFinsupp := List.toFinsupp (l := xs) } ≤ List.length xs"
},
{
"name": "R.fromTensor_eq_fromTensorFinsupp_fromPoly",
"content": "theorem R.fromTensor_eq_fromTensorFinsupp_fromPoly {coeffs : List Int} :\n R.fromTensor (q := q) (n := n) coeffs =\n R.fromPoly (q := q) (n := n) (R.fromTensorFinsupp q coeffs)"
},
{
"name": "R.fromTensorFinsupp_concat_monomial",
"content": "theorem R.fromTensorFinsupp_concat_monomial (c : Int) (cs : List Int) :\n (R.fromTensorFinsupp q (cs ++ [c])) =\n (R.fromTensorFinsupp q cs) +\n (Polynomial.monomial cs.length (Int.cast c : (ZMod q)))"
},
{
"name": "R.representative_fromPoly_eq",
"content": "@[simp]\ntheorem R.representative_fromPoly_eq (x : (ZMod q)[X]) (DEGREE: x.degree < (f q n).degree) :\n R.representative q n (R.fromPoly (n:=n) x) = x"
},
{
"name": "f_deg_eq",
"content": "theorem f_deg_eq : (f q n).degree = 2^n"
},
{
"name": "R.fromPoly_representative",
"content": "@[simp]\ntheorem R.fromPoly_representative [Fact (q > 1)]:\n forall a : R q n, (R.fromPoly (n:=n) (R.representative q n a)) = a"
},
{
"name": "R.repLength_leq_representative_degree_plus_1",
"content": "theorem R.repLength_leq_representative_degree_plus_1 (a : R q n) :\n a.repLength ≤ (R.representative q n a).natDegree + 1"
},
{
"name": "R.toTensor_length",
"content": "theorem R.toTensor_length {q n} (a : R q n) :\n (R.toTensor a).length = a.repLength"
}
] | [] | [
{
"name": "Poly.eq_iff_rep_eq",
"content": "theorem eq_iff_rep_eq [Fact (q > 1)] (a b : R q n) :\n a.representative = b.representative ↔ a = b"
},
{
"name": "Poly.from_poly_zero",
"content": "theorem from_poly_zero : R.fromPoly (0 : (ZMod q)[X]) (n := n) = (0 : R q n)"
},
{
"name": "Poly.rep_zero",
"content": "theorem rep_zero [Fact (q > 1)]: R.representative q n 0 = 0"
},
{
"name": "R.toTensor_getD",
"content": "theorem R.toTensor_getD [Fact (q > 1)] (a : R q n) (i : Nat) :\n a.toTensor.getD i 0 = (a.coeff i).toInt"
},
{
"name": "R.toTensor_getD'",
"content": "theorem R.toTensor_getD' [hqgt1 : Fact (q > 1)] (a : R q n) (i : Nat) :\n ↑(a.toTensor.getD i 0) = a.coeff i"
},
{
"name": "Poly.eq_iff_coeff_eq",
"content": "theorem eq_iff_coeff_eq [hqgt1 : Fact (q > 1)] (a b : R q n) :\n a = b ↔ Polynomial.coeff a.representative = Polynomial.coeff b.representative"
},
{
"name": "Poly.toTensor_fromTensor",
"content": "theorem toTensor_fromTensor [hqgt1 : Fact (q > 1)] (tensor : List Int) (i : Nat)\n (htensorlen : List.length tensor < 2 ^ n) :\n (R.fromTensor tensor (q:=q) (n :=n)).toTensor.getD i 0 = (tensor.getD i 0) % q"
}
] | import SSA.Projects.FullyHomomorphicEncryption.Basic
import Batteries.Data.List.Lemmas
import Mathlib.Data.List.Basic
namespace Poly
open Polynomial in
open Polynomial in
end Poly
namespace Poly | theorem fromTensor_toTensor [hqgt1 : Fact (q > 1)] (a : R q n)
(adeg : (R.representative q n a).natDegree + 1 < 2^n) :
R.fromTensor a.toTensor = a := | := by
cases h : Polynomial.degree (R.representative q n a) with
| bot =>
have h' := Polynomial.degree_eq_bot.1 h
rw [← rep_zero] at h'
have h'' := (eq_iff_rep_eq _ _).1 h'
simp only [R.fromTensor, R.toTensor, R.repLength]
rw [h, h'']
simp
| coe deg =>
apply (eq_iff_coeff_eq _ _).2
have hCoeff := R.toTensor_getD' (q := q) (n := n)
unfold R.coeff at hCoeff
apply funext
intro i
rw [← hCoeff, ← hCoeff]
rw [toTensor_fromTensor]
rw [← ZMod.coe_intCast]
norm_cast
· simp only [R.toTensor_length]
have hdeg := R.repLength_leq_representative_degree_plus_1 a
linarith | 5 | 83 | false | Compiler |
331 | NFA'.correct_spec | lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :
M.correct ζ L → M.accepts = langRel L | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
}
] | [
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
}
] | [
{
"name": "NFA.eval_append_singleton",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.eval_nil",
"module": "Mathlib.Computability.NFA"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "langRel",
"content": "def langRel (R : BVNRel n) : Set (BitVecs n) :=\n { bvs | R bvs.bvs }"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
},
{
"name": "in_enc",
"content": "@[simp]\nlemma in_enc : x ∈ enc '' S ↔ dec x ∈ S"
},
{
"name": "dec_snoc_in_langRel",
"content": "@[simp]\nlemma dec_snoc_in_langRel {n} {R : BVNRel n} {w : BitVecs' n} {a : BitVec n} :\n dec (w ++ [a]) ∈ langRel R ↔\n R (List.Vector.ofFn fun k => .cons (a.getLsbD k) ((dec w).bvs.get k))"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
def langRel (R : BVNRel n) : Set (BitVecs n) :=
{ bvs | R bvs.bvs }
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2) | lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :
M.correct ζ L → M.accepts = langRel L := | := by
rintro ⟨h1, h2, h3⟩
simp [accepts, accepts']
have heq : dec '' (enc '' langRel L) = langRel L := by simp
rw [←heq]
congr!
suffices h : M.M.correct (fun q => enc '' langRel (ζ q)) (enc '' langRel L) by
apply NFA.correct_spec h
constructor
· intros w; rw [in_enc]; simp [langRel, h1]; simp_rw [@in_enc _ _ w]; rfl
intros w; induction w using List.reverseRecOn
case nil =>
intros q; simp only [NFA.eval_nil]; rw [in_enc]; simp [h2, langRel]
case append_singleton w a ih =>
rintro q
simp only [NFA.eval_append_singleton]
rw [in_enc]
have h : M.M.eval w = { q | w ∈ enc '' langRel (ζ q) } := by
ext; rw [ih]; dsimp; rfl
rw [dec_snoc_in_langRel]
rw [h]; simp_rw [in_enc]
simp [langRel, h3] | 3 | 37 | false | Compiler |
332 | mem_matchVar | theorem mem_matchVar {Δ_out}
{varMap : Mapping Δ_in Γ_out} {ma : Mapping Δ_in Γ_out}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t} /- : -/
{matchLets : Lets d Δ_in .pure Δ_out} {w : Var Δ_out t}
(hvarMap : ((), varMap) ∈ matchVar lets v matchLets w ma)
{t': _ } {v' : _}
(hMatchLets : ⟨t', v'⟩ ∈ matchLets.vars w) :
⟨t', v'⟩ ∈ varMap :=
match matchLets /- , hvarMap, t', v' -/ with
| .nil => by
revert hMatchLets
simp only [Lets.vars, VarSet.ofVar, Finset.mem_singleton, Sigma.mk.inj_iff, and_imp]
rintro ⟨⟩ ⟨⟩
simp only [matchVar, Option.mem_def, unifyVars_eq_some_iff] at hvarMap
rcases hvarMap with ⟨_, rfl⟩ | ⟨h_lookup, rfl⟩
· simp
· simp [← AList.lookup_isSome, h_lookup]
| .var matchLets matchE => by
simp only [matchVar, Option.mem_def] at hvarMap
cases w using Var.appendCases with
| right w =>
simp only [Var.appendCases_appendInr] at hvarMap
apply mem_matchVar hvarMap
simpa [Lets.vars] using hMatchLets
| left w =>
simp only [Var.appendCases_appendInl, MatchVar.liftM_bind_eq_some_iff] at hvarMap
rcases hvarMap with ⟨h_isSome, hvarMap⟩
split_ifs at hvarMap with h_pure h_var <;> (try contradiction)
subst h_var
apply mem_matchArg hvarMap
rcases matchE with ⟨matchOp, _⟩
obtain rfl : matchOp = _ := h_pure.1.symm
simpa [Lets.vars] using hMatchLets | lean-mlir | LeanMLIR/LeanMLIR/Transforms/Rewrite/Match.lean | [
"import LeanMLIR.Framework",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Transforms.Rewrite.Mapping"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "AList",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "AList.insert",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Valuation.map",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Sigma",
"module": "Init.Core"
},
{
"name": "Sigma.mk",
"module": "Init.Core"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Iff",
"module": "Init.Core"
},
{
"name": "IsEmpty",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "StateT.bind",
"module": "Init.Control.State"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.Subset",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "List.Subset",
"module": "Init.Data.List.Basic"
},
{
"name": "reduceCtorEq",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
}
] | [
{
"name": "Mapping",
"content": "abbrev Mapping (Γ Δ : Ctxt Ty) : Type :=\n @AList (Σ t, Var Γ t) (fun x => Var Δ x.1)"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "last",
"content": "@[match_pattern]\ndef last (Γ : Ctxt Ty) (t : Ty) : Ctxt.Var (Ctxt.cons t Γ) t :=\n ⟨0, by admit /- proof elided -/\n ⟩"
},
{
"name": "Lets.vars",
"content": "def Lets.vars : Lets d Γ_in eff Γ_out → Var Γ_out t → VarSet Γ_in\n | .nil, v => VarSet.ofVar v\n | .var lets e, v => by admit /- proof elided -/\n | right v => exact lets.vars v\n | left _ => exact lets.varsOfVec e.args"
},
{
"name": "Com.vars",
"content": "def Com.vars (com : Com d Γ eff ts) : VarSet Γ :=\n com.toLets.varsOfVec com.returnVars"
},
{
"name": "Expr.returnVars",
"content": "def Expr.returnVars (e : Expr d Γ eff tys) : HVector e.outContext.Var tys :=\n .ofFn _ _ <| fun i => (Var.ofFin i).appendInl"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "ofFin",
"content": "def ofFin (i : Fin Γ.length) : Γ.Var (Γ[i]) :=\n ⟨i.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Lets.varsOfVec",
"content": "def Lets.varsOfVec (lets : Lets d Γ_in eff Γ_out) (vs : HVector Γ_out.Var ts) :\n VarSet Γ_in :=\n (vs.vars).biUnion (fun v => lets.vars v.2)"
},
{
"name": "HVector.vars",
"content": "def HVector.vars {l : List d.Ty} (T : HVector (Var Γ) l) : VarSet Γ :=\n T.foldl (fun _ s a => insert ⟨_, a⟩ s) ∅"
},
{
"name": "VarSet",
"content": "abbrev VarSet (Γ : Ctxt Ty) : Type :=\n Finset (Σ t, Γ.Var t)"
},
{
"name": "Com.returnVars",
"content": "def Com.returnVars : (com : Com d Γ eff ts) → HVector (Var com.outContext) ts\n | .rets vs => vs\n | .var _ body => body.returnVars"
},
{
"name": "Com.toLets",
"content": "def Com.toLets (com : Com d Γ eff t) : Lets d Γ eff com.outContext :=\n Lets.nil.addComToEnd com"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "ofVar",
"content": "@[simp]\ndef ofVar {Γ : Ctxt Ty} (v : Γ.Var t) : VarSet Γ :=\n {⟨_, v⟩}"
},
{
"name": "foldl",
"content": "def foldl {B : Type*} (f : ∀ (a : α), B → A a → B) :\n ∀ {l : List α}, B → HVector A l → B\n | [], b, .nil => b\n | t::_, b, .cons a as => foldl f (f t b a) as"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Bool.false_eq_true",
"module": "Init.Data.Bool"
},
{
"name": "IsEmpty.exists_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "Option.isSome_none",
"module": "Init.Data.Option.Basic"
},
{
"name": "iff_false",
"module": "Init.SimpLemmas"
},
{
"name": "AList.lookup_isSome",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Finset.mem_singleton",
"module": "Mathlib.Data.Finset.Insert"
},
{
"name": "Option.mem_def",
"module": "Init.Data.Option.Instances"
},
{
"name": "Sigma.mk.inj_iff",
"module": "Mathlib.Data.Sigma.Basic"
},
{
"name": "and_imp",
"module": "Init.SimpLemmas"
},
{
"name": "Option.bind_eq_some_iff",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "AList.entries_insert_of_notMem",
"module": "Mathlib.Data.List.AList"
},
{
"name": "AList.lookup_eq_none",
"module": "Mathlib.Data.List.AList"
},
{
"name": "List.subset_cons_of_subset",
"module": "Init.Data.List.Sublist"
},
{
"name": "IsEmpty.forall_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "forall_eq'",
"module": "Init.PropLemmas"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "implies_true",
"module": "Init.SimpLemmas"
},
{
"name": "AList.keys_subset_keys_of_entries_subset_entries",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Finset.biUnion_insert",
"module": "Mathlib.Data.Finset.Union"
},
{
"name": "Finset.mem_biUnion",
"module": "Mathlib.Data.Finset.Union"
},
{
"name": "Finset.mem_union",
"module": "Mathlib.Data.Finset.Lattice.Basic"
}
] | [
{
"name": "appendCases_appendInr",
"content": "@[simp] theorem appendCases_appendInr (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInr = (right v)"
},
{
"name": "appendCases_appendInl",
"content": "@[simp] theorem appendCases_appendInl (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInl = (left v)"
},
{
"name": "HVector.vars_cons",
"content": "@[simp] theorem HVector.vars_cons {t : d.Ty} {l : List d.Ty}\n (v : Var Γ t) (T : HVector (Var Γ) l) :\n (HVector.cons v T).vars = insert ⟨_, v⟩ T.vars"
}
] | [
{
"name": "MatchVarM",
"content": "abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)"
},
{
"name": "MatchVar",
"content": "abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit"
},
{
"name": "MatchVarM.unifyVars",
"content": "def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=\n fun ma =>\n match ma.lookup ⟨_, v⟩ with\n | some v =>\n if v = w then\n some ((), ma)\n else\n none\n | none =>\n some ((), AList.insert ⟨_, v⟩ w ma)"
},
{
"name": "matchArg",
"content": "def matchArg [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :\n {l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →\n MatchVar Δ_in Γ_out\n | _, .nil, .nil => return\n | t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do\n matchVar (t := t) lets vₗ matchLets vᵣ\n matchArg lets matchLets vsₗ vsᵣ\n termination_by l => (sizeOf matchLets, l.length + 1)"
},
{
"name": "matchVar",
"content": "def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :\n (matchLets : Lets d Δ_in .pure Δ_out) →\n (w : Var Δ_out t) →\n MatchVar Δ_in Γ_out\n \n | @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/\n | right w =>\n exact matchVar lets v matchLets w\n | left w => exact do\n let ⟨ts', w', ie⟩ ← lets.getPureExpr v\n if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then\n have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/"
},
{
"name": "MatchVar.IsMonotone",
"content": "def MatchVar.IsMonotone (f : MatchVar Δ Γ) : Prop :=\n ∀ mapIn, ∀ mapOut ∈ f mapIn,\n mapIn.entries ⊆ mapOut.2.entries"
}
] | [
{
"name": "unifyVars_eq_some_iff",
"content": "@[simp]\ntheorem unifyVars_eq_some_iff :\n unifyVars w v mapIn = some ((), mapOut)\n ↔ ( mapIn.lookup ⟨t, w⟩ = none ∧ mapIn.insert ⟨t, w⟩ v = mapOut\n ∨ mapIn.lookup ⟨t, w⟩ = v ∧ mapIn = mapOut\n )"
},
{
"name": "MatchVar.liftM_bind_eq_some_iff",
"content": "@[simp]\ntheorem MatchVar.liftM_bind_eq_some_iff (x? : Option α)\n (f : α → MatchVarM Δ Γ β) :\n ((liftM x? >>= f) mapIn = some mapOut)\n ↔ ( ∃ h : x?.isSome,\n f (x?.get h) mapIn = some mapOut )"
},
{
"name": "MatchVar.isMonotone_bind",
"content": "@[simp]\ntheorem MatchVar.isMonotone_bind {f : MatchVar Δ Γ} {g : Unit → MatchVar Δ Γ} :\n f.IsMonotone → (g ()).IsMonotone → IsMonotone (f >>= g)"
},
{
"name": "MatchVar.isMonotone_bind_liftM",
"content": "@[simp]\ntheorem MatchVar.isMonotone_bind_liftM {x? : Option α} {g : α → MatchVar Δ Γ} :\n IsMonotone (liftM x? >>= g) ↔ (∀ x ∈ x?, (g x).IsMonotone)"
},
{
"name": "MatchVar.isMonotone_none",
"content": "@[simp] theorem MatchVar.isMonotone_none : IsMonotone (none : MatchVar Δ Γ)"
},
{
"name": "MatchVar.isMonotone_unifyVars",
"content": "theorem MatchVar.isMonotone_unifyVars : IsMonotone (unifyVars w v)"
},
{
"name": "isMonotone_matchVarArg_aux",
"content": "theorem isMonotone_matchVarArg_aux (lets : Lets d Γ_in eff Γ_out) :\n (\n ∀ (Δ_out : Ctxt d.Ty)\n (matchLets : Lets d Δ_in EffectKind.pure Δ_out) (l : List d.Ty)\n (argsl : HVector Γ_out.Var l) (argsr : HVector Δ_out.Var l),\n (matchArg lets matchLets argsl argsr).IsMonotone\n )\n ∧ (\n ∀ (Δ_out : Ctxt d.Ty) (t : d.Ty) (v : Γ_out.Var t)\n (matchLets : Lets d Δ_in EffectKind.pure Δ_out)\n (w : Var Δ_out t),\n (matchVar lets v matchLets w).IsMonotone\n )"
},
{
"name": "isMonotone_matchArg",
"content": "theorem isMonotone_matchArg [DecidableEq d.Op]\n {Γ_out Δ_in Δ_out : Ctxt d.Ty}\n {lets : Lets d Γ_in eff Γ_out}\n {matchLets : Lets d Δ_in .pure Δ_out}\n {l : List d.Ty}\n {argsl : HVector (Var Γ_out) l}\n {argsr : HVector (Var Δ_out) l} :\n (matchArg lets matchLets argsl argsr).IsMonotone"
},
{
"name": "mem_matchArg",
"content": "theorem mem_matchArg {Δ_out}\n {lets : Lets d Γ_in eff Γ_out}\n {matchLets : Lets d Δ_in .pure Δ_out}\n {l : List d.Ty} {argsₗ : HVector (Var Γ_out) l}\n {argsᵣ : HVector (Var Δ_out) l} {ma : Mapping Δ_in Γ_out}\n {varMap : Mapping Δ_in Γ_out}\n (hvarMap : ((), varMap) ∈ matchArg lets matchLets argsₗ argsᵣ ma)\n {t' v'} : ⟨t', v'⟩ ∈ matchLets.varsOfVec argsᵣ → ⟨t', v'⟩ ∈ varMap"
}
] | import LeanMLIR.Framework
import LeanMLIR.Transforms.Rewrite.Mapping
open Ctxt (Var VarSet Valuation Hom)
variable {d} [DialectSignature d] [DecidableEq d.Ty]
variable {Γ : Ctxt d.Ty} {ty : d.Ty}
abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)
abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit
def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=
fun ma =>
match ma.lookup ⟨_, v⟩ with
| some v =>
if v = w then
some ((), ma)
else
none
| none =>
some ((), AList.insert ⟨_, v⟩ w ma)
open MatchVarM
variable [DecidableEq d.Op]
def matchArg [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :
{l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →
MatchVar Δ_in Γ_out
| _, .nil, .nil => return
| t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do
matchVar (t := t) lets vₗ matchLets vᵣ
matchArg lets matchLets vsₗ vsᵣ
termination_by l => (sizeOf matchLets, l.length + 1)
def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :
(matchLets : Lets d Δ_in .pure Δ_out) →
(w : Var Δ_out t) →
MatchVar Δ_in Γ_out
| @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/
| right w =>
exact matchVar lets v matchLets w
| left w => exact do
let ⟨ts', w', ie⟩ ← lets.getPureExpr v
if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then
have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/
end
section MatchVar
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out t te}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
variable (lets v matchLets w) (mapIn : Mapping _ _) in
variable (lets matchLets) {tys} (vs ws : HVector _ tys) (mapIn : Mapping _ _) in
namespace MatchVarResult
variable [TyDenote d.Ty] [∀ (t : d.Ty), Inhabited ⟦t⟧] in
section Left
variable {w : Δ_out.Var t}
variable {mapIn} (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInr mapIn)
end Left
variable {w : Var ⟨te⟩ _} {mapIn}
end MatchVarResult
end MatchVar
section SubsetEntries
def MatchVar.IsMonotone (f : MatchVar Δ Γ) : Prop :=
∀ mapIn, ∀ mapOut ∈ f mapIn,
mapIn.entries ⊆ mapOut.2.entries
open MatchVar
section UnifyVars
variable {Δ Γ : Ctxt d.Ty} {t} (w : Δ.Var t) (v : Γ.Var t)
end UnifyVars
variable [DecidableEq d.Op]
end SubsetEntries
namespace MatchArgResult
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out te}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
{u us}
{v : Γ_out.Var u} {vs : HVector Γ_out.Var us}
{w : Δ_out.Var u} {ws : HVector Δ_out.Var us}
{mapIn : Mapping _ _}
(mapOut : MatchArgResult lets matchLets (v ::ₕ vs) (w ::ₕ ws) mapIn)
end MatchArgResult
section DenoteLemmas
variable [TyDenote d.Ty] [DecidableEq d.Op]
variable [∀ (t : d.Ty), Inhabited ⟦t⟧]
variable [Monad d.m] [LawfulMonad d.m] [DialectDenote d]
section DenoteIntoSubtype
end DenoteIntoSubtype
variable {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out} | theorem mem_matchVar {Δ_out}
{varMap : Mapping Δ_in Γ_out} {ma : Mapping Δ_in Γ_out}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t} /- : -/
{matchLets : Lets d Δ_in .pure Δ_out} {w : Var Δ_out t}
(hvarMap : ((), varMap) ∈ matchVar lets v matchLets w ma)
{t': _ } {v' : _}
(hMatchLets : ⟨t', v'⟩ ∈ matchLets.vars w) :
⟨t', v'⟩ ∈ varMap := | :=
match matchLets /- , hvarMap, t', v' -/ with
| .nil => by
revert hMatchLets
simp only [Lets.vars, VarSet.ofVar, Finset.mem_singleton, Sigma.mk.inj_iff, and_imp]
rintro ⟨⟩ ⟨⟩
simp only [matchVar, Option.mem_def, unifyVars_eq_some_iff] at hvarMap
rcases hvarMap with ⟨_, rfl⟩ | ⟨h_lookup, rfl⟩
· simp
· simp [← AList.lookup_isSome, h_lookup]
| .var matchLets matchE => by
simp only [matchVar, Option.mem_def] at hvarMap
cases w using Var.appendCases with
| right w =>
simp only [Var.appendCases_appendInr] at hvarMap
apply mem_matchVar hvarMap
simpa [Lets.vars] using hMatchLets
| left w =>
simp only [Var.appendCases_appendInl, MatchVar.liftM_bind_eq_some_iff] at hvarMap
rcases hvarMap with ⟨h_isSome, hvarMap⟩
split_ifs at hvarMap with h_pure h_var <;> (try contradiction)
subst h_var
apply mem_matchArg hvarMap
rcases matchE with ⟨matchOp, _⟩
obtain rfl : matchOp = _ := h_pure.1.symm
simpa [Lets.vars] using hMatchLets | 7 | 104 | false | Compiler |
333 | MultiWidth.eval_fsmMsb_eq_BitStream_ofBitVecSext | theorem eval_fsmMsb_eq_BitStream_ofBitVecSext {wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
{tctx : Term.Ctx wcard tcard}
(tenv : Term.Ctx.Env tctx wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(w : WidthExpr wcard)
(x : Term bcard ncard icard pcard tctx (.bv w))
(xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))
(hxfsm : HTermFSMToBitStream xfsm)
(wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
(hwfsm : HNatFSMToBitstream wfsm)
(htenv : HTermEnv fsmEnv tenv benv) :
(fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv =
BitStream.ofBitVecSext (x.toBV benv nenv ienv penv tenv) | lean-mlir | Blase/Blase/MultiWidth/GoodFSM.lean | [
"import Blase.MultiWidth.Defs",
"import Blase.Vars",
"import Blase.KInduction.KInduction",
"import Lean",
"import Blase.Fast.FiniteStateMachine"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat.max",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.min",
"module": "Init.Data.Nat.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofBool",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"min\" : MLIR.Pretty.uniform_op",
"content": "syntax \"min\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "composeBinaryAux'",
"content": "def composeBinaryAux'\n (p : FSM Bool)\n (qtrue : FSM α)\n (qfalse : FSM α) :\n FSM α :=\n p.compose (α)\n (λ _ => α)\n (λ _ i => i)\n (λ b => match b with\n | true => qtrue\n | false => qfalse)"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "latchImmediate",
"content": "def latchImmediate (initVal : Bool) : FSM Bool where\n α := Unit\n initCarry := fun _ => initVal\n outputCirc :=\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state\n nextStateCirc := fun () =>\n let xval := Circuit.var true (inr false)\n let control := Circuit.var true (inr true)\n let state := Circuit.var true (inl ())\n Circuit.ite control xval state"
},
{
"name": "ite",
"content": "def ite (cond t f : Circuit α) : Circuit α :=\n (cond &&& t) ||| (~~~ cond &&& f)"
},
{
"name": "TermFSM",
"content": "structure TermFSM (wcard tcard bcard ncard icard pcard : Nat) (t : Nondep.Term) where\n toFsmZext : FSM (StateSpace wcard tcard bcard ncard icard pcard)\n width : NatFSM wcard tcard bcard ncard icard pcard t.width"
},
{
"name": "NatFSM",
"content": "structure NatFSM (wcard tcard bcard ncard icard pcard : Nat) (v : Nondep.WidthExpr) where\n toFsm : FSM (StateSpace wcard tcard bcard ncard icard pcard)"
},
{
"name": "StateSpace",
"content": "inductive StateSpace (wcard tcard bcard ncard icard pcard : Nat)\n| widthVar (v : Fin wcard)\n| termVar (v : Fin tcard)\n| predVar (v : Fin pcard)\n| boolVar (v : Fin bcard)\nderiving DecidableEq, Repr, Hashable"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| bvOfBool (b : Term) : Term\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr) : Term\n| binRel (k : BinaryRelationKind) (w : WidthExpr)\n (a : Term) (b : Term) : Term\n| or (p1 p2 : Term) : Term\n| and (p1 p2 : Term) : Term\n| pvar (v : Nat) : Term\n| boolBinRel (k : BoolBinaryRelationKind)\n (a b : Term) : Term\nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : Nat → WidthExpr → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : (k : Nat) → (v : WidthExpr) → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "HNatFSMToBitstream",
"content": "structure HNatFSMToBitstream {wcard : Nat} {v : WidthExpr wcard} {tcard : Nat} {bcard : Nat} {pcard : Nat}\n (fsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v)) : Prop where\n heq :\n ∀ (wenv : Fin wcard → Nat)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HWidthEnv fsmEnv wenv) →\n fsm.toFsm.eval fsmEnv =\n BitStream.ofNatUnary (v.toNat wenv)"
},
{
"name": "WidthExpr.toNat",
"content": "def WidthExpr.toNat (e : WidthExpr wcard) (env : WidthExpr.Env wcard) : Nat :=\n match e with\n | .const n => n\n | .var v => env v\n | .min v w => Nat.min (v.toNat env) (w.toNat env)\n | .max v w => Nat.max (v.toNat env) (w.toNat env)\n | .addK v k => v.toNat env + k\n | .kadd k v => k + v.toNat env"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr (wcard : Nat) : Type\n| const (n : Nat) : WidthExpr wcard\n| var : (v : Fin wcard) → WidthExpr wcard\n| min : (v w : WidthExpr wcard) → WidthExpr wcard\n| max : (v w : WidthExpr wcard) → WidthExpr wcard\n| addK : (v : WidthExpr wcard) → (k : Nat) → WidthExpr wcard\n| kadd : (k : Nat) → (v : WidthExpr wcard) → WidthExpr wcard"
},
{
"name": "WidthExpr.Env",
"content": "abbrev WidthExpr.Env (wcard : Nat) : Type :=\n Fin wcard → Nat"
},
{
"name": "HWidthEnv",
"content": "structure HWidthEnv {wcard tcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (wenv : Fin wcard → Nat) : Prop where\n heq_width : ∀ (v : Fin wcard),\n fsmEnv (StateSpace.widthVar v) = BitStream.ofNatUnary (wenv v)"
},
{
"name": "HPredicateEnv",
"content": "structure HPredicateEnv {wcard tcard bcard ncard icard pcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (penv : Fin pcard → Prop) : Prop where\n heq_width : ∀ (v : Fin pcard),\n fsmEnv (StateSpace.predVar v) = BitStream.ofProp (penv v)"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "ofNatUnary",
"content": "abbrev ofNatUnary (n : Nat) : BitStream :=\n fun i => decide (i < n)"
},
{
"name": "HPredFSMToBitStream",
"content": "structure HPredFSMToBitStream {pcard : Nat}\n {tctx : Term.Ctx wcard tcard}\n {p : Term bcard ncard icard pcard tctx .prop}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard\n (.ofDepTerm p)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (htenv : HTermEnv fsmEnv tenv benv) →\n (hpenv : HPredicateEnv fsmEnv penv) →\n p.toBV benv nenv ienv penv tenv ↔ (fsm.toFsmZext.eval fsmEnv = .negOne)"
},
{
"name": "Term.Ctx",
"content": "abbrev Term.Ctx (wcard : Nat) (tcard : Nat) : Type :=\n Fin tcard → WidthExpr wcard"
},
{
"name": "Term.BoolEnv",
"content": "def Term.BoolEnv (bcard : Nat) : Type := Fin bcard → Bool"
},
{
"name": "Term.IntEnv",
"content": "def Term.IntEnv (icard : Nat) : Type := Fin icard → Nat"
},
{
"name": "HTermFSMToBitStream",
"content": "structure HTermFSMToBitStream {w : WidthExpr wcard}\n {tctx : Term.Ctx wcard tcard}\n {t : Term bcard ncard icard pcard tctx (.bv w)}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm t)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HTermEnv fsmEnv tenv benv) →\n fsm.toFsmZext.eval fsmEnv =\n BitStream.ofBitVecZext (t.toBV benv nenv ienv penv tenv)"
},
{
"name": "Predicate.Env",
"content": "def Predicate.Env (pcard : Nat) : Type :=\n Fin pcard → Prop"
},
{
"name": "TermKind",
"content": "inductive TermKind (wcard : Nat) : Type\n| bool\n| bv (w : WidthExpr wcard) : TermKind wcard\n| prop\n| nat\n| int"
},
{
"name": "HTermEnv",
"content": "structure HTermEnv {wcard tcard bcard : Nat}\n {wenv : Fin wcard → Nat} {tctx : Term.Ctx wcard tcard}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (tenv : tctx.Env wenv)\n (benv : Term.BoolEnv bcard) : Prop\n extends HWidthEnv fsmEnv wenv where\n heq_term : ∀ (v : Fin tcard),\n fsmEnv (StateSpace.termVar v) = BitStream.ofBitVecZext (tenv v)\n heq_bool : ∀ (v : Fin bcard),\n fsmEnv (StateSpace.boolVar v) = BitStream.ofBool (benv v)"
},
{
"name": "BitStream.ofBool",
"content": "noncomputable def BitStream.ofBool (b : Bool) : BitStream := fun _i => b"
},
{
"name": "Term.Ctx.Env",
"content": "abbrev Term.Ctx.Env\n (tctx : Term.Ctx wcard tcard)\n (wenv : WidthExpr.Env wcard) :=\n (v : Fin tcard) → BitVec ((tctx v).toNat wenv)"
},
{
"name": "ofBitVecZext",
"content": "abbrev ofBitVecZext {w} (x : BitVec w) : BitStream :=\n fun i => x.getLsbD i"
},
{
"name": "Term.NatEnv",
"content": "def Term.NatEnv (ncard : Nat) : Type := Fin ncard → Nat"
},
{
"name": "Term.toBV",
"content": "def Term.toBV {wenv : WidthExpr.Env wcard}\n {tctx : Term.Ctx wcard tcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard)\n (tenv : tctx.Env wenv)\n (t : Term bcard ncard icard pcard tctx k) : k.denote wenv :=\nmatch t with\n| .ofNat w n => BitVec.ofNat (w.toNat wenv) n\n| .boolConst b => b\n| .var v => tenv.get v.1 v.2\n| .add (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a + b\n| .zext a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .setWidth a v => (a.toBV benv nenv ienv penv tenv).zeroExtend (v.toNat wenv)\n| .sext a v => (a.toBV benv nenv ienv penv tenv).signExtend (v.toNat wenv)\n| .bor a b (w := w) =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ||| b\n| .band (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a &&& b\n| .bxor (w := w) a b =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n let b : BitVec (w.toNat wenv) := (b.toBV benv nenv ienv penv tenv)\n a ^^^ b\n| .bnot (w := w) a =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n ~~~ a\n| .boolVar v => benv v\n| .shiftl (w := w) a k =>\n let a : BitVec (w.toNat wenv) := (a.toBV benv nenv ienv penv tenv)\n a <<< k\n| .bvOfBool b => BitVec.ofBool (b.toBV benv nenv ienv penv tenv)\n\n| .binWidthRel rel wa wb =>\n match rel with\n | .eq => wa.toNat wenv = wb.toNat wenv\n | .le => wa.toNat wenv ≤ wb.toNat wenv\n| .binRel rel _w a b =>\n match rel with\n | .eq => a.toBV benv nenv ienv penv tenv = b.toBV benv nenv ienv penv tenv\n | .ne => a.toBV benv nenv ienv penv tenv ≠ b.toBV benv nenv ienv penv tenv\n | .ult => (a.toBV benv nenv ienv penv tenv).ult (b.toBV benv nenv ienv penv tenv) = true\n | .ule => (a.toBV benv nenv ienv penv tenv).ule (b.toBV benv nenv ienv penv tenv) = true\n | .slt => (a.toBV benv nenv ienv penv tenv).slt (b.toBV benv nenv ienv penv tenv) = true\n | .sle => (a.toBV benv nenv ienv penv tenv).sle (b.toBV benv nenv ienv penv tenv) = true\n| .and p1 p2 => p1.toBV benv nenv ienv penv tenv ∧ p2.toBV benv nenv ienv penv tenv\n| .or p1 p2 => p1.toBV benv nenv ienv penv tenv ∨ p2.toBV benv nenv ienv penv tenv\n| .boolBinRel rel a b =>\n match rel with\n \n | .eq => (a.toBV benv nenv ienv penv tenv) = (b.toBV benv nenv ienv penv tenv)\n| .pvar v => penv v"
},
{
"name": "Term",
"content": "inductive Term {wcard tcard : Nat} (bcard : Nat) (ncard : Nat) (icard : Nat) (pcard : Nat)\n (tctx : Term.Ctx wcard tcard) : TermKind wcard → Type\n\n \n| ofNat (w : WidthExpr wcard) (n : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| var (v : Fin tcard) : Term bcard ncard icard pcard tctx (.bv (tctx v))\n \n| add (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| shiftl (a : Term bcard ncard icard pcard tctx (.bv w)) (k : Nat) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| band (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bxor (a b : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| bnot (a : Term bcard ncard icard pcard tctx (.bv w)) : Term bcard ncard icard pcard tctx (.bv w)\n \n| zext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| setWidth (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| sext (a : Term bcard ncard icard pcard tctx (.bv w)) (v : WidthExpr wcard) : Term bcard ncard icard pcard tctx (.bv v)\n \n| bvOfBool (b : Term bcard ncard icard pcard tctx .bool) : Term bcard ncard icard pcard tctx (.bv (.const 1))\n\n| boolConst (b : Bool) : Term bcard ncard icard pcard tctx .bool\n| boolVar (v : Fin bcard) : Term bcard ncard icard pcard tctx .bool\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr wcard) :\n Term bcard ncard icard pcard tctx .prop\n| binRel\n (k : BinaryRelationKind)\n (w : WidthExpr wcard)\n (a : Term bcard ncard icard pcard tctx (.bv w))\n (b : Term bcard ncard icard pcard tctx (.bv w)) :\n Term bcard ncard icard pcard tctx .prop\n| and (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| or (p1 p2 : Term bcard ncard icard pcard tctx (.prop)) : Term bcard ncard icard pcard tctx (.prop)\n| pvar (v : Fin pcard) : Term bcard ncard icard pcard tctx (.prop) \n\n\n| boolBinRel\n (k : BoolBinaryRelationKind)\n (a b : Term bcard ncard icard pcard tctx .bool) :\n Term bcard ncard icard pcard tctx (.prop)"
},
{
"name": "Term.Ctx.Env.get",
"content": "def Term.Ctx.Env.get {tcard : Nat}\n {wcard : Nat} {wenv : Fin wcard → Nat}\n {tctx : Term.Ctx wcard tcard}\n (tenv : tctx.Env wenv) (i : Nat) (hi : i < tcard) :\n BitVec ((tctx ⟨i, hi⟩).toNat wenv) :=\n tenv ⟨i, hi⟩"
},
{
"name": "BinaryRelationKind",
"content": "inductive BinaryRelationKind\n| eq\n| ne\n| ule\n| slt\n| sle\n| ult \nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "WidthBinaryRelationKind",
"content": "inductive WidthBinaryRelationKind\n| eq\n| le\n\n\nderiving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
}
] | [
{
"name": "BitVec.msb_eq_getLsbD_last",
"module": "Init.Data.BitVec.Lemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "MultiWidth.fsmMsb",
"content": "def fsmMsb (x w : FSM α) : FSM α :=\n composeBinaryAux'\n (FSM.latchImmediate false)\n (qfalse := x)\n (qtrue := w)"
}
] | [
{
"name": "MultiWidth.eval_fsmMsb_eq",
"content": "@[simp]\ntheorem eval_fsmMsb_eq {wcard bcard tcard : Nat}\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n {tctx : Term.Ctx wcard tcard}\n (tenv : Term.Ctx.Env tctx wenv)\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (w : WidthExpr wcard)\n (x : Term bcard ncard icard pcard tctx (.bv w))\n (xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))\n (hxfsm : HTermFSMToBitStream xfsm)\n (wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n (hwfsm : HNatFSMToBitstream wfsm)\n (htenv : HTermEnv fsmEnv tenv benv) :\n (fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv = (fun i =>\n BitStream.ofBitVecZext (x.toBV benv nenv ienv penv tenv) (min i (w.toNat wenv - 1)))"
}
] | import Blase.Fast.FiniteStateMachine
import Blase.Vars
import Blase.MultiWidth.Defs
import Blase.KInduction.KInduction
import Lean
namespace MultiWidth
def fsmMsb (x w : FSM α) : FSM α :=
composeBinaryAux'
(FSM.latchImmediate false)
(qfalse := x)
(qtrue := w) | theorem eval_fsmMsb_eq_BitStream_ofBitVecSext {wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
{tctx : Term.Ctx wcard tcard}
(tenv : Term.Ctx.Env tctx wenv)
(benv : Term.BoolEnv bcard)
(nenv : Term.NatEnv ncard)
(ienv : Term.IntEnv icard)
(w : WidthExpr wcard)
(x : Term bcard ncard icard pcard tctx (.bv w))
(xfsm : TermFSM wcard tcard bcard ncard icard pcard (.ofDepTerm x))
(hxfsm : HTermFSMToBitStream xfsm)
(wfsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
(hwfsm : HNatFSMToBitstream wfsm)
(htenv : HTermEnv fsmEnv tenv benv) :
(fsmMsb xfsm.toFsmZext wfsm.toFsm).eval fsmEnv =
BitStream.ofBitVecSext (x.toBV benv nenv ienv penv tenv) := | := by
rw [eval_fsmMsb_eq (wfsm := wfsm) (hwfsm := hwfsm) (hxfsm := hxfsm)
(tenv := tenv) (htenv := htenv)]
ext i
simp [BitStream.ofBitVecSext]
by_cases hi : i < w.toNat wenv
· simp [hi]
congr
omega
· simp [hi, BitVec.msb_eq_getLsbD_last]
congr
omega | 5 | 66 | false | Compiler |
334 | MultiWidth.eval_fsmUltUnary_eq_decide | theorem eval_fsmUltUnary_eq_decide
(a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
{wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
(henv : HWidthEnv fsmEnv wenv)
(ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :
((fsmUltUnary a b).eval fsmEnv) i =
(decide (min i (v.toNat wenv) < min i (w.toNat wenv))) | lean-mlir | Blase/Blase/MultiWidth/GoodFSM.lean | [
"import Blase.MultiWidth.Defs",
"import Blase.Vars",
"import Blase.KInduction.KInduction",
"import Lean",
"import Blase.Blase.Fast.BitStream",
"import Blase.Fast.FiniteStateMachine"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "Nat.max",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.min",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Decidable",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"min\" : MLIR.Pretty.uniform_op",
"content": "syntax \"min\" : MLIR.Pretty.uniform_op\n\nsyntax \"neg\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "StateSpace",
"content": "inductive StateSpace (wcard tcard bcard ncard icard pcard : Nat)\n| widthVar (v : Fin wcard)\n| termVar (v : Fin tcard)\n| predVar (v : Fin pcard)\n| boolVar (v : Fin bcard)\nderiving DecidableEq, Repr, Hashable"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| bvOfBool (b : Term) : Term\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr) : Term\n| binRel (k : BinaryRelationKind) (w : WidthExpr)\n (a : Term) (b : Term) : Term\n| or (p1 p2 : Term) : Term\n| and (p1 p2 : Term) : Term\n| pvar (v : Nat) : Term\n| boolBinRel (k : BoolBinaryRelationKind)\n (a b : Term) : Term\nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "NatFSM",
"content": "structure NatFSM (wcard tcard bcard ncard icard pcard : Nat) (v : Nondep.WidthExpr) where\n toFsm : FSM (StateSpace wcard tcard bcard ncard icard pcard)"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : Nat → WidthExpr → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "scanAnd",
"content": "def scanAnd : FSM Unit :=\n {\n α := Unit,\n initCarry := fun () => true,\n outputCirc := Circuit.var true (inl ()) &&& Circuit.var true (inr ()),\n nextStateCirc := fun () => (Circuit.var true (inl ())) &&& (Circuit.var true (inr ()))\n }"
},
{
"name": "scanOr",
"content": "def scanOr : FSM Unit :=\n {\n α := Unit,\n initCarry := fun () => false,\n outputCirc := Circuit.var true (inl ()) ||| Circuit.var true (inr ()),\n nextStateCirc := fun () => Circuit.var true (inl ()) ||| Circuit.var true (inr ())\n }"
},
{
"name": "composeBinaryAux'",
"content": "def composeBinaryAux'\n (p : FSM Bool)\n (qtrue : FSM α)\n (qfalse : FSM α) :\n FSM α :=\n p.compose (α)\n (λ _ => α)\n (λ _ i => i)\n (λ b => match b with\n | true => qtrue\n | false => qfalse)"
},
{
"name": "and",
"content": "def and : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := fun a => a.elim,\n outputCirc := Circuit.var true (inr true) &&& Circuit.var true (inr false),\n }"
},
{
"name": "WidthExpr.Env",
"content": "abbrev WidthExpr.Env (wcard : Nat) : Type :=\n Fin wcard → Nat"
},
{
"name": "HWidthEnv",
"content": "structure HWidthEnv {wcard tcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (wenv : Fin wcard → Nat) : Prop where\n heq_width : ∀ (v : Fin wcard),\n fsmEnv (StateSpace.widthVar v) = BitStream.ofNatUnary (wenv v)"
},
{
"name": "HPredicateEnv",
"content": "structure HPredicateEnv {wcard tcard bcard ncard icard pcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (penv : Fin pcard → Prop) : Prop where\n heq_width : ∀ (v : Fin pcard),\n fsmEnv (StateSpace.predVar v) = BitStream.ofProp (penv v)"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "ofNatUnary",
"content": "abbrev ofNatUnary (n : Nat) : BitStream :=\n fun i => decide (i < n)"
},
{
"name": "HNatFSMToBitstream",
"content": "structure HNatFSMToBitstream {wcard : Nat} {v : WidthExpr wcard} {tcard : Nat} {bcard : Nat} {pcard : Nat}\n (fsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v)) : Prop where\n heq :\n ∀ (wenv : Fin wcard → Nat)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HWidthEnv fsmEnv wenv) →\n fsm.toFsm.eval fsmEnv =\n BitStream.ofNatUnary (v.toNat wenv)"
},
{
"name": "WidthExpr.toNat",
"content": "def WidthExpr.toNat (e : WidthExpr wcard) (env : WidthExpr.Env wcard) : Nat :=\n match e with\n | .const n => n\n | .var v => env v\n | .min v w => Nat.min (v.toNat env) (w.toNat env)\n | .max v w => Nat.max (v.toNat env) (w.toNat env)\n | .addK v k => v.toNat env + k\n | .kadd k v => k + v.toNat env"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr (wcard : Nat) : Type\n| const (n : Nat) : WidthExpr wcard\n| var : (v : Fin wcard) → WidthExpr wcard\n| min : (v w : WidthExpr wcard) → WidthExpr wcard\n| max : (v w : WidthExpr wcard) → WidthExpr wcard\n| addK : (v : WidthExpr wcard) → (k : Nat) → WidthExpr wcard\n| kadd : (k : Nat) → (v : WidthExpr wcard) → WidthExpr wcard"
},
{
"name": "HPredFSMToBitStream",
"content": "structure HPredFSMToBitStream {pcard : Nat}\n {tctx : Term.Ctx wcard tcard}\n {p : Term bcard ncard icard pcard tctx .prop}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard\n (.ofDepTerm p)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (htenv : HTermEnv fsmEnv tenv benv) →\n (hpenv : HPredicateEnv fsmEnv penv) →\n p.toBV benv nenv ienv penv tenv ↔ (fsm.toFsmZext.eval fsmEnv = .negOne)"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
}
] | [
{
"name": "decide_eq_true_iff",
"module": "Init.PropLemmas"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "inf_of_le_left",
"module": "Mathlib.Order.Lattice"
},
{
"name": "le_refl",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "left_eq_inf",
"module": "Mathlib.Order.Lattice"
},
{
"name": "not_iff",
"module": "Mathlib.Logic.Basic"
},
{
"name": "not_le",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "not_lt",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "decide_eq_decide",
"module": "Init.PropLemmas"
}
] | [
{
"name": "scanOr_eq_decide",
"content": "theorem scanOr_eq_decide (s : BitStream) (n : Nat) :\n s.scanOr n = decide (∃ (i : Nat), i ≤ n ∧ s i = true)"
},
{
"name": "scanOr_true_iff",
"content": "theorem scanOr_true_iff (s : BitStream) (n : Nat)\n : s.scanOr n = true ↔ ∃ (i : Nat), (i ≤ n) ∧ s i = true"
},
{
"name": "scanOr_false_iff",
"content": "theorem scanOr_false_iff (s : BitStream) (n : Nat) : s.scanOr n = false ↔ ∀ (i : Nat), (hi : i ≤ n) → s i = false"
},
{
"name": "scanOr_succ",
"content": "@[simp]\ntheorem scanOr_succ (s : BitStream) : scanOr s (n+1) = ((s.scanOr n) || s (n + 1))"
},
{
"name": "scanAnd_eq_decide",
"content": "theorem scanAnd_eq_decide (s : BitStream) (n : Nat) :\n s.scanAnd n = decide (∀ (i : Nat), i ≤ n → s i = true)"
},
{
"name": "scanAnd_true_iff",
"content": "theorem scanAnd_true_iff (s : BitStream) (n : Nat) :\n s.scanAnd n = true ↔ ∀ (i : Nat), (hi : i ≤ n) → s i = true"
},
{
"name": "scanAnd_succ",
"content": "@[simp] theorem scanAnd_succ (s : BitStream) : scanAnd s (n+1) = ((s.scanAnd n) && s (n + 1))"
}
] | [
{
"name": "MultiWidth.NatFSM.fsmUnaryIndexUle",
"content": "def NatFSM.fsmUnaryIndexUle (a : NatFSM wcard tcard bcard ncard icard pcard v) :\n FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n composeUnaryAux (FSM.ls true) a.toFsm"
},
{
"name": "MultiWidth.fsmUnaryUle",
"content": "def fsmUnaryUle (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n composeUnaryAux FSM.scanAnd (b.fsmUnaryIndexUle ||| ~~~ a.fsmUnaryIndexUle)"
},
{
"name": "MultiWidth.fsmUnaryNeqUpto",
"content": "def fsmUnaryNeqUpto (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n composeUnaryAux FSM.scanOr (a.fsmUnaryIndexUle ^^^ b.fsmUnaryIndexUle)"
},
{
"name": "MultiWidth.fsmUltUnary",
"content": "def fsmUltUnary\n (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n composeBinaryAux' FSM.and (fsmUnaryUle a b) (fsmUnaryNeqUpto a b)"
}
] | [
{
"name": "MultiWidth.decide_eq_eq_decide_iff_decide",
"content": "private theorem decide_eq_eq_decide_iff_decide {P Q : Prop}\n [Decidable P] [Decidable Q] :\n (decide P = decide Q) = decide (P ↔ Q)"
},
{
"name": "MultiWidth.not_decide_eq_decide_lnot",
"content": "private theorem not_decide_eq_decide_lnot {P : Prop}\n [Decidable P] :\n (!(decide P)) = (decide (¬ P))"
},
{
"name": "MultiWidth.decide_and_decide_eq_decide",
"content": "private theorem decide_and_decide_eq_decide {P Q : Prop}\n [Decidable P] [Decidable Q] :\n (decide P && decide Q) = decide (P ∧ Q)"
},
{
"name": "MultiWidth.decide_or_decide_eq_decide",
"content": "private theorem decide_or_decide_eq_decide {P Q : Prop}\n [Decidable P] [Decidable Q] :\n (decide P || decide Q) = decide (P ∨ Q)"
},
{
"name": "MultiWidth.min_eq_of_not_le",
"content": "@[simp]\nprivate theorem min_eq_of_not_le {a b : Nat} (hab : ¬ a ≤ b) : min a b = b"
},
{
"name": "MultiWidth.min_eq_of_not_le'",
"content": "@[simp]\nprivate theorem min_eq_of_not_le' {a b : Nat} (hab : ¬ a ≤ b) : min b a = b"
},
{
"name": "MultiWidth.HNatFSMToBitstream.fsmIndexUle_eval_eq",
"content": "@[simp]\ntheorem HNatFSMToBitstream.fsmIndexUle_eval_eq\n (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n (henv : HWidthEnv fsmEnv wenv)\n (ha : HNatFSMToBitstream a) :\n (NatFSM.fsmUnaryIndexUle a).eval fsmEnv = fun i =>\n decide (i ≤ v.toNat wenv)"
},
{
"name": "MultiWidth.eval_fsmUnaryUle_eq_decide",
"content": "theorem eval_fsmUnaryUle_eq_decide\n (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n (henv : HWidthEnv fsmEnv wenv)\n (ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :\n ((fsmUnaryUle a b).eval fsmEnv) i =\n decide (min i (v.toNat wenv) ≤ min i (w.toNat wenv))"
},
{
"name": "MultiWidth.eval_fsmUnaryUle_eq_lt_or_decide",
"content": "@[simp]\ntheorem eval_fsmUnaryUle_eq_lt_or_decide\n (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n (henv : HWidthEnv fsmEnv wenv)\n (ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :\n ((fsmUnaryUle a b).eval fsmEnv) i =\n decide (i ≤ min (v.toNat wenv) (w.toNat wenv) ∨ (v.toNat wenv) ≤ (w.toNat wenv))"
},
{
"name": "MultiWidth.eval_fsmUnaryNeqUpto_eq_decide",
"content": "@[simp]\ntheorem eval_fsmUnaryNeqUpto_eq_decide\n (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n (henv : HWidthEnv fsmEnv wenv)\n (ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :\n ((fsmUnaryNeqUpto a b).eval fsmEnv) i =\n (decide (min i (v.toNat wenv) ≠ min i (w.toNat wenv)))"
}
] | import Blase.Fast.FiniteStateMachine
import Blase.Vars
import Blase.MultiWidth.Defs
import Blase.KInduction.KInduction
import Lean
namespace MultiWidth
def NatFSM.fsmUnaryIndexUle (a : NatFSM wcard tcard bcard ncard icard pcard v) :
FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
composeUnaryAux (FSM.ls true) a.toFsm
def fsmUnaryUle (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
composeUnaryAux FSM.scanAnd (b.fsmUnaryIndexUle ||| ~~~ a.fsmUnaryIndexUle)
def fsmUnaryNeqUpto (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
composeUnaryAux FSM.scanOr (a.fsmUnaryIndexUle ^^^ b.fsmUnaryIndexUle)
def fsmUltUnary
(a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
composeBinaryAux' FSM.and (fsmUnaryUle a b) (fsmUnaryNeqUpto a b) | theorem eval_fsmUltUnary_eq_decide
(a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
{wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
(henv : HWidthEnv fsmEnv wenv)
(ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :
((fsmUltUnary a b).eval fsmEnv) i =
(decide (min i (v.toNat wenv) < min i (w.toNat wenv))) := | := by
simp [fsmUltUnary]
rw [eval_fsmUnaryUle_eq_lt_or_decide (wenv := wenv) (henv := henv) (ha := ha) (hb := hb)]
rw [eval_fsmUnaryNeqUpto_eq_decide (wenv := wenv) (henv := henv) (ha := ha) (hb := hb)]
simp
generalize v.toNat wenv = v'
generalize w.toNat wenv = w'
simp only [not_decide_eq_decide_lnot,
decide_and_decide_eq_decide,
decide_or_decide_eq_decide, decide_eq_decide]
omega | 6 | 78 | false | Compiler |
335 | MultiWidth.eval_fsmUnaryNeqUpto_eq_decide | @[simp]
theorem eval_fsmUnaryNeqUpto_eq_decide
(a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
{wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
(henv : HWidthEnv fsmEnv wenv)
(ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :
((fsmUnaryNeqUpto a b).eval fsmEnv) i =
(decide (min i (v.toNat wenv) ≠ min i (w.toNat wenv))) | lean-mlir | Blase/Blase/MultiWidth/GoodFSM.lean | [
"import Blase.MultiWidth.Defs",
"import Blase.Vars",
"import Blase.KInduction.KInduction",
"import Lean",
"import Blase.Blase.Fast.BitStream",
"import Blase.Fast.FiniteStateMachine"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Nat.max",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.min",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Decidable",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"min\" : MLIR.Pretty.uniform_op",
"content": "syntax \"min\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "StateSpace",
"content": "inductive StateSpace (wcard tcard bcard ncard icard pcard : Nat)\n| widthVar (v : Fin wcard)\n| termVar (v : Fin tcard)\n| predVar (v : Fin pcard)\n| boolVar (v : Fin bcard)\nderiving DecidableEq, Repr, Hashable"
},
{
"name": "Term",
"content": "inductive Term\n| ofNat (w : WidthExpr) (n : Nat) : Term\n| var (v : Nat) (w : WidthExpr) : Term\n| add (w : WidthExpr) (a b : Term) : Term\n| zext (a : Term) (wnew : WidthExpr) : Term\n| setWidth (a : Term) (wnew : WidthExpr) : Term\n| sext (a : Term) (wnew : WidthExpr) : Term\n| bor (w : WidthExpr) (a b : Term) : Term\n| band (w : WidthExpr) (a b : Term) : Term\n| bxor (w : WidthExpr) (a b : Term) : Term\n| bnot (w : WidthExpr) (a : Term) : Term\n| boolVar (v : Nat) : Term\n| boolConst (b : Bool) : Term\n| shiftl (w : WidthExpr) (a : Term) (k : Nat) : Term\n| bvOfBool (b : Term) : Term\n| binWidthRel (k : WidthBinaryRelationKind) (wa wb : WidthExpr) : Term\n| binRel (k : BinaryRelationKind) (w : WidthExpr)\n (a : Term) (b : Term) : Term\n| or (p1 p2 : Term) : Term\n| and (p1 p2 : Term) : Term\n| pvar (v : Nat) : Term\n| boolBinRel (k : BoolBinaryRelationKind)\n (a b : Term) : Term\nderiving DecidableEq, Inhabited, Repr, Lean.ToExpr"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "NatFSM",
"content": "structure NatFSM (wcard tcard bcard ncard icard pcard : Nat) (v : Nondep.WidthExpr) where\n toFsm : FSM (StateSpace wcard tcard bcard ncard icard pcard)"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr where\n| const : Nat → WidthExpr\n| var : Nat → WidthExpr\n| max : WidthExpr → WidthExpr → WidthExpr\n| min : WidthExpr → WidthExpr → WidthExpr\n| addK : WidthExpr → Nat → WidthExpr\n| kadd : Nat → WidthExpr → WidthExpr\nderiving Inhabited, Repr, Hashable, DecidableEq, Lean.ToExpr"
},
{
"name": "scanOr",
"content": "def scanOr : FSM Unit :=\n {\n α := Unit,\n initCarry := fun () => false,\n outputCirc := Circuit.var true (inl ()) ||| Circuit.var true (inr ()),\n nextStateCirc := fun () => Circuit.var true (inl ()) ||| Circuit.var true (inr ())\n }"
},
{
"name": "WidthExpr.Env",
"content": "abbrev WidthExpr.Env (wcard : Nat) : Type :=\n Fin wcard → Nat"
},
{
"name": "HWidthEnv",
"content": "structure HWidthEnv {wcard tcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (wenv : Fin wcard → Nat) : Prop where\n heq_width : ∀ (v : Fin wcard),\n fsmEnv (StateSpace.widthVar v) = BitStream.ofNatUnary (wenv v)"
},
{
"name": "HPredicateEnv",
"content": "structure HPredicateEnv {wcard tcard bcard ncard icard pcard : Nat}\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream)\n (penv : Fin pcard → Prop) : Prop where\n heq_width : ∀ (v : Fin pcard),\n fsmEnv (StateSpace.predVar v) = BitStream.ofProp (penv v)"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "ofNatUnary",
"content": "abbrev ofNatUnary (n : Nat) : BitStream :=\n fun i => decide (i < n)"
},
{
"name": "HNatFSMToBitstream",
"content": "structure HNatFSMToBitstream {wcard : Nat} {v : WidthExpr wcard} {tcard : Nat} {bcard : Nat} {pcard : Nat}\n (fsm : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v)) : Prop where\n heq :\n ∀ (wenv : Fin wcard → Nat)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (henv : HWidthEnv fsmEnv wenv) →\n fsm.toFsm.eval fsmEnv =\n BitStream.ofNatUnary (v.toNat wenv)"
},
{
"name": "WidthExpr.toNat",
"content": "def WidthExpr.toNat (e : WidthExpr wcard) (env : WidthExpr.Env wcard) : Nat :=\n match e with\n | .const n => n\n | .var v => env v\n | .min v w => Nat.min (v.toNat env) (w.toNat env)\n | .max v w => Nat.max (v.toNat env) (w.toNat env)\n | .addK v k => v.toNat env + k\n | .kadd k v => k + v.toNat env"
},
{
"name": "WidthExpr",
"content": "inductive WidthExpr (wcard : Nat) : Type\n| const (n : Nat) : WidthExpr wcard\n| var : (v : Fin wcard) → WidthExpr wcard\n| min : (v w : WidthExpr wcard) → WidthExpr wcard\n| max : (v w : WidthExpr wcard) → WidthExpr wcard\n| addK : (v : WidthExpr wcard) → (k : Nat) → WidthExpr wcard\n| kadd : (k : Nat) → (v : WidthExpr wcard) → WidthExpr wcard"
},
{
"name": "HPredFSMToBitStream",
"content": "structure HPredFSMToBitStream {pcard : Nat}\n {tctx : Term.Ctx wcard tcard}\n {p : Term bcard ncard icard pcard tctx .prop}\n (fsm : TermFSM wcard tcard bcard ncard icard pcard\n (.ofDepTerm p)) : Prop where\n heq :\n ∀ {wenv : WidthExpr.Env wcard}\n (benv : Term.BoolEnv bcard)\n (nenv : Term.NatEnv ncard)\n (ienv : Term.IntEnv icard)\n (penv : Predicate.Env pcard) (tenv : tctx.Env wenv)\n (fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream),\n (htenv : HTermEnv fsmEnv tenv benv) →\n (hpenv : HPredicateEnv fsmEnv penv) →\n p.toBV benv nenv ienv penv tenv ↔ (fsm.toFsmZext.eval fsmEnv = .negOne)"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
}
] | [
{
"name": "decide_eq_true_iff",
"module": "Init.PropLemmas"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "inf_of_le_left",
"module": "Mathlib.Order.Lattice"
},
{
"name": "le_refl",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "left_eq_inf",
"module": "Mathlib.Order.Lattice"
},
{
"name": "not_iff",
"module": "Mathlib.Logic.Basic"
},
{
"name": "not_le",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "not_lt",
"module": "Mathlib.Order.Defs.LinearOrder"
}
] | [
{
"name": "scanOr_eq_decide",
"content": "theorem scanOr_eq_decide (s : BitStream) (n : Nat) :\n s.scanOr n = decide (∃ (i : Nat), i ≤ n ∧ s i = true)"
},
{
"name": "scanOr_true_iff",
"content": "theorem scanOr_true_iff (s : BitStream) (n : Nat)\n : s.scanOr n = true ↔ ∃ (i : Nat), (i ≤ n) ∧ s i = true"
},
{
"name": "scanOr_false_iff",
"content": "theorem scanOr_false_iff (s : BitStream) (n : Nat) : s.scanOr n = false ↔ ∀ (i : Nat), (hi : i ≤ n) → s i = false"
},
{
"name": "scanOr_succ",
"content": "@[simp]\ntheorem scanOr_succ (s : BitStream) : scanOr s (n+1) = ((s.scanOr n) || s (n + 1))"
}
] | [
{
"name": "MultiWidth.NatFSM.fsmUnaryIndexUle",
"content": "def NatFSM.fsmUnaryIndexUle (a : NatFSM wcard tcard bcard ncard icard pcard v) :\n FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n composeUnaryAux (FSM.ls true) a.toFsm"
},
{
"name": "MultiWidth.fsmUnaryNeqUpto",
"content": "def fsmUnaryNeqUpto (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n (b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=\n composeUnaryAux FSM.scanOr (a.fsmUnaryIndexUle ^^^ b.fsmUnaryIndexUle)"
}
] | [
{
"name": "MultiWidth.decide_eq_eq_decide_iff_decide",
"content": "private theorem decide_eq_eq_decide_iff_decide {P Q : Prop}\n [Decidable P] [Decidable Q] :\n (decide P = decide Q) = decide (P ↔ Q)"
},
{
"name": "MultiWidth.not_decide_eq_decide_lnot",
"content": "private theorem not_decide_eq_decide_lnot {P : Prop}\n [Decidable P] :\n (!(decide P)) = (decide (¬ P))"
},
{
"name": "MultiWidth.min_eq_of_not_le",
"content": "@[simp]\nprivate theorem min_eq_of_not_le {a b : Nat} (hab : ¬ a ≤ b) : min a b = b"
},
{
"name": "MultiWidth.min_eq_of_not_le'",
"content": "@[simp]\nprivate theorem min_eq_of_not_le' {a b : Nat} (hab : ¬ a ≤ b) : min b a = b"
},
{
"name": "MultiWidth.HNatFSMToBitstream.fsmIndexUle_eval_eq",
"content": "@[simp]\ntheorem HNatFSMToBitstream.fsmIndexUle_eval_eq\n (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))\n {wenv : WidthExpr.Env wcard}\n {fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}\n (henv : HWidthEnv fsmEnv wenv)\n (ha : HNatFSMToBitstream a) :\n (NatFSM.fsmUnaryIndexUle a).eval fsmEnv = fun i =>\n decide (i ≤ v.toNat wenv)"
}
] | import Blase.Fast.FiniteStateMachine
import Blase.Vars
import Blase.MultiWidth.Defs
import Blase.KInduction.KInduction
import Lean
namespace MultiWidth
def NatFSM.fsmUnaryIndexUle (a : NatFSM wcard tcard bcard ncard icard pcard v) :
FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
composeUnaryAux (FSM.ls true) a.toFsm
def fsmUnaryNeqUpto (a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w)) : FSM (StateSpace wcard tcard bcard ncard icard pcard) :=
composeUnaryAux FSM.scanOr (a.fsmUnaryIndexUle ^^^ b.fsmUnaryIndexUle) | @[simp]
theorem eval_fsmUnaryNeqUpto_eq_decide
(a : NatFSM wcard tcard bcard ncard icard pcard (.ofDep v))
(b : NatFSM wcard tcard bcard ncard icard pcard (.ofDep w))
{wenv : WidthExpr.Env wcard}
{fsmEnv : StateSpace wcard tcard bcard ncard icard pcard → BitStream}
(henv : HWidthEnv fsmEnv wenv)
(ha : HNatFSMToBitstream a) (hb : HNatFSMToBitstream b) :
((fsmUnaryNeqUpto a b).eval fsmEnv) i =
(decide (min i (v.toNat wenv) ≠ min i (w.toNat wenv))) := | := by
simp [fsmUnaryNeqUpto]
rw [ha.fsmIndexUle_eval_eq (henv := henv)]
rw [hb.fsmIndexUle_eval_eq (henv := henv)]
simp [BitStream.scanOr_eq_decide]
rw [not_decide_eq_decide_lnot]
rw [decide_eq_eq_decide_iff_decide]
rw [decide_eq_true_iff]
constructor
· intros hi
obtain ⟨j, hj₁, hj₂⟩ := hi
by_cases hiv : v.toNat wenv < i
· simp only [not_le, hiv, min_eq_of_not_le]
omega
· simp only [not_lt] at hiv
simp only [hiv, inf_of_le_left, left_eq_inf, not_le]
omega
· intros hivw
simp only [not_iff, not_le]
by_cases hiv : i < (v.toNat wenv)
· simp only [not_le, hiv, min_eq_of_not_le', left_eq_inf] at hivw ⊢
exists i
omega
· simp only [not_lt] at hiv; simp [hiv] at hivw
by_cases hiw : i < (w.toNat wenv)
· simp only [not_le, hiw, min_eq_of_not_le'] at hivw
have hiv' : (v.toNat wenv) ≤ i := by omega
exists i
omega
· simp only [not_lt] at hiw; simp [hiw] at hivw
by_cases hvw : v.toNat wenv < w.toNat wenv
· exists (w.toNat wenv)
simp only [le_refl, iff_true]
omega
· simp only [not_lt] at hvw
exists (v.toNat wenv)
omega | 5 | 61 | false | Compiler |
336 | CNFA.autWidth_spec | lemma CNFA.autWidth_spec : autWidth wp n |>.Sim (NFA'.autWidth wp n) | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.Blase.AutoStructs.Basic",
"import Blase.AutoStructs.Constructions",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Fin.mk",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BitVec.ofFin",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "SetRel",
"module": "Mathlib.Data.Rel"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
}
] | [
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "RawCNFA.empty",
"content": "def RawCNFA.empty : RawCNFA A := {\n stateMax := 0\n initials := ∅\n finals := ∅\n trans := ∅\n}"
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "WidthPredicate",
"content": "inductive WidthPredicate\n| eq\n| neq\n| lt\n| le\n| gt\n| ge\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "instFinEnumBV",
"content": "instance instFinEnumBV : FinEnum (BitVec w) where\n card := 2^w\n equiv := {\n toFun := fun x => x.toFin\n invFun := fun x => BitVec.ofFin x\n left_inv := by admit /- proof elided -/"
},
{
"name": "CNFA.Sim",
"content": "def CNFA.Sim (m : CNFA n) (M : NFA' n) :=\n m.m.Sim M.M"
},
{
"name": "RawCNFA.Sim",
"content": "def RawCNFA.Sim (m : RawCNFA A) (A : NFA A S) := ∃ R, RawCNFA.Simul m A R ⊤ ∅"
},
{
"name": "RawCNFA.Simul",
"content": "structure RawCNFA.Simul (m : RawCNFA A) (M : NFA A Q) (R : SetRel State Q) (D : Set Q) (T : Set (Q × A × Q)) where\n accept {s q} : s ~[R] q → (s ∈ m.finals ↔ q ∈ M.accept)\n initial₁ {s} : s ∈ m.initials → ∃ q ∈ M.start, s ~[R] q\n initial₂ {q} : q ∈ M.start → ∃ s ∈ m.initials, s ~[R] q\n trans_match₁ {s s' a q} : s ~[R] q → s' ∈ m.tr s a → ∃ q', q' ∈ M.step q a ∧ s' ~[R] q'\n trans_match₂ {s a q q'} : s ~[R] q → q' ∈ M.step q a → q ∈ D → (q, a, q') ∉ T → ∃ s', s' ∈ m.tr s a ∧ s' ~[R] q'"
},
{
"name": "RawCNFA.SimulFun",
"content": "structure RawCNFA.SimulFun (m : RawCNFA A) (M : NFA A Q) (f : m.states ≃ Q) where\n accept {q} : ((f.invFun q).val ∈ m.finals ↔ q ∈ M.accept)\n initial {q} : q ∈ M.start ↔ (f.invFun q).val ∈ m.initials\n trans_match {a q q'} : q' ∈ M.step q a ↔ (f.invFun q').val ∈ m.tr (f.invFun q) a"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "RawCNFA.WF",
"content": "structure RawCNFA.WF (m : RawCNFA A) where\n initials_lt : ∀ {s}, s ∈ m.initials → s ∈ m.states\n finals_lt : ∀ {s}, s ∈ m.finals → s ∈ m.states\n trans_src_lt : ∀ s_a ∈ m.trans, s_a.1 ∈ m.states\n trans_tgt_lt : s' ∈ m.tr s a → s' ∈ m.states"
},
{
"name": "RawCNFA.addTrans",
"content": "def RawCNFA.addTrans (m : RawCNFA A) (a : A) (s s' : State) : RawCNFA A :=\n let ns := m.trans.getD (s, a) ∅\n let ns := ns.insert s'\n { m with trans := m.trans.insert (s, a) ns }"
},
{
"name": "RawCNFA.newState",
"content": "def RawCNFA.newState (m : RawCNFA A) : State × RawCNFA A :=\n let old := m.stateMax\n let m := { m with stateMax := old + 1 }\n (old, m)"
},
{
"name": "RawCNFA.addInitial",
"content": "def RawCNFA.addInitial (m : RawCNFA A) (s : State) : RawCNFA A :=\n { m with initials := m.initials.insert s }"
}
] | [
{
"name": "BitVec.zero_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Finset.mem_range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Function.iterate_add",
"module": "Mathlib.Logic.Function.Iterate"
},
{
"name": "eq_of_forall_lt_iff",
"module": "Mathlib.Order.Basic"
},
{
"name": "gt_iff_lt",
"module": "Init.Core"
},
{
"name": "Fin.add_def",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fin.val_one",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "eq_iff_eq_of_cmp_eq_cmp",
"module": "Mathlib.Order.Compare"
}
] | [
{
"name": "wf_addTrans",
"content": "@[grind ., simp, aesop 50% unsafe]\nlemma wf_addTrans [LawfulBEq A] (m : RawCNFA A) (hwf : m.WF) s a s' (hin : s ∈ m.states) (hin' : s' ∈ m.states) :\n (m.addTrans a s s').WF"
},
{
"name": "RawCNFA.same_stateMax",
"content": "@[grind =, simp]\nlemma RawCNFA.same_stateMax (m : RawCNFA A) x y (z : Std.HashMap (State × A) (Std.HashSet State)) :\n (RawCNFA.mk m.stateMax x y z).states = m.states"
},
{
"name": "newState_eq",
"content": "@[grind =, simp, aesop 50% unsafe]\nlemma newState_eq (m : RawCNFA A) :\n m.newState.1 = m.stateMax"
},
{
"name": "addInitial_stateMax",
"content": "@[grind =, simp]\nlemma addInitial_stateMax {m : RawCNFA A} : (m.addInitial s).stateMax = m.stateMax"
},
{
"name": "addTrans_stateMax",
"content": "@[grind =, simp]\nlemma addTrans_stateMax {m : RawCNFA A} : (m.addTrans a s s').stateMax = m.stateMax"
},
{
"name": "simulFun_sim",
"content": "lemma simulFun_sim {m : CNFA n} f :\n m.m.SimulFun M.M f → m.Sim M"
},
{
"name": "simulFun_sim_raw",
"content": "lemma simulFun_sim_raw [LawfulBEq A] {m : RawCNFA A} (hwf : m.WF) f :\n m.SimulFun M f → m.Sim M"
},
{
"name": "RawCNFA.Simul.initial",
"content": "@[simp]\nlemma RawCNFA.Simul.initial {m : RawCNFA A} {M : NFA A Q} (hsim : m.Simul M R ⊤ ∅) :\n R.set_eq m.initials.toSet M.start"
}
] | [
{
"name": "WidthPredicate.final?",
"content": "def WidthPredicate.final? (wp : WidthPredicate) (n : Nat) (s : State) : Bool :=\n decide (wp.sat s n)"
},
{
"name": "RawCNFA.autWidth",
"content": "def RawCNFA.autWidth (wp : WidthPredicate) (n : Nat) : RawCNFA (BitVec 0) :=\n let m := (n+2).iterate f empty\n let m := m.addInitial 0\n m.addTrans (BitVec.zero 0) (n + 1) (n + 1)\nwhere\n f m :=\n let (s, m) := m.newState\n let m := if wp.final? n s then m.addFinal s else m\n if s > 0 then m.addTrans (BitVec.zero 0) (s-1) s else m"
},
{
"name": "CNFA.autWidth",
"content": "def CNFA.autWidth (wp : WidthPredicate) (n : Nat) : CNFA 0 :=\n ⟨RawCNFA.autWidth wp n, RawCNFA.autWidth_wf⟩"
},
{
"name": "NFA.autWidth",
"content": "def NFA.autWidth (wp : WidthPredicate) (n : Nat) : NFA (BitVec 0) (Fin (n+2)) where\n start := { 0 }\n accept := { s | wp.final? n s }\n step s₁ _ := { s₂ | if s₁ = Fin.last (n+1) then s₁ = s₂ else s₂ = s₁ + 1 }"
},
{
"name": "NFA'.autWidth",
"content": "def NFA'.autWidth (wp : WidthPredicate) (n : Nat) : NFA' 0 := ⟨_, NFA.autWidth wp n⟩"
},
{
"name": "autWidth_equiv",
"content": "def autWidth_equiv : (CNFA.autWidth wp n).m.states ≃ (NFA'.autWidth wp n).σ where\n toFun := fun ⟨s, hs⟩ =>\n Fin.mk s (by admit /- proof elided -/\n )\n invFun q := ⟨q.val, by admit /- proof elided -/\n ⟩\n left_inv := by admit /- proof elided -/"
}
] | [
{
"name": "RawCNFA.autWidth_spec",
"content": "lemma RawCNFA.autWidth_spec {wp : WidthPredicate} :\n let m := RawCNFA.autWidth wp n\n m.WF ∧ m.stateMax = n+2 ∧\n (∀ s, s ∈ m.states → (s ∈ m.initials ↔ s = 0) ∧ (s ∈ m.finals ↔ wp.final? n s)) ∧\n (∀ s s', s ∈ m.states → s' ∈ m.states → (s' ∈ m.tr s 0 ↔ if s = n+1 then s = s' else s' = s + 1))"
},
{
"name": "CNFA.autWidth_states",
"content": "@[simp]\nlemma CNFA.autWidth_states: s ∈ (autWidth wp n).m.states ↔ s < n+2"
},
{
"name": "CNFA.autWidth_initials",
"content": "lemma CNFA.autWidth_initials : s ∈ (autWidth wp n).m.initials ↔ s = 0"
},
{
"name": "CNFA.autWidth_finals",
"content": "lemma CNFA.autWidth_finals (hn : s < n + 2) : s ∈ (autWidth wp n).m.finals ↔ wp.final? n s"
},
{
"name": "CNFA.autWidth_tr",
"content": "lemma CNFA.autWidth_tr (hs : s < n + 2) (hs' : s' < n + 2) : s' ∈ (autWidth wp n).m.tr s 0 ↔ if s = n+1 then s = s' else s' = s + 1"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
section fsm
variable {arity : Type} [FinEnum arity]
open BitStream in
end fsm
section nfas_relations
def WidthPredicate.final? (wp : WidthPredicate) (n : Nat) (s : State) : Bool :=
decide (wp.sat s n)
def RawCNFA.autWidth (wp : WidthPredicate) (n : Nat) : RawCNFA (BitVec 0) :=
let m := (n+2).iterate f empty
let m := m.addInitial 0
m.addTrans (BitVec.zero 0) (n + 1) (n + 1)
where
f m :=
let (s, m) := m.newState
let m := if wp.final? n s then m.addFinal s else m
if s > 0 then m.addTrans (BitVec.zero 0) (s-1) s else m
def CNFA.autWidth (wp : WidthPredicate) (n : Nat) : CNFA 0 :=
⟨RawCNFA.autWidth wp n, RawCNFA.autWidth_wf⟩
def NFA.autWidth (wp : WidthPredicate) (n : Nat) : NFA (BitVec 0) (Fin (n+2)) where
start := { 0 }
accept := { s | wp.final? n s }
step s₁ _ := { s₂ | if s₁ = Fin.last (n+1) then s₁ = s₂ else s₂ = s₁ + 1 }
def NFA'.autWidth (wp : WidthPredicate) (n : Nat) : NFA' 0 := ⟨_, NFA.autWidth wp n⟩
def autWidth_equiv : (CNFA.autWidth wp n).m.states ≃ (NFA'.autWidth wp n).σ where
toFun := fun ⟨s, hs⟩ =>
Fin.mk s (by admit /- proof elided -/
)
invFun q := ⟨q.val, by admit /- proof elided -/
⟩
left_inv := by admit /- proof elided -/ | lemma CNFA.autWidth_spec : autWidth wp n |>.Sim (NFA'.autWidth wp n) := | := by
apply simulFun_sim autWidth_equiv; simp [autWidth_equiv]; constructor
· rintro q; simp_all [NFA'.autWidth, NFA.autWidth]; apply autWidth_finals (q.isLt)
· rintro q; simp_all [NFA'.autWidth, NFA.autWidth]; rw [autWidth_initials]; exact
eq_iff_eq_of_cmp_eq_cmp rfl
· rintro a q q'; fin_cases a; simp_all [NFA'.autWidth, NFA.autWidth, instFinEnumBV];
have h := @autWidth_tr q.val n q'.val wp q.isLt q'.isLt
unfold State at *
simp_all
rcases q with ⟨q, hq⟩
rcases q' with ⟨q', hq'⟩
simp [Fin.last]
split
· rfl
· rw [Fin.add_def]
simp only [Fin.val_one, Fin.mk.injEq]
rw [Nat.mod_eq_of_lt (by omega)] | 5 | 77 | false | Compiler |
337 | Ctxt.delete_append_appendInl | @[simp] theorem Ctxt.delete_append_appendInl {Γ : Ctxt Ty} {us : List Ty}
{r : DeleteRange Γ} :
(⟨us⟩ ++ Γ).delete r.appendInl = ⟨us⟩ ++ (Γ.delete r) | lean-mlir | LeanMLIR/LeanMLIR/Transforms/DCE.lean | [
"import Mathlib.Tactic.DepRewrite",
"import LeanMLIR.Framework",
"import Mathlib.Tactic.Linarith",
"import LeanMLIR.LeanMLIR.ErasedContext"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "List.ofFn",
"module": "Init.Data.List.OfFn"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "List.length",
"module": "Init.Prelude"
}
] | [
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "length",
"content": "@[grind=]\ndef length (Γ : Ctxt Ty) : Nat := Γ.toList.length"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
}
] | [
{
"name": "Fin.coe_cast",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "List.getElem?_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.getElem?_ofFn",
"module": "Init.Data.List.OfFn"
},
{
"name": "List.getElem_append_right",
"module": "Init.Data.List.BasicAux"
},
{
"name": "List.length_append",
"module": "Init.Data.List.Basic"
},
{
"name": "Nat.ge_of_not_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Option.dite_none_right_eq_some",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Valuation.ext",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "dite_eq_ite",
"module": "Init.ByCases"
}
] | [
{
"name": "ofList_append",
"content": "@[simp] theorem ofList_append {ts us : List Ty} :\n Ctxt.ofList ts ++ Ctxt.ofList us = Ctxt.ofList (ts ++ us)"
},
{
"name": "length_ofList",
"content": "@[simp, grind=] theorem length_ofList : (ofList ts).length = ts.length"
},
{
"name": "getElem?_ofList",
"content": "@[simp, grind=] theorem getElem?_ofList (i : Nat) : (ofList ts)[i]? = ts[i]?"
},
{
"name": "getElem_ofList",
"content": "@[simp, grind=] theorem getElem_ofList (i : Nat) (h : _) : (ofList ts)[i]'h = ts[i]'h"
}
] | [
{
"name": "DCE.DeleteRange",
"content": "structure DeleteRange (Γ : Ctxt Ty) where\n \n start : Fin (Γ.length + 1)\n \n num : Fin (Γ.length + 1 - start.val)"
},
{
"name": "DCE.DeleteRange.appendInl",
"content": "def appendInl {Γ : Ctxt Ty} {ts : List Ty}\n (r : DeleteRange Γ) : DeleteRange (⟨ts⟩ ++ Γ) where\n start := ⟨r.start + ts.length, by admit /- proof elided -/\n ⟩\n num := ⟨r.num, by admit /- proof elided -/\n ⟩"
},
{
"name": "Ctxt.delete",
"content": "def Ctxt.delete (Γ : Ctxt Ty) (vs : DeleteRange Γ) : Ctxt Ty :=\n Ctxt.ofList <| List.ofFn (n := Γ.length - vs.num.val) fun i =>\n have := vs.start.prop\n if hi : i.val < vs.start then\n Γ[i.val]\n else\n Γ[i.val + vs.num]"
}
] | [] | import LeanMLIR.Framework
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.DepRewrite
open Ctxt (Var Valuation Hom)
namespace DCE
structure DeleteRange (Γ : Ctxt Ty) where
start : Fin (Γ.length + 1)
num : Fin (Γ.length + 1 - start.val)
open DCE (DeleteRange)
namespace DeleteRange
def appendInl {Γ : Ctxt Ty} {ts : List Ty}
(r : DeleteRange Γ) : DeleteRange (⟨ts⟩ ++ Γ) where
start := ⟨r.start + ts.length, by admit /- proof elided -/
⟩
num := ⟨r.num, by admit /- proof elided -/
⟩
section Lemmas
end Lemmas
end DeleteRange
end DCE
open DCE (DeleteRange)
def Ctxt.delete (Γ : Ctxt Ty) (vs : DeleteRange Γ) : Ctxt Ty :=
Ctxt.ofList <| List.ofFn (n := Γ.length - vs.num.val) fun i =>
have := vs.start.prop
if hi : i.val < vs.start then
Γ[i.val]
else
Γ[i.val + vs.num] | @[simp] theorem Ctxt.delete_append_appendInl {Γ : Ctxt Ty} {us : List Ty}
{r : DeleteRange Γ} :
(⟨us⟩ ++ Γ).delete r.appendInl = ⟨us⟩ ++ (Γ.delete r) := | := by
rcases Γ with ⟨Γ⟩
ext i t
simp only [delete, ofList_append, length_ofList, List.length_append,
DeleteRange.val_start_appendInl, DeleteRange.val_num_appendInl, Fin.coe_cast, getElem_ofList,
dite_eq_ite, getElem?_ofList, List.getElem?_ofFn, Option.dite_none_right_eq_some,
Option.some.injEq]
rw [List.getElem?_append]
by_cases hi : i < us.length <;> simp only [reduceIte, hi]
· have : i < us.length + Γ.length - r.num := by grind
have : i < r.start + us.length := by grind
simp [*]
· simp only [List.getElem?_ofFn, Option.dite_none_right_eq_some, Option.some.injEq]
simp only [
List.getElem_append_right (Nat.ge_of_not_lt hi),
List.getElem_append_right (by grind : us.length ≤ i + r.num),
length_ofList
]
split <;> constructor <;> grind | 3 | 33 | false | Compiler |
338 | Lets.getPureExpr_var_appendInl | @[simp] theorem Lets.getPureExpr_var_appendInl (lets : Lets d Γ_in eff Γ_out)
(e : Expr d Γ_out eff ty) (v : Var ⟨ty⟩ u) :
getPureExpr (lets.var e) v.appendInl
= e.toPure?.map (fun e => ⟨_, v, e.changeVars <| e.contextHom⟩) | lean-mlir | LeanMLIR/LeanMLIR/Framework/Basic.lean | [
"import LeanMLIR.HVector",
"import LeanMLIR.ErasedContext",
"import SSA/Projects/CIRCT/HSxComb/HSxCombFunctor.lean",
"import SSA/Projects/CIRCT/DCxComb/DCxCombFunctor.lean",
"import SSA/Projects/Tensor2D/Tensor2D.lean",
"import SSA/Projects/RISCV64/Base.lean",
"import SSA/Projects/ModArith/Basic.lean",
"import SSA/Projects/Scf/ScfFunctor.lean",
"import Mathlib.Data.Finset.Union",
"import LeanMLIR.LeanMLIR.ErasedContext",
"import LeanMLIR.Framework.Dialect",
"import LeanMLIR/LeanMLIR/Transforms/CSE.lean",
"import LeanMLIR/LeanMLIR/Examples.lean",
"import LeanMLIR/LeanMLIR/Transforms/DCE.lean",
"import LeanMLIR.LeanMLIR.HVector",
"import SSA/Projects/FullyHomomorphicEncryption/Basic.lean",
"import LeanMLIR/LeanMLIR/Dialects/LLVM/Basic.lean",
"import SSA/Projects/Tensor1D/Tensor1D.lean",
"import LeanMLIR/LeanMLIR/Framework/Macro.lean",
"import SSA/Projects/LLVMRiscV/LLVMAndRiscv.lean",
"import LeanMLIR.EffectKind"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "decidable_of_iff",
"module": "Init.PropLemmas"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Valuation.mk",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Function.comp",
"module": "Init.Prelude"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "List.length",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.matchAlts",
"module": "Lean.Parser.Term"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Stream'",
"module": "Mathlib.Data.Stream.Defs"
}
] | [
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "Hom",
"content": "abbrev Hom (Γ Γ' : Ctxt Ty) := ⦃t : Ty⦄ → Γ.Var t → Γ'.Var t"
},
{
"name": "dropUntil",
"content": "def dropUntil : Ctxt Ty :=\n ⟨Γ.toList.drop (v.val + 1)⟩"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "Hom.castCodomain",
"content": "def Hom.castCodomain (h : Δ = Δ') (f : Γ.Hom Δ) : Γ.Hom Δ' :=\n fun _t v => (f v).castCtxt h"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "dropUntilHom",
"content": "abbrev dropUntilHom : Hom (Γ.dropUntil v) Γ := dropUntilDiff.toHom"
},
{
"name": "dropUntilDiff",
"content": "def dropUntilDiff : Diff (Γ.dropUntil v) Γ :=\n ⟨v.val+1, by admit /- proof elided -/\n ⟩"
},
{
"name": "emptyElim",
"content": "def emptyElim {α : Sort _} {t : Ty} : Ctxt.Var ∅ t → α :=\n fun ⟨_, h⟩ => by admit /- proof elided -/"
},
{
"name": "cons",
"content": "@[match_pattern]\ndef cons (hd : Ty) : Ctxt Ty → Ctxt Ty\n| ⟨tl⟩ => ⟨hd :: tl⟩"
},
{
"name": "Diff",
"content": "def Diff (Γ₁ Γ₂ : Ctxt Ty) : Type :=\n {d : Nat // Diff.Valid Γ₁ Γ₂ d}"
},
{
"name": "Diff.Valid",
"content": "@[simp]\nabbrev Diff.Valid (Γ₁ Γ₂ : Ctxt Ty) (d : Nat) : Prop :=\n ∀ {i t}, Γ₁[i]? = some t → Γ₂[i+d]? = some t"
},
{
"name": "Hom.id",
"content": "@[simp] abbrev Hom.id {Γ : Ctxt Ty} : Γ.Hom Γ :=\n fun _ v => v"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "HVectorLiteral",
"content": "structure HVectorLiteral where\n u : Level\n v : Level\n α : Q(Type $u)\n A : Q($α → Type $v)\n elems : Array ((a : Q($α)) × Q($A $a))"
},
{
"name": "length",
"content": "@[grind=]\ndef length (Γ : Ctxt Ty) : Nat := Γ.toList.length\n\n instance : DialectSignature $dialect where\n signature := fun op => match op with $matchAlts:matchAlts\n )"
},
{
"name": "(q",
"content": "noncomputable instance (q : ℕ) [Fact (q > 1)] : DialectDenote (ModArith q) where\ndenote\n | .add, arg, _ =>\n \n (fun args : R q × R q => args.1 + args.2) arg.toPair\n | .sub, arg, _ =>\n \n (fun args : R q × R q => args.1 - args.2) arg.toPair\n | .mul, arg, _ =>\n \n (fun args : R q × R q => args.1 * args.2) arg.toPair\n | .const _ c, _, _ =>\n \n c"
},
{
"name": "Op.signature",
"content": "@[simp, reducible]\ndef Op.signature : Op q n → Signature (Ty q n) :=\n fun o => {sig := Op.sig o, returnTypes := [Op.outTy o], regSig := []}"
},
{
"name": "Op.sig",
"content": "@[simp, reducible]\ndef Op.sig : Op q n → List (Ty q n)\n| Op.add => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.sub => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.mul => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.mul_constant => [Ty.polynomialLike, Ty.integer]\n| Op.leading_term => [Ty.polynomialLike]\n| Op.monomial => [Ty.integer, Ty.index]\n| Op.monomial_mul => [Ty.polynomialLike, Ty.index]\n| Op.from_tensor => [Ty.tensor]\n| Op.to_tensor => [Ty.polynomialLike]\n| Op.const _ => []\n| Op.const_int _ => []\n| Op.const_idx _ => []"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "Op.outTy",
"content": "@[simp, reducible]\ndef Op.outTy : Op q n → Ty q n\n| Op.add | Op.sub | Op.mul | Op.mul_constant | Op.leading_term | Op.monomial\n| Op.monomial_mul | Op.from_tensor | Op.const _ => Ty.polynomialLike\n| Op.to_tensor => Ty.tensor\n| Op.const_int _ => Ty.integer\n| Op.const_idx _ => Ty.index"
},
{
"name": "Op.regSig",
"content": "@[reducible, simp]\ndef Op.regSig : Op → RegionSignature Ty\n | .map2d => [([Ty.int], [.int])]\n | _ => []"
},
{
"name": "",
"content": "instance : DialectSignature Ex where\n signature\n | .add => ⟨[.nat, .nat], [], [.nat], .pure⟩\n | .beq => ⟨[.nat, .nat], [], [.bool], .pure⟩\n | .cst _ => ⟨[], [], [.nat], .pure⟩"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | beq : ExOp\n | cst : ℕ → ExOp\n deriving DecidableEq"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Ctxt.Var Γ .nat) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "Ex",
"content": "abbrev Ex : Dialect where\n Op := ExOp\n Ty := ExTy"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectSignature Tensor2D where\n signature op := { sig := op.sig, regSig := op.regSig, returnTypes := [op.outTy] }"
},
{
"name": "",
"content": "instance : DialectSignature Tensor1D where\n signature op := { sig := op.sig, regSig := op.regSig, returnTypes := [op.outTy], effectKind := .pure }"
},
{
"name": "",
"content": "instance : DialectSignature RV64 where\n signature o := {sig := Op.sig o, returnTypes := [Op.outTy o], regSig := []}"
},
{
"name": "Op.sig",
"content": "@[simp, reducible]\ndef Op.sig : Op → List Ty\n | .li _ => []\n | .mulh => [Ty.bv, Ty.bv]\n | .mulhu => [Ty.bv, Ty.bv]\n | .mulhsu => [Ty.bv, Ty.bv]\n | .divu => [Ty.bv, Ty.bv]\n | .remuw => [Ty.bv, Ty.bv]\n | .remu => [Ty.bv, Ty.bv]\n | .addiw (_imm : BitVec 12) => [Ty.bv]\n | .lui (_imm : BitVec 20) => [Ty.bv]\n | .auipc (_imm : BitVec 20) => [Ty.bv]\n | .slliw (_shamt : BitVec 5) => [Ty.bv]\n | .srliw (_shamt : BitVec 5) => [Ty.bv]\n | .sraiw (_shamt : BitVec 5) => [Ty.bv]\n | .slli (_shamt : BitVec 6) => [Ty.bv]\n | .srli (_shamt : BitVec 6) => [Ty.bv]\n | .srai (_shamt : BitVec 6) => [Ty.bv]\n | .addw => [Ty.bv, Ty.bv]\n | .subw => [Ty.bv, Ty.bv]\n | .sllw => [Ty.bv, Ty.bv]\n | .srlw => [Ty.bv, Ty.bv]\n | .sraw => [Ty.bv, Ty.bv]\n | .add => [Ty.bv, Ty.bv]\n | .slt => [Ty.bv, Ty.bv]\n | .sltu => [Ty.bv, Ty.bv]\n | .and => [Ty.bv, Ty.bv]\n | .or => [Ty.bv, Ty.bv]\n | .xor => [Ty.bv, Ty.bv]\n | .sll => [Ty.bv, Ty.bv]\n | .srl => [Ty.bv, Ty.bv]\n | .sub => [Ty.bv, Ty.bv]\n | .sra => [Ty.bv, Ty.bv]\n | .remw => [Ty.bv, Ty.bv]\n | .rem => [Ty.bv, Ty.bv]\n | .mul => [Ty.bv, Ty.bv]\n | .mulw => [Ty.bv, Ty.bv]\n | .div => [Ty.bv, Ty.bv]\n | .divw => [Ty.bv, Ty.bv]\n | .divuw => [Ty.bv, Ty.bv]\n | .addi (_imm : BitVec 12) => [Ty.bv]\n | .slti (_imm : BitVec 12) => [Ty.bv]\n | .sltiu (_imm : BitVec 12) => [Ty.bv]\n | .andi (_imm : BitVec 12) => [Ty.bv]\n | .ori (_imm : BitVec 12) => [Ty.bv]\n | .xori (_imm : BitVec 12) => [Ty.bv]\n | .bclr => [Ty.bv, Ty.bv]\n | .bext => [Ty.bv, Ty.bv]\n | .binv => [Ty.bv, Ty.bv]\n | .bset => [Ty.bv, Ty.bv]\n | .bclri (_shamt : BitVec 6) => [Ty.bv]\n | .bexti (_shamt : BitVec 6) => [Ty.bv]\n | .binvi (_shamt : BitVec 6) => [Ty.bv]\n | .bseti (_shamt : BitVec 6) => [Ty.bv]\n | .adduw => [Ty.bv, Ty.bv]\n | .sh1adduw => [Ty.bv, Ty.bv]\n | .sh2adduw => [Ty.bv, Ty.bv]\n | .sh3adduw => [Ty.bv, Ty.bv]\n | .sh1add => [Ty.bv, Ty.bv]\n | .sh2add => [Ty.bv, Ty.bv]\n | .sh3add => [Ty.bv, Ty.bv]\n | .slliuw (_shamt : BitVec 6) => [Ty.bv]\n | .andn => [Ty.bv, Ty.bv]\n | .orn => [Ty.bv, Ty.bv]\n | .xnor => [Ty.bv, Ty.bv]\n | .clz\n | .clzw\n | .ctz\n | .ctzw\n | .max => [Ty.bv, Ty.bv]\n | .maxu => [Ty.bv, Ty.bv]\n | .min => [Ty.bv, Ty.bv]\n | .minu => [Ty.bv, Ty.bv]\n | .sextb => [Ty.bv]\n | .sexth => [Ty.bv]\n | .zexth => [Ty.bv]\n | .rol => [Ty.bv, Ty.bv]\n | .rolw => [Ty.bv, Ty.bv]\n | .ror => [Ty.bv, Ty.bv]\n | .rori (_shamt : BitVec 6) =>[Ty.bv]\n | .roriw (_shamt : BitVec 5) =>[Ty.bv]\n | .rorw => [Ty.bv, Ty.bv]\n | .pack => [Ty.bv, Ty.bv]\n | .packh => [Ty.bv, Ty.bv]\n | .packw => [Ty.bv, Ty.bv]\n | .mv => [Ty.bv]\n | .not => [Ty.bv]\n | .neg => [Ty.bv]\n | .negw => [Ty.bv]\n | .sextw => [Ty.bv]\n | .zextb => [Ty.bv]\n | .zextw => [Ty.bv]\n | .seqz => [Ty.bv]\n | .snez => [Ty.bv]\n | .sltz => [Ty.bv]\n | .sgtz => [Ty.bv]"
},
{
"name": "Op",
"content": "inductive Op\n \n | li : (val : BitVec 64) → Op\n | lui (imm : BitVec 20)\n | auipc (imm : BitVec 20)\n | addi (imm : BitVec 12)\n | andi (imm : BitVec 12)\n | ori (imm : BitVec 12)\n | xori (imm : BitVec 12)\n | addiw (imm : BitVec 12)\n | add\n | slli (shamt : BitVec 6)\n | sub\n | and\n | or\n | xor\n | sll\n | srl\n | sra\n | addw\n | subw\n | sllw\n | srlw\n | sraw\n | slti (imm : BitVec 12)\n | sltiu (imm : BitVec 12)\n | srli (shamt : BitVec 6)\n | srai (shamt : BitVec 6)\n | slliw (shamt : BitVec 5)\n | srliw (shamt : BitVec 5)\n | sraiw (shamt : BitVec 5)\n | slt\n | sltu\n \n | mul\n | mulw\n | mulh\n | mulhu\n | mulhsu\n | divw\n | divuw\n | div\n | divu\n | remw\n | rem\n | remuw\n | remu\n \n \n | adduw\n | sh1adduw\n | sh2adduw\n | sh3adduw\n | sh1add\n | sh2add\n | sh3add\n | slliuw (shamt : BitVec 6)\n \n | andn\n | orn\n | xnor\n | clz\n | clzw\n | ctz\n | ctzw\n | max\n | maxu\n | min\n | minu\n | sextb\n | sexth\n | zexth\n | rol\n | rolw\n | ror\n | rori (_shamt : BitVec 6)\n | roriw (_shamt : BitVec 5)\n | rorw\n \n | bclr\n | bclri (shamt : BitVec 6)\n | bext\n | bexti (shamt : BitVec 6)\n | binv\n | binvi (shamt : BitVec 6)\n | bset\n | bseti (shamt : BitVec 6)\n \n | pack\n | packh\n | packw\n \n | mv\n | not\n | neg\n | negw\n | sextw\n | zextb\n | zextw\n | seqz\n | snez\n | sltz\n | sgtz\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty\n | bv : Ty\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "",
"content": "instance : DialectSignature (FHE q n) := ⟨Op.signature⟩"
},
{
"name": "",
"content": "instance : DialectSignature LLVM where\n signature op := ⟨op.sig, [], [op.outTy], .pure⟩"
},
{
"name": "",
"content": "instance : DialectSignature HSxComb where\n signature := fun op =>\n match op with\n | .comb o => liftSig (signature o) \n \n \n | .hs o => MLIR2Handshake.instDialectSignatureHandshake.signature o"
},
{
"name": "Op",
"content": "inductive Op : Type _\n | comb (o : MLIR2Comb.Comb.Op)\n | hs (o : MLIR2Handshake.Handshake.Op)\n deriving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "liftSig",
"content": "def liftSig (sig : Signature MLIR2Comb.Ty) : Signature MLIR2Handshake.Ty :=\n Signature.mk (sig.sig.map liftTy) [] (liftTy sig.outTy)"
},
{
"name": "liftTy",
"content": "def liftTy : MLIR2Comb.Ty → MLIR2Handshake.Ty\n| .bitvec w => .stream (.bitvec w)"
},
{
"name": "Ty",
"content": "inductive Ty\n| stream (ty2 : Ty2) : Ty \n| stream2 (ty2 : Ty2) : Ty \n| stream2token (ty2 : Ty2) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty\n| bitvec (w : Nat) : Ty \nderiving DecidableEq, Repr, ToExpr"
},
{
"name": "Ty2",
"content": "inductive Ty2\n | bitvec (w : Nat) : Ty2\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "map",
"content": "def map {α β : Type} (s : Stream α) (f : α → β) : Stream β :=\n fun i => (s i).map f"
},
{
"name": "Stream",
"content": "def Stream (β : Type) := Stream' (Option β)"
},
{
"name": "",
"content": "instance : DialectSignature DCxComb where\n signature := fun op =>\n match op with\n | .comb o => liftSig (signature o) \n \n \n | .dc o => MLIR2DC.instDialectSignatureDC.signature o"
},
{
"name": "Op",
"content": "inductive Op : Type _\n | comb (o : MLIR2Comb.Comb.Op)\n | dc (o : MLIR2DC.DC.Op)\n deriving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "liftSig",
"content": "def liftSig (sig : Signature MLIR2Comb.Ty) : Signature MLIR2DC.Ty :=\n Signature.mk (sig.sig.map liftTy) [] (liftTy sig.outTy)"
},
{
"name": "liftTy",
"content": "def liftTy : MLIR2Comb.Ty → MLIR2DC.Ty\n| .bitvec w => .valuestream w"
},
{
"name": "Ty",
"content": "inductive Ty\n| tokenstream : Ty\n| tokenstream2 : Ty\n| valuestream (w : Nat) : Ty \n| valuestream2 (w : Nat) : Ty \n| valuetokenstream (w : Nat) : Ty \n| variadicvaluetokenstream (w : Nat) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "[SIG",
"content": "instance [SIG : DialectSignature d] [DENOTE : DialectDenote d] {Γ : Ctxt d.Ty} {t}\n (com : Com d Γ .pure t) : Inhabited (DCEType com) where\n default :=\n ⟨Γ, Hom.id, com, by admit /- proof elided -/\n ⟩"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq, Repr"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "LLVMPlusRiscVSignature",
"content": "@[simp]\ninstance LLVMPlusRiscVSignature : DialectSignature LLVMPlusRiscV where\n signature\n | .llvm llvmOp => .llvm <$> DialectSignature.signature llvmOp\n | .riscv riscvOp => .riscv <$> DialectSignature.signature riscvOp\n | .castRiscv w =>\n {sig := [Ty.riscv .bv], returnTypes := [Ty.llvm (.bitvec w)], regSig := []}\n | .castLLVM w =>\n {sig := [Ty.llvm (.bitvec w)], returnTypes := [Ty.riscv .bv], regSig := []}"
},
{
"name": "Op",
"content": "inductive Op where\n | llvm : LLVM.Op -> Op\n | riscv : RISCV64.RV64.Op -> Op\n | castRiscv : Nat → Op\n | castLLVM : Nat → Op\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty where\n | llvm : LLVM.Ty -> Ty\n | riscv : RISCV64.RV64.Ty -> Ty\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "",
"content": "instance : DialectSignature ExOp ExTy where\n signature\n | .add => ⟨[.nat, .nat], [], .nat, .pure⟩\n | .beq => ⟨[.nat, .nat], [], .bool, .pure⟩\n | .cst _ => ⟨[], [], .nat, .pure⟩"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | beq : ExOp\n | cst : ℕ → ExOp\n deriving DecidableEq, Repr"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .nat) : Expr Γ .nat :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := EffectKind.le_refl _)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n deriving DecidableEq, Repr"
},
{
"name": "Expr",
"content": "abbrev Expr (Γ) (ty) := _root_.Expr ExOp Γ .pure ty"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Γ .nat :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := EffectKind.le_refl _)\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "",
"content": "instance : DialectSignature ExOp ExTy where\n signature\n | .add => ⟨[.nat, .nat], [], .nat, .pure⟩\n | .runK _ => ⟨[.nat], [([.nat], .nat)], .nat, .pure⟩"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | runK : ℕ → ExOp\n deriving DecidableEq, Repr"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .nat) : Expr Γ .nat :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := EffectKind.pure_le _)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "[TyDenote",
"content": "@[reducible]\ninstance [TyDenote d.Ty] [DialectSignature d] [DialectDenote d]\n [B : HasBool d] [N : HasNat d] [I : HasInt d] : DialectSignature (Scf d) where\n signature\n | .coe o => signature (d:=d) o\n | .if t t' => ⟨[B.ty, t], [(⟨[t]⟩, [t']), (⟨[t]⟩, [t'])], [t'], .impure⟩\n \n \n \n \n \n | .for t => ⟨[ I.ty, I.ty, N.ty, t], [(⟨[I.ty, t]⟩, [t])], [t], .impure⟩\n | .run t => ⟨[t], [(⟨[t]⟩, [t])], [t], .impure⟩\n | .iterate _k => ⟨[I.ty], [(⟨[I.ty]⟩, [I.ty])], [I.ty], .impure⟩"
},
{
"name": "HasTy",
"content": "class HasTy (d : Dialect) (DenotedTy : Type) [TyDenote d.Ty] [DialectSignature d] where\n ty : d.Ty\n denote_eq : toType ty = DenotedTy := by admit /- proof elided -/"
},
{
"name": "Scf.Op",
"content": "inductive Scf.Op (Op' Ty' : Type) (m') [TyDenote Ty'] [DialectSignature ⟨Op', Ty', m'⟩]\n [DialectDenote ⟨Op', Ty', m'⟩] : Type _\n | coe (o : Op')\n | iterate (k : ℕ) \n | run (inputty : Ty') \n | if (inputty retty' : Ty') \n | for (ty : Ty')\n deriving DecidableEq, Repr"
},
{
"name": "iterate",
"content": "@[simp_denote] def iterate {Γ : Ctxt _} (k : Nat) (input : Var Γ Arith.Ty.int)\n (body : Com ScfArith ⟨[.int]⟩ .impure .int) : Expr ScfArith Γ .impure .int :=\n Expr.mk\n (op := .iterate k)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons input .nil)\n (regArgs := HVector.cons body HVector.nil)"
},
{
"name": "ScfArith",
"content": "abbrev ScfArith := Scf Arith"
},
{
"name": "Scf",
"content": "def Scf (d : Dialect) [TyDenote d.Ty] [DialectSignature d] [DialectDenote d] : Dialect where\n Op := Scf.Op d.Op d.Ty d.m\n Ty := d.Ty\n m := d.m"
},
{
"name": "Op",
"content": "inductive Op\n | add : Op \n | add_nat : Op \n | axpy : Op \n | neg : Op \n | const : (val : ℤ) → Op\n | const_nat : (val : ℕ) → Op"
},
{
"name": "run",
"content": "@[simp_denote]\ndef run {Γ : Ctxt _} {t : Arith.Ty} (v : Var Γ t) (body : Com ScfArith ⟨[t]⟩ .impure t) :\n Expr ScfArith Γ .impure t :=\n Expr.mk\n (op := .run t)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons v .nil)\n (regArgs := HVector.cons body <| HVector.nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n| int\n| bool\n| nat\n deriving DecidableEq, Repr"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "neg",
"content": "@[simp_denote] def neg {Γ : Ctxt _} (a : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .neg)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "axpy",
"content": "@[simp_denote] def axpy {Γ : Ctxt _} (a : Var Γ .int) (x : Var Γ .nat) (b: Var Γ .int) :\n Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .axpy)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons x <| .cons b .nil)\n (regArgs := .nil)"
},
{
"name": "add_nat",
"content": "@[simp_denote] def add_nat (e₁ e₂ : Var Γ .nat) : Expr ScfArith Γ .pure .nat :=\n Expr.mk\n (op := .coe <| .add_nat)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n | int\n \n | int2\n deriving DecidableEq, Lean.ToExpr"
},
{
"name": "Op",
"content": "inductive Op\n | noop\n | mkPair\n | unPair\n deriving Lean.ToExpr"
},
{
"name": "Arith",
"content": "abbrev Arith : Dialect := {Op, Ty}"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectSignature Arith where\n signature\n | .axpy => ⟨[.int, .nat, .int], [], [.int], .pure⟩\n | .neg => ⟨[.int], [], [.int], .pure⟩\n | .const _ => ⟨[], [], [.int], .pure⟩\n | .const_nat _ => ⟨[], [], [.nat], .pure⟩\n | .add => ⟨[.int, .int], [], [.int], .pure⟩\n | .add_nat => ⟨[.nat, .nat], [], [.nat], .pure⟩"
},
{
"name": "add",
"content": "@[simp_denote] def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Option.map_map",
"module": "Init.Data.Option.Lemmas"
}
] | [
{
"name": "map_map",
"content": "theorem map_map {A B C : α → Type*} {l : List α} (t : HVector A l)\n (f : ∀ a, A a → B a) (g : ∀ a, B a → C a) :\n (t.map f).map g = t.map (fun a v => g a (f a v))"
},
{
"name": "val_lt",
"content": "theorem val_lt (v : Γ.Var t) : v.val < Γ.length"
},
{
"name": "length_ofList",
"content": "@[simp, grind=] theorem length_ofList : (ofList ts).length = ts.length"
},
{
"name": "getElem?_ofList",
"content": "@[simp, grind=] theorem getElem?_ofList (i : Nat) : (ofList ts)[i]? = ts[i]?"
},
{
"name": "appendCases_appendInl",
"content": "@[simp] theorem appendCases_appendInl (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInl = (left v)"
}
] | [
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "Signature.mk",
"content": "abbrev Signature.mk (sig : List Ty) (regSig : RegionSignature Ty) (returnTypes : List Ty) : Signature Ty :=\n { sig, regSig, returnTypes }"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "DialectSignature.sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "DialectSignature.regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "DialectSignature.returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "DialectSignature.effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Expr",
"content": "inductive Expr : (Γ : Ctxt d.Ty) → (eff : EffectKind) → (ty : List d.Ty) → Type where\n | mk {Γ} {ty} (op : d.Op)\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) <| DialectSignature.sig op)\n \n (regArgs : HVector (fun t : Ctxt d.Ty × List d.Ty => Com t.1 .impure t.2)\n (DialectSignature.regSig op)) : Expr Γ eff ty"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "HVector",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Expr",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Com.decidableEq",
"content": "protected instance Com.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty]\n {Γ : Ctxt d.Ty} {eff : EffectKind} {tys : List d.Ty} : DecidableEq (Com d Γ eff tys)\n | .rets v₁, .rets v₂ => decidable_of_iff (v₁ = v₂) (by admit /- proof elided -/\n )\n | .var (ty := ty₁) e₁ body₁, .var (ty := ty₂) e₂ body₂ =>\n if hα : ty₁ = ty₂\n then by\n subst hα\n letI := Expr.decidableEq e₁ e₂\n letI := Com.decidableEq body₁ body₂\n exact decidable_of_iff (e₁ = e₂ ∧ body₁ = body₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )\n | .rets _, .var _ _ => isFalse (fun h => Com.noConfusion h)\n | .var _ _, .rets _ => isFalse (fun h => Com.noConfusion h)"
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r)"
},
{
"name": "Expr.contextHom",
"content": "abbrev Expr.contextHom (e : Expr d Γ eff ts) : Γ.Hom e.outContext :=\n Hom.id.appendCodomain"
},
{
"name": "Expr.changeVars",
"content": "def Expr.changeVars (varsMap : Γ.Hom Γ') {ty} (e : Expr d Γ eff ty) :\n Expr d Γ' eff ty :=\n ⟨e.op, e.ty_eq, e.eff_le, e.args.map varsMap, e.regArgs⟩"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "Lets.getPureExprAux",
"content": "def Lets.getPureExprAux {Γ₁ Γ₂ : Ctxt d.Ty} {t} : Lets d Γ₁ eff Γ₂ → (v : Var Γ₂ t) →\n Option (Σ ts, (Var ⟨ts⟩ t) × Expr d (Γ₂.dropUntil v) .pure ts)\n | .nil, _ => none\n | .var (Γ_out := Γ_out) (t := t) lets e, v => by admit /- proof elided -/\n | right v =>\n apply cast ?_ <| Lets.getPureExprAux lets v\n simp\n | left v =>\n have h : (Ctxt.dropUntil t v) ++ Γ_out = e.outContext.dropUntil v.appendInl := by admit /- proof elided -/"
},
{
"name": "Lets.getPureExpr",
"content": "def Lets.getPureExpr {Γ₁ Γ₂ : Ctxt d.Ty} (lets : Lets d Γ₁ eff Γ₂) {t : d.Ty} (v : Var Γ₂ t) :\n Option (Σ ts, (Var ⟨ts⟩ t) × Expr d Γ₂ .pure ts) :=\n (getPureExprAux lets v).map fun ⟨_, v, e⟩ =>\n ⟨_, v, e.changeVars Ctxt.dropUntilHom⟩"
}
] | [
{
"name": "Expr.changeVars_changeVars",
"content": "@[simp] theorem Expr.changeVars_changeVars (e : Expr d Γ eff ty) (f : Γ.Hom Δ) (g : Δ.Hom Ξ) :\n (e.changeVars f).changeVars g = e.changeVars (f.comp g)"
}
] | import LeanMLIR.ErasedContext
import LeanMLIR.HVector
import LeanMLIR.EffectKind
import LeanMLIR.Framework.Dialect
import Mathlib.Data.Finset.Union
open Ctxt (Var VarSet Valuation Hom)
open TyDenote (toType)
abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)
structure Signature (Ty : Type) where
mkEffectful ::
sig : List Ty
regSig : RegionSignature Ty
returnTypes : List Ty
effectKind : EffectKind := .pure
abbrev Signature.mk (sig : List Ty) (regSig : RegionSignature Ty) (returnTypes : List Ty) : Signature Ty :=
{ sig, regSig, returnTypes }
class DialectSignature (d : Dialect) where
signature : d.Op → Signature d.Ty
namespace DialectSignature
variable {d} [s : DialectSignature d]
def sig := Signature.sig ∘ s.signature
def regSig := Signature.regSig ∘ s.signature
def returnTypes := Signature.returnTypes ∘ s.signature
def effectKind := Signature.effectKind ∘ s.signature
end DialectSignature
class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where
denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →
(HVector (fun t : Ctxt d.Ty × List d.Ty =>
t.1.Valuation
→ EffectKind.impure.toMonad d.m (HVector toType t.2))
(DialectSignature.regSig op)) →
((DialectSignature.effectKind op).toMonad d.m
(HVector toType <| DialectSignature.returnTypes op))
section DataStructures
variable (d : Dialect) [DialectSignature d]
inductive Expr : (Γ : Ctxt d.Ty) → (eff : EffectKind) → (ty : List d.Ty) → Type where
| mk {Γ} {ty} (op : d.Op)
(ty_eq : ty = DialectSignature.returnTypes op)
(eff_le : DialectSignature.effectKind op ≤ eff)
(args : HVector (Var Γ) <| DialectSignature.sig op)
(regArgs : HVector (fun t : Ctxt d.Ty × List d.Ty => Com t.1 .impure t.2)
(DialectSignature.regSig op)) : Expr Γ eff ty
inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where
| rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys
| var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β
end
abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=
ts ++ Γ
abbrev Regions (regSig : RegionSignature d.Ty) : Type :=
HVector (fun t => Com d t.1 .impure t.2) regSig
inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :
(Γ_out : Ctxt d.Ty) → Type where
| nil : Lets Γ_in eff Γ_in
| var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext
variable {d} [DialectSignature d]
protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :
∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)
| _, .nil, .nil => isTrue rfl
| _, .cons x₁ v₁, .cons x₂ v₂ =>
letI := HVector.decidableEqReg v₁ v₂
letI := Com.decidableEq x₁ x₂
decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/
)
protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :
{Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)
| Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>
if ho : op₁ = op₂ then by
subst ho
letI := HVector.decidableEq arg₁ arg₂
letI := HVector.decidableEqReg regArgs₁ regArgs₂
exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/
)
else isFalse (by admit /- proof elided -/
)
protected instance Com.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty]
{Γ : Ctxt d.Ty} {eff : EffectKind} {tys : List d.Ty} : DecidableEq (Com d Γ eff tys)
| .rets v₁, .rets v₂ => decidable_of_iff (v₁ = v₂) (by admit /- proof elided -/
)
| .var (ty := ty₁) e₁ body₁, .var (ty := ty₂) e₂ body₂ =>
if hα : ty₁ = ty₂
then by
subst hα
letI := Expr.decidableEq e₁ e₂
letI := Com.decidableEq body₁ body₂
exact decidable_of_iff (e₁ = e₂ ∧ body₁ = body₂) (by admit /- proof elided -/
)
else isFalse (by admit /- proof elided -/
)
| .rets _, .var _ _ => isFalse (fun h => Com.noConfusion h)
| .var _ _, .rets _ => isFalse (fun h => Com.noConfusion h)
end -- decEq
end DataStructures
variable {d : Dialect} [DialectSignature d]
section Rec
variable {eff t} {motive : ∀ {Γ}, Com d Γ eff t → Sort u}
(rets : ∀ {Γ : Ctxt _} , (v : HVector Γ.Var t) → motive (Com.rets v))
(var : ∀ {Γ} {u},
(e : Expr d Γ eff u) → (body : Com d e.outContext eff t) →
motive body → motive (Com.var e body))
def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=
Com.rec
(motive_1 := fun _ _ _ _ => PUnit)
(motive_2 := fun _ eff' t' c =>
(h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))
(motive_3 := fun _ _ => PUnit)
(fun _ _ _ _ _ _ => ⟨⟩)
(fun v h₁ h₂ =>
cast (by admit /- proof elided -/
) <| rets (h₂ ▸ v))
(fun e' body' _ r' h₁ h₂ =>
let e := h₁ ▸ e'
let body : Com _ _ eff t := cast (by admit /- proof elided -/
) body'
let r : motive body := cast (by admit /- proof elided -/
) (r' h₁ h₂)
cast (by admit /- proof elided -/
) <| var e body r)
⟨⟩
(fun _ _ _ _ => ⟨⟩)
com
rfl
rfl
variable {rets} {var} {Γ : Ctxt _}
end Rec
def Expr.args {Γ ts} (e : Expr d Γ eff ts) :
HVector (Var Γ) (DialectSignature.sig e.op) :=
Expr.casesOn e (fun _ _ _ args _ => args)
def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :
Regions d (DialectSignature.regSig e.op) :=
Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)
section Lemmas
namespace Com
end Com
end Lemmas
def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=
Com.rec' (motive := fun _ => Ctxt d.Ty)
(@fun Γ _ => Γ)
(fun _ _ r => r)
abbrev Expr.contextHom (e : Expr d Γ eff ts) : Γ.Hom e.outContext :=
Hom.id.appendCodomain
section Lemmas
end Lemmas
variable [TyDenote d.Ty] [DialectDenote d] [DecidableEq d.Ty] [Monad d.m] [LawfulMonad d.m]
end
section Unfoldings
open EffectKind (liftEffect)
end Unfoldings
section Lemmas
end Lemmas
def Expr.changeVars (varsMap : Γ.Hom Γ') {ty} (e : Expr d Γ eff ty) :
Expr d Γ' eff ty :=
⟨e.op, e.ty_eq, e.eff_le, e.args.map varsMap, e.regArgs⟩
section Lemmas
variable {Γ Γ' : Ctxt d.Ty} {t} (f : Γ.Hom Γ') (e : Expr d Γ eff t) (V : Γ'.Valuation)
end Lemmas
structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)
(Γ_out : Ctxt d.Ty) (ts : List d.Ty) where
lets : Lets d Γ_in eff Γ_out
rets : HVector Γ_out.Var ts
section Lemmas
end Lemmas
section toPureLemmas
variable {Γ eff ty} {e : Expr d Γ eff ty} (h : e.HasPureOp)
end toPureLemmas
section DenoteInsert
end DenoteInsert
def Lets.getPureExprAux {Γ₁ Γ₂ : Ctxt d.Ty} {t} : Lets d Γ₁ eff Γ₂ → (v : Var Γ₂ t) →
Option (Σ ts, (Var ⟨ts⟩ t) × Expr d (Γ₂.dropUntil v) .pure ts)
| .nil, _ => none
| .var (Γ_out := Γ_out) (t := t) lets e, v => by admit /- proof elided -/
| right v =>
apply cast ?_ <| Lets.getPureExprAux lets v
simp
| left v =>
have h : (Ctxt.dropUntil t v) ++ Γ_out = e.outContext.dropUntil v.appendInl := by admit /- proof elided -/
def Lets.getPureExpr {Γ₁ Γ₂ : Ctxt d.Ty} (lets : Lets d Γ₁ eff Γ₂) {t : d.Ty} (v : Var Γ₂ t) :
Option (Σ ts, (Var ⟨ts⟩ t) × Expr d Γ₂ .pure ts) :=
(getPureExprAux lets v).map fun ⟨_, v, e⟩ =>
⟨_, v, e.changeVars Ctxt.dropUntilHom⟩ | @[simp] theorem Lets.getPureExpr_var_appendInl (lets : Lets d Γ_in eff Γ_out)
(e : Expr d Γ_out eff ty) (v : Var ⟨ty⟩ u) :
getPureExpr (lets.var e) v.appendInl
= e.toPure?.map (fun e => ⟨_, v, e.changeVars <| e.contextHom⟩) := | := by
simp only [getPureExpr, getPureExprAux, Ctxt.getElem?_ofList, Var.appendCases_appendInl,
Option.map_map]
congr 1
funext e
simp only [Expr.changeVars_changeVars, Function.comp]
congr 3
funext _ v'
apply Subtype.ext
have := v.val_lt
simp; grind | 6 | 70 | false | Compiler |
339 | Expr.denote_castPureToEff | @[simp] theorem Expr.denote_castPureToEff {e : Expr d Γ .pure t} :
denote (e.castPureToEff eff) = fun V => pure (e.denote V) | lean-mlir | LeanMLIR/LeanMLIR/Framework/Basic.lean | [
"import LeanMLIR.HVector",
"import LeanMLIR.ErasedContext",
"import SSA/Projects/CIRCT/HSxComb/HSxCombFunctor.lean",
"import SSA/Projects/CIRCT/DCxComb/DCxCombFunctor.lean",
"import SSA/Projects/Tensor2D/Tensor2D.lean",
"import SSA/Projects/RISCV64/Base.lean",
"import SSA/Projects/ModArith/Basic.lean",
"import LeanMLIR.LeanMLIR.EffectKind",
"import SSA/Projects/PaperExamples/PaperExamples.lean",
"import SSA/Projects/Scf/ScfFunctor.lean",
"import Mathlib.Data.Finset.Union",
"import LeanMLIR.Framework.Dialect",
"import LeanMLIR/LeanMLIR/Transforms/CSE.lean",
"import SSA/Projects/FullyHomomorphicEncryption/Basic.lean",
"import LeanMLIR/LeanMLIR/Transforms/DCE.lean",
"import LeanMLIR/LeanMLIR/Examples.lean",
"import LeanMLIR/LeanMLIR/Dialects/LLVM/Basic.lean",
"import SSA/Projects/Tensor1D/Tensor1D.lean",
"import LeanMLIR/LeanMLIR/Framework/Macro.lean",
"import SSA/Projects/LLVMRiscV/LLVMAndRiscv.lean",
"import LeanMLIR.EffectKind"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "decidable_of_iff",
"module": "Init.PropLemmas"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Valuation.mk",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.matchAlts",
"module": "Lean.Parser.Term"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "RV64.sub",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sltiu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.slt",
"module": "RISCV.Instructions"
},
{
"name": "RV64.andi",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sltu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.adduw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.addiw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.xori",
"module": "RISCV.Instructions"
},
{
"name": "RV64.addi",
"module": "RISCV.Instructions"
},
{
"name": "RV64.subw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.add",
"module": "RISCV.Instructions"
},
{
"name": "RV64.addw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.andn",
"module": "RISCV.Instructions"
},
{
"name": "RV64.auipc",
"module": "RISCV.Instructions"
},
{
"name": "RV64.bclr",
"module": "RISCV.Instructions"
},
{
"name": "RV64.bclri",
"module": "RISCV.Instructions"
},
{
"name": "RV64.bext",
"module": "RISCV.Instructions"
},
{
"name": "RV64.bexti",
"module": "RISCV.Instructions"
},
{
"name": "RV64.binv",
"module": "RISCV.Instructions"
},
{
"name": "RV64.binvi",
"module": "RISCV.Instructions"
},
{
"name": "RV64.bset",
"module": "RISCV.Instructions"
},
{
"name": "RV64.bseti",
"module": "RISCV.Instructions"
},
{
"name": "RV64.clz",
"module": "RISCV.Instructions"
},
{
"name": "RV64.clzw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.ctz",
"module": "RISCV.Instructions"
},
{
"name": "RV64.ctzw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.div",
"module": "RISCV.Instructions"
},
{
"name": "RV64.divu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.divuw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.divw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.lui",
"module": "RISCV.Instructions"
},
{
"name": "RV64.max",
"module": "RISCV.Instructions"
},
{
"name": "RV64.maxu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.min",
"module": "RISCV.Instructions"
},
{
"name": "RV64.minu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.mul",
"module": "RISCV.Instructions"
},
{
"name": "RV64.mulh",
"module": "RISCV.Instructions"
},
{
"name": "RV64.mulhsu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.mulhu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.mulw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.ori",
"module": "RISCV.Instructions"
},
{
"name": "RV64.orn",
"module": "RISCV.Instructions"
},
{
"name": "RV64.pack",
"module": "RISCV.Instructions"
},
{
"name": "RV64.packh",
"module": "RISCV.Instructions"
},
{
"name": "RV64.packw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.rem",
"module": "RISCV.Instructions"
},
{
"name": "RV64.remu",
"module": "RISCV.Instructions"
},
{
"name": "RV64.remuw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.remw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.rol",
"module": "RISCV.Instructions"
},
{
"name": "RV64.rolw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.ror",
"module": "RISCV.Instructions"
},
{
"name": "RV64.rori",
"module": "RISCV.Instructions"
},
{
"name": "RV64.roriw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.rorw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sextb",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sexth",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sh1add",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sh1adduw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sh2add",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sh2adduw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sh3add",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sh3adduw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sll",
"module": "RISCV.Instructions"
},
{
"name": "RV64.slli",
"module": "RISCV.Instructions"
},
{
"name": "RV64.slliuw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.slliw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sllw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.slti",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sra",
"module": "RISCV.Instructions"
},
{
"name": "RV64.srai",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sraiw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.sraw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.srl",
"module": "RISCV.Instructions"
},
{
"name": "RV64.srli",
"module": "RISCV.Instructions"
},
{
"name": "RV64.srliw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.srlw",
"module": "RISCV.Instructions"
},
{
"name": "RV64.xnor",
"module": "RISCV.Instructions"
},
{
"name": "RV64.xor",
"module": "RISCV.Instructions"
},
{
"name": "RV64.zexth",
"module": "RISCV.Instructions"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Ideal",
"module": "Mathlib.RingTheory.Ideal.Defs"
},
{
"name": "Ideal.Quotient.mk",
"module": "Mathlib.RingTheory.Ideal.Quotient.Defs"
},
{
"name": "Ideal.span",
"module": "Mathlib.RingTheory.Ideal.Span"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.monomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Function.surjInv",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "Polynomial.coeff",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.degree",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
},
{
"name": "Polynomial.map",
"module": "Mathlib.Algebra.Polynomial.Eval.Defs"
},
{
"name": "List.replicate",
"module": "Init.Data.List.Basic"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "BitVec.signExtend",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "cast",
"module": "Init.Prelude"
},
{
"name": "cond",
"module": "Init.Prelude"
},
{
"name": "Stream'",
"module": "Mathlib.Data.Stream.Defs"
}
] | [
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "liftEffect",
"content": "def liftEffect [Pure m] {e1 e2 : EffectKind} {α : Type}\n (hle : e1 ≤ e2) (v1 : e1.toMonad m α) : e2.toMonad m α :=\n match e1, e2, hle with\n | .pure, .pure, _ | .impure, .impure, _ => v1\n | .pure, .impure, _ => Pure.pure v1"
},
{
"name": "toMonad",
"content": "def toMonad (e : EffectKind) (m : Type → Type) : Type → Type :=\n match e with\n | pure => Id\n | impure => m"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList\n\n @[simp_denote]\n instance : DialectDenote $dialect where\n denote := fun op => match op with $matchAlts:matchAlts\n )"
},
{
"name": "(q",
"content": "noncomputable instance (q : ℕ) [Fact (q > 1)] : DialectDenote (ModArith q) where\ndenote\n | .add, arg, _ =>\n \n (fun args : R q × R q => args.1 + args.2) arg.toPair\n | .sub, arg, _ =>\n \n (fun args : R q × R q => args.1 - args.2) arg.toPair\n | .mul, arg, _ =>\n \n (fun args : R q × R q => args.1 * args.2) arg.toPair\n | .const _ c, _, _ =>\n \n c"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectDenote Ex where\n denote\n | .cst n, _, _ => n ::ₕ .nil\n | .add, .cons (a : Nat) (.cons b .nil), _ => a + b ::ₕ .nil\n | .beq, .cons (a : Nat) (.cons b .nil), _ => (a == b) ::ₕ .nil"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | beq : ExOp\n | cst : ℕ → ExOp\n deriving DecidableEq"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Ctxt.Var Γ .nat) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "Ex",
"content": "abbrev Ex : Dialect where\n Op := ExOp\n Ty := ExTy"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "cons",
"content": "@[match_pattern]\ndef cons (hd : Ty) : Ctxt Ty → Ctxt Ty\n| ⟨tl⟩ => ⟨hd :: tl⟩"
},
{
"name": "",
"content": "@[simp, reducible]\ninstance : DialectDenote RV64 where\n denote o args _ := [o.denote args]ₕ"
},
{
"name": "Op.denote",
"content": "@[simp, simp_denote]\nabbrev Op.denote : (o : RV64.Op) → HVector toType o.sig → ⟦o.outTy⟧\n | .li imm, _ => imm\n | .addiw imm, regs => RV64.addiw imm (regs.getN 0)\n | .lui imm, regs => RV64.lui imm\n | .auipc imm, regs => RV64.auipc imm (regs.getN 0)\n | .slliw shamt, regs => RV64.slliw shamt (regs.getN 0)\n | .srliw shamt, regs => RV64.srliw shamt (regs.getN 0)\n | .sraiw shamt, regs => RV64.sraiw shamt (regs.getN 0)\n | .slli shamt, regs => RV64.slli shamt (regs.getN 0)\n | .srli shamt, regs => RV64.srli shamt (regs.getN 0)\n | .srai shamt, regs => RV64.srai shamt (regs.getN 0)\n | .addw, regs => RV64.addw (regs.getN 1) (regs.getN 0)\n | .subw, regs => RV64.subw (regs.getN 1) (regs.getN 0)\n | .sllw, regs => RV64.sllw (regs.getN 1) (regs.getN 0)\n | .srlw, regs => RV64.srlw (regs.getN 1) (regs.getN 0)\n | .sraw, regs => RV64.sraw (regs.getN 1) (regs.getN 0)\n | .add, regs => RV64.add (regs.getN 1) (regs.getN 0)\n | .slt, regs => RV64.slt (regs.getN 1) (regs.getN 0)\n | .sltu, regs => RV64.sltu (regs.getN 1) (regs.getN 0)\n | .and, regs => RV64.and (regs.getN 1) (regs.getN 0)\n | .or, regs => RV64.or (regs.getN 1) (regs.getN 0)\n | .xor, regs => RV64.xor (regs.getN 1) (regs.getN 0)\n | .sll, regs => RV64.sll (regs.getN 1) (regs.getN 0)\n | .srl, regs => RV64.srl (regs.getN 1) (regs.getN 0)\n | .sub, regs => RV64.sub (regs.getN 1) (regs.getN 0)\n | .sra, regs => RV64.sra (regs.getN 1) (regs.getN 0)\n | .remw, regs => RV64.remw (regs.getN 1) (regs.getN 0)\n | .remuw, regs => RV64.remuw (regs.getN 1) (regs.getN 0)\n | .rem, regs => RV64.rem (regs.getN 1) (regs.getN 0)\n | .remu, regs => RV64.remu (regs.getN 1) (regs.getN 0)\n | .mulhu,regs => RV64.mulhu (regs.getN 1) (regs.getN 0)\n | .mul ,regs => RV64.mul (regs.getN 1) (regs.getN 0)\n | .mulhsu ,regs => RV64.mulhsu (regs.getN 1) (regs.getN 0)\n | .mulh,regs => RV64.mulh (regs.getN 1) (regs.getN 0)\n | .mulw, regs => RV64.mulw (regs.getN 1) (regs.getN 0)\n | .div, regs => RV64.div (regs.getN 1) (regs.getN 0)\n | .divu, regs => RV64.divu (regs.getN 1) (regs.getN 0)\n | .divw, regs => RV64.divw (regs.getN 1) (regs.getN 0)\n | .divuw, regs => RV64.divuw (regs.getN 1) (regs.getN 0)\n | .addi imm, reg => RV64.addi imm (reg.getN 0)\n | .slti imm, reg => RV64.slti imm (reg.getN 0)\n | .sltiu imm, reg => RV64.sltiu imm (reg.getN 0)\n | .andi imm, reg => RV64.andi imm (reg.getN 0)\n | .ori imm, reg => RV64.ori imm (reg.getN 0)\n | .xori imm, reg => RV64.xori imm (reg.getN 0)\n | .bclr, regs => RV64.bclr (regs.getN 1) (regs.getN 0)\n | .bext, regs => RV64.bext (regs.getN 1) (regs.getN 0)\n | .binv, regs => RV64.binv (regs.getN 1) (regs.getN 0)\n | .bset, regs => RV64.bset (regs.getN 1) (regs.getN 0)\n | .bclri shamt , reg => RV64.bclri shamt (reg.getN 0)\n | .bexti shamt, reg => RV64.bexti shamt (reg.getN 0)\n | .binvi shamt, reg => RV64.binvi shamt (reg.getN 0)\n | .bseti shamt, reg => RV64.bseti shamt (reg.getN 0)\n | .adduw, regs => RV64.adduw (regs.getN 1) (regs.getN 0)\n | .sh1adduw , regs => RV64.sh1adduw (regs.getN 1) (regs.getN 0)\n | .sh2adduw, regs => RV64.sh2adduw (regs.getN 1) (regs.getN 0)\n | .sh3adduw, regs => RV64.sh3adduw (regs.getN 1) (regs.getN 0)\n | .sh1add, regs => RV64.sh1add (regs.getN 1) (regs.getN 0)\n | .sh2add, regs => RV64.sh2add (regs.getN 1) (regs.getN 0)\n | .sh3add, regs => RV64.sh3add (regs.getN 1) (regs.getN 0)\n | .slliuw shamt, regs => RV64.slliuw shamt (regs.getN 0)\n | .andn, regs => RV64.andn (regs.getN 1) (regs.getN 0)\n | .orn, regs => RV64.orn (regs.getN 1) (regs.getN 0)\n | .xnor, regs => RV64.xnor (regs.getN 1) (regs.getN 0)\n | .clz, regs => RV64.clz (regs.getN 1)\n | .clzw, regs => RV64.clzw (regs.getN 1)\n | .ctz, regs => RV64.ctz (regs.getN 1)\n | .ctzw, regs => RV64.ctzw (regs.getN 1)\n | .max, regs => RV64.max (regs.getN 1) (regs.getN 0)\n | .maxu, regs => RV64.maxu (regs.getN 1) (regs.getN 0)\n | .min, regs => RV64.min (regs.getN 1) (regs.getN 0)\n | .minu, regs => RV64.minu (regs.getN 1) (regs.getN 0)\n | .sextb, reg => RV64.sextb (reg.getN 0)\n | .sexth, reg => RV64.sexth (reg.getN 0)\n | .zexth, reg => RV64.zexth (reg.getN 0)\n | .rol, regs => RV64.rol (regs.getN 1) (regs.getN 0)\n | .rolw, regs => RV64.rolw (regs.getN 1) (regs.getN 0)\n | .ror, regs => RV64.ror (regs.getN 1) (regs.getN 0)\n | .rori shamt, regs => RV64.rori shamt (regs.getN 0)\n | .roriw shamt, regs => RV64.roriw shamt (regs.getN 0)\n | .rorw, regs => RV64.rorw (regs.getN 1) (regs.getN 0)\n | .pack, regs => RV64.pack (regs.getN 1) (regs.getN 0)\n | .packh, regs => RV64.packh (regs.getN 1) (regs.getN 0)\n | .packw, regs => RV64.packw (regs.getN 1) (regs.getN 0)\n \n | .mv, regs => RV64.mv_pseudo (regs.getN 0)\n | .not, regs => RV64.not_pseudo (regs.getN 0)\n | .neg, regs => RV64.neg_pseudo (regs.getN 0)\n | .negw, regs => RV64.negw_pseudo (regs.getN 0)\n | .sextw, regs => RV64.sextw_pseudo (regs.getN 0)\n | .zextb, regs => RV64.zextb_pseudo (regs.getN 0)\n | .zextw, regs => RV64.zextw_pseudo (regs.getN 0)\n | .seqz, regs => RV64.seqz_pseudo (regs.getN 0)\n | .snez, regs => RV64.snez_pseudo (regs.getN 0)\n | .sltz, regs => RV64.sltz_pseudo (regs.getN 0)\n | .sgtz, regs => RV64.sgtz_pseudo (regs.getN 0)"
},
{
"name": "Op",
"content": "inductive Op\n \n | li : (val : BitVec 64) → Op\n | lui (imm : BitVec 20)\n | auipc (imm : BitVec 20)\n | addi (imm : BitVec 12)\n | andi (imm : BitVec 12)\n | ori (imm : BitVec 12)\n | xori (imm : BitVec 12)\n | addiw (imm : BitVec 12)\n | add\n | slli (shamt : BitVec 6)\n | sub\n | and\n | or\n | xor\n | sll\n | srl\n | sra\n | addw\n | subw\n | sllw\n | srlw\n | sraw\n | slti (imm : BitVec 12)\n | sltiu (imm : BitVec 12)\n | srli (shamt : BitVec 6)\n | srai (shamt : BitVec 6)\n | slliw (shamt : BitVec 5)\n | srliw (shamt : BitVec 5)\n | sraiw (shamt : BitVec 5)\n | slt\n | sltu\n \n | mul\n | mulw\n | mulh\n | mulhu\n | mulhsu\n | divw\n | divuw\n | div\n | divu\n | remw\n | rem\n | remuw\n | remu\n \n \n | adduw\n | sh1adduw\n | sh2adduw\n | sh3adduw\n | sh1add\n | sh2add\n | sh3add\n | slliuw (shamt : BitVec 6)\n \n | andn\n | orn\n | xnor\n | clz\n | clzw\n | ctz\n | ctzw\n | max\n | maxu\n | min\n | minu\n | sextb\n | sexth\n | zexth\n | rol\n | rolw\n | ror\n | rori (_shamt : BitVec 6)\n | roriw (_shamt : BitVec 5)\n | rorw\n \n | bclr\n | bclri (shamt : BitVec 6)\n | bext\n | bexti (shamt : BitVec 6)\n | binv\n | binvi (shamt : BitVec 6)\n | bset\n | bseti (shamt : BitVec 6)\n \n | pack\n | packh\n | packw\n \n | mv\n | not\n | neg\n | negw\n | sextw\n | zextb\n | zextw\n | seqz\n | snez\n | sltz\n | sgtz\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "RV64",
"content": "@[simp]\nabbrev RV64 : Dialect where\n Op := Op\n Ty := Ty"
},
{
"name": "Ty",
"content": "inductive Ty\n | bv : Ty\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "neg_pseudo",
"content": "@[simp_riscv]\ndef neg_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.sub rs1_val 0"
},
{
"name": "seqz_pseudo",
"content": "@[simp_riscv]\ndef seqz_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.sltiu 1 rs1_val"
},
{
"name": "sgtz_pseudo",
"content": "@[simp_riscv]\ndef sgtz_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.slt rs1_val 0"
},
{
"name": "zextb_pseudo",
"content": "@[simp_riscv]\ndef zextb_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.andi 255 rs1_val"
},
{
"name": "snez_pseudo",
"content": "@[simp_riscv]\ndef snez_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.sltu rs1_val 0"
},
{
"name": "sltz_pseudo",
"content": "@[simp_riscv]\ndef sltz_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.slt 0 rs1_val"
},
{
"name": "zextw_pseudo",
"content": "@[simp_riscv]\ndef zextw_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.adduw 0 rs1_val"
},
{
"name": "sextw_pseudo",
"content": "@[simp_riscv]\ndef sextw_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.addiw 0 rs1_val"
},
{
"name": "not_pseudo",
"content": "@[simp_riscv]\ndef not_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.xori (-1) rs1_val"
},
{
"name": "mv_pseudo",
"content": "@[simp_riscv]\ndef mv_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.addi 0 rs1_val"
},
{
"name": "negw_pseudo",
"content": "@[simp_riscv]\ndef negw_pseudo (rs1_val : BitVec 64) : BitVec 64 :=\n RV64.subw rs1_val 0"
},
{
"name": "",
"content": "@[simp]\nnoncomputable instance : DialectDenote (FHE q n) where\n denote\n | Op.add, arg, _ => [(fun args : R q n × R q n => args.1 + args.2) arg.toPair]ₕ\n | Op.sub, arg, _ => [(fun args : R q n × R q n => args.1 - args.2) arg.toPair]ₕ\n | Op.mul, arg, _ => [(fun args : R q n × R q n => args.1 * args.2) arg.toPair]ₕ\n | Op.mul_constant, arg, _ => [(fun args : R q n × Int => args.1 * ↑(args.2)) arg.toPair]ₕ\n | Op.leading_term, arg, _ => [R.leadingTerm arg.toSingle]ₕ\n | Op.monomial, arg, _ => [(fun args => R.monomial ↑(args.1) args.2) arg.toPair]ₕ\n | Op.monomial_mul, arg, _ => [(fun args : R q n × Nat => args.1 * R.monomial 1 args.2) arg.toPair]ₕ\n | Op.from_tensor, arg, _ => [R.fromTensor arg.toSingle]ₕ\n | Op.to_tensor, arg, _ => [R.toTensor' arg.toSingle]ₕ\n | Op.const c, _arg, _\n | Op.const_int c, _, _\n | Op.const_idx c, _, _ => [c]ₕ"
},
{
"name": "R.fromTensor",
"content": "noncomputable def R.fromTensor {q n} (coeffs : List Int) : R q n :=\n coeffs.zipIdx.foldl (init := 0) fun res (c, i) =>\n res + R.monomial ↑c i"
},
{
"name": "R.monomial",
"content": "noncomputable def R.monomial {q n : Nat} (c : ZMod q) (i : Nat): R q n :=\n R.fromPoly (Polynomial.monomial i c)"
},
{
"name": "R.fromPoly",
"content": "abbrev R.fromPoly {q n : Nat} : (ZMod q)[X] →+* R q n := Ideal.Quotient.mk (Ideal.span {f q n})"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "R.leadingTerm",
"content": "noncomputable def R.leadingTerm {q n} (a : R q n) : R q n :=\n let deg? := Polynomial.degree a.representative\n match deg? with\n | .none => 0\n | .some deg => R.monomial (a.coeff deg) deg"
},
{
"name": "R.representative",
"content": "noncomputable def R.representative :\n R q n → (ZMod q)[X] := fun x => R.representative' q n x %ₘ (f q n)"
},
{
"name": "R.representative'",
"content": "private noncomputable def R.representative' :\n R q n → (ZMod q)[X] := Function.surjInv (R.surjective_fromPoly q n)"
},
{
"name": "R.coeff",
"content": "noncomputable def R.coeff {q n} (a : R q n) (i : Nat) : ZMod q :=\n Polynomial.coeff a.representative i"
},
{
"name": "R.toTensor'",
"content": "noncomputable def R.toTensor' {q n} (a : R q n) : List Int :=\n let t := a.toTensor\n t ++ List.replicate (2^n - t.length + 1) 0"
},
{
"name": "R.toTensor",
"content": "noncomputable def R.toTensor {q n} (a : R q n) : List Int :=\n List.range a.repLength |>.map fun i =>\n a.coeff i |>.toInt"
},
{
"name": "R.repLength",
"content": "noncomputable def R.repLength {q n} (a : R q n) : Nat := match\n Polynomial.degree a.representative with\n | none => 0\n | some d => d + 1"
},
{
"name": "",
"content": "instance : DialectDenote LLVM := ⟨\n fun o args _ => [Op.denote o args]ₕ\n⟩"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectDenote SimpleReg where\n denote\n | .const n, _, _ => BitVec.ofInt 32 n ::ₕ .nil\n | .add, [(a : BitVec 32), (b : BitVec 32)]ₕ , _ => a + b ::ₕ .nil\n | .iterate k, [(x : BitVec 32)]ₕ, [(f : _ → _)]ₕ =>\n let f := fun y => (f y).getN 0\n let f' (v : BitVec 32) : BitVec 32 := f (Ctxt.Valuation.nil.cons v)\n let y := k.iterate f' x\n [y]ₕ"
},
{
"name": "Op",
"content": "inductive Op : Type\n | add : Op\n | const : (val : ℤ) → Op\n | iterate (k : ℕ) : Op\n deriving DecidableEq"
},
{
"name": "add",
"content": "@[simp_denote]\ndef add {Γ : Ctxt _} (e₁ e₂ : Var Γ int) : Expr SimpleReg Γ .pure [int] :=\n Expr.mk\n (op := .add)\n (eff_le := by admit /- proof elided -/\n )\n (ty_eq := rfl)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "SimpleReg.int",
"content": "abbrev SimpleReg.int : SimpleReg.Ty := .int"
},
{
"name": "SimpleReg",
"content": "abbrev SimpleReg : Dialect where\n Op := Op\n Ty := Ty"
},
{
"name": "iterate",
"content": "@[simp_denote]\ndef iterate {Γ : Ctxt _} (k : Nat) (input : Var Γ int) (body : Com SimpleReg ⟨[int]⟩ .impure [int]) :\n Expr SimpleReg Γ .pure [int] :=\n Expr.mk\n (op := Op.iterate k)\n (eff_le := by admit /- proof elided -/\n )\n (ty_eq := rfl)\n (args := .cons input .nil)\n (regArgs := HVector.cons body HVector.nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n | int\n deriving DecidableEq"
},
{
"name": "[SIG",
"content": "instance [SIG : DialectSignature d] [DENOTE : DialectDenote d] {Γ : Ctxt d.Ty} {t}\n (com : Com d Γ .pure t) : Inhabited (DCEType com) where\n default :=\n ⟨Γ, Hom.id, com, by admit /- proof elided -/\n ⟩"
},
{
"name": "Hom.id",
"content": "@[simp] abbrev Hom.id {Γ : Ctxt Ty} : Γ.Hom Γ :=\n fun _ v => v"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectDenote Ex where\n denote\n | .cst n, _, _ => n ::ₕ .nil\n | .add, (a : Nat) ::ₕ b ::ₕ .nil, _ => a + b ::ₕ .nil\n | .beq, (a : Nat) ::ₕ b ::ₕ .nil, _ => (a == b) ::ₕ .nil"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq, Repr"
},
{
"name": "",
"content": "@[simp, reducible]\ninstance : DialectDenote (LLVMPlusRiscV) where\n denote\n | .llvm llvmOp, args, .nil => do\n let xs ← DialectDenote.denote llvmOp (llvmArgsFromHybrid args) .nil\n return xs.map' Ty.llvm (fun t x => x)\n | .riscv (riscvOp), args, .nil => do\n let xs ← DialectDenote.denote riscvOp (riscvArgsFromHybrid args) .nil\n return xs.map' Ty.riscv (fun t x => x)\n | .castRiscv _ , elemToCast, _ =>\n let toCast : BitVec 64 :=\n elemToCast.getN 0 (by admit /- proof elided -/\n )\n [castriscvToLLVM toCast]ₕ\n | .castLLVM _,\n (elemToCast : HVector TyDenote.toType [Ty.llvm (.bitvec _)]), _ =>\n let toCast : PoisonOr (BitVec _) :=\n elemToCast.getN 0 (by admit /- proof elided -/\n )\n [castLLVMToriscv toCast]ₕ"
},
{
"name": "Op",
"content": "inductive Op where\n | llvm : LLVM.Op -> Op\n | riscv : RISCV64.RV64.Op -> Op\n | castRiscv : Nat → Op\n | castLLVM : Nat → Op\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "castLLVMToriscv",
"content": "@[simp_riscv]\ndef castLLVMToriscv (toCast : PoisonOr (BitVec w)) : BitVec 64 :=\n BitVec.signExtend 64 (toCast.toOption.getD 0#w)"
},
{
"name": "PoisonOr",
"content": "structure PoisonOr (α : Type) where\n ofOption :: toOption : Option α\n deriving DecidableEq"
},
{
"name": "castriscvToLLVM",
"content": "@[simp_riscv]\ndef castriscvToLLVM (toCast : BitVec 64) : PoisonOr (BitVec w) :=\n .value (BitVec.signExtend w toCast)"
},
{
"name": "llvmArgsFromHybrid",
"content": "@[simp_denote]\ndef llvmArgsFromHybrid : {tys : List LLVM.Ty} →\n HVector TyDenote.toType (tys.map LLVMRiscV.Ty.llvm) → HVector TyDenote.toType tys\n | [], .nil => .nil\n | _ :: _, .cons x xs => .cons x (llvmArgsFromHybrid xs)"
},
{
"name": "Ty",
"content": "inductive Ty where\n | llvm : LLVM.Ty -> Ty\n | riscv : RISCV64.RV64.Ty -> Ty\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "riscvArgsFromHybrid",
"content": "@[simp_denote]\ndef riscvArgsFromHybrid : {tys : List RISCV64.RV64.Ty} →\n HVector TyDenote.toType (tys.map LLVMRiscV.Ty.riscv) → HVector TyDenote.toType tys\n | [], .nil => .nil\n | _ :: _, .cons x xs => .cons x (riscvArgsFromHybrid xs)"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectDenote ExOp ExTy where\n denote\n | .cst n, _, _ => n\n | .add, .cons (a : Nat) (.cons b .nil), _ => a + b\n | .beq, .cons (a : Nat) (.cons b .nil), _ => a == b"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | beq : ExOp\n | cst : ℕ → ExOp\n deriving DecidableEq, Repr"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .nat) : Expr Γ .nat :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := EffectKind.le_refl _)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n deriving DecidableEq, Repr"
},
{
"name": "Expr",
"content": "abbrev Expr (Γ) (ty) := _root_.Expr ExOp Γ .pure ty"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Γ .nat :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := EffectKind.le_refl _)\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectDenote ExOp ExTy where\n denote\n | .add, .cons (a : Nat) (.cons b .nil), _ => a + b\n | .runK (k : Nat), (.cons (v : Nat) .nil), (.cons rgn _nil) =>\n k.iterate (fun val => rgn (fun _ty _var => val)) v"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | runK : ℕ → ExOp\n deriving DecidableEq, Repr"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .nat) : Expr Γ .nat :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := EffectKind.pure_le _)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "[Monad",
"content": "@[reducible]\ninstance [Monad d.m] : DialectDenote (Scf d) where\n denote\n | .coe o', args', regArgs' =>\n let denote' := DialectDenote.denote o'\n by\n exact denote' args' regArgs'\n | .if t t', (.cons (cond ) (.cons v .nil)),\n (.cons (f : Ctxt.Valuation ⟨[t]⟩ → d.m (HVector toType [t'])) (.cons (g : _ → _) .nil)) =>\n let body := if B.denote_eq ▸ cond then f else g\n body (Ctxt.Valuation.nil.cons v)\n | .run _t, (.cons v .nil), (.cons (f : _ → _) .nil) =>\n f (Ctxt.Valuation.nil.cons v)\n | .for ty, (.cons istart (.cons istep (.cons niter (.cons vstart .nil)))),\n (.cons (f : _ → _) .nil) => do\n let istart : ℤ := Z.denote_eq ▸ istart\n let istep : ℤ := Z.denote_eq ▸ istep\n let niter : ℕ := N.denote_eq ▸ niter\n let f' : LoopBody (d.m ⟦ty⟧) := fun i v => do\n let v ← v\n let i := Z.denote_eq.symm ▸ i\n let xs ← f (Valuation.ofPair i v)\n return xs.get (0 : Fin 1)\n let to_iterate := f'.counterDecorator (α := d.m ⟦ty⟧) (δ := istep)\n let loop_fn := niter.iterate (op := to_iterate)\n let x ← (loop_fn (istart, pure vstart)).2\n return [x]ₕ\n\n | .iterate k, (.cons (x) .nil), (.cons (f : _ → _) .nil) => do\n let x : ℤ := Z.denote_eq ▸ x\n let coe : ℤ = toType Z.ty := Z.denote_eq.symm\n let f' (v : d.m ℤ) : d.m ℤ := do\n let v ← v\n let xs ← f (Ctxt.Valuation.nil.cons (cast coe v))\n let x := xs.getN 0\n return coe ▸ x\n let y ← (k.iterate f' (pure x))\n return [cast Z.denote_eq.symm y]ₕ"
},
{
"name": "counterDecorator",
"content": "def counterDecorator (δ : Int) (f : LoopBody α) : Int × α → Int × α :=\n fun (i, v) => (i + δ, f i v)"
},
{
"name": "Scf.Op",
"content": "inductive Scf.Op (Op' Ty' : Type) (m') [TyDenote Ty'] [DialectSignature ⟨Op', Ty', m'⟩]\n [DialectDenote ⟨Op', Ty', m'⟩] : Type _\n | coe (o : Op')\n | iterate (k : ℕ) \n | run (inputty : Ty') \n | if (inputty retty' : Ty') \n | for (ty : Ty')\n deriving DecidableEq, Repr"
},
{
"name": "HasTy",
"content": "class HasTy (d : Dialect) (DenotedTy : Type) [TyDenote d.Ty] [DialectSignature d] where\n ty : d.Ty\n denote_eq : toType ty = DenotedTy := by admit /- proof elided -/"
},
{
"name": "LoopBody",
"content": "abbrev LoopBody (t : Type) : Type := Int → t → t"
},
{
"name": "iterate",
"content": "@[simp_denote] def iterate {Γ : Ctxt _} (k : Nat) (input : Var Γ Arith.Ty.int)\n (body : Com ScfArith ⟨[.int]⟩ .impure .int) : Expr ScfArith Γ .impure .int :=\n Expr.mk\n (op := .iterate k)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons input .nil)\n (regArgs := HVector.cons body HVector.nil)"
},
{
"name": "ScfArith",
"content": "abbrev ScfArith := Scf Arith"
},
{
"name": "Scf",
"content": "def Scf (d : Dialect) [TyDenote d.Ty] [DialectSignature d] [DialectDenote d] : Dialect where\n Op := Scf.Op d.Op d.Ty d.m\n Ty := d.Ty\n m := d.m"
},
{
"name": "Op",
"content": "inductive Op\n | add : Op \n | add_nat : Op \n | axpy : Op \n | neg : Op \n | const : (val : ℤ) → Op\n | const_nat : (val : ℕ) → Op"
},
{
"name": "run",
"content": "@[simp_denote]\ndef run {Γ : Ctxt _} {t : Arith.Ty} (v : Var Γ t) (body : Com ScfArith ⟨[t]⟩ .impure t) :\n Expr ScfArith Γ .impure t :=\n Expr.mk\n (op := .run t)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons v .nil)\n (regArgs := HVector.cons body <| HVector.nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n| int\n| bool\n| nat\n deriving DecidableEq, Repr"
},
{
"name": "neg",
"content": "@[simp_denote] def neg {Γ : Ctxt _} (a : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .neg)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "axpy",
"content": "@[simp_denote] def axpy {Γ : Ctxt _} (a : Var Γ .int) (x : Var Γ .nat) (b: Var Γ .int) :\n Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .axpy)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons x <| .cons b .nil)\n (regArgs := .nil)"
},
{
"name": "add_nat",
"content": "@[simp_denote] def add_nat (e₁ e₂ : Var Γ .nat) : Expr ScfArith Γ .pure .nat :=\n Expr.mk\n (op := .coe <| .add_nat)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n | int\n \n | int2\n deriving DecidableEq, Lean.ToExpr"
},
{
"name": "Op",
"content": "inductive Op\n | noop\n | mkPair\n | unPair\n deriving Lean.ToExpr"
},
{
"name": "Arith",
"content": "abbrev Arith : Dialect := {Op, Ty}"
},
{
"name": "Valuation.ofPair",
"content": "def Valuation.ofPair {t₁ t₂ : Ty} (v₁: ⟦t₁⟧) (v₂ : ⟦t₂⟧) :\n Valuation (Ctxt.ofList [t₁, t₂]) :=\n Valuation.ofHVector (.cons v₁ <| .cons v₂ <| .nil )"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectDenote Arith where\n denote\n | .const n, _, _ => [n]ₕ\n | .const_nat n, _, _ => [n]ₕ\n | .neg, .cons (a : ℤ ) .nil, _ => [-a]ₕ\n | .axpy, .cons (a : ℤ) (.cons (x : ℕ) (.cons (b : ℤ) .nil)), _ => [a * (x : ℤ) + b]ₕ\n | .add, .cons (a : ℤ) (.cons (b : ℤ) .nil), _ => [a + b]ₕ\n | .add_nat, .cons (a : ℕ) (.cons (b : ℕ) .nil), _ => [a + b]ₕ"
},
{
"name": "add",
"content": "@[simp_denote] def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)\n\n instance : DialectSignature $dialect where\n signature := fun op => match op with $matchAlts:matchAlts\n )"
},
{
"name": "Op.signature",
"content": "@[simp, reducible]\ndef Op.signature : Op q n → Signature (Ty q n) :=\n fun o => {sig := Op.sig o, returnTypes := [Op.outTy o], regSig := []}"
},
{
"name": "Op.sig",
"content": "@[simp, reducible]\ndef Op.sig : Op q n → List (Ty q n)\n| Op.add => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.sub => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.mul => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.mul_constant => [Ty.polynomialLike, Ty.integer]\n| Op.leading_term => [Ty.polynomialLike]\n| Op.monomial => [Ty.integer, Ty.index]\n| Op.monomial_mul => [Ty.polynomialLike, Ty.index]\n| Op.from_tensor => [Ty.tensor]\n| Op.to_tensor => [Ty.polynomialLike]\n| Op.const _ => []\n| Op.const_int _ => []\n| Op.const_idx _ => []"
},
{
"name": "Op.outTy",
"content": "@[simp, reducible]\ndef Op.outTy : Op q n → Ty q n\n| Op.add | Op.sub | Op.mul | Op.mul_constant | Op.leading_term | Op.monomial\n| Op.monomial_mul | Op.from_tensor | Op.const _ => Ty.polynomialLike\n| Op.to_tensor => Ty.tensor\n| Op.const_int _ => Ty.integer\n| Op.const_idx _ => Ty.index"
},
{
"name": "Op.regSig",
"content": "@[reducible, simp]\ndef Op.regSig : Op → RegionSignature Ty\n | .map2d => [([Ty.int], [.int])]\n | _ => []"
},
{
"name": "",
"content": "instance : DialectSignature Ex where\n signature\n | .add => ⟨[.nat, .nat], [], [.nat], .pure⟩\n | .beq => ⟨[.nat, .nat], [], [.bool], .pure⟩\n | .cst _ => ⟨[], [], [.nat], .pure⟩"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectSignature Tensor2D where\n signature op := { sig := op.sig, regSig := op.regSig, returnTypes := [op.outTy] }"
},
{
"name": "",
"content": "instance : DialectSignature Tensor1D where\n signature op := { sig := op.sig, regSig := op.regSig, returnTypes := [op.outTy], effectKind := .pure }"
},
{
"name": "",
"content": "instance : DialectSignature RV64 where\n signature o := {sig := Op.sig o, returnTypes := [Op.outTy o], regSig := []}"
},
{
"name": "Op.sig",
"content": "@[simp, reducible]\ndef Op.sig : Op → List Ty\n | .li _ => []\n | .mulh => [Ty.bv, Ty.bv]\n | .mulhu => [Ty.bv, Ty.bv]\n | .mulhsu => [Ty.bv, Ty.bv]\n | .divu => [Ty.bv, Ty.bv]\n | .remuw => [Ty.bv, Ty.bv]\n | .remu => [Ty.bv, Ty.bv]\n | .addiw (_imm : BitVec 12) => [Ty.bv]\n | .lui (_imm : BitVec 20) => [Ty.bv]\n | .auipc (_imm : BitVec 20) => [Ty.bv]\n | .slliw (_shamt : BitVec 5) => [Ty.bv]\n | .srliw (_shamt : BitVec 5) => [Ty.bv]\n | .sraiw (_shamt : BitVec 5) => [Ty.bv]\n | .slli (_shamt : BitVec 6) => [Ty.bv]\n | .srli (_shamt : BitVec 6) => [Ty.bv]\n | .srai (_shamt : BitVec 6) => [Ty.bv]\n | .addw => [Ty.bv, Ty.bv]\n | .subw => [Ty.bv, Ty.bv]\n | .sllw => [Ty.bv, Ty.bv]\n | .srlw => [Ty.bv, Ty.bv]\n | .sraw => [Ty.bv, Ty.bv]\n | .add => [Ty.bv, Ty.bv]\n | .slt => [Ty.bv, Ty.bv]\n | .sltu => [Ty.bv, Ty.bv]\n | .and => [Ty.bv, Ty.bv]\n | .or => [Ty.bv, Ty.bv]\n | .xor => [Ty.bv, Ty.bv]\n | .sll => [Ty.bv, Ty.bv]\n | .srl => [Ty.bv, Ty.bv]\n | .sub => [Ty.bv, Ty.bv]\n | .sra => [Ty.bv, Ty.bv]\n | .remw => [Ty.bv, Ty.bv]\n | .rem => [Ty.bv, Ty.bv]\n | .mul => [Ty.bv, Ty.bv]\n | .mulw => [Ty.bv, Ty.bv]\n | .div => [Ty.bv, Ty.bv]\n | .divw => [Ty.bv, Ty.bv]\n | .divuw => [Ty.bv, Ty.bv]\n | .addi (_imm : BitVec 12) => [Ty.bv]\n | .slti (_imm : BitVec 12) => [Ty.bv]\n | .sltiu (_imm : BitVec 12) => [Ty.bv]\n | .andi (_imm : BitVec 12) => [Ty.bv]\n | .ori (_imm : BitVec 12) => [Ty.bv]\n | .xori (_imm : BitVec 12) => [Ty.bv]\n | .bclr => [Ty.bv, Ty.bv]\n | .bext => [Ty.bv, Ty.bv]\n | .binv => [Ty.bv, Ty.bv]\n | .bset => [Ty.bv, Ty.bv]\n | .bclri (_shamt : BitVec 6) => [Ty.bv]\n | .bexti (_shamt : BitVec 6) => [Ty.bv]\n | .binvi (_shamt : BitVec 6) => [Ty.bv]\n | .bseti (_shamt : BitVec 6) => [Ty.bv]\n | .adduw => [Ty.bv, Ty.bv]\n | .sh1adduw => [Ty.bv, Ty.bv]\n | .sh2adduw => [Ty.bv, Ty.bv]\n | .sh3adduw => [Ty.bv, Ty.bv]\n | .sh1add => [Ty.bv, Ty.bv]\n | .sh2add => [Ty.bv, Ty.bv]\n | .sh3add => [Ty.bv, Ty.bv]\n | .slliuw (_shamt : BitVec 6) => [Ty.bv]\n | .andn => [Ty.bv, Ty.bv]\n | .orn => [Ty.bv, Ty.bv]\n | .xnor => [Ty.bv, Ty.bv]\n | .clz\n | .clzw\n | .ctz\n | .ctzw\n | .max => [Ty.bv, Ty.bv]\n | .maxu => [Ty.bv, Ty.bv]\n | .min => [Ty.bv, Ty.bv]\n | .minu => [Ty.bv, Ty.bv]\n | .sextb => [Ty.bv]\n | .sexth => [Ty.bv]\n | .zexth => [Ty.bv]\n | .rol => [Ty.bv, Ty.bv]\n | .rolw => [Ty.bv, Ty.bv]\n | .ror => [Ty.bv, Ty.bv]\n | .rori (_shamt : BitVec 6) =>[Ty.bv]\n | .roriw (_shamt : BitVec 5) =>[Ty.bv]\n | .rorw => [Ty.bv, Ty.bv]\n | .pack => [Ty.bv, Ty.bv]\n | .packh => [Ty.bv, Ty.bv]\n | .packw => [Ty.bv, Ty.bv]\n | .mv => [Ty.bv]\n | .not => [Ty.bv]\n | .neg => [Ty.bv]\n | .negw => [Ty.bv]\n | .sextw => [Ty.bv]\n | .zextb => [Ty.bv]\n | .zextw => [Ty.bv]\n | .seqz => [Ty.bv]\n | .snez => [Ty.bv]\n | .sltz => [Ty.bv]\n | .sgtz => [Ty.bv]"
},
{
"name": "",
"content": "instance : DialectSignature (FHE q n) := ⟨Op.signature⟩"
},
{
"name": "",
"content": "instance : DialectSignature LLVM where\n signature op := ⟨op.sig, [], [op.outTy], .pure⟩"
},
{
"name": "",
"content": "instance : DialectSignature HSxComb where\n signature := fun op =>\n match op with\n | .comb o => liftSig (signature o) \n \n \n | .hs o => MLIR2Handshake.instDialectSignatureHandshake.signature o"
},
{
"name": "Op",
"content": "inductive Op : Type _\n | comb (o : MLIR2Comb.Comb.Op)\n | hs (o : MLIR2Handshake.Handshake.Op)\n deriving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "liftSig",
"content": "def liftSig (sig : Signature MLIR2Comb.Ty) : Signature MLIR2Handshake.Ty :=\n Signature.mk (sig.sig.map liftTy) [] (liftTy sig.outTy)"
},
{
"name": "liftTy",
"content": "def liftTy : MLIR2Comb.Ty → MLIR2Handshake.Ty\n| .bitvec w => .stream (.bitvec w)"
},
{
"name": "Ty",
"content": "inductive Ty\n| stream (ty2 : Ty2) : Ty \n| stream2 (ty2 : Ty2) : Ty \n| stream2token (ty2 : Ty2) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty\n| bitvec (w : Nat) : Ty \nderiving DecidableEq, Repr, ToExpr"
},
{
"name": "Ty2",
"content": "inductive Ty2\n | bitvec (w : Nat) : Ty2\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "map",
"content": "def map {α β : Type} (s : Stream α) (f : α → β) : Stream β :=\n fun i => (s i).map f"
},
{
"name": "Stream",
"content": "def Stream (β : Type) := Stream' (Option β)"
},
{
"name": "",
"content": "instance : DialectSignature DCxComb where\n signature := fun op =>\n match op with\n | .comb o => liftSig (signature o) \n \n \n | .dc o => MLIR2DC.instDialectSignatureDC.signature o"
},
{
"name": "Op",
"content": "inductive Op : Type _\n | comb (o : MLIR2Comb.Comb.Op)\n | dc (o : MLIR2DC.DC.Op)\n deriving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "liftSig",
"content": "def liftSig (sig : Signature MLIR2Comb.Ty) : Signature MLIR2DC.Ty :=\n Signature.mk (sig.sig.map liftTy) [] (liftTy sig.outTy)"
},
{
"name": "liftTy",
"content": "def liftTy : MLIR2Comb.Ty → MLIR2DC.Ty\n| .bitvec w => .valuestream w"
},
{
"name": "Ty",
"content": "inductive Ty\n| tokenstream : Ty\n| tokenstream2 : Ty\n| valuestream (w : Nat) : Ty \n| valuestream2 (w : Nat) : Ty \n| valuetokenstream (w : Nat) : Ty \n| variadicvaluetokenstream (w : Nat) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "LLVMPlusRiscVSignature",
"content": "@[simp]\ninstance LLVMPlusRiscVSignature : DialectSignature LLVMPlusRiscV where\n signature\n | .llvm llvmOp => .llvm <$> DialectSignature.signature llvmOp\n | .riscv riscvOp => .riscv <$> DialectSignature.signature riscvOp\n | .castRiscv w =>\n {sig := [Ty.riscv .bv], returnTypes := [Ty.llvm (.bitvec w)], regSig := []}\n | .castLLVM w =>\n {sig := [Ty.llvm (.bitvec w)], returnTypes := [Ty.riscv .bv], regSig := []}"
},
{
"name": "",
"content": "instance : DialectSignature ExOp ExTy where\n signature\n | .add => ⟨[.nat, .nat], [], .nat, .pure⟩\n | .beq => ⟨[.nat, .nat], [], .bool, .pure⟩\n | .cst _ => ⟨[], [], .nat, .pure⟩"
},
{
"name": "",
"content": "instance : DialectSignature ExOp ExTy where\n signature\n | .add => ⟨[.nat, .nat], [], .nat, .pure⟩\n | .runK _ => ⟨[.nat], [([.nat], .nat)], .nat, .pure⟩"
},
{
"name": "[TyDenote",
"content": "@[reducible]\ninstance [TyDenote d.Ty] [DialectSignature d] [DialectDenote d]\n [B : HasBool d] [N : HasNat d] [I : HasInt d] : DialectSignature (Scf d) where\n signature\n | .coe o => signature (d:=d) o\n | .if t t' => ⟨[B.ty, t], [(⟨[t]⟩, [t']), (⟨[t]⟩, [t'])], [t'], .impure⟩\n \n \n \n \n \n | .for t => ⟨[ I.ty, I.ty, N.ty, t], [(⟨[I.ty, t]⟩, [t])], [t], .impure⟩\n | .run t => ⟨[t], [(⟨[t]⟩, [t])], [t], .impure⟩\n | .iterate _k => ⟨[I.ty], [(⟨[I.ty]⟩, [I.ty])], [I.ty], .impure⟩"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectSignature Arith where\n signature\n | .axpy => ⟨[.int, .nat, .int], [], [.int], .pure⟩\n | .neg => ⟨[.int], [], [.int], .pure⟩\n | .const _ => ⟨[], [], [.int], .pure⟩\n | .const_nat _ => ⟨[], [], [.nat], .pure⟩\n | .add => ⟨[.int, .int], [], [.int], .pure⟩\n | .add_nat => ⟨[.nat, .nat], [], [.nat], .pure⟩"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "pure_liftEffect",
"content": "@[simp]\ntheorem pure_liftEffect {eff₁ eff₂ : EffectKind}\n (hle : eff₁ ≤ .pure) [Monad m] (x : eff₁.toMonad m α) :\n (Pure.pure (liftEffect hle x) : eff₂.toMonad m α)\n = liftEffect (by cases hle; constructor) x"
},
{
"name": "eq_of_le_pure",
"content": "@[simp]\ntheorem eq_of_le_pure {e : EffectKind}\n (he : e ≤ pure) : e = pure"
},
{
"name": "pure_map",
"content": "theorem pure_map (f : α → β) (x : pure.toMonad m α) (eff : EffectKind) :\n (Pure.pure (f <$> x : pure.toMonad m _) : eff.toMonad m _) = f <$> (Pure.pure x)"
}
] | [
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "Signature.mk",
"content": "abbrev Signature.mk (sig : List Ty) (regSig : RegionSignature Ty) (returnTypes : List Ty) : Signature Ty :=\n { sig, regSig, returnTypes }"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "DialectSignature.sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "DialectSignature.regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "DialectSignature.returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "DialectSignature.effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Expr",
"content": "inductive Expr : (Γ : Ctxt d.Ty) → (eff : EffectKind) → (ty : List d.Ty) → Type where\n | mk {Γ} {ty} (op : d.Op)\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) <| DialectSignature.sig op)\n \n (regArgs : HVector (fun t : Ctxt d.Ty × List d.Ty => Com t.1 .impure t.2)\n (DialectSignature.regSig op)) : Expr Γ eff ty"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "HVector",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Expr",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Com.decidableEq",
"content": "protected instance Com.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty]\n {Γ : Ctxt d.Ty} {eff : EffectKind} {tys : List d.Ty} : DecidableEq (Com d Γ eff tys)\n | .rets v₁, .rets v₂ => decidable_of_iff (v₁ = v₂) (by admit /- proof elided -/\n )\n | .var (ty := ty₁) e₁ body₁, .var (ty := ty₂) e₂ body₂ =>\n if hα : ty₁ = ty₂\n then by\n subst hα\n letI := Expr.decidableEq e₁ e₂\n letI := Com.decidableEq body₁ body₂\n exact decidable_of_iff (e₁ = e₂ ∧ body₁ = body₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )\n | .rets _, .var _ _ => isFalse (fun h => Com.noConfusion h)\n | .var _ _, .rets _ => isFalse (fun h => Com.noConfusion h)"
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r)"
},
{
"name": "HVector.denote",
"content": "def HVector.denote :\n {l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →\n HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l\n | _, .nil => HVector.nil\n | _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)"
},
{
"name": "Expr.denote",
"content": "def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :\n eff.toMonad d.m (e.outContext.Valuation) :=\n match e with\n | ⟨op, ty_eq, heff, args, regArgs⟩ => do\n let argsDenote := args.map V\n let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote\n return (val ++ V).cast (by admit /- proof elided -/\n )"
},
{
"name": "Com.denote",
"content": "def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →\n eff.toMonad d.m (HVector toType ty)\n | .rets vs, Γv => pure (vs.map Γv)\n | .var e body, V => e.denote V >>= body.denote"
},
{
"name": "Lets.denote",
"content": "def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}\n (lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=\n match lets with\n | .nil => return V\n | .var lets' e => lets'.denote V >>= e.denote"
},
{
"name": "Expr.denoteOp",
"content": "def Expr.denoteOp (e : Expr d Γ eff ty) (V : Γ.Valuation) :\n eff.toMonad d.m (HVector toType ty) :=\n EffectKind.liftEffect e.eff_le <| cast (by admit /- proof elided -/\n ) <|\n DialectDenote.denote e.op (e.args.map V) e.regArgs.denote"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "FlatCom.denote",
"content": "@[simp] abbrev FlatCom.denote [DialectDenote d]\n (flatCom : FlatCom d Γ eff Γ_out ts)\n (V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=\n flatCom.lets.denote V >>= (return flatCom.rets.map ·)"
},
{
"name": "Expr.changeEffect",
"content": "def Expr.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Expr d Γ eff₁ t → Expr d Γ eff₂ t\n | Expr.mk op ty_eq eff_le args regArgs =>\n have heff : DialectSignature.effectKind op ≤ eff₂ := by admit /- proof elided -/"
},
{
"name": "Expr.castPureToEff",
"content": "def Expr.castPureToEff (eff : EffectKind) : Expr d Γ .pure t → Expr d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
}
] | [
{
"name": "Expr.op_mk",
"content": "@[simp]\ntheorem Expr.op_mk {Γ : Ctxt d.Ty} {ty} {eff : EffectKind} (op : d.Op)\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op))\n (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).op = op"
},
{
"name": "Expr.args_mk",
"content": "@[simp]\ntheorem Expr.args_mk {Γ : Ctxt d.Ty} {ty eff op}\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op)) (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).args = args"
},
{
"name": "Expr.regArgs_mk",
"content": "@[simp]\ntheorem Expr.regArgs_mk {Γ : Ctxt d.Ty} {ty eff op}\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) (DialectSignature.sig op)) (regArgs) :\n (Expr.mk op ty_eq eff_le args regArgs).regArgs = regArgs"
},
{
"name": "Expr.denote_unfold",
"content": "theorem Expr.denote_unfold (e : Expr d Γ eff ty) :\n e.denote = fun V => (· ++ V) <$> (e.denoteOp V)"
}
] | import LeanMLIR.ErasedContext
import LeanMLIR.HVector
import LeanMLIR.EffectKind
import LeanMLIR.Framework.Dialect
import Mathlib.Data.Finset.Union
open Ctxt (Var VarSet Valuation Hom)
open TyDenote (toType)
abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)
structure Signature (Ty : Type) where
mkEffectful ::
sig : List Ty
regSig : RegionSignature Ty
returnTypes : List Ty
effectKind : EffectKind := .pure
abbrev Signature.mk (sig : List Ty) (regSig : RegionSignature Ty) (returnTypes : List Ty) : Signature Ty :=
{ sig, regSig, returnTypes }
class DialectSignature (d : Dialect) where
signature : d.Op → Signature d.Ty
namespace DialectSignature
variable {d} [s : DialectSignature d]
def sig := Signature.sig ∘ s.signature
def regSig := Signature.regSig ∘ s.signature
def returnTypes := Signature.returnTypes ∘ s.signature
def effectKind := Signature.effectKind ∘ s.signature
end DialectSignature
class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where
denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →
(HVector (fun t : Ctxt d.Ty × List d.Ty =>
t.1.Valuation
→ EffectKind.impure.toMonad d.m (HVector toType t.2))
(DialectSignature.regSig op)) →
((DialectSignature.effectKind op).toMonad d.m
(HVector toType <| DialectSignature.returnTypes op))
section DataStructures
variable (d : Dialect) [DialectSignature d]
inductive Expr : (Γ : Ctxt d.Ty) → (eff : EffectKind) → (ty : List d.Ty) → Type where
| mk {Γ} {ty} (op : d.Op)
(ty_eq : ty = DialectSignature.returnTypes op)
(eff_le : DialectSignature.effectKind op ≤ eff)
(args : HVector (Var Γ) <| DialectSignature.sig op)
(regArgs : HVector (fun t : Ctxt d.Ty × List d.Ty => Com t.1 .impure t.2)
(DialectSignature.regSig op)) : Expr Γ eff ty
inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where
| rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys
| var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β
end
abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=
ts ++ Γ
abbrev Regions (regSig : RegionSignature d.Ty) : Type :=
HVector (fun t => Com d t.1 .impure t.2) regSig
inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :
(Γ_out : Ctxt d.Ty) → Type where
| nil : Lets Γ_in eff Γ_in
| var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext
variable {d} [DialectSignature d]
protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :
∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)
| _, .nil, .nil => isTrue rfl
| _, .cons x₁ v₁, .cons x₂ v₂ =>
letI := HVector.decidableEqReg v₁ v₂
letI := Com.decidableEq x₁ x₂
decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/
)
protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :
{Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)
| Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>
if ho : op₁ = op₂ then by
subst ho
letI := HVector.decidableEq arg₁ arg₂
letI := HVector.decidableEqReg regArgs₁ regArgs₂
exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/
)
else isFalse (by admit /- proof elided -/
)
protected instance Com.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty]
{Γ : Ctxt d.Ty} {eff : EffectKind} {tys : List d.Ty} : DecidableEq (Com d Γ eff tys)
| .rets v₁, .rets v₂ => decidable_of_iff (v₁ = v₂) (by admit /- proof elided -/
)
| .var (ty := ty₁) e₁ body₁, .var (ty := ty₂) e₂ body₂ =>
if hα : ty₁ = ty₂
then by
subst hα
letI := Expr.decidableEq e₁ e₂
letI := Com.decidableEq body₁ body₂
exact decidable_of_iff (e₁ = e₂ ∧ body₁ = body₂) (by admit /- proof elided -/
)
else isFalse (by admit /- proof elided -/
)
| .rets _, .var _ _ => isFalse (fun h => Com.noConfusion h)
| .var _ _, .rets _ => isFalse (fun h => Com.noConfusion h)
end -- decEq
end DataStructures
variable {d : Dialect} [DialectSignature d]
section Rec
variable {eff t} {motive : ∀ {Γ}, Com d Γ eff t → Sort u}
(rets : ∀ {Γ : Ctxt _} , (v : HVector Γ.Var t) → motive (Com.rets v))
(var : ∀ {Γ} {u},
(e : Expr d Γ eff u) → (body : Com d e.outContext eff t) →
motive body → motive (Com.var e body))
def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=
Com.rec
(motive_1 := fun _ _ _ _ => PUnit)
(motive_2 := fun _ eff' t' c =>
(h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))
(motive_3 := fun _ _ => PUnit)
(fun _ _ _ _ _ _ => ⟨⟩)
(fun v h₁ h₂ =>
cast (by admit /- proof elided -/
) <| rets (h₂ ▸ v))
(fun e' body' _ r' h₁ h₂ =>
let e := h₁ ▸ e'
let body : Com _ _ eff t := cast (by admit /- proof elided -/
) body'
let r : motive body := cast (by admit /- proof elided -/
) (r' h₁ h₂)
cast (by admit /- proof elided -/
) <| var e body r)
⟨⟩
(fun _ _ _ _ => ⟨⟩)
com
rfl
rfl
variable {rets} {var} {Γ : Ctxt _}
end Rec
def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=
Expr.casesOn e (fun op _ _ _ _ => op)
def Expr.args {Γ ts} (e : Expr d Γ eff ts) :
HVector (Var Γ) (DialectSignature.sig e.op) :=
Expr.casesOn e (fun _ _ _ args _ => args)
def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :
Regions d (DialectSignature.regSig e.op) :=
Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)
section Lemmas
namespace Com
end Com
end Lemmas
def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=
Com.rec' (motive := fun _ => Ctxt d.Ty)
(@fun Γ _ => Γ)
(fun _ _ r => r)
section Lemmas
end Lemmas
variable [TyDenote d.Ty] [DialectDenote d] [DecidableEq d.Ty] [Monad d.m] [LawfulMonad d.m]
def HVector.denote :
{l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →
HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l
| _, .nil => HVector.nil
| _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)
def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :
eff.toMonad d.m (e.outContext.Valuation) :=
match e with
| ⟨op, ty_eq, heff, args, regArgs⟩ => do
let argsDenote := args.map V
let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote
return (val ++ V).cast (by admit /- proof elided -/
)
def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →
eff.toMonad d.m (HVector toType ty)
| .rets vs, Γv => pure (vs.map Γv)
| .var e body, V => e.denote V >>= body.denote
end
def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}
(lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=
match lets with
| .nil => return V
| .var lets' e => lets'.denote V >>= e.denote
section Unfoldings
open EffectKind (liftEffect)
def Expr.denoteOp (e : Expr d Γ eff ty) (V : Γ.Valuation) :
eff.toMonad d.m (HVector toType ty) :=
EffectKind.liftEffect e.eff_le <| cast (by admit /- proof elided -/
) <|
DialectDenote.denote e.op (e.args.map V) e.regArgs.denote
end Unfoldings
section Lemmas
end Lemmas
section Lemmas
variable {Γ Γ' : Ctxt d.Ty} {t} (f : Γ.Hom Γ') (e : Expr d Γ eff t) (V : Γ'.Valuation)
end Lemmas
structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)
(Γ_out : Ctxt d.Ty) (ts : List d.Ty) where
lets : Lets d Γ_in eff Γ_out
rets : HVector Γ_out.Var ts
@[simp] abbrev FlatCom.denote [DialectDenote d]
(flatCom : FlatCom d Γ eff Γ_out ts)
(V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=
flatCom.lets.denote V >>= (return flatCom.rets.map ·)
def Expr.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :
Expr d Γ eff₁ t → Expr d Γ eff₂ t
| Expr.mk op ty_eq eff_le args regArgs =>
have heff : DialectSignature.effectKind op ≤ eff₂ := by admit /- proof elided -/
def Expr.castPureToEff (eff : EffectKind) : Expr d Γ .pure t → Expr d Γ eff t :=
changeEffect (EffectKind.pure_le eff)
section Lemmas | @[simp] theorem Expr.denote_castPureToEff {e : Expr d Γ .pure t} :
denote (e.castPureToEff eff) = fun V => pure (e.denote V) := | := by
rcases e with ⟨op, rfl, eff_le, _, _⟩
cases eff
case pure => rfl
case impure =>
funext V
simp only [castPureToEff, changeEffect, denote_unfold, denoteOp, op_mk, args_mk, regArgs_mk,
EffectKind.pure_map, EffectKind.pure_liftEffect] | 6 | 69 | false | Compiler |
340 | CIRCTStream.Stream.removeNone_equiv | theorem removeNone_equiv (x : Stream α) :
x.removeNone ~ x | lean-mlir | SSA/Projects/CIRCT/Stream/WeakBisim.lean | [
"import SSA.Projects.CIRCT.Stream.Stream",
"import Mathlib.Data.Stream.Init",
"import Mathlib.Logic.Function.Iterate"
] | [
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Stream'",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Stream'.const",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Stream'.head",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Nat.strongRecOn",
"module": "Init.WF"
},
{
"name": "Stream'.drop",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Stream'.get",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Stream'.tail",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Stream'.corec",
"module": "Mathlib.Data.Stream.Defs"
}
] | [
{
"name": "syntax \"neg\" : MLIR.Pretty.uniform_op",
"content": "syntax \"neg\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "Stream",
"content": "def Stream (β : Type) := Stream' (Option β)"
},
{
"name": "head",
"content": "def head : Stream α → Option α := Stream'.head"
},
{
"name": "tail",
"content": "def tail : Stream α → Stream α := Stream'.tail"
},
{
"name": "corec",
"content": "def corec {α} {β} (s0 : β) (f : β → (Option α × β)) : Stream α :=\n Stream'.corec (f · |>.fst) (f · |>.snd) s0"
}
] | [
{
"name": "Nat.not_lt_zero",
"module": "Init.Prelude"
},
{
"name": "Nat.zero_add",
"module": "Init.Data.Nat.Basic"
},
{
"name": "false_implies",
"module": "Init.SimpLemmas"
},
{
"name": "implies_true",
"module": "Init.SimpLemmas"
},
{
"name": "ne_eq",
"module": "Init.SimpLemmas"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "CIRCTStream.Stream.stuck",
"content": "def stuck (α : Type) : Stream α := Stream'.const none"
},
{
"name": "CIRCTStream.Stream.nonesUntilSome",
"content": "noncomputable def nonesUntilSome (x : Stream α) (not_stuck : x ≠ stuck α) : Nat :=\n prop.choose\nwhere\n prop : ∃ i, (x.drop i).head.isSome ∧ ∀ j < i, x.get j = none := by admit /- proof elided -/"
},
{
"name": "CIRCTStream.Stream.dropLeadingNones",
"content": "noncomputable def dropLeadingNones (x : Stream α) (not_stuck : x ≠ stuck α) : Stream α:=\n x.drop (nonesUntilSome x not_stuck)"
},
{
"name": "CIRCTStream.Stream.removeNone",
"content": "noncomputable def removeNone (x : Stream α) : Stream α :=\n Stream.corec x fun x =>\n if h : x ≠ stuck α then\n let x := x.dropLeadingNones h\n (x.head, x.tail)\n else\n (none, x)"
}
] | [
{
"name": "CIRCTStream.Stream.nonesUntilSome_spec",
"content": "theorem nonesUntilSome_spec (x : Stream α) (not_stuck : x ≠ stuck α) :\n (dropLeadingNones x not_stuck).head.isSome\n ∧ ∀ j < nonesUntilSome x not_stuck, x.get j = none"
},
{
"name": "CIRCTStream.Stream.head_removeNone",
"content": "@[simp] theorem head_removeNone (x : Stream α) :\n x.removeNone.head =\n if h : x ≠ stuck α then\n (x.dropLeadingNones h).head\n else\n none"
}
] | import SSA.Projects.CIRCT.Stream.Stream
import Mathlib.Logic.Function.Iterate
import Mathlib.Data.Stream.Init
namespace CIRCTStream
namespace Stream
namespace Bisim
scoped infix:50 " ~ " => Bisim
end Bisim
open Bisim
def stuck (α : Type) : Stream α := Stream'.const none
noncomputable def nonesUntilSome (x : Stream α) (not_stuck : x ≠ stuck α) : Nat :=
prop.choose
where
prop : ∃ i, (x.drop i).head.isSome ∧ ∀ j < i, x.get j = none := by admit /- proof elided -/
noncomputable def dropLeadingNones (x : Stream α) (not_stuck : x ≠ stuck α) : Stream α:=
x.drop (nonesUntilSome x not_stuck)
open Classical in
noncomputable def removeNone (x : Stream α) : Stream α :=
Stream.corec x fun x =>
if h : x ≠ stuck α then
let x := x.dropLeadingNones h
(x.head, x.tail)
else
(none, x)
open Classical in
open Classical in
open Classical in | theorem removeNone_equiv (x : Stream α) :
x.removeNone ~ x := | := by
apply Bisim.coinduct (· = ·.removeNone)
· rintro _ x rfl
· use 0
simp only [Nat.zero_add, Nat.not_lt_zero, false_implies, implies_true, true_and]
by_cases x_eq_stuck : x = stuck α
case pos =>
subst x_eq_stuck
refine ⟨0, ?_, ?_, by intros; contradiction⟩
· show tail _ = removeNone (stuck α).tail; simp
· show head _ = none; simp
case neg =>
have ⟨_, h2⟩ := nonesUntilSome_spec x x_eq_stuck
refine ⟨nonesUntilSome x x_eq_stuck, ?_, ?_, h2⟩
· show x.removeNone.tail = removeNone (Stream'.drop _ x)
have (w : Nat) : x.drop (w + 1) = tail (x.drop w) := by simp [tail]
rw [this]
simp [x_eq_stuck]
rfl
· show x.removeNone.head = _
simp only [head_removeNone, ne_eq, x_eq_stuck, dropLeadingNones]
simp [head]
· rfl | 4 | 26 | false | Compiler |
341 | autOfTermUnop_bv_language | lemma autOfTermUnop_bv_language op {t : Term} (m : CNFA (t.arity + 1)) :
m.bv_recognizes t.language →
(autOfTermUnop op m |>.bv_recognizes (op.subst_arity' ▸ (op.subst t).language)) | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.Blase.AutoStructs.Basic",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.Blase.AutoStructs.Constructions",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.card",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Array.foldl",
"module": "Init.Data.Array.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Array.size",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "cond",
"module": "Init.Prelude"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Array.emptyWithCapacity",
"module": "Init.Prelude"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
},
{
"name": "Array.empty",
"module": "Init.Prelude"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.equiv",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Subsingleton",
"module": "Init.Core"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "SetRel",
"module": "Mathlib.Data.Rel"
},
{
"name": "Array.back?",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.isEmpty",
"module": "Init.Data.Array.Basic"
},
{
"name": "List.next",
"module": "Mathlib.Data.List.Cycle"
},
{
"name": "L",
"module": "Archive.Hairer"
},
{
"name": "Eq",
"module": "Init.Prelude"
},
{
"name": "Fin.natAdd",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "NeZero",
"module": "Init.Data.NeZero"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "DFA",
"module": "Mathlib.Computability.DFA"
},
{
"name": "NFA.toDFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "syntax \"max\" : MLIR.Pretty.uniform_op",
"content": "syntax \"max\" : MLIR.Pretty.uniform_op\n\nsyntax \"slt\" : MLIR.Pretty.uniform_op\n\nsyntax \"xor\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "carry",
"content": "def carry (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n => (addAux' initCarry x y n).2"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "worklistRun",
"content": "def worklistRun (final : S → Bool) (inits : Array S)\n (hinits : inits.toList.Nodup) (f : S → Array (BitVec n × S)) : CNFA n :=\n ⟨worklistRun' _ S final inits hinits f, worklistRun'_wf (BitVec n) S⟩"
},
{
"name": "worklistRun'",
"content": "def worklistRun' (final : S → Bool) (inits : Array S) (hinits : inits.toList.Nodup) (f : S → Array (A × S)) : RawCNFA A :=\n let st0 := worklist.initState _ _ inits hinits final\n go st0\nwhere go (st0 : worklist.St A S) : RawCNFA A :=\n if hemp : st0.worklist.isEmpty then st0.m else\n let sa? := st0.worklist.back?\n match heq : sa? with\n | some sa =>\n let wl := st0.worklist.pop\n let st1 := { st0 with worklist := wl,\n worklist_nodup := by admit /- proof elided -/"
},
{
"name": "worklist.St",
"content": "structure worklist.St where\n m : RawCNFA A\n map : Std.HashMap S State := ∅\n worklist : Array S := ∅\n worklist_nodup : worklist.toList.Nodup\n worklist_incl : ∀ sa ∈ worklist, sa ∈ map"
},
{
"name": "worklist.initState",
"content": "def worklist.initState (inits : Array S) (hinits : inits.toList.Nodup) (final? : S → Bool) : worklist.St A S :=\n let m := RawCNFA.empty (A := A)\n let mapm := inits.foldl (init := (Std.HashMap.emptyWithCapacity, m)) fun (map, m) sa =>\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := if final? sa then m.addFinal s else m\n (map.insert sa s, m)\n let map := mapm.1\n let m := mapm.2\n let worklist_incl : ∀ sa ∈ inits, sa ∈ map :="
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.empty",
"content": "def RawCNFA.empty : RawCNFA A := {\n stateMax := 0\n initials := ∅\n finals := ∅\n trans := ∅\n}"
},
{
"name": "processOneElem",
"content": "def processOneElem (final : S → Bool) (s : State) (st : worklist.St A S) : A × S → worklist.St A S :=\n fun (a', sa') =>\n let (s', st') := st.addOrCreateState _ _ (final sa') sa'\n let m := st'.m.addTrans a' s s'\n { st' with m }"
},
{
"name": "worklist.St.addOrCreateState",
"content": "def worklist.St.addOrCreateState (st : worklist.St A S) (final? : Bool) (sa : S) : State × worklist.St A S :=\n match heq : st.map[sa]? with\n | some s => (s, st)\n | none =>\n let (s, m) := st.m.newState\n let m := if final? then m.addFinal s else m\n let map := st.map.insert sa s\n let worklist := st.worklist.push sa\n have worklist_nodup : worklist.toList.Nodup := by admit /- proof elided -/"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "sub",
"content": "def sub (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).1"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "ofTerm",
"content": "abbrev ofTerm (t : Term) : FSM (Fin t.arity) := termEvalEqFSM t |>.toFSM"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "termEvalEqFSM",
"content": "def termEvalEqFSM : ∀ (t : Term), FSMTermSolution t\n | ofNat n =>\n { toFSM := FSM.ofNat n,\n good := by admit /- proof elided -/"
},
{
"name": "or",
"content": "def or : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ||| Circuit.var true (inr false),\n nextStateCirc := fun a => a.elim\n }"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (n : Nat) : FSM Unit :=\n match n with\n | 0 => FSM.id\n | n + 1 => composeUnaryAux (FSM.ls false) (shiftLeft n)"
},
{
"name": "id",
"content": "def id : FSM Unit := {\n α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr ()),\n nextStateCirc := Empty.elim\n}"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "and",
"content": "def and : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := fun a => a.elim,\n outputCirc := Circuit.var true (inr true) &&& Circuit.var true (inr false),\n }"
},
{
"name": "xor",
"content": "def xor : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ^^^ Circuit.var true (inr false),\n nextStateCirc := Empty.elim\n }"
},
{
"name": "neg",
"content": "def neg : FSM Unit :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "composeBinary",
"content": "def composeBinary\n (p : FSM Bool)\n {t₁ t₂ : Term}\n (q₁ : FSMTermSolution t₁)\n (q₂ : FSMTermSolution t₂) :\n FSM (Fin (max t₁.arity t₂.arity)) := composeBinaryAux p q₁.toFSM q₂.toFSM"
},
{
"name": "composeBinaryAux",
"content": "def composeBinaryAux\n (p : FSM Bool)\n (q₁ : FSM (Fin a₁))\n (q₂ : FSM (Fin a₂)) :\n FSM (Fin (max a₁ a₂)) :=\n p.compose (Fin (max a₁ a₂))\n (λ b => Fin (cond b a₁ a₂))\n (λ b i => Fin.castLE (by admit /- proof elided -/\n ) i)\n (λ b => match b with\n | true => q₁\n | false => q₂)"
},
{
"name": "FSMTermSolution",
"content": "structure FSMTermSolution (t : Term) extends FSM (Fin t.arity) where\n ( good : t.evalFin = toFSM.eval )"
},
{
"name": "Term.evalFin",
"content": "@[simp] def Term.evalFin (t : Term) (vars : Fin (arity t) → BitStream) : BitStream :=\n match t with\n | var n => vars (Fin.last n)\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | or t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | xor t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | not t => ~~~(t.evalFin vars)\n | add t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | sub t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | neg t => -(Term.evalFin t vars)\n \n \n | shiftL t n => BitStream.shiftLeft (Term.evalFin t vars) n"
},
{
"name": "Predicate.evalFin",
"content": "@[simp] def Predicate.evalFin (p : Predicate) (vars : Fin (arity p) → BitStream) : BitStream :=\nmatch p with\n| .width .eq n => BitStream.falseIffEq n\n| .width .neq n => BitStream.falseIffNeq n\n| .width .lt n => BitStream.falseIffLt n\n| .width .le n => BitStream.falseIffLe n\n| .width .gt n => BitStream.falseIffGt n\n| .width .ge n => BitStream.falseIffGe n\n| .binary .eq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalEq x₁ x₂\n| .binary .neq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalNeq x₁ x₂\n| .land p q =>\n \n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLand x₁ x₂\n| .lor p q =>\n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor x₁ x₂\n| .binary .slt p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalSlt x₁ x₂\n| .binary .sle p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalSlt x₁ x₂) (Predicate.evalEq x₁ x₂)\n| .binary .ult p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n (Predicate.evalUlt x₁ x₂)\n| .binary .ule p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalUlt x₁ x₂) (Predicate.evalEq x₁ x₂)"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "Predicate",
"content": "inductive Predicate : Type where\n \n| width (wp : WidthPredicate) (n : Nat) : Predicate\n| binary (p : BinaryPredicate) (t₁ t₂ : Term)\n| land (p q : Predicate) : Predicate\n| lor (p q : Predicate) : Predicate\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "ofNat",
"content": "def ofNat (n : Nat) : FSM (Fin 0) :=\n match hn : n with\n | 0 => FSM.zero\n\n | n' + 1 =>\n let bit := n.testBit 0\n let m := n / 2\n have h : m < n := by admit /- proof elided -/"
},
{
"name": "zero",
"content": "def zero : FSM (Fin 0) :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.fals\n }"
},
{
"name": "composeUnary",
"content": "def composeUnary\n (p : FSM Unit)\n {t : Term}\n (q : FSMTermSolution t) :\n FSM (Fin t.arity) := composeUnaryAux p q.toFSM"
},
{
"name": "one",
"content": "def one : FSM (Fin 0) :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "var",
"content": "def var (n : ℕ) : FSM (Fin (n+1)) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "add",
"content": "def add : FSM Bool :=\n { α := Unit,\n initCarry := λ _ => false,\n nextStateCirc := fun () =>\n Circuit.var true (inr true) &&& Circuit.var true (inr false) |||\n Circuit.var true (inr true) &&& Circuit.var true (inl ()) |||\n Circuit.var true (inr false) &&& Circuit.var true (inl ()),\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n }"
},
{
"name": "negOne",
"content": "def negOne : FSM (Fin 0) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "sub",
"content": "def sub : FSM Bool :=\n { α := Unit,\n initCarry := fun _ => false,\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n nextStateCirc := fun _ =>\n (Circuit.var false (inr true) &&& Circuit.var true (inr false)) |||\n (Circuit.var false (inr true) ^^^ Circuit.var true (inr false)) &&&\n (Circuit.var true (inl ()))\n }"
},
{
"name": "not",
"content": "def not : FSM Unit :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.var false (inr ())\n }"
},
{
"name": "add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "neg",
"content": "def neg (x : BitStream) : BitStream :=\n fun n => (negAux x n).1"
},
{
"name": "negAux",
"content": "def negAux (x : BitStream) : Nat → Bool × Bool\n | 0 => (x 0, !(x 0))\n | n+1 =>\n let borrow := (negAux x n).2\n let a := x (n + 1)\n (xor (!a) borrow, !a && borrow)"
},
{
"name": "CNFA.inter",
"content": "def CNFA.inter (m1 m2 : CNFA n) : CNFA n := product (fun b1 b2 => b1 && b2) m1 m2"
},
{
"name": "product",
"content": "def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=\n worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)\n (by admit /- proof elided -/\n ) f\nwhere final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)\n f (ss : m₁.m.states × m₂.m.states) :=\n let (s1, s2) := ss\n (FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>\n product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))\n (fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as"
},
{
"name": "product.prodArray'",
"content": "@[inline]\ndef product.prodArray' (a : Array γ) :=\n m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>\n m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s1 s2)"
},
{
"name": "product.inits_nodup",
"content": "def product.inits_nodup : inits m₁ m₂ |>.toList.Nodup :="
},
{
"name": "product.inits",
"content": "def product.inits (m₁ m₂ : CNFA n) :=\n product.prodArray Prod.mk @m₁.wf.initials_lt @m₂.wf.initials_lt"
},
{
"name": "product.prodArray",
"content": "@[inline]\ndef product.prodArray := prodArray' f hm₁ hm₂ (Array.emptyWithCapacity <| m₁.size * m₂.size)"
},
{
"name": "CNFA.inter_bv_language",
"content": "def CNFA.inter_bv_language (m₁ m₂ : CNFA n) :\n m₁.bv_recognizes L₁ →\n m₂.bv_recognizes L₂ →\n (m₁.inter m₂).bv_recognizes (L₁ ∩ L₂) :="
},
{
"name": "HashSet.inter",
"content": "def HashSet.inter [BEq A] [Hashable A] (m1 m2 : Std.HashSet A) : Std.HashSet A :=\n m1.fold (init := ∅) fun mi x => if m2.contains x then mi.insert x else mi"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "eval",
"content": "def eval (x : arity → BitStream) : BitStream :=\n fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2"
},
{
"name": "nextBit",
"content": "def nextBit : p.State → (arity → Bool) → p.State × Bool :=\n fun carry inputBits =>\n let input := Sum.elim carry inputBits\n let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input\n let outBit : Bool := (p.outputCirc).eval input\n (newState, outBit)"
},
{
"name": "State",
"content": "abbrev State : Type := p.α → Bool"
},
{
"name": "carry",
"content": "def carry (x : arity → BitStream) : ℕ → p.State\n | 0 => p.initCarry\n | n+1 => (p.nextBit (carry x n) (fun i => x i n)).1"
},
{
"name": "carryBV",
"content": "def carryBV (x : ar → BitVec w) : p.State :=\n p.carry (fun ar => .ofBitVecSext (x ar)) w"
},
{
"name": "evalBV",
"content": "def evalBV {w} (x : ar → BitVec w) : BitVec w :=\n BitVec.ofFn fun k => p.eval (fun ar => .ofBitVecSext (x ar)) k"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "Term.language",
"content": "def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=\n { bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }"
},
{
"name": "Formula.arity",
"content": "@[simp]\ndef Formula.arity : Formula → Nat\n| width _ _ => 0\n| atom _ t1 t2 => max t1.arity t2.arity\n| msbSet t => t.arity\n| unop _ φ => φ.arity\n| binop _ φ1 φ2 => max φ1.arity φ2.arity"
},
{
"name": "Term.evalFinBV",
"content": "@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=\n match t with\n | .var n => vars (Fin.last n)\n | .zero => BitVec.zero w\n | .one => 1\n | .negOne => -1\n | .ofNat n => BitVec.ofNat _ n\n | .and t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | .or t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | .xor t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | .not t => ~~~(t.evalFinBV vars)\n \n | .add t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | .sub t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | .neg t => -(t.evalFinBV vars)\n | .shiftL a n => (a.evalFinBV vars) <<< n"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
},
{
"name": "worklistRun_spec",
"content": "def worklistRun_spec : (worklistRun S final inits hinits f |>.Sim $ nfa' inits final f) :=\n worklistRun'_spec inits final f"
},
{
"name": "nfa'",
"content": "def nfa' : NFA' n :=\n { σ := _, M := nfa inits final f }"
},
{
"name": "nfa",
"content": "def nfa : NFA A S where\n start := { sa | sa ∈ inits }\n accept := { sa | final sa }\n step sa a := { sa' | (a, sa') ∈ f sa }"
},
{
"name": "worklistRun'_spec",
"content": "def worklistRun'_spec :\n (worklistRun' A S final inits hinits f |>.Sim $ nfa inits final f) :="
},
{
"name": "StInv",
"content": "structure StInv (m : RawCNFA A) (map : Std.HashMap S State) where\n wf : m.WF\n map_states : ∀ (sa : S) s, map[sa]? = some s → s ∈ m.states\n map_surj : ∀ s : m.states, ∃ (sa : S), map[sa]? = some s.val\n map_inj : ∀ {s} {sa sa' : S}, map[sa]? = some s → map[sa']? = some s → sa = sa'"
},
{
"name": "worklist.St.D",
"content": "def worklist.St.D (st : worklist.St A S) : Set S := st.visited"
},
{
"name": "worklist.St.visited",
"content": "def worklist.St.visited (st : worklist.St A S) : Set S := { s : S | s ∈ st.map ∧ s ∉ st.worklist }"
},
{
"name": "worklistGo_spec",
"content": "def worklistGo_spec {st : worklist.St A S} (inv : StInv A S st.m st.map) :\n st.sim inits final f ∅ →\n (worklistRun'.go A S final f st |>.Sim $ nfa inits final f) :="
},
{
"name": "worklist.St.rel",
"content": "def worklist.St.rel (st : worklist.St A S) : SetRel State S := {(s, sa) | st.map[sa]? = some s }"
},
{
"name": "processOneElem_mot",
"content": "def processOneElem_mot (s : State) (sa : S) (n : ℕ) (st : worklist.St A S) : Prop :=\n st.map[sa]? = some s ∧\n sa ∈ st.visited ∧\n StInv A S st.m st.map ∧\n st.sim inits final f {(sa1, a, sa') | sa1 = sa ∧ ∃ k ≥ n, (f sa)[k]? = some (a, sa') }"
},
{
"name": "worklist.St.sim",
"content": "abbrev worklist.St.sim {st : worklist.St A S} (T : Set (S × A × S)) :=\n st.m.Simul (nfa inits final f) st.rel st.D T"
},
{
"name": "RawCNFA.Sim",
"content": "def RawCNFA.Sim (m : RawCNFA A) (A : NFA A S) := ∃ R, RawCNFA.Simul m A R ⊤ ∅"
},
{
"name": "RawCNFA.Simul",
"content": "structure RawCNFA.Simul (m : RawCNFA A) (M : NFA A Q) (R : SetRel State Q) (D : Set Q) (T : Set (Q × A × Q)) where\n accept {s q} : s ~[R] q → (s ∈ m.finals ↔ q ∈ M.accept)\n initial₁ {s} : s ∈ m.initials → ∃ q ∈ M.start, s ~[R] q\n initial₂ {q} : q ∈ M.start → ∃ s ∈ m.initials, s ~[R] q\n trans_match₁ {s s' a q} : s ~[R] q → s' ∈ m.tr s a → ∃ q', q' ∈ M.step q a ∧ s' ~[R] q'\n trans_match₂ {s a q q'} : s ~[R] q → q' ∈ M.step q a → q ∈ D → (q, a, q') ∉ T → ∃ s', s' ∈ m.tr s a ∧ s' ~[R] q'"
},
{
"name": "RawCNFA.SimulFun",
"content": "structure RawCNFA.SimulFun (m : RawCNFA A) (M : NFA A Q) (f : m.states ≃ Q) where\n accept {q} : ((f.invFun q).val ∈ m.finals ↔ q ∈ M.accept)\n initial {q} : q ∈ M.start ↔ (f.invFun q).val ∈ m.initials\n trans_match {a q q'} : q' ∈ M.step q a ↔ (f.invFun q').val ∈ m.tr (f.invFun q) a"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "CNFA.Sim",
"content": "def CNFA.Sim (m : CNFA n) (M : NFA' n) :=\n m.m.Sim M.M"
},
{
"name": "CNFA.bv_recognizes",
"content": "def CNFA.bv_recognizes (m : CNFA n) (L : Set (BitVecs n)) :=\n ∃ L', m.recognizes L' ∧ L = dec '' L'"
},
{
"name": "RawCNFA.recognizes",
"content": "def RawCNFA.recognizes (m : RawCNFA A) (L : Language A) :=\n ∃ (σ : Type) (M : NFA A σ), m.Sim M ∧ M.accepts = L"
},
{
"name": "CNFA.recognizes",
"content": "def CNFA.recognizes (m : CNFA n) (L : Language (BitVec n)) :=\n ∃ (M : NFA' n), m.Sim M ∧ M.M.accepts = L"
},
{
"name": "BitVecs.cast",
"content": "def BitVecs.cast (bvs : BitVecs n) (h : n = n') : BitVecs n' :=\n { w := bvs.w, bvs := h ▸ bvs.bvs }"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "CNFA.minimize",
"content": "def CNFA.minimize (m : CNFA n) : CNFA n :=\n let mᵣ := m.reverse.determinize\n mᵣ.reverse.determinize"
},
{
"name": "CNFA.determinize",
"content": "def CNFA.determinize (m : CNFA n) : CNFA n :=\n worklistRun (BitVec m.m.stateMax)\n (fun ss => ss.any fun n b => b == true && n ∈ m.m.finals)\n (determinize.inits m)\n (by admit /- proof elided -/\n )\n f\nwhere\n f := fun (ss : BitVec m.m.stateMax) =>\n (FinEnum.toList (BitVec n)).foldl (init := Array.empty) fun ts a =>\n let ss' := m.m.transSetBV ss a\n ts.push (a, ss')"
},
{
"name": "CNFA.determinize.inits",
"content": "def CNFA.determinize.inits (m : CNFA n) : Array (BitVec m.m.stateMax) :=\n #[BitVec.ofFn (fun n => n ∈ m.m.initials)]"
},
{
"name": "CNFA.reverse",
"content": "def CNFA.reverse (m : CNFA n) : CNFA n :=\n ⟨m.m.reverse, RawCNFA.reverse_spec m.wf |>.1⟩"
},
{
"name": "RawCNFA.reverse",
"content": "def RawCNFA.reverse (m : RawCNFA A) : RawCNFA A :=\n let m' := { stateMax := m.stateMax, trans := Std.HashMap.emptyWithCapacity m.trans.size, initials := m.finals, finals := m.initials}\n m.trans.fold (init := m') processState\nwhere\n processState := fun m' (s, a) ss' =>\n ss'.fold (init := m') fun m' s' => m'.addTrans a s' s"
},
{
"name": "CNFA.toNFA'",
"content": "def CNFA.toNFA' (m : CNFA n) : NFA' n := ⟨_, m.toNFA⟩"
},
{
"name": "CNFA.toNFA",
"content": "def CNFA.toNFA (m : CNFA n) : NFA (BitVec n) m.m.states where\n start := { s | s.val ∈ m.m.initials }\n accept := { s | s.val ∈ m.m.finals }\n step s₁ a := { s₂ | s₂.val ∈ m.m.tr s₁.val a }"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "reverse",
"content": "def reverse (M : NFA' n) : NFA' n where\n σ := _\n M := M.M.reverse"
},
{
"name": "CNFA.determinize_spec",
"content": "def CNFA.determinize_spec (m : CNFA n)\n {M : NFA' n} (hsim : m.Sim M) :\n m.determinize.Sim M.determinize :="
},
{
"name": "bv_to_set",
"content": "private def bv_to_set (bv : BitVec w) : Set State :=\n { s | bv.getLsbD s }"
},
{
"name": "_root_.SetRel.set_eq",
"content": "structure _root_.SetRel.set_eq (R : SetRel α β) (A : Set α) (B : Set β) where\n fwd : a ∈ A → ∃ b ∈ B, a ~[R] b\n bwd : b ∈ B → ∃ a ∈ A, a ~[R] b"
},
{
"name": "RawCNFA.lift",
"content": "@[inline]\ndef RawCNFA.lift (m₁: RawCNFA (BitVec n1)) (f : Fin n1 → Fin n2) : RawCNFA (BitVec n2) :=\n let trans := (List.range m₁.stateMax).foldl (init := ∅) fun m2 s => processState m2 s\n { m₁ with trans }\nwhere"
},
{
"name": "CNFA.lift",
"content": "@[inline]\ndef CNFA.lift (m: CNFA n1) (f : Fin n1 → Fin n2) : CNFA n2 :=\n ⟨m.m.lift f, m.m.lift_wf m.wf⟩"
},
{
"name": "RawCNFA.proj",
"content": "@[inline]\ndef RawCNFA.proj (m1: RawCNFA (BitVec n1)) (f : Fin n2 → Fin n1) : RawCNFA (BitVec n2) :=\n let trans := m1.trans.keysArray.foldl (init := Std.HashMap.emptyWithCapacity) process\n { m1 with trans }\nwhere"
},
{
"name": "CNFA.proj_spec",
"content": "def CNFA.proj_spec (m : CNFA n2) (f : Fin n1 → Fin n2) {M : NFA' n2} :\n m.Sim M → (m.proj f |>.Sim (M.proj f)) :="
},
{
"name": "CNFA.proj",
"content": "@[inline]\ndef CNFA.proj (m: CNFA n2) (f : Fin n1 → Fin n2) : CNFA n1 :=\n ⟨m.m.proj f, m.m.proj_wf m.wf⟩"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "List.nodup_singleton",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "NFA.eval_append_singleton",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.eval_nil",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Fin.ext_iff",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.mod_le",
"module": "Init.Data.Nat.Div.Basic"
},
{
"name": "eq_iff_iff",
"module": "Init.Core"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "ite_cond_eq_true",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
},
{
"name": "bisim_comp",
"content": "lemma bisim_comp (m : RawCNFA A) :\n m.Sim M₁ → M₁.Bisim M₂ → m.Sim M₂"
},
{
"name": "bisimul_comp",
"content": "lemma bisimul_comp {m : RawCNFA A} :\n m.Simul M₁ R₁ ⊤ ∅ → M₁.Bisimul R₂ M₂ →\n m.Simul M₂ (R₁.comp R₂) ⊤ ∅"
},
{
"name": "CNFA.bv_recognizes_equiv",
"content": "lemma CNFA.bv_recognizes_equiv {m : CNFA n} :\n m.bv_recognizes L ↔ ∃ (M : NFA' n), m.Sim M ∧ M.accepts = L"
},
{
"name": "List.Vector.append_get_ge",
"content": "@[simp]\nlemma List.Vector.append_get_ge {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: n ≤ i) :\n (x ++ y).get i = y.get ((i.cast (Nat.add_comm n m) |>.subNat n hlt))"
},
{
"name": "List.Vector.append_get_lt",
"content": "@[simp]\nlemma List.Vector.append_get_lt {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: i < n) :\n (x ++ y).get i = x.get (i.castLT hlt)"
},
{
"name": "BitVecs.transport_getElem",
"content": "@[simp]\nlemma BitVecs.transport_getElem {bvs : BitVecs m} (f : Fin n → Fin m) (i : Fin n) :\n (bvs.transport f).bvs.get i = bvs.bvs.get (f i)"
},
{
"name": "CNFA.minimize_bv_language",
"content": "lemma CNFA.minimize_bv_language {m : CNFA n} :\n m.bv_recognizes L → m.minimize.bv_recognizes L"
},
{
"name": "CNFA.minimize_language",
"content": "lemma CNFA.minimize_language {m : CNFA n} :\n m.recognizes L → m.minimize.recognizes L"
},
{
"name": "CNFA.reverse_language",
"content": "lemma CNFA.reverse_language {m : CNFA n} (hl : m.recognizes L) : m.reverse.recognizes L.reverse"
},
{
"name": "CNFA.reverse_spec",
"content": "lemma CNFA.reverse_spec {m : CNFA n} : m.reverse.Sim m.toNFA'.reverse"
},
{
"name": "RawCNFA.reverse_spec",
"content": "lemma RawCNFA.reverse_spec {m : RawCNFA A} (hwf : m.WF) :\n let m'"
},
{
"name": "RawCNFA.reverse_spec_procesState",
"content": "lemma RawCNFA.reverse_spec_procesState {m : RawCNFA A} (hwf : m.WF) s₀ a₀ ss' (hs₀ : s₀ ∈ m.states) :\n let motive m' ss'"
},
{
"name": "CNFA.determinize_language",
"content": "lemma CNFA.determinize_language {m : CNFA n} :\n m.recognizes L → m.determinize.recognizes L"
},
{
"name": "CNFA.lift_bv_language",
"content": "@[simp]\nlemma CNFA.lift_bv_language {m : CNFA n1} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.lift f |>.bv_recognizes (BitVecs.transport f ⁻¹' L))"
},
{
"name": "CNFA.lift_spec",
"content": "lemma CNFA.lift_spec (m : CNFA n1) (f : Fin n1 → Fin n2) {M : NFA' n1} :\n m.Sim M → (m.lift f |>.Sim (M.lift f))"
},
{
"name": "CNFA.proj_bv_language",
"content": "lemma CNFA.proj_bv_language {m : CNFA n2} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.proj f |>.bv_recognizes (BitVecs.transport f '' L))"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "langRel",
"content": "def langRel (R : BVNRel n) : Set (BitVecs n) :=\n { bvs | R bvs.bvs }"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "Alphabet",
"content": "abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)"
},
{
"name": "finFunToBitVec",
"content": "def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=\n BitVec.ofFn fun i => c (fe.equiv.invFun i)"
},
{
"name": "bitVecToFinFun",
"content": "def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=\n fun c => bv[FinEnum.equiv.toFun c]"
},
{
"name": "NFA.ofFSM",
"content": "def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where\n start := { q | q = p.initCarry }\n accept := ⊤\n step s a := {s' |\n let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))\n s' = s'' ∧ a.msb = b }"
},
{
"name": "inFSMRel",
"content": "@[simp]\nabbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=\n bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_sa",
"content": "def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>\n inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_correct",
"content": "def NFA'.ofFSM_correct (p : FSM arity) :\n (NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :="
},
{
"name": "CNFA.ofFSM",
"content": "def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=\n worklistRun (BitVec (FinEnum.card p.α))\n (fun _ => true)\n #[finFunToBitVec p.initCarry]\n (by admit /- proof elided -/\n )\n f\n where"
},
{
"name": "NFA.msbState",
"content": "inductive NFA.msbState : Type where\n| i | f\nderiving DecidableEq, Fintype"
},
{
"name": "liftUnop",
"content": "def liftUnop n : Fin (n + 1) → Fin (n + 2) :=\n fun k =>\n if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "TermBinop",
"content": "inductive TermBinop where\n| and | or | xor | add | sub"
},
{
"name": "TermBinop.subst",
"content": "def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=\n match op with\n | .and => .and t₁ t₂\n | .or => .or t₁ t₂\n | .xor => .xor t₁ t₂\n | .add => .add t₁ t₂\n | .sub => .sub t₁ t₂"
},
{
"name": "TermBinop.openTerm",
"content": "def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)"
},
{
"name": "TermBinop.termGadget",
"content": "def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=\n match t with\n | .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM\n | .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM\n | .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM\n | .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM\n | .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM"
},
{
"name": "TermUnop",
"content": "inductive TermUnop where\n| neg | not | shiftL (k : Nat)"
},
{
"name": "TermUnop.openTerm",
"content": "def TermUnop.openTerm (op : TermUnop) : Term :=\n match op with\n | .neg => .neg (.var 0)\n | .not => .not (.var 0)\n | .shiftL k => .shiftL (.var 0) k"
},
{
"name": "TermUnop.openTerm_arity'",
"content": "@[simp]\ndef TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :="
},
{
"name": "TermUnop.subst",
"content": "def TermUnop.subst (op : TermUnop) (t : Term) : Term :=\n match op with\n | .neg => .neg t\n | .not => .not t\n | .shiftL k => .shiftL t k"
},
{
"name": "TermUnop.termGadget",
"content": "def TermUnop.termGadget (t : TermUnop) : CNFA 2 :=\n match t with\n | .neg => FSM.ofTerm (.neg (.var 0)) |> CNFA.ofFSM\n | .not => FSM.ofTerm (.not (.var 0)) |> CNFA.ofFSM\n | .shiftL k => FSM.ofTerm (.shiftL (.var 0) k) |> CNFA.ofFSM"
},
{
"name": "autOfTermUnop",
"content": "def autOfTermUnop (op : TermUnop) (m : CNFA (n + 1)) : CNFA (n + 1) :=\n let mop : CNFA 2 := op.termGadget\n let mop : CNFA (n + 2) := mop.lift (λ i ↦ i.natAdd n)\n let m : CNFA (n + 2) := m.lift (λ i ↦ i.castLE (by admit /- proof elided -/\n ))\n let m := CNFA.inter m mop\n let mfinal := m.proj (liftUnop n)\n mfinal.minimize"
},
{
"name": "swapLastTwo",
"content": "def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=\n if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x"
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
},
{
"name": "in_enc",
"content": "@[simp]\nlemma in_enc : x ∈ enc '' S ↔ dec x ∈ S"
},
{
"name": "dec_snoc_in_langRel",
"content": "@[simp]\nlemma dec_snoc_in_langRel {n} {R : BVNRel n} {w : BitVecs' n} {a : BitVec n} :\n dec (w ++ [a]) ∈ langRel R ↔\n R (List.Vector.ofFn fun k => .cons (a.getLsbD k) ((dec w).bvs.get k))"
},
{
"name": "NFA'.correct_spec",
"content": "lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :\n M.correct ζ L → M.accepts = langRel L"
},
{
"name": "NFA'.ofFSM_spec",
"content": "@[simp]\nlemma NFA'.ofFSM_spec (t : Term) :\n (ofFSM (FSM.ofTerm t)).accepts = t.language"
},
{
"name": "CNFA.ofFSM_spec",
"content": "lemma CNFA.ofFSM_spec (p : FSM arity) :\n (CNFA.ofFSM p).Sim (NFA'.ofFSM p)"
},
{
"name": "CNFA.ofFSM_bv_language",
"content": "lemma CNFA.ofFSM_bv_language :\n (CNFA.ofFSM (FSM.ofTerm t)).bv_recognizes t.language"
},
{
"name": "TermBinop.subst_arity'",
"content": "lemma TermBinop.subst_arity' {op : TermBinop} : (op.subst t₁ t₂).arity + 1= t₁.arity ⊔ t₂.arity + 1"
},
{
"name": "BitVecs.cast_eq",
"content": "@[simp]\nlemma BitVecs.cast_eq (x : BitVecs n) (h : n = n') : h ▸ x = x.cast h"
},
{
"name": "Fin.natAdd_zero'",
"content": "lemma Fin.natAdd_zero' [h : NeZero m] : Fin.natAdd (m := m) n 0 = n"
},
{
"name": "TermUnop.subst_arity'",
"content": "@[simp]\nlemma TermUnop.subst_arity' {op : TermUnop} : (op.subst t).arity + 1 = t.arity + 1"
},
{
"name": "TermUnop.alt_lang",
"content": "lemma TermUnop.alt_lang {t : Term} (op : TermUnop) :\n (op.subst_arity' ▸ (op.subst t).language) =\n let lop : Set (BitVecs 2) := op.openTerm_arity' ▸ op.openTerm.language\n let lop' : Set (BitVecs (t.arity + 2)) := lop.lift (λ i ↦ i.natAdd t.arity)\n let lt : Set (BitVecs (t.arity + 2)) := t.language.lift (λ i ↦ i.castLE (by omega))\n let l := lt ∩ lop'\n l.proj (liftUnop t.arity)"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
def langRel (R : BVNRel n) : Set (BitVecs n) :=
{ bvs | R bvs.bvs }
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)
variable {arity : Type} [FinEnum arity]
def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=
BitVec.ofFn fun i => c (fe.equiv.invFun i)
def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=
fun c => bv[FinEnum.equiv.toFun c]
def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where
start := { q | q = p.initCarry }
accept := ⊤
step s a := {s' |
let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))
s' = s'' ∧ a.msb = b }
@[simp]
abbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=
bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>
inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_correct (p : FSM arity) :
(NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :=
open BitStream in
def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=
worklistRun (BitVec (FinEnum.card p.α))
(fun _ => true)
#[finFunToBitVec p.initCarry]
(by admit /- proof elided -/
)
f
where
end fsm
section nfas_relations
inductive NFA.msbState : Type where
| i | f
deriving DecidableEq, Fintype
end nfas_relations
def liftUnop n : Fin (n + 1) → Fin (n + 2) :=
fun k =>
if k = n then Fin.last (n+1) else k.castLE (by admit /- proof elided -/
)
inductive TermBinop where
| and | or | xor | add | sub
def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=
match op with
| .and => .and t₁ t₂
| .or => .or t₁ t₂
| .xor => .xor t₁ t₂
| .add => .add t₁ t₂
| .sub => .sub t₁ t₂
def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)
def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=
match t with
| .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM
| .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM
| .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM
| .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM
| .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM
inductive TermUnop where
| neg | not | shiftL (k : Nat)
def TermUnop.openTerm (op : TermUnop) : Term :=
match op with
| .neg => .neg (.var 0)
| .not => .not (.var 0)
| .shiftL k => .shiftL (.var 0) k
@[simp]
def TermUnop.openTerm_arity' (op : TermUnop) : op.openTerm.arity + 1 = 2 :=
def TermUnop.subst (op : TermUnop) (t : Term) : Term :=
match op with
| .neg => .neg t
| .not => .not t
| .shiftL k => .shiftL t k
def TermUnop.termGadget (t : TermUnop) : CNFA 2 :=
match t with
| .neg => FSM.ofTerm (.neg (.var 0)) |> CNFA.ofFSM
| .not => FSM.ofTerm (.not (.var 0)) |> CNFA.ofFSM
| .shiftL k => FSM.ofTerm (.shiftL (.var 0) k) |> CNFA.ofFSM
def autOfTermUnop (op : TermUnop) (m : CNFA (n + 1)) : CNFA (n + 1) :=
let mop : CNFA 2 := op.termGadget
let mop : CNFA (n + 2) := mop.lift (λ i ↦ i.natAdd n)
let m : CNFA (n + 2) := m.lift (λ i ↦ i.castLE (by admit /- proof elided -/
))
let m := CNFA.inter m mop
let mfinal := m.proj (liftUnop n)
mfinal.minimize
def swapLastTwo (x : Fin (n + 2)) : Fin (n + 2) :=
if x = Fin.last (n + 1) then n else if x = n then Fin.last (n + 1) else x | lemma autOfTermUnop_bv_language op {t : Term} (m : CNFA (t.arity + 1)) :
m.bv_recognizes t.language →
(autOfTermUnop op m |>.bv_recognizes (op.subst_arity' ▸ (op.subst t).language)) := | := by
rintro hrec
rw [TermUnop.alt_lang]
simp only [autOfTermUnop]
simp
apply CNFA.minimize_bv_language
apply CNFA.proj_bv_language
apply CNFA.inter_bv_language
· apply CNFA.lift_bv_language; assumption
· apply CNFA.lift_bv_language
simp [TermUnop.openTerm, TermUnop.termGadget]
rcases op <;> apply CNFA.ofFSM_bv_language | 11 | 289 | false | Compiler |
342 | Std.HashMap.fold_induction | theorem Std.HashMap.fold_induction [BEq α] [LawfulBEq α] [DecidableEq α] [Hashable α]
{f : γ → α → β → γ} {m : HashMap α β} {motive : γ → (α → Option β) → Prop} :
motive b (λ _ ↦ none) →
(∀ b x y m, m x = none → motive b m → motive (f b x y) (Function.update m x y)) →
motive (m.fold f b) m.toPFun | lean-mlir | Blase/Blase/AutoStructs/ForMathlib.lean | [
"import Mathlib.Data.Rel",
"import Mathlib.Data.FinEnum",
"import Mathlib.Data.Vector.Basic",
"import Blase.AutoStructs.ForLean",
"import Mathlib.Computability.NFA"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Function.update",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "Option.map",
"module": "Init.Prelude"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Prod.snd",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap.map",
"module": "Std.Data.HashMap.AdditionalOperations"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Set.ext",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Std.HashMap.contains_eq_isSome_getElem?",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "Std.HashMap.contains_eq_isSome_getKey?",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "Std.HashMap.find?_toList_eq_some_iff_getKey?_eq_some_and_getElem?_eq_some",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "Function.update_apply",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "List.find?_some",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_of_find?_eq_some",
"module": "Init.Data.List.Find"
},
{
"name": "List.pairwise_append",
"module": "Init.Data.List.Pairwise"
},
{
"name": "Std.HashMap.fold_eq_foldl_toList",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Std.HashMap.toPFun",
"content": "def Std.HashMap.toPFun [BEq α] [Hashable α] (m : HashMap α β) (x : α) : Option β := m[x]?"
}
] | [
{
"name": "Std.HashMap.toPFun_toList",
"content": "theorem Std.HashMap.toPFun_toList[BEq α] [LawfulBEq α] [Hashable α] (m : HashMap α β) :\n m.toPFun = λ k ↦ m.toList.find? (λ x ↦ x.1 == k) |>.map Prod.snd"
}
] | import Mathlib.Computability.NFA
import Mathlib.Data.FinEnum
import Mathlib.Data.Rel
import Mathlib.Data.Vector.Basic
import Blase.AutoStructs.ForLean
open Set
open Mathlib
open SetRel
namespace NFA
end NFA
def Std.HashMap.toPFun [BEq α] [Hashable α] (m : HashMap α β) (x : α) : Option β := m[x]? | theorem Std.HashMap.fold_induction [BEq α] [LawfulBEq α] [DecidableEq α] [Hashable α]
{f : γ → α → β → γ} {m : HashMap α β} {motive : γ → (α → Option β) → Prop} :
motive b (λ _ ↦ none) →
(∀ b x y m, m x = none → motive b m → motive (f b x y) (Function.update m x y)) →
motive (m.fold f b) m.toPFun := | := by
rintro hemp hind
rw [Std.HashMap.fold_eq_foldl_toList, toPFun_toList]
have := m.distinct_keys_toList
revert this
induction m.toList using List.reverseRecOn
case nil =>
simp_all
case append_singleton xs xy ih =>
rcases xy with ⟨x, y⟩
rintro hd
simp_all
simp [List.pairwise_append] at hd
rcases hd with ⟨hd, hnew⟩
let f := fun k => Option.map Prod.snd (List.find? (fun x => x.1 == k) xs)
specialize ih (by simp [hd])
have hnewf : f x = none := by
simp [f]; grind
specialize hind _ x y _ hnewf ih
convert hind using 1
ext a b; simp
rw [Function.update_apply]
split_ifs with hcond
· subst hcond; constructor
· rintro ⟨a', hf | hf⟩
· obtain h := List.find?_some hf
simp at h; subst h
grind [List.mem_of_find?_eq_some]
· grind
· simp only [Option.some.injEq, true_and]
rintro rfl
aesop
· simp [f]; grind | 2 | 26 | false | Compiler |
343 | Lets.getPureExpr_var_appendInr | @[simp] theorem Lets.getPureExpr_var_appendInr (lets : Lets d Γ_in eff Γ_out) (e : Expr d Γ_out _ ty₁)
(v : Var Γ_out ty₂):
getPureExpr (lets.var e) v.appendInr
= (fun ⟨_, w, e'⟩ => ⟨_, w, e'.changeVars <| e.contextHom⟩) <$> (getPureExpr lets v) | lean-mlir | LeanMLIR/LeanMLIR/Framework/Basic.lean | [
"import LeanMLIR.HVector",
"import LeanMLIR.ErasedContext",
"import SSA/Projects/CIRCT/HSxComb/HSxCombFunctor.lean",
"import SSA/Projects/CIRCT/DCxComb/DCxCombFunctor.lean",
"import SSA/Projects/Tensor2D/Tensor2D.lean",
"import SSA/Projects/RISCV64/Base.lean",
"import SSA/Projects/ModArith/Basic.lean",
"import SSA/Projects/Scf/ScfFunctor.lean",
"import Mathlib.Data.Finset.Union",
"import LeanMLIR.Framework.Dialect",
"import LeanMLIR/LeanMLIR/Transforms/CSE.lean",
"import LeanMLIR/LeanMLIR/Examples.lean",
"import LeanMLIR/LeanMLIR/Transforms/DCE.lean",
"import LeanMLIR.LeanMLIR.HVector",
"import SSA/Projects/FullyHomomorphicEncryption/Basic.lean",
"import LeanMLIR/LeanMLIR/Dialects/LLVM/Basic.lean",
"import SSA/Projects/Tensor1D/Tensor1D.lean",
"import LeanMLIR/LeanMLIR/Framework/Macro.lean",
"import SSA/Projects/LLVMRiscV/LLVMAndRiscv.lean",
"import LeanMLIR.EffectKind"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "decidable_of_iff",
"module": "Init.PropLemmas"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Valuation.mk",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Sigma",
"module": "Init.Core"
},
{
"name": "Sigma.mk",
"module": "Init.Core"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.matchAlts",
"module": "Lean.Parser.Term"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Stream'",
"module": "Mathlib.Data.Stream.Defs"
}
] | [
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "Hom",
"content": "abbrev Hom (Γ Γ' : Ctxt Ty) := ⦃t : Ty⦄ → Γ.Var t → Γ'.Var t"
},
{
"name": "dropUntil",
"content": "def dropUntil : Ctxt Ty :=\n ⟨Γ.toList.drop (v.val + 1)⟩"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "Hom.castCodomain",
"content": "def Hom.castCodomain (h : Δ = Δ') (f : Γ.Hom Δ) : Γ.Hom Δ' :=\n fun _t v => (f v).castCtxt h"
},
{
"name": "appendInl",
"content": "def appendInl (v : Γ.Var t) : (Γ ++ Δ).Var t :=\n ⟨v.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "dropUntilHom",
"content": "abbrev dropUntilHom : Hom (Γ.dropUntil v) Γ := dropUntilDiff.toHom"
},
{
"name": "dropUntilDiff",
"content": "def dropUntilDiff : Diff (Γ.dropUntil v) Γ :=\n ⟨v.val+1, by admit /- proof elided -/\n ⟩"
},
{
"name": "emptyElim",
"content": "def emptyElim {α : Sort _} {t : Ty} : Ctxt.Var ∅ t → α :=\n fun ⟨_, h⟩ => by admit /- proof elided -/"
},
{
"name": "cons",
"content": "@[match_pattern]\ndef cons (hd : Ty) : Ctxt Ty → Ctxt Ty\n| ⟨tl⟩ => ⟨hd :: tl⟩"
},
{
"name": "Diff",
"content": "def Diff (Γ₁ Γ₂ : Ctxt Ty) : Type :=\n {d : Nat // Diff.Valid Γ₁ Γ₂ d}"
},
{
"name": "Diff.Valid",
"content": "@[simp]\nabbrev Diff.Valid (Γ₁ Γ₂ : Ctxt Ty) (d : Nat) : Prop :=\n ∀ {i t}, Γ₁[i]? = some t → Γ₂[i+d]? = some t"
},
{
"name": "Hom.id",
"content": "@[simp] abbrev Hom.id {Γ : Ctxt Ty} : Γ.Hom Γ :=\n fun _ v => v"
},
{
"name": "appendInr",
"content": "def appendInr (v : Var Δ t) : (Γ ++ Δ).Var t :=\n ⟨v.val + Γ.length, by admit /- proof elided -/\n ⟩"
},
{
"name": "length",
"content": "@[grind=]\ndef length (Γ : Ctxt Ty) : Nat := Γ.toList.length"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "HVectorLiteral",
"content": "structure HVectorLiteral where\n u : Level\n v : Level\n α : Q(Type $u)\n A : Q($α → Type $v)\n elems : Array ((a : Q($α)) × Q($A $a))\n\n instance : DialectSignature $dialect where\n signature := fun op => match op with $matchAlts:matchAlts\n )"
},
{
"name": "(q",
"content": "noncomputable instance (q : ℕ) [Fact (q > 1)] : DialectDenote (ModArith q) where\ndenote\n | .add, arg, _ =>\n \n (fun args : R q × R q => args.1 + args.2) arg.toPair\n | .sub, arg, _ =>\n \n (fun args : R q × R q => args.1 - args.2) arg.toPair\n | .mul, arg, _ =>\n \n (fun args : R q × R q => args.1 * args.2) arg.toPair\n | .const _ c, _, _ =>\n \n c"
},
{
"name": "Op.signature",
"content": "@[simp, reducible]\ndef Op.signature : Op q n → Signature (Ty q n) :=\n fun o => {sig := Op.sig o, returnTypes := [Op.outTy o], regSig := []}"
},
{
"name": "Op.sig",
"content": "@[simp, reducible]\ndef Op.sig : Op q n → List (Ty q n)\n| Op.add => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.sub => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.mul => [Ty.polynomialLike, Ty.polynomialLike]\n| Op.mul_constant => [Ty.polynomialLike, Ty.integer]\n| Op.leading_term => [Ty.polynomialLike]\n| Op.monomial => [Ty.integer, Ty.index]\n| Op.monomial_mul => [Ty.polynomialLike, Ty.index]\n| Op.from_tensor => [Ty.tensor]\n| Op.to_tensor => [Ty.polynomialLike]\n| Op.const _ => []\n| Op.const_int _ => []\n| Op.const_idx _ => []"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "Op.outTy",
"content": "@[simp, reducible]\ndef Op.outTy : Op q n → Ty q n\n| Op.add | Op.sub | Op.mul | Op.mul_constant | Op.leading_term | Op.monomial\n| Op.monomial_mul | Op.from_tensor | Op.const _ => Ty.polynomialLike\n| Op.to_tensor => Ty.tensor\n| Op.const_int _ => Ty.integer\n| Op.const_idx _ => Ty.index"
},
{
"name": "Op.regSig",
"content": "@[reducible, simp]\ndef Op.regSig : Op → RegionSignature Ty\n | .map2d => [([Ty.int], [.int])]\n | _ => []"
},
{
"name": "",
"content": "instance : DialectSignature Ex where\n signature\n | .add => ⟨[.nat, .nat], [], [.nat], .pure⟩\n | .beq => ⟨[.nat, .nat], [], [.bool], .pure⟩\n | .cst _ => ⟨[], [], [.nat], .pure⟩"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | beq : ExOp\n | cst : ℕ → ExOp\n deriving DecidableEq"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Ctxt.Var Γ .nat) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "Ex",
"content": "abbrev Ex : Dialect where\n Op := ExOp\n Ty := ExTy"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectSignature Tensor2D where\n signature op := { sig := op.sig, regSig := op.regSig, returnTypes := [op.outTy] }"
},
{
"name": "",
"content": "instance : DialectSignature Tensor1D where\n signature op := { sig := op.sig, regSig := op.regSig, returnTypes := [op.outTy], effectKind := .pure }"
},
{
"name": "",
"content": "instance : DialectSignature RV64 where\n signature o := {sig := Op.sig o, returnTypes := [Op.outTy o], regSig := []}"
},
{
"name": "Op.sig",
"content": "@[simp, reducible]\ndef Op.sig : Op → List Ty\n | .li _ => []\n | .mulh => [Ty.bv, Ty.bv]\n | .mulhu => [Ty.bv, Ty.bv]\n | .mulhsu => [Ty.bv, Ty.bv]\n | .divu => [Ty.bv, Ty.bv]\n | .remuw => [Ty.bv, Ty.bv]\n | .remu => [Ty.bv, Ty.bv]\n | .addiw (_imm : BitVec 12) => [Ty.bv]\n | .lui (_imm : BitVec 20) => [Ty.bv]\n | .auipc (_imm : BitVec 20) => [Ty.bv]\n | .slliw (_shamt : BitVec 5) => [Ty.bv]\n | .srliw (_shamt : BitVec 5) => [Ty.bv]\n | .sraiw (_shamt : BitVec 5) => [Ty.bv]\n | .slli (_shamt : BitVec 6) => [Ty.bv]\n | .srli (_shamt : BitVec 6) => [Ty.bv]\n | .srai (_shamt : BitVec 6) => [Ty.bv]\n | .addw => [Ty.bv, Ty.bv]\n | .subw => [Ty.bv, Ty.bv]\n | .sllw => [Ty.bv, Ty.bv]\n | .srlw => [Ty.bv, Ty.bv]\n | .sraw => [Ty.bv, Ty.bv]\n | .add => [Ty.bv, Ty.bv]\n | .slt => [Ty.bv, Ty.bv]\n | .sltu => [Ty.bv, Ty.bv]\n | .and => [Ty.bv, Ty.bv]\n | .or => [Ty.bv, Ty.bv]\n | .xor => [Ty.bv, Ty.bv]\n | .sll => [Ty.bv, Ty.bv]\n | .srl => [Ty.bv, Ty.bv]\n | .sub => [Ty.bv, Ty.bv]\n | .sra => [Ty.bv, Ty.bv]\n | .remw => [Ty.bv, Ty.bv]\n | .rem => [Ty.bv, Ty.bv]\n | .mul => [Ty.bv, Ty.bv]\n | .mulw => [Ty.bv, Ty.bv]\n | .div => [Ty.bv, Ty.bv]\n | .divw => [Ty.bv, Ty.bv]\n | .divuw => [Ty.bv, Ty.bv]\n | .addi (_imm : BitVec 12) => [Ty.bv]\n | .slti (_imm : BitVec 12) => [Ty.bv]\n | .sltiu (_imm : BitVec 12) => [Ty.bv]\n | .andi (_imm : BitVec 12) => [Ty.bv]\n | .ori (_imm : BitVec 12) => [Ty.bv]\n | .xori (_imm : BitVec 12) => [Ty.bv]\n | .bclr => [Ty.bv, Ty.bv]\n | .bext => [Ty.bv, Ty.bv]\n | .binv => [Ty.bv, Ty.bv]\n | .bset => [Ty.bv, Ty.bv]\n | .bclri (_shamt : BitVec 6) => [Ty.bv]\n | .bexti (_shamt : BitVec 6) => [Ty.bv]\n | .binvi (_shamt : BitVec 6) => [Ty.bv]\n | .bseti (_shamt : BitVec 6) => [Ty.bv]\n | .adduw => [Ty.bv, Ty.bv]\n | .sh1adduw => [Ty.bv, Ty.bv]\n | .sh2adduw => [Ty.bv, Ty.bv]\n | .sh3adduw => [Ty.bv, Ty.bv]\n | .sh1add => [Ty.bv, Ty.bv]\n | .sh2add => [Ty.bv, Ty.bv]\n | .sh3add => [Ty.bv, Ty.bv]\n | .slliuw (_shamt : BitVec 6) => [Ty.bv]\n | .andn => [Ty.bv, Ty.bv]\n | .orn => [Ty.bv, Ty.bv]\n | .xnor => [Ty.bv, Ty.bv]\n | .clz\n | .clzw\n | .ctz\n | .ctzw\n | .max => [Ty.bv, Ty.bv]\n | .maxu => [Ty.bv, Ty.bv]\n | .min => [Ty.bv, Ty.bv]\n | .minu => [Ty.bv, Ty.bv]\n | .sextb => [Ty.bv]\n | .sexth => [Ty.bv]\n | .zexth => [Ty.bv]\n | .rol => [Ty.bv, Ty.bv]\n | .rolw => [Ty.bv, Ty.bv]\n | .ror => [Ty.bv, Ty.bv]\n | .rori (_shamt : BitVec 6) =>[Ty.bv]\n | .roriw (_shamt : BitVec 5) =>[Ty.bv]\n | .rorw => [Ty.bv, Ty.bv]\n | .pack => [Ty.bv, Ty.bv]\n | .packh => [Ty.bv, Ty.bv]\n | .packw => [Ty.bv, Ty.bv]\n | .mv => [Ty.bv]\n | .not => [Ty.bv]\n | .neg => [Ty.bv]\n | .negw => [Ty.bv]\n | .sextw => [Ty.bv]\n | .zextb => [Ty.bv]\n | .zextw => [Ty.bv]\n | .seqz => [Ty.bv]\n | .snez => [Ty.bv]\n | .sltz => [Ty.bv]\n | .sgtz => [Ty.bv]"
},
{
"name": "Op",
"content": "inductive Op\n \n | li : (val : BitVec 64) → Op\n | lui (imm : BitVec 20)\n | auipc (imm : BitVec 20)\n | addi (imm : BitVec 12)\n | andi (imm : BitVec 12)\n | ori (imm : BitVec 12)\n | xori (imm : BitVec 12)\n | addiw (imm : BitVec 12)\n | add\n | slli (shamt : BitVec 6)\n | sub\n | and\n | or\n | xor\n | sll\n | srl\n | sra\n | addw\n | subw\n | sllw\n | srlw\n | sraw\n | slti (imm : BitVec 12)\n | sltiu (imm : BitVec 12)\n | srli (shamt : BitVec 6)\n | srai (shamt : BitVec 6)\n | slliw (shamt : BitVec 5)\n | srliw (shamt : BitVec 5)\n | sraiw (shamt : BitVec 5)\n | slt\n | sltu\n \n | mul\n | mulw\n | mulh\n | mulhu\n | mulhsu\n | divw\n | divuw\n | div\n | divu\n | remw\n | rem\n | remuw\n | remu\n \n \n | adduw\n | sh1adduw\n | sh2adduw\n | sh3adduw\n | sh1add\n | sh2add\n | sh3add\n | slliuw (shamt : BitVec 6)\n \n | andn\n | orn\n | xnor\n | clz\n | clzw\n | ctz\n | ctzw\n | max\n | maxu\n | min\n | minu\n | sextb\n | sexth\n | zexth\n | rol\n | rolw\n | ror\n | rori (_shamt : BitVec 6)\n | roriw (_shamt : BitVec 5)\n | rorw\n \n | bclr\n | bclri (shamt : BitVec 6)\n | bext\n | bexti (shamt : BitVec 6)\n | binv\n | binvi (shamt : BitVec 6)\n | bset\n | bseti (shamt : BitVec 6)\n \n | pack\n | packh\n | packw\n \n | mv\n | not\n | neg\n | negw\n | sextw\n | zextb\n | zextw\n | seqz\n | snez\n | sltz\n | sgtz\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty\n | bv : Ty\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "",
"content": "instance : DialectSignature (FHE q n) := ⟨Op.signature⟩"
},
{
"name": "",
"content": "instance : DialectSignature LLVM where\n signature op := ⟨op.sig, [], [op.outTy], .pure⟩"
},
{
"name": "",
"content": "instance : DialectSignature HSxComb where\n signature := fun op =>\n match op with\n | .comb o => liftSig (signature o) \n \n \n | .hs o => MLIR2Handshake.instDialectSignatureHandshake.signature o"
},
{
"name": "Op",
"content": "inductive Op : Type _\n | comb (o : MLIR2Comb.Comb.Op)\n | hs (o : MLIR2Handshake.Handshake.Op)\n deriving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "liftSig",
"content": "def liftSig (sig : Signature MLIR2Comb.Ty) : Signature MLIR2Handshake.Ty :=\n Signature.mk (sig.sig.map liftTy) [] (liftTy sig.outTy)"
},
{
"name": "liftTy",
"content": "def liftTy : MLIR2Comb.Ty → MLIR2Handshake.Ty\n| .bitvec w => .stream (.bitvec w)"
},
{
"name": "Ty",
"content": "inductive Ty\n| stream (ty2 : Ty2) : Ty \n| stream2 (ty2 : Ty2) : Ty \n| stream2token (ty2 : Ty2) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty\n| bitvec (w : Nat) : Ty \nderiving DecidableEq, Repr, ToExpr"
},
{
"name": "Ty2",
"content": "inductive Ty2\n | bitvec (w : Nat) : Ty2\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "map",
"content": "def map {α β : Type} (s : Stream α) (f : α → β) : Stream β :=\n fun i => (s i).map f"
},
{
"name": "Stream",
"content": "def Stream (β : Type) := Stream' (Option β)"
},
{
"name": "",
"content": "instance : DialectSignature DCxComb where\n signature := fun op =>\n match op with\n | .comb o => liftSig (signature o) \n \n \n | .dc o => MLIR2DC.instDialectSignatureDC.signature o"
},
{
"name": "Op",
"content": "inductive Op : Type _\n | comb (o : MLIR2Comb.Comb.Op)\n | dc (o : MLIR2DC.DC.Op)\n deriving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "liftSig",
"content": "def liftSig (sig : Signature MLIR2Comb.Ty) : Signature MLIR2DC.Ty :=\n Signature.mk (sig.sig.map liftTy) [] (liftTy sig.outTy)"
},
{
"name": "liftTy",
"content": "def liftTy : MLIR2Comb.Ty → MLIR2DC.Ty\n| .bitvec w => .valuestream w"
},
{
"name": "Ty",
"content": "inductive Ty\n| tokenstream : Ty\n| tokenstream2 : Ty\n| valuestream (w : Nat) : Ty \n| valuestream2 (w : Nat) : Ty \n| valuetokenstream (w : Nat) : Ty \n| variadicvaluetokenstream (w : Nat) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "[SIG",
"content": "instance [SIG : DialectSignature d] [DENOTE : DialectDenote d] {Γ : Ctxt d.Ty} {t}\n (com : Com d Γ .pure t) : Inhabited (DCEType com) where\n default :=\n ⟨Γ, Hom.id, com, by admit /- proof elided -/\n ⟩"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq, Repr"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Ex Γ .pure [.nat] :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "LLVMPlusRiscVSignature",
"content": "@[simp]\ninstance LLVMPlusRiscVSignature : DialectSignature LLVMPlusRiscV where\n signature\n | .llvm llvmOp => .llvm <$> DialectSignature.signature llvmOp\n | .riscv riscvOp => .riscv <$> DialectSignature.signature riscvOp\n | .castRiscv w =>\n {sig := [Ty.riscv .bv], returnTypes := [Ty.llvm (.bitvec w)], regSig := []}\n | .castLLVM w =>\n {sig := [Ty.llvm (.bitvec w)], returnTypes := [Ty.riscv .bv], regSig := []}"
},
{
"name": "Op",
"content": "inductive Op where\n | llvm : LLVM.Op -> Op\n | riscv : RISCV64.RV64.Op -> Op\n | castRiscv : Nat → Op\n | castLLVM : Nat → Op\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Ty",
"content": "inductive Ty where\n | llvm : LLVM.Ty -> Ty\n | riscv : RISCV64.RV64.Ty -> Ty\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "",
"content": "instance : DialectSignature ExOp ExTy where\n signature\n | .add => ⟨[.nat, .nat], [], .nat, .pure⟩\n | .beq => ⟨[.nat, .nat], [], .bool, .pure⟩\n | .cst _ => ⟨[], [], .nat, .pure⟩"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | beq : ExOp\n | cst : ℕ → ExOp\n deriving DecidableEq, Repr"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .nat) : Expr Γ .nat :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := EffectKind.le_refl _)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n deriving DecidableEq, Repr"
},
{
"name": "Expr",
"content": "abbrev Expr (Γ) (ty) := _root_.Expr ExOp Γ .pure ty"
},
{
"name": "cst",
"content": "def cst {Γ : Ctxt _} (n : ℕ) : Expr Γ .nat :=\n Expr.mk\n (op := .cst n)\n (ty_eq := rfl)\n (eff_le := EffectKind.le_refl _)\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "",
"content": "instance : DialectSignature ExOp ExTy where\n signature\n | .add => ⟨[.nat, .nat], [], .nat, .pure⟩\n | .runK _ => ⟨[.nat], [([.nat], .nat)], .nat, .pure⟩"
},
{
"name": "ExOp",
"content": "inductive ExOp : Type\n | add : ExOp\n | runK : ℕ → ExOp\n deriving DecidableEq, Repr"
},
{
"name": "add",
"content": "def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .nat) : Expr Γ .nat :=\n Expr.mk\n (op := .add)\n (ty_eq := rfl)\n (eff_le := EffectKind.pure_le _)\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "[TyDenote",
"content": "@[reducible]\ninstance [TyDenote d.Ty] [DialectSignature d] [DialectDenote d]\n [B : HasBool d] [N : HasNat d] [I : HasInt d] : DialectSignature (Scf d) where\n signature\n | .coe o => signature (d:=d) o\n | .if t t' => ⟨[B.ty, t], [(⟨[t]⟩, [t']), (⟨[t]⟩, [t'])], [t'], .impure⟩\n \n \n \n \n \n | .for t => ⟨[ I.ty, I.ty, N.ty, t], [(⟨[I.ty, t]⟩, [t])], [t], .impure⟩\n | .run t => ⟨[t], [(⟨[t]⟩, [t])], [t], .impure⟩\n | .iterate _k => ⟨[I.ty], [(⟨[I.ty]⟩, [I.ty])], [I.ty], .impure⟩"
},
{
"name": "HasTy",
"content": "class HasTy (d : Dialect) (DenotedTy : Type) [TyDenote d.Ty] [DialectSignature d] where\n ty : d.Ty\n denote_eq : toType ty = DenotedTy := by admit /- proof elided -/"
},
{
"name": "Scf.Op",
"content": "inductive Scf.Op (Op' Ty' : Type) (m') [TyDenote Ty'] [DialectSignature ⟨Op', Ty', m'⟩]\n [DialectDenote ⟨Op', Ty', m'⟩] : Type _\n | coe (o : Op')\n | iterate (k : ℕ) \n | run (inputty : Ty') \n | if (inputty retty' : Ty') \n | for (ty : Ty')\n deriving DecidableEq, Repr"
},
{
"name": "iterate",
"content": "@[simp_denote] def iterate {Γ : Ctxt _} (k : Nat) (input : Var Γ Arith.Ty.int)\n (body : Com ScfArith ⟨[.int]⟩ .impure .int) : Expr ScfArith Γ .impure .int :=\n Expr.mk\n (op := .iterate k)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons input .nil)\n (regArgs := HVector.cons body HVector.nil)"
},
{
"name": "ScfArith",
"content": "abbrev ScfArith := Scf Arith"
},
{
"name": "Scf",
"content": "def Scf (d : Dialect) [TyDenote d.Ty] [DialectSignature d] [DialectDenote d] : Dialect where\n Op := Scf.Op d.Op d.Ty d.m\n Ty := d.Ty\n m := d.m"
},
{
"name": "Op",
"content": "inductive Op\n | add : Op \n | add_nat : Op \n | axpy : Op \n | neg : Op \n | const : (val : ℤ) → Op\n | const_nat : (val : ℕ) → Op"
},
{
"name": "run",
"content": "@[simp_denote]\ndef run {Γ : Ctxt _} {t : Arith.Ty} (v : Var Γ t) (body : Com ScfArith ⟨[t]⟩ .impure t) :\n Expr ScfArith Γ .impure t :=\n Expr.mk\n (op := .run t)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons v .nil)\n (regArgs := HVector.cons body <| HVector.nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n| int\n| bool\n| nat\n deriving DecidableEq, Repr"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "neg",
"content": "@[simp_denote] def neg {Γ : Ctxt _} (a : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .neg)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "axpy",
"content": "@[simp_denote] def axpy {Γ : Ctxt _} (a : Var Γ .int) (x : Var Γ .nat) (b: Var Γ .int) :\n Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .axpy)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons x <| .cons b .nil)\n (regArgs := .nil)"
},
{
"name": "add_nat",
"content": "@[simp_denote] def add_nat (e₁ e₂ : Var Γ .nat) : Expr ScfArith Γ .pure .nat :=\n Expr.mk\n (op := .coe <| .add_nat)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n | int\n \n | int2\n deriving DecidableEq, Lean.ToExpr"
},
{
"name": "Op",
"content": "inductive Op\n | noop\n | mkPair\n | unPair\n deriving Lean.ToExpr"
},
{
"name": "Arith",
"content": "abbrev Arith : Dialect := {Op, Ty}"
},
{
"name": "",
"content": "@[reducible]\ninstance : DialectSignature Arith where\n signature\n | .axpy => ⟨[.int, .nat, .int], [], [.int], .pure⟩\n | .neg => ⟨[.int], [], [.int], .pure⟩\n | .const _ => ⟨[], [], [.int], .pure⟩\n | .const_nat _ => ⟨[], [], [.nat], .pure⟩\n | .add => ⟨[.int, .int], [], [.int], .pure⟩\n | .add_nat => ⟨[.nat, .nat], [], [.nat], .pure⟩"
},
{
"name": "add",
"content": "@[simp_denote] def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Option.map_none",
"module": "Init.Data.Option.Basic"
},
{
"name": "Option.map_some",
"module": "Init.Data.Option.Basic"
},
{
"name": "cast_eq_iff_heq",
"module": "Batteries.Logic"
},
{
"name": "Function.comp_apply",
"module": "Init.Core"
},
{
"name": "Option.map_eq_map",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Option.map_map",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "heq_eq_eq",
"module": "Init.SimpLemmas"
},
{
"name": "true_and",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "map_map",
"content": "theorem map_map {A B C : α → Type*} {l : List α} (t : HVector A l)\n (f : ∀ a, A a → B a) (g : ∀ a, B a → C a) :\n (t.map f).map g = t.map (fun a v => g a (f a v))"
}
] | [
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "Signature.mk",
"content": "abbrev Signature.mk (sig : List Ty) (regSig : RegionSignature Ty) (returnTypes : List Ty) : Signature Ty :=\n { sig, regSig, returnTypes }"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "DialectSignature.sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "DialectSignature.regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "DialectSignature.returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "DialectSignature.effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Expr",
"content": "inductive Expr : (Γ : Ctxt d.Ty) → (eff : EffectKind) → (ty : List d.Ty) → Type where\n | mk {Γ} {ty} (op : d.Op)\n (ty_eq : ty = DialectSignature.returnTypes op)\n (eff_le : DialectSignature.effectKind op ≤ eff)\n (args : HVector (Var Γ) <| DialectSignature.sig op)\n \n (regArgs : HVector (fun t : Ctxt d.Ty × List d.Ty => Com t.1 .impure t.2)\n (DialectSignature.regSig op)) : Expr Γ eff ty"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "HVector",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Expr",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Com.decidableEq",
"content": "protected instance Com.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty]\n {Γ : Ctxt d.Ty} {eff : EffectKind} {tys : List d.Ty} : DecidableEq (Com d Γ eff tys)\n | .rets v₁, .rets v₂ => decidable_of_iff (v₁ = v₂) (by admit /- proof elided -/\n )\n | .var (ty := ty₁) e₁ body₁, .var (ty := ty₂) e₂ body₂ =>\n if hα : ty₁ = ty₂\n then by\n subst hα\n letI := Expr.decidableEq e₁ e₂\n letI := Com.decidableEq body₁ body₂\n exact decidable_of_iff (e₁ = e₂ ∧ body₁ = body₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )\n | .rets _, .var _ _ => isFalse (fun h => Com.noConfusion h)\n | .var _ _, .rets _ => isFalse (fun h => Com.noConfusion h)"
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r)"
},
{
"name": "Expr.contextHom",
"content": "abbrev Expr.contextHom (e : Expr d Γ eff ts) : Γ.Hom e.outContext :=\n Hom.id.appendCodomain"
},
{
"name": "Expr.changeVars",
"content": "def Expr.changeVars (varsMap : Γ.Hom Γ') {ty} (e : Expr d Γ eff ty) :\n Expr d Γ' eff ty :=\n ⟨e.op, e.ty_eq, e.eff_le, e.args.map varsMap, e.regArgs⟩"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "Lets.getPureExprAux",
"content": "def Lets.getPureExprAux {Γ₁ Γ₂ : Ctxt d.Ty} {t} : Lets d Γ₁ eff Γ₂ → (v : Var Γ₂ t) →\n Option (Σ ts, (Var ⟨ts⟩ t) × Expr d (Γ₂.dropUntil v) .pure ts)\n | .nil, _ => none\n | .var (Γ_out := Γ_out) (t := t) lets e, v => by admit /- proof elided -/\n | right v =>\n apply cast ?_ <| Lets.getPureExprAux lets v\n simp\n | left v =>\n have h : (Ctxt.dropUntil t v) ++ Γ_out = e.outContext.dropUntil v.appendInl := by admit /- proof elided -/"
},
{
"name": "Lets.getPureExpr",
"content": "def Lets.getPureExpr {Γ₁ Γ₂ : Ctxt d.Ty} (lets : Lets d Γ₁ eff Γ₂) {t : d.Ty} (v : Var Γ₂ t) :\n Option (Σ ts, (Var ⟨ts⟩ t) × Expr d Γ₂ .pure ts) :=\n (getPureExprAux lets v).map fun ⟨_, v, e⟩ =>\n ⟨_, v, e.changeVars Ctxt.dropUntilHom⟩"
}
] | [
{
"name": "Expr.changeVars_changeVars",
"content": "@[simp] theorem Expr.changeVars_changeVars (e : Expr d Γ eff ty) (f : Γ.Hom Δ) (g : Δ.Hom Ξ) :\n (e.changeVars f).changeVars g = e.changeVars (f.comp g)"
},
{
"name": "Expr.changeVars_castCodomain",
"content": "theorem Expr.changeVars_castCodomain (e : Expr d Γ eff t)\n (f : Hom Γ Δ) (h : Δ = Δ') :\n e.changeVars (f.castCodomain h) = cast (by simp [h]) (e.changeVars f)"
},
{
"name": "Lets.getPureExprAux_var_appendInr",
"content": "@[simp] theorem Lets.getPureExprAux_var_appendInr (lets : Lets d Γ_in eff Γ_out)\n (e : Expr d Γ_out eff ty₁) (v : Var Γ_out ty₂) :\n getPureExprAux (lets.var e) v.appendInr\n = (getPureExprAux lets v).map fun ⟨_, w, e⟩ =>\n ⟨_, w, e.changeVars <| Hom.id.castCodomain (by simp)⟩"
}
] | import LeanMLIR.ErasedContext
import LeanMLIR.HVector
import LeanMLIR.EffectKind
import LeanMLIR.Framework.Dialect
import Mathlib.Data.Finset.Union
open Ctxt (Var VarSet Valuation Hom)
open TyDenote (toType)
abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)
structure Signature (Ty : Type) where
mkEffectful ::
sig : List Ty
regSig : RegionSignature Ty
returnTypes : List Ty
effectKind : EffectKind := .pure
abbrev Signature.mk (sig : List Ty) (regSig : RegionSignature Ty) (returnTypes : List Ty) : Signature Ty :=
{ sig, regSig, returnTypes }
class DialectSignature (d : Dialect) where
signature : d.Op → Signature d.Ty
namespace DialectSignature
variable {d} [s : DialectSignature d]
def sig := Signature.sig ∘ s.signature
def regSig := Signature.regSig ∘ s.signature
def returnTypes := Signature.returnTypes ∘ s.signature
def effectKind := Signature.effectKind ∘ s.signature
end DialectSignature
class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where
denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →
(HVector (fun t : Ctxt d.Ty × List d.Ty =>
t.1.Valuation
→ EffectKind.impure.toMonad d.m (HVector toType t.2))
(DialectSignature.regSig op)) →
((DialectSignature.effectKind op).toMonad d.m
(HVector toType <| DialectSignature.returnTypes op))
section DataStructures
variable (d : Dialect) [DialectSignature d]
inductive Expr : (Γ : Ctxt d.Ty) → (eff : EffectKind) → (ty : List d.Ty) → Type where
| mk {Γ} {ty} (op : d.Op)
(ty_eq : ty = DialectSignature.returnTypes op)
(eff_le : DialectSignature.effectKind op ≤ eff)
(args : HVector (Var Γ) <| DialectSignature.sig op)
(regArgs : HVector (fun t : Ctxt d.Ty × List d.Ty => Com t.1 .impure t.2)
(DialectSignature.regSig op)) : Expr Γ eff ty
inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where
| rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys
| var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β
end
abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=
ts ++ Γ
abbrev Regions (regSig : RegionSignature d.Ty) : Type :=
HVector (fun t => Com d t.1 .impure t.2) regSig
inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :
(Γ_out : Ctxt d.Ty) → Type where
| nil : Lets Γ_in eff Γ_in
| var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext
variable {d} [DialectSignature d]
protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :
∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)
| _, .nil, .nil => isTrue rfl
| _, .cons x₁ v₁, .cons x₂ v₂ =>
letI := HVector.decidableEqReg v₁ v₂
letI := Com.decidableEq x₁ x₂
decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/
)
protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :
{Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)
| Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>
if ho : op₁ = op₂ then by
subst ho
letI := HVector.decidableEq arg₁ arg₂
letI := HVector.decidableEqReg regArgs₁ regArgs₂
exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/
)
else isFalse (by admit /- proof elided -/
)
protected instance Com.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty]
{Γ : Ctxt d.Ty} {eff : EffectKind} {tys : List d.Ty} : DecidableEq (Com d Γ eff tys)
| .rets v₁, .rets v₂ => decidable_of_iff (v₁ = v₂) (by admit /- proof elided -/
)
| .var (ty := ty₁) e₁ body₁, .var (ty := ty₂) e₂ body₂ =>
if hα : ty₁ = ty₂
then by
subst hα
letI := Expr.decidableEq e₁ e₂
letI := Com.decidableEq body₁ body₂
exact decidable_of_iff (e₁ = e₂ ∧ body₁ = body₂) (by admit /- proof elided -/
)
else isFalse (by admit /- proof elided -/
)
| .rets _, .var _ _ => isFalse (fun h => Com.noConfusion h)
| .var _ _, .rets _ => isFalse (fun h => Com.noConfusion h)
end -- decEq
end DataStructures
variable {d : Dialect} [DialectSignature d]
section Rec
variable {eff t} {motive : ∀ {Γ}, Com d Γ eff t → Sort u}
(rets : ∀ {Γ : Ctxt _} , (v : HVector Γ.Var t) → motive (Com.rets v))
(var : ∀ {Γ} {u},
(e : Expr d Γ eff u) → (body : Com d e.outContext eff t) →
motive body → motive (Com.var e body))
def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=
Com.rec
(motive_1 := fun _ _ _ _ => PUnit)
(motive_2 := fun _ eff' t' c =>
(h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))
(motive_3 := fun _ _ => PUnit)
(fun _ _ _ _ _ _ => ⟨⟩)
(fun v h₁ h₂ =>
cast (by admit /- proof elided -/
) <| rets (h₂ ▸ v))
(fun e' body' _ r' h₁ h₂ =>
let e := h₁ ▸ e'
let body : Com _ _ eff t := cast (by admit /- proof elided -/
) body'
let r : motive body := cast (by admit /- proof elided -/
) (r' h₁ h₂)
cast (by admit /- proof elided -/
) <| var e body r)
⟨⟩
(fun _ _ _ _ => ⟨⟩)
com
rfl
rfl
variable {rets} {var} {Γ : Ctxt _}
end Rec
def Expr.args {Γ ts} (e : Expr d Γ eff ts) :
HVector (Var Γ) (DialectSignature.sig e.op) :=
Expr.casesOn e (fun _ _ _ args _ => args)
def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :
Regions d (DialectSignature.regSig e.op) :=
Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)
section Lemmas
namespace Com
end Com
end Lemmas
def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=
Com.rec' (motive := fun _ => Ctxt d.Ty)
(@fun Γ _ => Γ)
(fun _ _ r => r)
abbrev Expr.contextHom (e : Expr d Γ eff ts) : Γ.Hom e.outContext :=
Hom.id.appendCodomain
section Lemmas
end Lemmas
variable [TyDenote d.Ty] [DialectDenote d] [DecidableEq d.Ty] [Monad d.m] [LawfulMonad d.m]
end
section Unfoldings
open EffectKind (liftEffect)
end Unfoldings
section Lemmas
end Lemmas
def Expr.changeVars (varsMap : Γ.Hom Γ') {ty} (e : Expr d Γ eff ty) :
Expr d Γ' eff ty :=
⟨e.op, e.ty_eq, e.eff_le, e.args.map varsMap, e.regArgs⟩
section Lemmas
variable {Γ Γ' : Ctxt d.Ty} {t} (f : Γ.Hom Γ') (e : Expr d Γ eff t) (V : Γ'.Valuation)
end Lemmas
structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)
(Γ_out : Ctxt d.Ty) (ts : List d.Ty) where
lets : Lets d Γ_in eff Γ_out
rets : HVector Γ_out.Var ts
section Lemmas
end Lemmas
section toPureLemmas
variable {Γ eff ty} {e : Expr d Γ eff ty} (h : e.HasPureOp)
end toPureLemmas
section DenoteInsert
end DenoteInsert
def Lets.getPureExprAux {Γ₁ Γ₂ : Ctxt d.Ty} {t} : Lets d Γ₁ eff Γ₂ → (v : Var Γ₂ t) →
Option (Σ ts, (Var ⟨ts⟩ t) × Expr d (Γ₂.dropUntil v) .pure ts)
| .nil, _ => none
| .var (Γ_out := Γ_out) (t := t) lets e, v => by admit /- proof elided -/
| right v =>
apply cast ?_ <| Lets.getPureExprAux lets v
simp
| left v =>
have h : (Ctxt.dropUntil t v) ++ Γ_out = e.outContext.dropUntil v.appendInl := by admit /- proof elided -/
def Lets.getPureExpr {Γ₁ Γ₂ : Ctxt d.Ty} (lets : Lets d Γ₁ eff Γ₂) {t : d.Ty} (v : Var Γ₂ t) :
Option (Σ ts, (Var ⟨ts⟩ t) × Expr d Γ₂ .pure ts) :=
(getPureExprAux lets v).map fun ⟨_, v, e⟩ =>
⟨_, v, e.changeVars Ctxt.dropUntilHom⟩ | @[simp] theorem Lets.getPureExpr_var_appendInr (lets : Lets d Γ_in eff Γ_out) (e : Expr d Γ_out _ ty₁)
(v : Var Γ_out ty₂):
getPureExpr (lets.var e) v.appendInr
= (fun ⟨_, w, e'⟩ => ⟨_, w, e'.changeVars <| e.contextHom⟩) <$> (getPureExpr lets v) := | := by
simp only [getPureExpr, getPureExprAux_var_appendInr, Option.map_eq_map, Option.map_map]
congr 1
funext ⟨_, e⟩
simp only [Function.comp_apply, Expr.changeVars_changeVars, Sigma.mk.injEq, heq_eq_eq, true_and]
congr 2
funext t v
apply Subtype.ext
simp [Hom.castCodomain]
grind | 6 | 76 | false | Compiler |
344 | mem_matchArg | theorem mem_matchArg {Δ_out}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out}
{l : List d.Ty} {argsₗ : HVector (Var Γ_out) l}
{argsᵣ : HVector (Var Δ_out) l} {ma : Mapping Δ_in Γ_out}
{varMap : Mapping Δ_in Γ_out}
(hvarMap : ((), varMap) ∈ matchArg lets matchLets argsₗ argsᵣ ma)
{t' v'} : ⟨t', v'⟩ ∈ matchLets.varsOfVec argsᵣ → ⟨t', v'⟩ ∈ varMap :=
match l, argsₗ, argsᵣ/- , ma, varMap, hvarMap -/ with
| .nil, .nil, .nil /- , _, varMap, _ -/ => by simp [Lets.varsOfVec]
| .cons t ts, .cons vₗ argsₗ, .cons vᵣ args /-, ma, varMap, h -/ => by
simp only [matchArg, bind, Option.mem_def, StateT.bind, Option.bind_eq_some_iff] at hvarMap
rcases hvarMap with ⟨ma', h₁, h₂⟩
simp only [HVector.vars_cons, Finset.biUnion_insert, Finset.mem_union,
Finset.mem_biUnion, Sigma.exists, Lets.varsOfVec]
rintro (h | ⟨a, b, hab⟩)
· exact AList.keys_subset_keys_of_entries_subset_entries
(isMonotone_matchArg _ _ h₂)
(mem_matchVar (matchLets := matchLets) h₁ h)
· apply mem_matchArg h₂
unfold Lets.varsOfVec
apply Finset.mem_biUnion.mpr ⟨_, hab.1, hab.2⟩ | lean-mlir | LeanMLIR/LeanMLIR/Transforms/Rewrite/Match.lean | [
"import LeanMLIR.Framework",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Transforms.Rewrite.Mapping"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "AList",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "AList.insert",
"module": "Mathlib.Data.List.AList"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "Valuation.map",
"module": "Mathlib.RingTheory.Valuation.Basic"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Sigma",
"module": "Init.Core"
},
{
"name": "StateT.bind",
"module": "Init.Control.State"
},
{
"name": "Sigma.mk",
"module": "Init.Core"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Iff",
"module": "Init.Core"
},
{
"name": "IsEmpty",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Set.Subset",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "List.Subset",
"module": "Init.Data.List.Basic"
},
{
"name": "reduceCtorEq",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
}
] | [
{
"name": "Mapping",
"content": "abbrev Mapping (Γ Δ : Ctxt Ty) : Type :=\n @AList (Σ t, Var Γ t) (fun x => Var Δ x.1)"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "last",
"content": "@[match_pattern]\ndef last (Γ : Ctxt Ty) (t : Ty) : Ctxt.Var (Ctxt.cons t Γ) t :=\n ⟨0, by admit /- proof elided -/\n ⟩"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Lets.varsOfVec",
"content": "def Lets.varsOfVec (lets : Lets d Γ_in eff Γ_out) (vs : HVector Γ_out.Var ts) :\n VarSet Γ_in :=\n (vs.vars).biUnion (fun v => lets.vars v.2)"
},
{
"name": "Lets.vars",
"content": "def Lets.vars : Lets d Γ_in eff Γ_out → Var Γ_out t → VarSet Γ_in\n | .nil, v => VarSet.ofVar v\n | .var lets e, v => by admit /- proof elided -/\n | right v => exact lets.vars v\n | left _ => exact lets.varsOfVec e.args"
},
{
"name": "Com.vars",
"content": "def Com.vars (com : Com d Γ eff ts) : VarSet Γ :=\n com.toLets.varsOfVec com.returnVars"
},
{
"name": "Expr.returnVars",
"content": "def Expr.returnVars (e : Expr d Γ eff tys) : HVector e.outContext.Var tys :=\n .ofFn _ _ <| fun i => (Var.ofFin i).appendInl"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "ofFin",
"content": "def ofFin (i : Fin Γ.length) : Γ.Var (Γ[i]) :=\n ⟨i.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Com.returnVars",
"content": "def Com.returnVars : (com : Com d Γ eff ts) → HVector (Var com.outContext) ts\n | .rets vs => vs\n | .var _ body => body.returnVars"
},
{
"name": "Com.toLets",
"content": "def Com.toLets (com : Com d Γ eff t) : Lets d Γ eff com.outContext :=\n Lets.nil.addComToEnd com"
},
{
"name": "VarSet",
"content": "abbrev VarSet (Γ : Ctxt Ty) : Type :=\n Finset (Σ t, Γ.Var t)"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "HVector.vars",
"content": "def HVector.vars {l : List d.Ty} (T : HVector (Var Γ) l) : VarSet Γ :=\n T.foldl (fun _ s a => insert ⟨_, a⟩ s) ∅"
},
{
"name": "ofVar",
"content": "@[simp]\ndef ofVar {Γ : Ctxt Ty} (v : Γ.Var t) : VarSet Γ :=\n {⟨_, v⟩}"
},
{
"name": "foldl",
"content": "def foldl {B : Type*} (f : ∀ (a : α), B → A a → B) :\n ∀ {l : List α}, B → HVector A l → B\n | [], b, .nil => b\n | t::_, b, .cons a as => foldl f (f t b a) as"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Bool.false_eq_true",
"module": "Init.Data.Bool"
},
{
"name": "IsEmpty.exists_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "Option.isSome_none",
"module": "Init.Data.Option.Basic"
},
{
"name": "iff_false",
"module": "Init.SimpLemmas"
},
{
"name": "Option.bind_eq_some_iff",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "AList.entries_insert_of_notMem",
"module": "Mathlib.Data.List.AList"
},
{
"name": "AList.lookup_eq_none",
"module": "Mathlib.Data.List.AList"
},
{
"name": "List.subset_cons_of_subset",
"module": "Init.Data.List.Sublist"
},
{
"name": "Option.mem_def",
"module": "Init.Data.Option.Instances"
},
{
"name": "IsEmpty.forall_iff",
"module": "Mathlib.Logic.IsEmpty"
},
{
"name": "forall_eq'",
"module": "Init.PropLemmas"
},
{
"name": "iff_true",
"module": "Init.SimpLemmas"
},
{
"name": "implies_true",
"module": "Init.SimpLemmas"
},
{
"name": "AList.keys_subset_keys_of_entries_subset_entries",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Finset.biUnion_insert",
"module": "Mathlib.Data.Finset.Union"
},
{
"name": "Finset.mem_biUnion",
"module": "Mathlib.Data.Finset.Union"
},
{
"name": "Finset.mem_union",
"module": "Mathlib.Data.Finset.Lattice.Basic"
},
{
"name": "AList.lookup_isSome",
"module": "Mathlib.Data.List.AList"
},
{
"name": "Finset.mem_singleton",
"module": "Mathlib.Data.Finset.Insert"
},
{
"name": "Sigma.mk.inj_iff",
"module": "Mathlib.Data.Sigma.Basic"
},
{
"name": "and_imp",
"module": "Init.SimpLemmas"
}
] | [
{
"name": "appendCases_appendInl",
"content": "@[simp] theorem appendCases_appendInl (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInl = (left v)"
},
{
"name": "HVector.vars_cons",
"content": "@[simp] theorem HVector.vars_cons {t : d.Ty} {l : List d.Ty}\n (v : Var Γ t) (T : HVector (Var Γ) l) :\n (HVector.cons v T).vars = insert ⟨_, v⟩ T.vars"
},
{
"name": "appendCases_appendInr",
"content": "@[simp] theorem appendCases_appendInr (v : Γ.Var t) :\n appendCases (motive := motive) left right v.appendInr = (right v)"
}
] | [
{
"name": "MatchVarM",
"content": "abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)"
},
{
"name": "MatchVar",
"content": "abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit"
},
{
"name": "MatchVarM.unifyVars",
"content": "def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=\n fun ma =>\n match ma.lookup ⟨_, v⟩ with\n | some v =>\n if v = w then\n some ((), ma)\n else\n none\n | none =>\n some ((), AList.insert ⟨_, v⟩ w ma)"
},
{
"name": "matchArg",
"content": "def matchArg [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :\n {l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →\n MatchVar Δ_in Γ_out\n | _, .nil, .nil => return\n | t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do\n matchVar (t := t) lets vₗ matchLets vᵣ\n matchArg lets matchLets vsₗ vsᵣ\n termination_by l => (sizeOf matchLets, l.length + 1)"
},
{
"name": "matchVar",
"content": "def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]\n (lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :\n (matchLets : Lets d Δ_in .pure Δ_out) →\n (w : Var Δ_out t) →\n MatchVar Δ_in Γ_out\n \n | @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/\n | right w =>\n exact matchVar lets v matchLets w\n | left w => exact do\n let ⟨ts', w', ie⟩ ← lets.getPureExpr v\n if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then\n have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/"
},
{
"name": "MatchVar.IsMonotone",
"content": "def MatchVar.IsMonotone (f : MatchVar Δ Γ) : Prop :=\n ∀ mapIn, ∀ mapOut ∈ f mapIn,\n mapIn.entries ⊆ mapOut.2.entries"
}
] | [
{
"name": "unifyVars_eq_some_iff",
"content": "@[simp]\ntheorem unifyVars_eq_some_iff :\n unifyVars w v mapIn = some ((), mapOut)\n ↔ ( mapIn.lookup ⟨t, w⟩ = none ∧ mapIn.insert ⟨t, w⟩ v = mapOut\n ∨ mapIn.lookup ⟨t, w⟩ = v ∧ mapIn = mapOut\n )"
},
{
"name": "MatchVar.liftM_bind_eq_some_iff",
"content": "@[simp]\ntheorem MatchVar.liftM_bind_eq_some_iff (x? : Option α)\n (f : α → MatchVarM Δ Γ β) :\n ((liftM x? >>= f) mapIn = some mapOut)\n ↔ ( ∃ h : x?.isSome,\n f (x?.get h) mapIn = some mapOut )"
},
{
"name": "MatchVar.isMonotone_bind",
"content": "@[simp]\ntheorem MatchVar.isMonotone_bind {f : MatchVar Δ Γ} {g : Unit → MatchVar Δ Γ} :\n f.IsMonotone → (g ()).IsMonotone → IsMonotone (f >>= g)"
},
{
"name": "MatchVar.isMonotone_bind_liftM",
"content": "@[simp]\ntheorem MatchVar.isMonotone_bind_liftM {x? : Option α} {g : α → MatchVar Δ Γ} :\n IsMonotone (liftM x? >>= g) ↔ (∀ x ∈ x?, (g x).IsMonotone)"
},
{
"name": "MatchVar.isMonotone_none",
"content": "@[simp] theorem MatchVar.isMonotone_none : IsMonotone (none : MatchVar Δ Γ)"
},
{
"name": "MatchVar.isMonotone_unifyVars",
"content": "theorem MatchVar.isMonotone_unifyVars : IsMonotone (unifyVars w v)"
},
{
"name": "isMonotone_matchVarArg_aux",
"content": "theorem isMonotone_matchVarArg_aux (lets : Lets d Γ_in eff Γ_out) :\n (\n ∀ (Δ_out : Ctxt d.Ty)\n (matchLets : Lets d Δ_in EffectKind.pure Δ_out) (l : List d.Ty)\n (argsl : HVector Γ_out.Var l) (argsr : HVector Δ_out.Var l),\n (matchArg lets matchLets argsl argsr).IsMonotone\n )\n ∧ (\n ∀ (Δ_out : Ctxt d.Ty) (t : d.Ty) (v : Γ_out.Var t)\n (matchLets : Lets d Δ_in EffectKind.pure Δ_out)\n (w : Var Δ_out t),\n (matchVar lets v matchLets w).IsMonotone\n )"
},
{
"name": "isMonotone_matchArg",
"content": "theorem isMonotone_matchArg [DecidableEq d.Op]\n {Γ_out Δ_in Δ_out : Ctxt d.Ty}\n {lets : Lets d Γ_in eff Γ_out}\n {matchLets : Lets d Δ_in .pure Δ_out}\n {l : List d.Ty}\n {argsl : HVector (Var Γ_out) l}\n {argsr : HVector (Var Δ_out) l} :\n (matchArg lets matchLets argsl argsr).IsMonotone"
}
] | import LeanMLIR.Framework
import LeanMLIR.Transforms.Rewrite.Mapping
open Ctxt (Var VarSet Valuation Hom)
variable {d} [DialectSignature d] [DecidableEq d.Ty]
variable {Γ : Ctxt d.Ty} {ty : d.Ty}
abbrev MatchVarM (Δ Γ : Ctxt d.Ty) := (StateT (Mapping Δ Γ) Option)
abbrev MatchVar (Δ Γ : Ctxt d.Ty) := MatchVarM Δ Γ Unit
def MatchVarM.unifyVars {Δ Γ : Ctxt d.Ty} (v : Δ.Var t) (w : Γ.Var t) : MatchVar Δ Γ :=
fun ma =>
match ma.lookup ⟨_, v⟩ with
| some v =>
if v = w then
some ((), ma)
else
none
| none =>
some ((), AList.insert ⟨_, v⟩ w ma)
open MatchVarM
variable [DecidableEq d.Op]
def matchArg [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (matchLets : Lets d Δ_in .pure Δ_out) :
{l : List d.Ty} → HVector (Var Γ_out) l → HVector (Var Δ_out) l →
MatchVar Δ_in Γ_out
| _, .nil, .nil => return
| t::l, .cons vₗ vsₗ, .cons vᵣ vsᵣ => do
matchVar (t := t) lets vₗ matchLets vᵣ
matchArg lets matchLets vsₗ vsᵣ
termination_by l => (sizeOf matchLets, l.length + 1)
def matchVar {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty} {t : d.Ty} [DecidableEq d.Op]
(lets : Lets d Γ_in eff Γ_out) (v : Var Γ_out t) :
(matchLets : Lets d Δ_in .pure Δ_out) →
(w : Var Δ_out t) →
MatchVar Δ_in Γ_out
| @Lets.var _ _ _ _ Δ_out ts matchLets matchExpr, w => by admit /- proof elided -/
| right w =>
exact matchVar lets v matchLets w
| left w => exact do
let ⟨ts', w', ie⟩ ← lets.getPureExpr v
if hs : ∃ h : ie.op = matchExpr.op, ie.regArgs = (h ▸ matchExpr.regArgs) then
have hts : Ctxt.ofList ts' = ts := by admit /- proof elided -/
end
section MatchVar
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out t te}
{lets : Lets d Γ_in eff Γ_out} {v : Var Γ_out t}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
variable (lets v matchLets w) (mapIn : Mapping _ _) in
variable (lets matchLets) {tys} (vs ws : HVector _ tys) (mapIn : Mapping _ _) in
namespace MatchVarResult
variable [TyDenote d.Ty] [∀ (t : d.Ty), Inhabited ⟦t⟧] in
section Left
variable {w : Δ_out.Var t}
variable {mapIn} (mapOut : MatchVarResult lets v (.var matchLets matchExpr) w.appendInr mapIn)
end Left
variable {w : Var ⟨te⟩ _} {mapIn}
end MatchVarResult
end MatchVar
section SubsetEntries
def MatchVar.IsMonotone (f : MatchVar Δ Γ) : Prop :=
∀ mapIn, ∀ mapOut ∈ f mapIn,
mapIn.entries ⊆ mapOut.2.entries
open MatchVar
section UnifyVars
variable {Δ Γ : Ctxt d.Ty} {t} (w : Δ.Var t) (v : Γ.Var t)
end UnifyVars
variable [DecidableEq d.Op]
end SubsetEntries
namespace MatchArgResult
variable [DecidableEq d.Op] {Γ_in Γ_out Δ_in Δ_out te}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out}
{matchExpr : Expr d Δ_out .pure te}
{u us}
{v : Γ_out.Var u} {vs : HVector Γ_out.Var us}
{w : Δ_out.Var u} {ws : HVector Δ_out.Var us}
{mapIn : Mapping _ _}
(mapOut : MatchArgResult lets matchLets (v ::ₕ vs) (w ::ₕ ws) mapIn)
end MatchArgResult
section DenoteLemmas
variable [TyDenote d.Ty] [DecidableEq d.Op]
variable [∀ (t : d.Ty), Inhabited ⟦t⟧]
variable [Monad d.m] [LawfulMonad d.m] [DialectDenote d]
section DenoteIntoSubtype
end DenoteIntoSubtype
variable {Γ_in Γ_out Δ_in Δ_out : Ctxt d.Ty}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out} | theorem mem_matchArg {Δ_out}
{lets : Lets d Γ_in eff Γ_out}
{matchLets : Lets d Δ_in .pure Δ_out}
{l : List d.Ty} {argsₗ : HVector (Var Γ_out) l}
{argsᵣ : HVector (Var Δ_out) l} {ma : Mapping Δ_in Γ_out}
{varMap : Mapping Δ_in Γ_out}
(hvarMap : ((), varMap) ∈ matchArg lets matchLets argsₗ argsᵣ ma)
{t' v'} : ⟨t', v'⟩ ∈ matchLets.varsOfVec argsᵣ → ⟨t', v'⟩ ∈ varMap := | :=
match l, argsₗ, argsᵣ/- , ma, varMap, hvarMap -/ with
| .nil, .nil, .nil /- , _, varMap, _ -/ => by simp [Lets.varsOfVec]
| .cons t ts, .cons vₗ argsₗ, .cons vᵣ args /-, ma, varMap, h -/ => by
simp only [matchArg, bind, Option.mem_def, StateT.bind, Option.bind_eq_some_iff] at hvarMap
rcases hvarMap with ⟨ma', h₁, h₂⟩
simp only [HVector.vars_cons, Finset.biUnion_insert, Finset.mem_union,
Finset.mem_biUnion, Sigma.exists, Lets.varsOfVec]
rintro (h | ⟨a, b, hab⟩)
· exact AList.keys_subset_keys_of_entries_subset_entries
(isMonotone_matchArg _ _ h₂)
(mem_matchVar (matchLets := matchLets) h₁ h)
· apply mem_matchArg h₂
unfold Lets.varsOfVec
apply Finset.mem_biUnion.mpr ⟨_, hab.1, hab.2⟩ | 7 | 104 | false | Compiler |
345 | transBV_spec | @[simp]
lemma transBV_spec {m : CNFA n} {res} {s : m.m.states} :
s' ∈ bv_to_set (m.m.transBV' res s a) ↔
(s' ∈ bv_to_set res ∨ s' ∈ m.m.tr s a) | lean-mlir | Blase/Blase/AutoStructs/Constructions.lean | [
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Worklist",
"import Mathlib.Tactic.ApplyFun",
"import Mathlib.Data.Fintype.Prod"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "LawfulBEq",
"module": "Init.Core"
}
] | [
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "Std.HashSet.toSet",
"content": "def Std.HashSet.toSet [BEq α] [Hashable α] (m : HashSet α) : Set α := { x | x ∈ m }"
}
] | [
{
"name": "Finset.mem_range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Nat.lt_of_le_of_lt",
"module": "Init.Prelude"
},
{
"name": "Set.mem_insert_iff",
"module": "Mathlib.Data.Set.Insert"
},
{
"name": "Set.union_singleton",
"module": "Mathlib.Data.Set.Insert"
},
{
"name": "not_lt",
"module": "Mathlib.Order.Defs.LinearOrder"
}
] | [
{
"name": "Std.HashSet.fold_induction",
"content": "theorem Std.HashSet.fold_induction [BEq α] [LawfulBEq α] [Hashable α]\n {f : β → α → β} {m : HashSet α} {motive : β → Set α → Prop} :\n motive b ∅ →\n (∀ b x s, x ∉ s → motive b s → motive (f b x) (s ∪ {x})) →\n motive (m.fold f b) m.toSet"
},
{
"name": "Std.HashSet.toSet_toList[BEq",
"content": "theorem Std.HashSet.toSet_toList[BEq α] [LawfulBEq α] [Hashable α] (m : HashSet α) : m.toSet = { x | x ∈ m.toList }"
}
] | [
{
"name": "bv_to_set",
"content": "private def bv_to_set (bv : BitVec w) : Set State :=\n { s | bv.getLsbD s }"
}
] | [
{
"name": "bv_to_set_or",
"content": "@[simp]\nlemma bv_to_set_or {m : CNFA n} (x y : BitVec m.m.stateMax) :\n (s ∈ bv_to_set (x ||| y)) ↔ (s ∈ bv_to_set x ∨ s ∈ bv_to_set y)"
},
{
"name": "bv_to_set_shift",
"content": "@[simp]\nlemma bv_to_set_shift (x s : Nat) :\n (s ∈ bv_to_set (1#w <<< x)) ↔ (s = x ∧ x < w)"
}
] | import Mathlib.Data.Fintype.Prod
import Blase.AutoStructs.Worklist
import Mathlib.Tactic.ApplyFun
open SetRel
section sink
variable {A : Type} [BEq A] [Hashable A] [DecidableEq A] [FinEnum A]
end sink
section generic_prod
variable {α} [BEq α] [Hashable α] [LawfulBEq α]
variable {β} [BEq β] [Hashable β] [LawfulBEq β]
variable {S₁ : Finset α} {S₂ : Finset β}
variable {γ} (f : S₁ → S₂ → γ) (hinj : Function.Injective2 f)
variable {m₁ : Std.HashSet α} (hm₁ : ∀ s₁ ∈ m₁, s₁ ∈ S₁)
variable {m₂ : Std.HashSet β} (hm₂ : ∀ s₂ ∈ m₂, s₂ ∈ S₂)
end generic_prod
section product
variable {A : Type} [BEq A] [LawfulBEq A] [Hashable A] [DecidableEq A] [FinEnum A]
end product
section determinization
variable {A : Type} [BEq A] [LawfulBEq A] [Hashable A] [DecidableEq A] [FinEnum A]
private def bv_to_set (bv : BitVec w) : Set State :=
{ s | bv.getLsbD s } | @[simp]
lemma transBV_spec {m : CNFA n} {res} {s : m.m.states} :
s' ∈ bv_to_set (m.m.transBV' res s a) ↔
(s' ∈ bv_to_set res ∨ s' ∈ m.m.tr s a) := | := by
let motive (bv : BitVec m.m.stateMax) (X : Set State) :=
∀ s' (hlt : s' < m.m.stateMax),
s' ∈ bv_to_set bv ↔ (s' ∈ bv_to_set res ∨ s' ∈ X)
suffices h : motive (m.m.transBV' res s a) (m.m.tr s a).toSet by
by_cases hlt : s' < m.m.stateMax
· simp_all [motive]
· constructor
· simp_all [bv_to_set]
· rintro (h | h); simp_all [bv_to_set]
apply m.wf.trans_tgt_lt at h; simp_all only [RawCNFA.states, not_lt, Finset.mem_range]
suffices _ : m.m.stateMax < m.m.stateMax by simp_all
exact Nat.lt_of_le_of_lt hlt h
apply Std.HashSet.fold_induction
· simp [motive]
rintro bv s S hnin ih s' hlt
simp only [bv_to_set_or, bv_to_set_shift, Set.union_singleton, Set.mem_insert_iff]
constructor
· rintro (hold | ⟨rfl, hin⟩)
· apply ih _ hlt |>.mp at hold; tauto
· tauto
· rintro (hold | rfl | hS)
· left; apply (ih _ hlt).mpr; tauto
· tauto
· left; apply (ih _ hlt).mpr; tauto | 2 | 28 | false | Compiler |
346 | autOfRelation_accepts | @[simp]
lemma autOfRelation_accepts (r : Relation) :
r.absAutOfRelation.accepts = r.language | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fintype",
"module": "Mathlib.Data.Fintype.Defs"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "cmp",
"module": "Mathlib.Data.Ordering.Basic"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "BitVec.ofFin",
"module": "Init.Prelude"
},
{
"name": "BitVec.ule",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.ult",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.sle",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.slt",
"module": "Init.Data.BitVec.Basic"
}
] | [
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "RelationOrdering",
"content": "inductive RelationOrdering\n| lt | le | gt | ge\nderiving Repr, Fintype"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "Relation",
"content": "inductive Relation\n| eq\n| signed (ord : RelationOrdering)\n| unsigned (ord : RelationOrdering)\nderiving Repr"
},
{
"name": "evalRelation",
"content": "def evalRelation (rel : Relation) {w} (bv1 bv2 : BitVec w) : Prop :=\n match rel with\n | .eq => bv1 = bv2\n | .signed .lt => bv1.slt bv2\n | .signed .le => bv1.sle bv2\n | .signed .gt => bv2.slt bv1\n | .signed .ge => bv2.sle bv1\n | .unsigned .lt => bv1.ult bv2\n | .unsigned .le => bv1.ule bv2\n | .unsigned .gt => bv2.ult bv1\n | .unsigned .ge => bv2.ule bv1"
},
{
"name": "bv2",
"content": "def bv2 : BitVec 4 := BitVec.ofNat 4 1 "
},
{
"name": "bv1",
"content": "def bv1 : BitVec 4 := BitVec.ofNat 4 5 "
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "instFinEnumBV",
"content": "instance instFinEnumBV : FinEnum (BitVec w) where\n card := 2^w\n equiv := {\n toFun := fun x => x.toFin\n invFun := fun x => BitVec.ofFin x\n left_inv := by admit /- proof elided -/"
}
] | [
{
"name": "NFA.eval_append_singleton",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.eval_nil",
"module": "Mathlib.Computability.NFA"
},
{
"name": "BitVec.toNat_eq",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "le_iff_lt_or_eq",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "Nat.le_antisymm",
"module": "Init.Prelude"
},
{
"name": "BitVec.toInt_inj",
"module": "Init.Data.BitVec.Lemmas"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVRel",
"content": "abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "NFA'.sa2",
"content": "def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel"
},
{
"name": "langRel",
"content": "def langRel (R : BVNRel n) : Set (BitVecs n) :=\n { bvs | R bvs.bvs }"
},
{
"name": "langRel2",
"content": "def langRel2 (R : BVRel) : Set (BitVecs 2) :=\n { bvs | R (bvs.bvs.get 0) (bvs.bvs.get 1) }"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "NFA.autEq",
"content": "def NFA.autEq : NFA (BitVec 2) Unit :=\n { start := ⊤, accept := ⊤, step _ a := { _s' | if a = 0 ∨ a = 3 then true else false }}"
},
{
"name": "NFA'.autEq",
"content": "def NFA'.autEq : NFA' 2 :=\n ⟨Unit, NFA.autEq⟩"
},
{
"name": "NFA'.eqRel",
"content": "def NFA'.eqRel : BVRel := fun _ x y => x = y"
},
{
"name": "NFA.unsignedCmpState",
"content": "inductive NFA.unsignedCmpState : Type where\n| eq | gt | lt\nderiving Fintype, DecidableEq"
},
{
"name": "NFA.unsignedCmpStep",
"content": "def NFA.unsignedCmpStep (q : NFA.unsignedCmpState) (a : BitVec 2) : List NFA.unsignedCmpState :=\n match q, a with\n | .eq, 0 => [ .eq ] | .eq, 3 => [ .eq ] | .eq, 1 => [ .gt ] | .eq, 2 => [ .lt ]\n | .gt, 0 => [ .gt ] | .gt, 1 => [ .gt ] | .gt, 3 => [ .gt ] | .gt, 2 => [ .lt ]\n | .lt, 0 => [ .lt ] | .lt, 1 => [ .gt ] | .lt, 2 => [ .lt ] | .lt, 3 => [ .lt ]"
},
{
"name": "NFA.autUnsignedCmp",
"content": "def NFA.autUnsignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) unsignedCmpState where\n step s a := { s' | s' ∈ unsignedCmpStep s a }\n start := {s | s = .eq }\n accept := { s | s ∈ match cmp with | .lt => [unsignedCmpState.lt] | .le => [.lt, .eq] | .gt => [.gt] | .ge => [.gt, .eq] }"
},
{
"name": "NFA'.autUnsignedCmp",
"content": "def NFA'.autUnsignedCmp (cmp: RelationOrdering) : NFA' 2 :=\n ⟨_, NFA.autUnsignedCmp cmp⟩"
},
{
"name": "RelationOrdering.urel",
"content": "def RelationOrdering.urel (cmp : RelationOrdering) : BVRel :=\n match cmp with\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .le => fun _ bv1 bv2 => bv1.ule bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1\n | .ge => fun _ bv1 bv2 => bv2.ule bv1"
},
{
"name": "NFA'.autUnsignedCmpSA",
"content": "def NFA'.autUnsignedCmpSA (q : NFA.unsignedCmpState) : BVRel :=\n match q with\n | .eq => fun _ bv1 bv2 => bv1 = bv2\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1"
},
{
"name": "NFA.signedCmpState",
"content": "inductive NFA.signedCmpState : Type where\n| eq | gt | lt | ltfin | gtfin\nderiving DecidableEq, Fintype"
},
{
"name": "NFA.signedCmpStep",
"content": "def NFA.signedCmpStep (q : NFA.signedCmpState) (a : BitVec 2) : List NFA.signedCmpState :=\n match q, a with\n | .eq, 0 => [ .eq ] | .eq, 3 => [.eq] | .eq, 1 => [.gt, .ltfin] | .eq, 2 => [ .lt, .gtfin ]\n | .gt, 0 => [ .gt, .gtfin ] | .gt, 1 => [ .gt, .ltfin ] | .gt, 3 => [ .gt, .gtfin ] | .gt, 2 => [ .lt, .gtfin ]\n | .lt, 0 => [ .lt, .ltfin ] | .lt, 1 => [ .gt, .ltfin ] | .lt, 2 => [ .lt, .gtfin ] | .lt, 3 => [ .lt, .ltfin ]\n | .gtfin, _ => ∅\n | .ltfin, _ => ∅"
},
{
"name": "NFA.autSignedCmp",
"content": "def NFA.autSignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) signedCmpState where\n step s a := { s' | s' ∈ signedCmpStep s a }\n start := { s | s = signedCmpState.eq }\n accept := { s | s ∈ match cmp with | .lt => [NFA.signedCmpState.ltfin] | .le => [.ltfin, .eq] | .gt => [.gtfin] | .ge => [.gtfin, .eq] }"
},
{
"name": "NFA'.autSignedCmp",
"content": "def NFA'.autSignedCmp (cmp: RelationOrdering) : NFA' 2 :=\n ⟨_, NFA.autSignedCmp cmp⟩"
},
{
"name": "RelationOrdering.srel",
"content": "def RelationOrdering.srel (cmp : RelationOrdering) : BVRel :=\n match cmp with\n | .lt => fun _ bv1 bv2 => bv1.slt bv2\n | .le => fun _ bv1 bv2 => bv1.sle bv2\n | .gt => fun _ bv1 bv2 => bv2.slt bv1\n | .ge => fun _ bv1 bv2 => bv2.sle bv1"
},
{
"name": "NFA'.autSignedCmpSA",
"content": "def NFA'.autSignedCmpSA (q : NFA.signedCmpState) : BVRel :=\n match q with\n | .eq => fun _ bv1 bv2 => bv1 = bv2\n | .lt => fun _ bv1 bv2 => bv1.ult bv2\n | .gt => fun _ bv1 bv2 => bv2.ult bv1\n | .ltfin => fun _ bv1 bv2 => bv1.slt bv2\n | .gtfin => fun _ bv1 bv2 => bv2.slt bv1"
},
{
"name": "Relation.absAutOfRelation",
"content": "def Relation.absAutOfRelation (rel : Relation) : NFA' 2 :=\n match rel with\n | .eq => NFA'.autEq\n | .unsigned cmp => NFA'.autUnsignedCmp cmp\n | .signed cmp => NFA'.autSignedCmp cmp"
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
},
{
"name": "in_enc",
"content": "@[simp]\nlemma in_enc : x ∈ enc '' S ↔ dec x ∈ S"
},
{
"name": "dec_snoc_in_langRel",
"content": "@[simp]\nlemma dec_snoc_in_langRel {n} {R : BVNRel n} {w : BitVecs' n} {a : BitVec n} :\n dec (w ++ [a]) ∈ langRel R ↔\n R (List.Vector.ofFn fun k => .cons (a.getLsbD k) ((dec w).bvs.get k))"
},
{
"name": "NFA'.correct_spec",
"content": "lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :\n M.correct ζ L → M.accepts = langRel L"
},
{
"name": "NFA'.correct2_spec",
"content": "lemma NFA'.correct2_spec {M : NFA' 2} {ζ : M.sa2} {L : BVRel} :\n M.correct2 ζ L → M.accepts = langRel2 L"
},
{
"name": "NFA'.autEq_correct",
"content": "lemma NFA'.autEq_correct : autEq.correct2 (fun _ => eqRel) eqRel"
},
{
"name": "BitVec.ule_iff_ult_or_eq",
"content": "lemma BitVec.ule_iff_ult_or_eq {w : ℕ} (bv1 bv2 : BitVec w):\n (bv1.ule bv2) = true ↔ (bv1.ult bv2) = true ∨ bv1 = bv2"
},
{
"name": "ucmp_tricho",
"content": "@[simp]\nlemma ucmp_tricho {bv1 bv2 : BitVec w} : (bv2.ult bv1) = false → (bv1.ult bv2) = false → bv1 = bv2"
},
{
"name": "NFA'.autUnsignedCmp_correct",
"content": "lemma NFA'.autUnsignedCmp_correct cmp : autUnsignedCmp cmp |>.correct2 autUnsignedCmpSA cmp.urel"
},
{
"name": "BitVec.sle_iff_slt_or_eq",
"content": "private lemma BitVec.sle_iff_slt_or_eq {w : ℕ} (bv1 bv2 : BitVec w):\n (bv1.sle bv2) = true ↔ (bv1.slt bv2) = true ∨ bv1 = bv2"
},
{
"name": "NFA'.autSignedCmp_correct",
"content": "lemma NFA'.autSignedCmp_correct cmp : autSignedCmp cmp |>.correct2 autSignedCmpSA cmp.srel"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVRel := ∀ ⦃w⦄, BitVec w → BitVec w → Prop
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
def NFA'.sa2 (M : NFA' 2) := M.σ → BVRel
def langRel (R : BVNRel n) : Set (BitVecs n) :=
{ bvs | R bvs.bvs }
def langRel2 (R : BVRel) : Set (BitVecs 2) :=
{ bvs | R (bvs.bvs.get 0) (bvs.bvs.get 1) }
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
variable {arity : Type} [FinEnum arity]
open BitStream in
end fsm
section nfas_relations
def NFA.autEq : NFA (BitVec 2) Unit :=
{ start := ⊤, accept := ⊤, step _ a := { _s' | if a = 0 ∨ a = 3 then true else false }}
def NFA'.autEq : NFA' 2 :=
⟨Unit, NFA.autEq⟩
def NFA'.eqRel : BVRel := fun _ x y => x = y
inductive NFA.unsignedCmpState : Type where
| eq | gt | lt
deriving Fintype, DecidableEq
def NFA.unsignedCmpStep (q : NFA.unsignedCmpState) (a : BitVec 2) : List NFA.unsignedCmpState :=
match q, a with
| .eq, 0 => [ .eq ] | .eq, 3 => [ .eq ] | .eq, 1 => [ .gt ] | .eq, 2 => [ .lt ]
| .gt, 0 => [ .gt ] | .gt, 1 => [ .gt ] | .gt, 3 => [ .gt ] | .gt, 2 => [ .lt ]
| .lt, 0 => [ .lt ] | .lt, 1 => [ .gt ] | .lt, 2 => [ .lt ] | .lt, 3 => [ .lt ]
def NFA.autUnsignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) unsignedCmpState where
step s a := { s' | s' ∈ unsignedCmpStep s a }
start := {s | s = .eq }
accept := { s | s ∈ match cmp with | .lt => [unsignedCmpState.lt] | .le => [.lt, .eq] | .gt => [.gt] | .ge => [.gt, .eq] }
def NFA'.autUnsignedCmp (cmp: RelationOrdering) : NFA' 2 :=
⟨_, NFA.autUnsignedCmp cmp⟩
def RelationOrdering.urel (cmp : RelationOrdering) : BVRel :=
match cmp with
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .le => fun _ bv1 bv2 => bv1.ule bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
| .ge => fun _ bv1 bv2 => bv2.ule bv1
def NFA'.autUnsignedCmpSA (q : NFA.unsignedCmpState) : BVRel :=
match q with
| .eq => fun _ bv1 bv2 => bv1 = bv2
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
inductive NFA.signedCmpState : Type where
| eq | gt | lt | ltfin | gtfin
deriving DecidableEq, Fintype
def NFA.signedCmpStep (q : NFA.signedCmpState) (a : BitVec 2) : List NFA.signedCmpState :=
match q, a with
| .eq, 0 => [ .eq ] | .eq, 3 => [.eq] | .eq, 1 => [.gt, .ltfin] | .eq, 2 => [ .lt, .gtfin ]
| .gt, 0 => [ .gt, .gtfin ] | .gt, 1 => [ .gt, .ltfin ] | .gt, 3 => [ .gt, .gtfin ] | .gt, 2 => [ .lt, .gtfin ]
| .lt, 0 => [ .lt, .ltfin ] | .lt, 1 => [ .gt, .ltfin ] | .lt, 2 => [ .lt, .gtfin ] | .lt, 3 => [ .lt, .ltfin ]
| .gtfin, _ => ∅
| .ltfin, _ => ∅
def NFA.autSignedCmp (cmp: RelationOrdering) : NFA (BitVec 2) signedCmpState where
step s a := { s' | s' ∈ signedCmpStep s a }
start := { s | s = signedCmpState.eq }
accept := { s | s ∈ match cmp with | .lt => [NFA.signedCmpState.ltfin] | .le => [.ltfin, .eq] | .gt => [.gtfin] | .ge => [.gtfin, .eq] }
def NFA'.autSignedCmp (cmp: RelationOrdering) : NFA' 2 :=
⟨_, NFA.autSignedCmp cmp⟩
def RelationOrdering.srel (cmp : RelationOrdering) : BVRel :=
match cmp with
| .lt => fun _ bv1 bv2 => bv1.slt bv2
| .le => fun _ bv1 bv2 => bv1.sle bv2
| .gt => fun _ bv1 bv2 => bv2.slt bv1
| .ge => fun _ bv1 bv2 => bv2.sle bv1
def NFA'.autSignedCmpSA (q : NFA.signedCmpState) : BVRel :=
match q with
| .eq => fun _ bv1 bv2 => bv1 = bv2
| .lt => fun _ bv1 bv2 => bv1.ult bv2
| .gt => fun _ bv1 bv2 => bv2.ult bv1
| .ltfin => fun _ bv1 bv2 => bv1.slt bv2
| .gtfin => fun _ bv1 bv2 => bv2.slt bv1
end nfas_relations
def Relation.absAutOfRelation (rel : Relation) : NFA' 2 :=
match rel with
| .eq => NFA'.autEq
| .unsigned cmp => NFA'.autUnsignedCmp cmp
| .signed cmp => NFA'.autSignedCmp cmp | @[simp]
lemma autOfRelation_accepts (r : Relation) :
r.absAutOfRelation.accepts = r.language := | := by
simp [Relation.absAutOfRelation]
rcases r with ⟨⟩ | ⟨cmp⟩ | ⟨cmp⟩ <;> simp
· rw [NFA'.correct2_spec NFA'.autEq_correct]
simp [langRel2, NFA'.eqRel, evalRelation]
· rw [NFA'.correct2_spec (NFA'.autSignedCmp_correct cmp)]
simp [langRel2, evalRelation, RelationOrdering.srel]
cases cmp <;> simp
· rw [NFA'.correct2_spec (NFA'.autUnsignedCmp_correct cmp)]
simp [langRel2, evalRelation, RelationOrdering.urel]
cases cmp <;> simp | 6 | 90 | false | Compiler |
347 | ScfFunctor.ForAddToMul.correct | theorem correct : Com.denote (lhs v0) = Com.denote (rhs v0) | lean-mlir | SSA/Projects/Scf/ScfFunctor.lean | [
"import LeanMLIR.Util",
"import LeanMLIR.Framework",
"import LeanMLIR.ErasedContext",
"import Mathlib.Tactic.Linarith",
"import Mathlib.Logic.Function.Iterate",
"import LeanMLIR.Tactic"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
}
] | [
{
"name": "macro \"simp_peephole\" loc:(location)? : tactic =>",
"content": "macro \"simp_peephole\" loc:(location)? : tactic =>\n `(tactic|(\n \n first\n | rw [funext_iff (α := Ctxt.Valuation _)] $[$loc]?\n | change ∀ (_ : Ctxt.Valuation _), _ $[$loc]?\n | skip\n\n \n simp (config := {failIfUnchanged := false}) only\n [Expr.denote_castPureToEff, simp_denote] $[$loc]?\n \n \n \n ))"
},
{
"name": "cons",
"content": "@[match_pattern]\ndef cons (hd : Ty) : Ctxt Ty → Ctxt Ty\n| ⟨tl⟩ => ⟨hd :: tl⟩"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "Ty",
"content": "inductive Ty\n | int\n \n | int2\n deriving DecidableEq, Lean.ToExpr"
},
{
"name": "Op",
"content": "inductive Op\n | noop\n | mkPair\n | unPair\n deriving Lean.ToExpr"
},
{
"name": "Com.ret",
"content": "def Com.ret {Γ : Ctxt d.Ty} {ty : d.Ty} {eff : EffectKind} : Γ.Var ty → Com d Γ eff [ty] :=\n (Com.rets [·]ₕ)"
},
{
"name": "Com.letPure",
"content": "def Com.letPure (e : Expr d Γ .pure t) (body : Com d (e.outContext) eff u) : Com d Γ eff u :=\n body.var (e.castPureToEff eff)"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "Expr.castPureToEff",
"content": "def Expr.castPureToEff (eff : EffectKind) : Expr d Γ .pure t → Expr d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
},
{
"name": "Expr.changeEffect",
"content": "def Expr.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Expr d Γ eff₁ t → Expr d Γ eff₂ t\n | Expr.mk op ty_eq eff_le args regArgs =>\n have heff : DialectSignature.effectKind op ≤ eff₂ := by admit /- proof elided -/"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "Com.denote",
"content": "def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →\n eff.toMonad d.m (HVector toType ty)\n | .rets vs, Γv => pure (vs.map Γv)\n | .var e body, V => e.denote V >>= body.denote"
},
{
"name": "Lets.denote",
"content": "def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}\n (lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=\n match lets with\n | .nil => return V\n | .var lets' e => lets'.denote V >>= e.denote"
},
{
"name": "HVector.denote",
"content": "def HVector.denote :\n {l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →\n HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l\n | _, .nil => HVector.nil\n | _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)"
},
{
"name": "FlatCom.denote",
"content": "@[simp] abbrev FlatCom.denote [DialectDenote d]\n (flatCom : FlatCom d Γ eff Γ_out ts)\n (V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=\n flatCom.lets.denote V >>= (return flatCom.rets.map ·)"
},
{
"name": "RegionSignature.map",
"content": "def RegionSignature.map (f : Ty → Ty') : RegionSignature Ty → RegionSignature Ty' :=\n List.map fun ⟨Γ, ty⟩ => (Γ.map f, ty.map f)"
},
{
"name": "Signature.map",
"content": "def Signature.map (f : Ty → Ty') : Signature Ty → Signature Ty' :=\n fun sig => {\n sig := sig.sig.map f\n regSig := sig.regSig.map f\n returnTypes := sig.returnTypes.map f\n }"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "Expr.denote",
"content": "def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :\n eff.toMonad d.m (e.outContext.Valuation) :=\n match e with\n | ⟨op, ty_eq, heff, args, regArgs⟩ => do\n let argsDenote := args.map V\n let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote\n return (val ++ V).cast (by admit /- proof elided -/\n )"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "liftEffect",
"content": "def liftEffect [Pure m] {e1 e2 : EffectKind} {α : Type}\n (hle : e1 ≤ e2) (v1 : e1.toMonad m α) : e2.toMonad m α :=\n match e1, e2, hle with\n | .pure, .pure, _ | .impure, .impure, _ => v1\n | .pure, .impure, _ => Pure.pure v1"
},
{
"name": "toMonad",
"content": "def toMonad (e : EffectKind) (m : Type → Type) : Type → Type :=\n match e with\n | pure => Id\n | impure => m"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "Com.ty",
"content": "def Com.ty : Com d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "Function.comp_apply",
"module": "Init.Core"
},
{
"name": "Function.iterate_succ",
"module": "Mathlib.Logic.Function.Iterate"
},
{
"name": "Nat.cast_add",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.cast_one",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "and_true",
"module": "Init.SimpLemmas"
},
{
"name": "Int.mul_comm",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "add_left_iterate",
"module": "Mathlib.Algebra.Group.Basic"
},
{
"name": "nsmul_eq_mul",
"module": "Mathlib.Algebra.Ring.Defs"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "ScfFunctor.HasTy",
"content": "class HasTy (d : Dialect) (DenotedTy : Type) [TyDenote d.Ty] [DialectSignature d] where\n ty : d.Ty\n denote_eq : toType ty = DenotedTy := by admit /- proof elided -/"
},
{
"name": "ScfFunctor.Scf.Op",
"content": "inductive Scf.Op (Op' Ty' : Type) (m') [TyDenote Ty'] [DialectSignature ⟨Op', Ty', m'⟩]\n [DialectDenote ⟨Op', Ty', m'⟩] : Type _\n | coe (o : Op')\n | iterate (k : ℕ) \n | run (inputty : Ty') \n | if (inputty retty' : Ty') \n | for (ty : Ty')\n deriving DecidableEq, Repr"
},
{
"name": "ScfFunctor.Scf",
"content": "def Scf (d : Dialect) [TyDenote d.Ty] [DialectSignature d] [DialectDenote d] : Dialect where\n Op := Scf.Op d.Op d.Ty d.m\n Ty := d.Ty\n m := d.m"
},
{
"name": "ScfFunctor.Scf.LoopBody",
"content": "abbrev LoopBody (t : Type) : Type := Int → t → t"
},
{
"name": "ScfFunctor.Scf.LoopBody.counterDecorator",
"content": "def counterDecorator (δ : Int) (f : LoopBody α) : Int × α → Int × α :=\n fun (i, v) => (i + δ, f i v)"
},
{
"name": "ScfFunctor.Scf.LoopBody.IndexInvariant",
"content": "def IndexInvariant (f : LoopBody t) : Prop :=\n ∀ (i j : Int) (v : t), f i v = f j v"
},
{
"name": "ScfFunctor.Scf.LoopBody.atZero",
"content": "def atZero (f : LoopBody t) : t → t := fun v => f 0 v"
},
{
"name": "ScfFunctor.Arith.Ty",
"content": "inductive Ty\n| int\n| bool\n| nat\n deriving DecidableEq, Repr"
},
{
"name": "ScfFunctor.Arith.Op",
"content": "inductive Op\n | add : Op \n | add_nat : Op \n | axpy : Op \n | neg : Op \n | const : (val : ℤ) → Op\n | const_nat : (val : ℕ) → Op"
},
{
"name": "ScfFunctor.Arith.Arith",
"content": "abbrev Arith : Dialect := {Op, Ty}"
},
{
"name": "ScfFunctor.ScfArith",
"content": "abbrev ScfArith := Scf Arith"
},
{
"name": "ScfFunctor.cst",
"content": "@[simp_denote] def cst (n : ℤ) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .const n)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "ScfFunctor.add",
"content": "@[simp_denote] def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .add)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "ScfFunctor.add_nat",
"content": "@[simp_denote] def add_nat (e₁ e₂ : Var Γ .nat) : Expr ScfArith Γ .pure .nat :=\n Expr.mk\n (op := .coe <| .add_nat)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons e₁ <| .cons e₂ .nil)\n (regArgs := .nil)"
},
{
"name": "ScfFunctor.axpy",
"content": "@[simp_denote] def axpy {Γ : Ctxt _} (a : Var Γ .int) (x : Var Γ .nat) (b: Var Γ .int) :\n Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .axpy)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons x <| .cons b .nil)\n (regArgs := .nil)"
},
{
"name": "ScfFunctor.neg",
"content": "@[simp_denote] def neg {Γ : Ctxt _} (a : Var Γ .int) : Expr ScfArith Γ .pure .int :=\n Expr.mk\n (op := .coe <| .neg)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "ScfFunctor.iterate",
"content": "@[simp_denote] def iterate {Γ : Ctxt _} (k : Nat) (input : Var Γ Arith.Ty.int)\n (body : Com ScfArith ⟨[.int]⟩ .impure .int) : Expr ScfArith Γ .impure .int :=\n Expr.mk\n (op := .iterate k)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons input .nil)\n (regArgs := HVector.cons body HVector.nil)"
},
{
"name": "ScfFunctor.run",
"content": "@[simp_denote]\ndef run {Γ : Ctxt _} {t : Arith.Ty} (v : Var Γ t) (body : Com ScfArith ⟨[t]⟩ .impure t) :\n Expr ScfArith Γ .impure t :=\n Expr.mk\n (op := .run t)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons v .nil)\n (regArgs := HVector.cons body <| HVector.nil)"
},
{
"name": "ScfFunctor.for_",
"content": "@[simp_denote] def for_ {Γ : Ctxt Arith.Ty} {t : Arith.Ty}\n (start step : Var Γ Arith.Ty.int)\n (niter : Var Γ Arith.Ty.nat) (v : Var Γ t) (body : Com ScfArith ⟨[.int, t]⟩ .impure t) :\n Expr ScfArith Γ .impure t :=\n Expr.mk\n (op := .for t)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons start <| .cons step <| .cons niter <| .cons v .nil)\n (regArgs := HVector.cons body <| HVector.nil)"
},
{
"name": "ScfFunctor.ForAddToMul.lhs",
"content": "def lhs (vincrement : ℤ) : Com ScfArith ⟨[ .nat, .int]⟩ .impure .int :=\n Com.letPure (cst 0) <|\n Com.letPure (cst 1) <|\n Com.var (for_ (t := .int)\n ⟨ 1, rfl⟩\n ⟨ 0, rfl⟩\n ⟨ 2, rfl⟩\n ⟨ 3, rfl⟩ (\n Com.letPure (cst vincrement) <|\n Com.letPure (add ⟨0, rfl⟩ ⟨2, rfl⟩) \n <| Com.ret ⟨0, rfl⟩)) <|\n Com.ret ⟨0, rfl⟩"
},
{
"name": "ScfFunctor.ForAddToMul.rhs",
"content": "def rhs (vincrement : ℤ) : Com ScfArith ⟨[ .nat, .int]⟩ .pure .int :=\n Com.var (cst vincrement) <|\n Com.var (axpy ⟨0, rfl⟩ ⟨1, rfl⟩ ⟨2, rfl⟩) <|\n Com.ret ⟨0, rfl⟩"
}
] | [
{
"name": "ScfFunctor.Scf.LoopBody.eq_invariant_fn",
"content": "theorem eq_invariant_fn\n (f : LoopBody t) (g : t → t) (hf : ∀ (i : Int) (v : t), f i v = g v) :\n LoopBody.IndexInvariant f ∧ atZero f = g"
},
{
"name": "ScfFunctor.Scf.LoopBody.IndexInvariant.eval'",
"content": "@[simp]\ntheorem eval' {f : LoopBody t} (hf : LoopBody.IndexInvariant f) (i : Int) (v : t) :\n f i v = f.atZero v"
}
] | import Mathlib.Logic.Function.Iterate
import Mathlib.Tactic.Linarith
import LeanMLIR.Framework
import LeanMLIR.Tactic
import LeanMLIR.ErasedContext
import LeanMLIR.Util
open LeanMLIR
open Ctxt(Var)
namespace ScfFunctor
open TyDenote
class HasTy (d : Dialect) (DenotedTy : Type) [TyDenote d.Ty] [DialectSignature d] where
ty : d.Ty
denote_eq : toType ty = DenotedTy := by admit /- proof elided -/
inductive Scf.Op (Op' Ty' : Type) (m') [TyDenote Ty'] [DialectSignature ⟨Op', Ty', m'⟩]
[DialectDenote ⟨Op', Ty', m'⟩] : Type _
| coe (o : Op')
| iterate (k : ℕ)
| run (inputty : Ty')
| if (inputty retty' : Ty')
| for (ty : Ty')
deriving DecidableEq, Repr
def Scf (d : Dialect) [TyDenote d.Ty] [DialectSignature d] [DialectDenote d] : Dialect where
Op := Scf.Op d.Op d.Ty d.m
Ty := d.Ty
m := d.m
namespace Scf
section InheritedInstances
variable {d : Dialect} [TyDenote d.Ty] [DialectSignature d] [DialectDenote d]
end InheritedInstances
abbrev LoopBody (t : Type) : Type := Int → t → t
namespace LoopBody
def counterDecorator (δ : Int) (f : LoopBody α) : Int × α → Int × α :=
fun (i, v) => (i + δ, f i v)
def atZero (f : LoopBody t) : t → t := fun v => f 0 v
end LoopBody
namespace LoopBody.IndexInvariant
end LoopBody.IndexInvariant
namespace LoopBody.counterDecorator
end LoopBody.counterDecorator
variable [TyDenote d.Ty] [DialectSignature d] [DialectDenote d]
[B : HasBool d] [N : HasNat d] [Z : HasInt d]
open Ctxt (Valuation) in
end Scf
namespace Arith
inductive Ty
| int
| bool
| nat
deriving DecidableEq, Repr
inductive Op
| add : Op
| add_nat : Op
| axpy : Op
| neg : Op
| const : (val : ℤ) → Op
| const_nat : (val : ℕ) → Op
abbrev Arith : Dialect := {Op, Ty}
end Arith
abbrev ScfArith := Scf Arith
open LeanMLIR.SingleReturnCompat (Com Expr)
@[simp_denote] def cst (n : ℤ) : Expr ScfArith Γ .pure .int :=
Expr.mk
(op := .coe <| .const n)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .nil)
(regArgs := .nil)
@[simp_denote] def add {Γ : Ctxt _} (e₁ e₂ : Var Γ .int) : Expr ScfArith Γ .pure .int :=
Expr.mk
(op := .coe <| .add)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons e₁ <| .cons e₂ .nil)
(regArgs := .nil)
@[simp_denote] def add_nat (e₁ e₂ : Var Γ .nat) : Expr ScfArith Γ .pure .nat :=
Expr.mk
(op := .coe <| .add_nat)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons e₁ <| .cons e₂ .nil)
(regArgs := .nil)
@[simp_denote] def axpy {Γ : Ctxt _} (a : Var Γ .int) (x : Var Γ .nat) (b: Var Γ .int) :
Expr ScfArith Γ .pure .int :=
Expr.mk
(op := .coe <| .axpy)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons a <| .cons x <| .cons b .nil)
(regArgs := .nil)
@[simp_denote] def neg {Γ : Ctxt _} (a : Var Γ .int) : Expr ScfArith Γ .pure .int :=
Expr.mk
(op := .coe <| .neg)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons a <| .nil)
(regArgs := .nil)
@[simp_denote] def iterate {Γ : Ctxt _} (k : Nat) (input : Var Γ Arith.Ty.int)
(body : Com ScfArith ⟨[.int]⟩ .impure .int) : Expr ScfArith Γ .impure .int :=
Expr.mk
(op := .iterate k)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons input .nil)
(regArgs := HVector.cons body HVector.nil)
@[simp_denote]
def run {Γ : Ctxt _} {t : Arith.Ty} (v : Var Γ t) (body : Com ScfArith ⟨[t]⟩ .impure t) :
Expr ScfArith Γ .impure t :=
Expr.mk
(op := .run t)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons v .nil)
(regArgs := HVector.cons body <| HVector.nil)
@[simp_denote] def for_ {Γ : Ctxt Arith.Ty} {t : Arith.Ty}
(start step : Var Γ Arith.Ty.int)
(niter : Var Γ Arith.Ty.nat) (v : Var Γ t) (body : Com ScfArith ⟨[.int, t]⟩ .impure t) :
Expr ScfArith Γ .impure t :=
Expr.mk
(op := .for t)
(ty_eq := rfl)
(eff_le := by admit /- proof elided -/
)
(args := .cons start <| .cons step <| .cons niter <| .cons v .nil)
(regArgs := HVector.cons body <| HVector.nil)
namespace ForAddToMul
def lhs (vincrement : ℤ) : Com ScfArith ⟨[ .nat, .int]⟩ .impure .int :=
Com.letPure (cst 0) <|
Com.letPure (cst 1) <|
Com.var (for_ (t := .int)
⟨ 1, rfl⟩
⟨ 0, rfl⟩
⟨ 2, rfl⟩
⟨ 3, rfl⟩ (
Com.letPure (cst vincrement) <|
Com.letPure (add ⟨0, rfl⟩ ⟨2, rfl⟩)
<| Com.ret ⟨0, rfl⟩)) <|
Com.ret ⟨0, rfl⟩
def rhs (vincrement : ℤ) : Com ScfArith ⟨[ .nat, .int]⟩ .pure .int :=
Com.var (cst vincrement) <|
Com.var (axpy ⟨0, rfl⟩ ⟨1, rfl⟩ ⟨2, rfl⟩) <|
Com.ret ⟨0, rfl⟩
open Scf in
open Arith in | theorem correct : Com.denote (lhs v0) = Com.denote (rhs v0) := | := by
unfold lhs rhs
simp_peephole
intros A B
rw [Scf.LoopBody.counterDecorator.const_index_fn_iterate (f' := fun v => v0 + v)] <;> try rfl
simp only [add_left_iterate, nsmul_eq_mul, Int.mul_comm] | 8 | 102 | false | Compiler |
348 | Zipper.denote_insertPureCom_eq_of | theorem denote_insertPureCom_eq_of [LawfulMonad d.m]
{zip : Zipper d Γ_in eff tys} {vs}
{newCom : Com d zip.Γ_mid .pure newTys} {V_in : Valuation Γ_in}
(h : ∀ V : zip.top.ValidDenotation,
newCom.denote V.val = vs.map V.val) :
(zip.insertPureCom vs newCom).denote V_in = zip.denote V_in | lean-mlir | LeanMLIR/LeanMLIR/Framework/Zipper.lean | [
"import LeanMLIR.Transforms.Rewrite.Match",
"import LeanMLIR.LeanMLIR.Transforms.Rewrite.Match",
"import LeanMLIR.LeanMLIR.HVector",
"import LeanMLIR.LeanMLIR.Framework.Basic",
"import LeanMLIR.Framework.Basic"
] | [
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "Computation",
"module": "Mathlib.Data.Seq.Computation"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Subtype",
"module": "Init.Prelude"
},
{
"name": "Subtype.mk",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Sigma",
"module": "Init.Core"
},
{
"name": "Sigma.mk",
"module": "Init.Core"
},
{
"name": "Subtype.val",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"llvm.and\" : MLIR.Pretty.uniform_op",
"content": "syntax \"llvm.and\" : MLIR.Pretty.uniform_op\n\nsyntax \"llvm.ashr\" : MLIR.Pretty.exact_op\n\nsyntax \"llvm.add\" : MLIR.Pretty.overflow_op\n\nsyntax \"llvm.return\" : MLIR.Pretty.uniform_op"
},
{
"name": "notation:50 x \" ≤ₛ \" y => BitVec.sle x y",
"content": "notation:50 x \" ≤ₛ \" y => BitVec.sle x y"
},
{
"name": "notation:50 x \" >ᵤ \" y => BitVec.ult y x",
"content": "notation:50 x \" >ᵤ \" y => BitVec.ult y x"
},
{
"name": "notation:50 x \" ≥ᵤ \" y => BitVec.ule y x",
"content": "notation:50 x \" ≥ᵤ \" y => BitVec.ule y x"
},
{
"name": "notation:50 x \" <ᵤ \" y => BitVec.ult x y",
"content": "notation:50 x \" <ᵤ \" y => BitVec.ult x y"
},
{
"name": "notation:50 x \" ≥ₛ \" y => BitVec.sle y x",
"content": "notation:50 x \" ≥ₛ \" y => BitVec.sle y x"
},
{
"name": "notation:50 x \" <ₛ \" y => BitVec.slt x y",
"content": "notation:50 x \" <ₛ \" y => BitVec.slt x y"
},
{
"name": "notation:50 x \" >ₛ \" y => BitVec.slt y x",
"content": "notation:50 x \" >ₛ \" y => BitVec.slt y x"
},
{
"name": "notation:50 x \" ≤ᵤ \" y => BitVec.ule x y",
"content": "notation:50 x \" ≤ᵤ \" y => BitVec.ule x y"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $resName:mlir_op_operand = $name:InstCombine.cmp_op_name $x, $y $[: $t]?) => do\n let some opName := extractOpName name.raw\n | Macro.throwUnsupported\n let t ← t.getDM `(mlir_type| _)\n `(mlir_op| $resName:mlir_op_operand = $opName ($x, $y) : ($t, $t) -> (i1) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $resName:mlir_op_operand = $name:InstCombine.int_cast_op $x : $t to $t') => do\n let some opName := extractOpName name.raw\n | Macro.throwUnsupported\n `(mlir_op| $resName:mlir_op_operand = $opName ($x) : ($t) -> $t')"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant( $x $[: $inner_type]?)\n $[: $outer_type]? ) => do\n \n let outer_type ← outer_type.getDM `(mlir_type| _)\n let inner_type := inner_type.getD outer_type\n `(mlir_op| $res:mlir_op_operand = \"llvm.mlir.constant\"()\n {value = $x:neg_num : $inner_type} : () -> ($outer_type) )\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant( ${ $x:term }) $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n let x ← `(MLIR.AST.AttrValue.int $x [mlir_type| $t])\n `(mlir_op| $res:mlir_op_operand = \"llvm.mlir.constant\"() {value = $$($x) } : () -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (true) $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (1 : i1) : i1)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (false) $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant (0 : i1) : i1)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant $x $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant($x $[: $t]?) $[: $t]?)\n | `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant ${ $x:term } $[: $t]?) =>\n `(mlir_op| $res:mlir_op_operand = llvm.mlir.constant($$($x) $[: $t]?) $[: $t]?)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.icmp $p $x, $y $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n match p.getString with\n | \"eq\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.eq\" ($x, $y) : ($t, $t) -> (i1))\n | \"ne\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ne\" ($x, $y) : ($t, $t) -> (i1))\n | \"slt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.slt\" ($x, $y) : ($t, $t) -> (i1))\n | \"sle\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sle\" ($x, $y) : ($t, $t) -> (i1))\n | \"sgt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sgt\" ($x, $y) : ($t, $t) -> (i1))\n | \"sge\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.sge\" ($x, $y) : ($t, $t) -> (i1))\n | \"ult\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ult\" ($x, $y) : ($t, $t) -> (i1))\n | \"ule\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ule\" ($x, $y) : ($t, $t) -> (i1))\n | \"ugt\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.ugt\" ($x, $y) : ($t, $t) -> (i1))\n | \"uge\" => `(mlir_op| $res:mlir_op_operand = \"llvm.icmp.uge\" ($x, $y) : ($t, $t) -> (i1))\n | _ => Macro.throwErrorAt p s!\"unexpected predicate {p.getString}\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = llvm.select $c, $x, $y $[: $t]?) => do\n let t ← t.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"llvm.select\" ($c, $x, $y) : (i1, $t, $t) -> ($t))"
},
{
"name": "Lets",
"content": "inductive Lets (Γ_in : Ctxt d.Ty) (eff : EffectKind) :\n (Γ_out : Ctxt d.Ty) → Type where\n | nil : Lets Γ_in eff Γ_in\n | var (body : Lets Γ_in eff Γ_out) (e : Expr d Γ_out eff t) : Lets Γ_in eff e.outContext"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "EffectKind",
"content": "inductive EffectKind\n| pure \n| impure \nderiving Repr, DecidableEq, Lean.ToExpr"
},
{
"name": "Com",
"content": "inductive Com : Ctxt d.Ty → EffectKind → List d.Ty → Type where\n | rets {Γ} {tys} {eff : EffectKind} (vs : HVector Γ.Var tys) : Com Γ eff tys\n | var (e : Expr Γ eff ty) (body : Com (ty ++ Γ) eff β) : Com Γ eff β"
},
{
"name": "FlatCom",
"content": "structure FlatCom (d : Dialect) [DialectSignature d] (Γ_in : Ctxt d.Ty) (eff : EffectKind)\n (Γ_out : Ctxt d.Ty) (ts : List d.Ty) where\n lets : Lets d Γ_in eff Γ_out\n rets : HVector Γ_out.Var ts"
},
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Hom.with",
"content": "def Hom.with [DecidableEq Ty] {Γ₁ Γ₂ : Ctxt Ty} (f : Γ₁.Hom Γ₂) {ts}\n (v₁ : HVector Γ₁.Var ts) (v₂ : HVector Γ₂.Var ts) : Γ₁.Hom Γ₂ :=\n fun _ w =>\n match v₁.idxOf? w with\n | none => f w\n | some ⟨i, h⟩ => (v₂.get i).cast h"
},
{
"name": "Hom",
"content": "abbrev Hom (Γ Γ' : Ctxt Ty) := ⦃t : Ty⦄ → Γ.Var t → Γ'.Var t"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "Valuation.instAppendHVector",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "map",
"content": "def map (f : Ty₁ → Ty₂) : Ctxt Ty₁ → Ctxt Ty₂ :=\n ofList ∘ (List.map f) ∘ toList"
},
{
"name": "Com.outContextHom",
"content": "def Com.outContextHom (com : Com d Γ eff t) : Γ.Hom com.outContext :=\n com.outContextDiff.toHom"
},
{
"name": "Com.outContext",
"content": "def Com.outContext {Γ} : Com d Γ eff ts → Ctxt d.Ty :=\n Com.rec' (motive := fun _ => Ctxt d.Ty)\n (@fun Γ _ => Γ) \n (fun _ _ r => r) "
},
{
"name": "Com.rec'",
"content": "def Com.rec' {Γ} (com : Com d Γ eff t) : motive com :=\n \n Com.rec\n (motive_1 := fun _ _ _ _ => PUnit)\n (motive_2 := fun _ eff' t' c =>\n (h₁ : eff = eff') → (h₂ : t = t') → motive (h₁ ▸ h₂ ▸ c))\n (motive_3 := fun _ _ => PUnit)\n (fun _ _ _ _ _ _ => ⟨⟩) \n (fun v h₁ h₂ => \n cast (by admit /- proof elided -/\n ) <| rets (h₂ ▸ v))\n (fun e' body' _ r' h₁ h₂ => \n let e := h₁ ▸ e'\n let body : Com _ _ eff t := cast (by admit /- proof elided -/\n ) body'\n let r : motive body := cast (by admit /- proof elided -/\n ) (r' h₁ h₂)\n cast (by admit /- proof elided -/\n ) <| var e body r)\n ⟨⟩\n (fun _ _ _ _ => ⟨⟩)\n com\n rfl\n rfl"
},
{
"name": "Valuation.cast",
"content": "def Valuation.cast {Γ Δ : Ctxt Ty} (h : Γ = Δ) (V : Valuation Γ) : Valuation Δ :=\n fun _ v => V <| v.castCtxt h.symm"
},
{
"name": "Com.outContextDiff",
"content": "def Com.outContextDiff (com : Com d Γ eff ts) : Γ.Diff com.outContext :=\n ⟨com.bvars, by admit /- proof elided -/\n ⟩"
},
{
"name": "Expr.outContext",
"content": "abbrev Expr.outContext (_ : Expr d Γ eff ts) : Ctxt d.Ty :=\n ts ++ Γ"
},
{
"name": "Expr.bvars",
"content": "@[simp, grind=] def Expr.bvars (e : Expr d Γ eff Δ) : Nat :=\n (DialectSignature.returnTypes e.op).length"
},
{
"name": "returnTypes",
"content": "def returnTypes := Signature.returnTypes ∘ s.signature"
},
{
"name": "Signature",
"content": "structure Signature (Ty : Type) where\n mkEffectful ::\n sig : List Ty\n regSig : RegionSignature Ty\n returnTypes : List Ty\n effectKind : EffectKind := .pure"
},
{
"name": "DialectSignature",
"content": "class DialectSignature (d : Dialect) where\n signature : d.Op → Signature d.Ty"
},
{
"name": "Com.bvars",
"content": "def Com.bvars : Com d Γ eff t → Nat :=\n Com.rec'\n (fun _ => 0)\n (fun e _body bodySize => e.bvars + bodySize)"
},
{
"name": "Diff",
"content": "def Diff (Γ₁ Γ₂ : Ctxt Ty) : Type :=\n {d : Nat // Diff.Valid Γ₁ Γ₂ d}"
},
{
"name": "Diff.Valid",
"content": "@[simp]\nabbrev Diff.Valid (Γ₁ Γ₂ : Ctxt Ty) (d : Nat) : Prop :=\n ∀ {i t}, Γ₁[i]? = some t → Γ₂[i+d]? = some t"
},
{
"name": "toHom",
"content": "def toHom (d : Diff Γ₁ Γ₂) : Hom Γ₁ Γ₂ :=\n fun _ v => ⟨v.val + d.val, d.property v.property⟩"
},
{
"name": "castCtxt",
"content": "def castCtxt (h_eq : Γ = Δ) : Γ.Var ty → Δ.Var ty\n | ⟨i, h⟩ => ⟨i, h_eq ▸ h⟩"
},
{
"name": "Com.denoteLets",
"content": "def Com.denoteLets : (com : Com d Γ eff ty) → (Γv : Valuation Γ) →\n eff.toMonad d.m (com.outContext.Valuation)\n | .rets _, V => pure V\n | .var e body, V =>\n e.denote V >>= body.denoteLets >>= fun V =>\n return V.cast (by admit /- proof elided -/\n )"
},
{
"name": "DialectDenote",
"content": "class DialectDenote (d : Dialect) [TyDenote d.Ty] [DialectSignature d] where\n denote : (op : d.Op) → HVector toType (DialectSignature.sig op) →\n (HVector (fun t : Ctxt d.Ty × List d.Ty =>\n t.1.Valuation\n → EffectKind.impure.toMonad d.m (HVector toType t.2))\n (DialectSignature.regSig op)) →\n ((DialectSignature.effectKind op).toMonad d.m\n (HVector toType <| DialectSignature.returnTypes op))"
},
{
"name": "Lets.denote",
"content": "def Lets.denote [DialectSignature d] [DialectDenote d] {Γ₂}\n (lets : Lets d Γ₁ eff Γ₂) (V : Valuation Γ₁) : (eff.toMonad d.m <| Valuation Γ₂) :=\n match lets with\n | .nil => return V\n | .var lets' e => lets'.denote V >>= e.denote"
},
{
"name": "sig",
"content": "def sig := Signature.sig ∘ s.signature"
},
{
"name": "regSig",
"content": "def regSig := Signature.regSig ∘ s.signature"
},
{
"name": "RegionSignature",
"content": "abbrev RegionSignature Ty := List (Ctxt Ty × List Ty)"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "effectKind",
"content": "def effectKind := Signature.effectKind ∘ s.signature"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "HVector.denote",
"content": "def HVector.denote :\n {l : RegionSignature d.Ty} → (T : HVector (fun t => Com d t.1 .impure t.2) l) →\n HVector (fun t => t.1.Valuation → EffectKind.impure.toMonad d.m (HVector toType t.2)) l\n | _, .nil => HVector.nil\n | _, .cons v vs => HVector.cons (v.denote) (HVector.denote vs)"
},
{
"name": "FlatCom.denote",
"content": "@[simp] abbrev FlatCom.denote [DialectDenote d]\n (flatCom : FlatCom d Γ eff Γ_out ts)\n (V : Γ.Valuation) : eff.toMonad d.m (HVector toType ts) :=\n flatCom.lets.denote V >>= (return flatCom.rets.map ·)"
},
{
"name": "RegionSignature.map",
"content": "def RegionSignature.map (f : Ty → Ty') : RegionSignature Ty → RegionSignature Ty' :=\n List.map fun ⟨Γ, ty⟩ => (Γ.map f, ty.map f)"
},
{
"name": "Signature.map",
"content": "def Signature.map (f : Ty → Ty') : Signature Ty → Signature Ty' :=\n fun sig => {\n sig := sig.sig.map f\n regSig := sig.regSig.map f\n returnTypes := sig.returnTypes.map f\n }"
},
{
"name": "Expr.denote",
"content": "def Expr.denote {ty} (e : Expr d Γ eff ty) (V : Valuation Γ) :\n eff.toMonad d.m (e.outContext.Valuation) :=\n match e with\n | ⟨op, ty_eq, heff, args, regArgs⟩ => do\n let argsDenote := args.map V\n let val ← EffectKind.liftEffect heff <| DialectDenote.denote op argsDenote regArgs.denote\n return (val ++ V).cast (by admit /- proof elided -/\n )"
},
{
"name": "Expr.op",
"content": "def Expr.op {Γ : Ctxt d.Ty} {eff : EffectKind} {ty} (e : Expr d Γ eff ty) : d.Op :=\n Expr.casesOn e (fun op _ _ _ _ => op)"
},
{
"name": "liftEffect",
"content": "def liftEffect [Pure m] {e1 e2 : EffectKind} {α : Type}\n (hle : e1 ≤ e2) (v1 : e1.toMonad m α) : e2.toMonad m α :=\n match e1, e2, hle with\n | .pure, .pure, _ | .impure, .impure, _ => v1\n | .pure, .impure, _ => Pure.pure v1"
},
{
"name": "toMonad",
"content": "def toMonad (e : EffectKind) (m : Type → Type) : Type → Type :=\n match e with\n | pure => Id\n | impure => m"
},
{
"name": "Com.denote",
"content": "def Com.denote : Com d Γ eff ty → (Γv : Valuation Γ) →\n eff.toMonad d.m (HVector toType ty)\n | .rets vs, Γv => pure (vs.map Γv)\n | .var e body, V => e.denote V >>= body.denote"
},
{
"name": "Com.ty",
"content": "def Com.ty : Com d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "cast",
"content": "def cast (h_eq : ty₁ = ty₂) : Γ.Var ty₁ → Γ.Var ty₂\n | ⟨i, h⟩ => ⟨i, h_eq ▸ h⟩"
},
{
"name": "cast",
"content": "def cast (h₁ : Γ = Γ') (h₂ : Δ = Δ') : Diff Γ Δ → Diff Γ' Δ'\n | ⟨n, h⟩ => ⟨n, by admit /- proof elided -/\n ⟩"
},
{
"name": "Com.castPureToEff",
"content": "def Com.castPureToEff (eff : EffectKind) : Com d Γ .pure t → Com d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
},
{
"name": "Com.changeEffect",
"content": "def Com.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Com d Γ eff₁ t → Com d Γ eff₂ t := fun com =>\n Com.rec' (motive := @fun Γ _ => eff₁ ≤ eff₂ → Com d Γ eff₂ t)\n (fun v _h => rets v)\n (fun e _body castBody h => var (e.changeEffect h) (castBody h))\n com h"
},
{
"name": "Expr.changeEffect",
"content": "def Expr.changeEffect {eff₁ eff₂ : EffectKind} (h : eff₁ ≤ eff₂) :\n Expr d Γ eff₁ t → Expr d Γ eff₂ t\n | Expr.mk op ty_eq eff_le args regArgs =>\n have heff : DialectSignature.effectKind op ≤ eff₂ := by admit /- proof elided -/"
},
{
"name": "Expr.args",
"content": "def Expr.args {Γ ts} (e : Expr d Γ eff ts) :\n HVector (Var Γ) (DialectSignature.sig e.op) :=\n Expr.casesOn e (fun _ _ _ args _ => args)"
},
{
"name": "Expr.regArgs",
"content": "def Expr.regArgs {Γ ts} (e : Expr d Γ eff ts) :\n Regions d (DialectSignature.regSig e.op) :=\n Expr.casesOn e (fun _ _ _ _ regArgs => regArgs)"
},
{
"name": "Regions",
"content": "abbrev Regions (regSig : RegionSignature d.Ty) : Type :=\n HVector (fun t => Com d t.1 .impure t.2) regSig"
},
{
"name": "com",
"content": "def com := mkCom (d := InstCombine.MetaLLVM 0) bb0 |>.toOption |>.get (by admit /- proof elided -/\n)"
},
{
"name": "bb0",
"content": "def bb0 : Region 0 := [mlir_region|\n{\n ^bb0(%arg0: i32):\n %0 = llvm.mlir.constant(8) : i32\n %1 = llvm.mlir.constant(31) : i32\n %2 = llvm.ashr %arg0, %1 : i32\n %3 = llvm.and %2, %0 : i32\n %4 = llvm.add %3, %2 : i32\n llvm.return %4 : i32\n }]"
},
{
"name": "Region",
"content": "structure Region where\n (name: String)\n (args: List <| TypedSSAVal φ)\n (ops: List Op)"
},
{
"name": "MetaLLVM",
"content": "abbrev MetaLLVM (φ : Nat) : Dialect where\n Op := MOp φ\n Ty := MTy φ"
},
{
"name": "Ty",
"content": "@[deprecated \"Use `LLVM.Ty` instead\" (since:=\"2025-04-30\")] abbrev Ty := LLVM.Ty"
},
{
"name": "Op",
"content": "@[deprecated \"Use `LLVM.Op` instead\" (since:=\"2025-04-30\")] abbrev Op := LLVM.Op"
},
{
"name": "MOp",
"content": "inductive MOp (φ : Nat) : Type\n | unary (w : Width φ) (op : MOp.UnaryOp φ) : MOp φ\n | binary (w : Width φ) (op : MOp.BinaryOp) : MOp φ\n | select (w : Width φ) : MOp φ\n | icmp (c : IntPred) (w : Width φ) : MOp φ\n \n | const (w : Width φ) (val : ℤ) : MOp φ\nderiving Repr, DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "binary",
"content": "@[match_pattern] abbrev binary (w : Nat) (op : MOp.BinaryOp) : LLVM.Op :=\n MOp.binary (.concrete w) op"
},
{
"name": "MOp.BinaryOp",
"content": "inductive MOp.BinaryOp : Type\n | and\n | or (disjoint : DisjointFlag := {disjoint := false} )\n | xor\n | shl (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | lshr (exact : ExactFlag := {exact := false} )\n | ashr (exact : ExactFlag := {exact := false} )\n | urem\n | srem\n | add (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | mul (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | sub (nswnuw : NoWrapFlags := {nsw := false, nuw := false} )\n | sdiv (exact : ExactFlag := {exact := false} )\n | udiv (exact : ExactFlag := {exact := false} )\nderiving DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "LLVM",
"content": "def LLVM : Dialect where\n Op := MOp 0\n Ty := MTy 0"
},
{
"name": "MTy",
"content": "inductive MTy (φ : Nat)\n | bitvec (w : Width φ) : MTy φ\n deriving DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "Width",
"content": "abbrev Width φ := ConcreteOrMVar Nat φ"
},
{
"name": "ConcreteOrMVar",
"content": "inductive ConcreteOrMVar (α : Type u) (φ : Nat)\n | concrete (a : α)\n | mvar (i : Fin φ)\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "const",
"content": "@[match_pattern] abbrev const (w : Nat) (val : ℤ) : LLVM.Op := MOp.const (.concrete w) val"
},
{
"name": "MOp.UnaryOp",
"content": "inductive MOp.UnaryOp (φ : Nat) : Type\n | neg\n | not\n | copy\n | freeze\n | trunc (w' : Width φ) (noWrapFlags : NoWrapFlags := {nsw := false, nuw := false} )\n | zext (w' : Width φ) (nneg : NonNegFlag := {nneg := false} )\n | sext (w' : Width φ)\nderiving Repr, DecidableEq, Inhabited, Lean.ToExpr"
},
{
"name": "select",
"content": "@[simp_llvm_option]\ndef select {w : Nat} (c? : IntW 1) (x? y? : IntW w ) : IntW w := do\n let c ← c?\n if c = 1#1 then x? else y?"
},
{
"name": "IntW",
"content": "def IntW w := PoisonOr <| BitVec w"
},
{
"name": "PoisonOr",
"content": "structure PoisonOr (α : Type) where\n val : α\n poisonous : Bool\nderiving Inhabited, DecidableEq"
},
{
"name": "icmp",
"content": "@[simp_llvm_option]\ndef icmp {w : Nat} (c : IntPred) (x y : IntW w) : IntW 1 := do\n let x' ← x\n let y' ← y\n icmp? c x' y'"
},
{
"name": "icmp?",
"content": "@[simp_llvm]\ndef icmp? {w : Nat} (c : IntPred) (x y : BitVec w) : IntW 1 :=\n .value ↑(icmp' c x y)"
},
{
"name": "IntPred",
"content": "inductive IntPred where\n | eq\n | ne\n | ugt\n | uge\n | ult\n | ule\n | sgt\n | sge\n | slt\n | sle\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "icmp'",
"content": "@[simp_llvm]\ndef icmp' {w : Nat} (c : IntPred) (x y : BitVec w) : Bool :=\n match c with\n | .eq => (x == y)\n | .ne => (x != y)\n | .sgt => (x >ₛ y)\n | .sge => (x ≥ₛ y)\n | .slt => (x <ₛ y)\n | .sle => (x ≤ₛ y)\n | .ugt => (x >ᵤ y)\n | .uge => (x ≥ᵤ y)\n | .ult => (x <ᵤ y)\n | .ule => (x ≤ᵤ y)"
},
{
"name": "mkCom",
"content": "def mkCom [TransformTy d φ] [TransformExpr d φ] [TransformReturn d φ]\n (reg : MLIR.AST.Region φ) :\n ExceptM d (Σ (Γ : Ctxt d.Ty) (eff : EffectKind) (ty : _), Com d Γ eff ty) :=\n match reg.ops with\n | [] => throw <| .generic \"Ill-formed region (empty)\"\n | coms => BuilderM.runWithEmptyMapping <| do\n let Γ ← declareBindings ∅ reg.args\n let com ← mkComHelper Γ coms\n return ⟨Γ, com⟩"
},
{
"name": "FlatCom.denoteLets",
"content": "def FlatCom.denoteLets (flatCom : FlatCom d Γ eff Γ_out t) (Γv : Γ.Valuation) :\n eff.toMonad d.m <| Γ_out.Valuation :=\n flatCom.lets.denote Γv"
},
{
"name": "Com.toLets",
"content": "def Com.toLets (com : Com d Γ eff t) : Lets d Γ eff com.outContext :=\n Lets.nil.addComToEnd com"
},
{
"name": "Lets.castPureToEff",
"content": "def Lets.castPureToEff (eff : EffectKind) : Lets d Γ_in .pure Γ_out → Lets d Γ_in eff Γ_out\n | .nil => .nil\n | .var body e => .var (body.castPureToEff eff) (e.castPureToEff eff)"
},
{
"name": "Expr.castPureToEff",
"content": "def Expr.castPureToEff (eff : EffectKind) : Expr d Γ .pure t → Expr d Γ eff t :=\n changeEffect (EffectKind.pure_le eff)"
},
{
"name": "Expr.returnVars",
"content": "def Expr.returnVars (e : Expr d Γ eff tys) : HVector e.outContext.Var tys :=\n .ofFn _ _ <| fun i => (Var.ofFin i).appendInl"
},
{
"name": "ofFin",
"content": "def ofFin (i : Fin Γ.length) : Γ.Var (Γ[i]) :=\n ⟨i.val, by admit /- proof elided -/\n ⟩"
},
{
"name": "Com.returnVars",
"content": "def Com.returnVars : (com : Com d Γ eff ts) → HVector (Var com.outContext) ts\n | .rets vs => vs\n | .var _ body => body.returnVars"
},
{
"name": "Valuation.comap",
"content": "def Valuation.comap {Γi Γo : Ctxt Ty} (Γiv: Γi.Valuation) (hom : Ctxt.Hom Γo Γi) : Γo.Valuation :=\n fun _to vo => Γiv (hom vo)"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "HVectorLiteral",
"content": "structure HVectorLiteral where\n u : Level\n v : Level\n α : Q(Type $u)\n A : Q($α → Type $v)\n elems : Array ((a : Q($α)) × Q($A $a))"
},
{
"name": "Lets.ValidDenotation",
"content": "def Lets.ValidDenotation (lets : Lets d Γ_in eff Γ_out) :=\n { V // ∀ {t ts} {v : Var _ t} {w : Var ⟨ts⟩ t} {e} ,\n lets.getPureExpr v = some ⟨ts, w, e⟩\n → (e.pdenoteOp V)[w] = V v }"
},
{
"name": "Lets.denoteIntoSubtype",
"content": "def Lets.denoteIntoSubtype (lets : Lets d Γ_in eff Γ_out) (Γv : Valuation Γ_in) :\n eff.toMonad d.m lets.ValidDenotation :=\n match lets with\n | .nil => return ⟨Γv, by admit /- proof elided -/\n ⟩\n | @Lets.var _ _ _ _ Γ_out eTy body e => do\n let ⟨Vout, h⟩ ← body.denoteIntoSubtype Γv\n let Ve ← e.denoteOpIntoSubtype Vout\n return ⟨Ve.val ++ Vout, by admit /- proof elided -/\n ⟩"
},
{
"name": "Expr.denoteOpIntoSubtype",
"content": "def Expr.denoteOpIntoSubtype (e : Expr d Γ_in eff tys) (Γv : Valuation Γ_in) :\n eff.toMonad d.m {x // e.IsDenotationForPureE Γv x} :=\n match h_pure : e.toPure? with\n | some ePure => pure ⟨ePure.denoteOp Γv, by admit /- proof elided -/\n ⟩\n | none => (Subtype.mk · (by admit /- proof elided -/\n )) <$> (e.denoteOp Γv)"
},
{
"name": "Expr.IsDenotationForPureE",
"content": "abbrev Expr.IsDenotationForPureE (e : Expr d Γ eff tys) (Γv : Valuation Γ)\n (x : HVector toType tys) : Prop :=\n ∀ (ePure : Expr d Γ .pure tys), e.toPure? = some ePure → ePure.denoteOp Γv = x"
},
{
"name": "appendCases",
"content": "@[elab_as_elim]\ndef appendCases\n {motive : (Γ ++ Δ).Var t → Sort u}\n (left : (v : Var Γ t) → motive (appendInl v))\n (right : (v : Var Δ t) → motive (appendInr v)) :\n (v : (Γ ++ Δ).Var t) → motive v\n | ⟨idx, h⟩ =>\n if hv : idx < Γ.length then\n left ⟨idx, by admit /- proof elided -/\n ⟩\n else\n let v' : Var _ _ := ⟨idx - Γ.length, by admit /- proof elided -/\n ⟩\n have eq : v'.appendInr = ⟨idx, h⟩ := by admit /- proof elided -/"
},
{
"name": "Expr.toPure?",
"content": "def Expr.toPure? (e : Expr d Γ eff ty) : Option (Expr d Γ .pure ty) :=\n if h : e.HasPureOp then\n some <| e.toPure h\n else\n none"
},
{
"name": "Expr.toPure",
"content": "def Expr.toPure (e : Expr d Γ eff ty) (h : e.HasPureOp) : Expr d Γ .pure ty :=\n ⟨e.op, e.ty_eq, EffectKind.le_of_eq h, e.args, e.regArgs⟩"
},
{
"name": "Expr.ty",
"content": "def Expr.ty : Expr d Γ eff [t] → d.Ty := fun _ => t"
},
{
"name": "Expr.HasPureOp",
"content": "def Expr.HasPureOp (e : Expr d Γ eff ty) : Prop :=\n DialectSignature.effectKind e.op = .pure"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
},
{
"name": "TyDenote.toType",
"content": "notation \"⟦\" x \"⟧\" => TyDenote.toType x"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "Com.denoteLets_eq",
"content": "theorem Com.denoteLets_eq {com : Com d Γ eff t} : com.denoteLets = com.toLets.denote"
},
{
"name": "Lets.denote_var",
"content": "@[simp] theorem Lets.denote_var {lets : Lets d Γ_in eff Γ_out} {e : Expr d Γ_out eff t} :\n (lets.var e).denote = fun V_in => lets.denote V_in >>= e.denote"
},
{
"name": "castCtxt_rfl",
"content": "@[simp, grind=] theorem castCtxt_rfl (h : Γ = Γ) : v.castCtxt h = v"
},
{
"name": "Com.returnVars_castPureToEff",
"content": "@[simp] theorem Com.returnVars_castPureToEff (eff : _) (com : Com d Γ .pure tys) :\n (com.castPureToEff eff).returnVars = com.returnVars.map (fun _ v => v.castCtxt (by simp))"
},
{
"name": "Valuation.comap_apply",
"content": "@[simp] theorem Valuation.comap_apply {Γi Γo : Ctxt Ty}\n (V : Γi.Valuation) (f : Ctxt.Hom Γo Γi) (v : Γo.Var t) :\n V.comap f v = V (f v)"
},
{
"name": "Com.denoteLets_castPureToEff",
"content": "@[simp] theorem Com.denoteLets_castPureToEff {com : Com d Γ .pure ty} :\n denoteLets (com.castPureToEff eff)\n = fun V => pure (com.denoteLets V |>.comap fun _ v => v.castCtxt (by simp))"
},
{
"name": "Com.denoteLets_returnVars",
"content": "@[simp] theorem Com.denoteLets_returnVars (c : Com d Γ .pure tys) (V : Valuation Γ) :\n c.returnVars.map (c.denoteLets V) = c.denote V"
},
{
"name": "Id.bind_eq'",
"content": "theorem Id.bind_eq' (x : Id α) (f : α → id β) : x >>= f = f x"
},
{
"name": "Id.pure_eq'",
"content": "theorem Id.pure_eq' (a : α) : (pure a : Id α) = a"
},
{
"name": "Ctxt.Valuation.comap_outContextHom_denoteLets",
"content": "@[simp] theorem Ctxt.Valuation.comap_outContextHom_denoteLets {com : Com d Γ .pure ty} {V} :\n Valuation.comap (com.denoteLets V) com.outContextHom = V"
},
{
"name": "Com.bvars_castPureToEff",
"content": "@[simp] theorem Com.bvars_castPureToEff {com : Com d Γ .pure ty} :\n (com.castPureToEff eff).bvars = com.bvars"
},
{
"name": "Valuation.comap_with",
"content": "@[simp] theorem Valuation.comap_with [DecidableEq Ty] {Γ Δ : Ctxt Ty}\n {V : Valuation Γ} {map : Δ.Hom Γ} {vs : HVector Δ.Var ty} {ws : HVector Γ.Var ty} :\n V.comap (map.with vs ws) = (V.comap map).reassignVars vs (ws.map V)"
},
{
"name": "map_map",
"content": "theorem map_map {A B C : α → Type*} {l : List α} (t : HVector A l)\n (f : ∀ a, A a → B a) (g : ∀ a, B a → C a) :\n (t.map f).map g = t.map (fun a v => g a (f a v))"
},
{
"name": "castCtxt_castCtxt",
"content": "@[simp, grind=] theorem castCtxt_castCtxt (h₁ : Γ = Δ) (h₂ : Δ = Ξ) :\n (v.castCtxt h₁).castCtxt h₂ = v.castCtxt (by simp [*])"
},
{
"name": "Lets.denote_eq_denoteIntoSubtype",
"content": "theorem Lets.denote_eq_denoteIntoSubtype (lets : Lets d Γ_in eff Γ_out) (Γv : Valuation Γ_in) :\n lets.denote Γv = Subtype.val <$> (lets.denoteIntoSubtype Γv)"
},
{
"name": "Expr.denoteOp_eq_denoteOpIntoSubtype",
"content": "theorem Expr.denoteOp_eq_denoteOpIntoSubtype (e : Expr d Γ eff tys) (V : Valuation Γ) :\n e.denoteOp V = Subtype.val <$> e.denoteOpIntoSubtype V"
}
] | [
{
"name": "Zipper",
"content": "structure Zipper (Γ_in : Ctxt d.Ty) (eff : EffectKind) (tys : List d.Ty) where\n \n {Γ_mid : Ctxt d.Ty}\n \n top : Lets d Γ_in eff Γ_mid\n \n bot : Com d Γ_mid eff tys"
},
{
"name": "Zipper.denote",
"content": "def denote (zip : Zipper d Γ_in eff tys) (V_in : Valuation Γ_in) :\n eff.toMonad d.m (HVector toType tys) :=\n (zip.top.denote V_in) >>= zip.bot.denote"
},
{
"name": "Zipper.insertCom",
"content": "def insertCom (zip : Zipper d Γ_in eff ty)\n (vs : HVector zip.Γ_mid.Var newTy) (newCom : Com d zip.Γ_mid eff newTy) :\n Zipper d Γ_in eff ty :=\n let top := zip.top.addComToEnd newCom\n \n let bot := zip.bot.changeVars <| newCom.outContextHom.with vs newCom.returnVars\n \n \n { top, bot }"
},
{
"name": "Zipper.insertPureCom",
"content": "def insertPureCom (zip : Zipper d Γ_in eff ty)\n (vs : HVector zip.Γ_mid.Var newTy)\n (newCom : Com d zip.Γ_mid .pure newTy) : Zipper d Γ_in eff ty :=\n zip.insertCom vs (newCom.castPureToEff eff)"
}
] | [
{
"name": "Zipper.denote_insertCom",
"content": "theorem denote_insertCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]\n {newCom : Com d zip.Γ_mid eff newTys} {vs : HVector zip.Γ_mid.Var newTys} :\n (zip.insertCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do\n let V_mid ← zip.top.denote V_in\n let V_newMid ← newCom.denoteLets V_mid\n zip.bot.denote\n (V_newMid.comap <| newCom.outContextHom.with vs newCom.returnVars)\n )"
},
{
"name": "Zipper.denote_insertPureCom",
"content": "theorem denote_insertPureCom {zip : Zipper d Γ_in eff t₁} [LawfulMonad d.m]\n {newCom : Com d zip.Γ_mid .pure newTys} {vs : HVector zip.Γ_mid.Var newTys} :\n (zip.insertPureCom vs newCom).denote = (fun (V_in : Valuation Γ_in) => do\n let V_mid ← zip.top.denote V_in\n zip.bot.denote\n ((Com.denoteLets newCom V_mid).comap <| newCom.outContextHom.with vs newCom.returnVars)\n )"
}
] | import LeanMLIR.Framework.Basic
import LeanMLIR.Transforms.Rewrite.Match
open Ctxt (Valuation Var Hom)
variable (d : Dialect) [DialectSignature d]
structure Zipper (Γ_in : Ctxt d.Ty) (eff : EffectKind) (tys : List d.Ty) where
{Γ_mid : Ctxt d.Ty}
top : Lets d Γ_in eff Γ_mid
bot : Com d Γ_mid eff tys
namespace Zipper
variable {d}
section Denote
variable [TyDenote d.Ty] [DialectDenote d] [Monad d.m]
def denote (zip : Zipper d Γ_in eff tys) (V_in : Valuation Γ_in) :
eff.toMonad d.m (HVector toType tys) :=
(zip.top.denote V_in) >>= zip.bot.denote
end Denote
section ToCom
variable {Γ_mid}
variable [TyDenote d.Ty] [DialectDenote d] [Monad d.m]
end ToCom
section InsertCom
variable [DecidableEq d.Ty]
def insertCom (zip : Zipper d Γ_in eff ty)
(vs : HVector zip.Γ_mid.Var newTy) (newCom : Com d zip.Γ_mid eff newTy) :
Zipper d Γ_in eff ty :=
let top := zip.top.addComToEnd newCom
let bot := zip.bot.changeVars <| newCom.outContextHom.with vs newCom.returnVars
{ top, bot }
def insertPureCom (zip : Zipper d Γ_in eff ty)
(vs : HVector zip.Γ_mid.Var newTy)
(newCom : Com d zip.Γ_mid .pure newTy) : Zipper d Γ_in eff ty :=
zip.insertCom vs (newCom.castPureToEff eff)
section Lemmas
variable [TyDenote d.Ty] [DialectDenote d] [Monad d.m] | theorem denote_insertPureCom_eq_of [LawfulMonad d.m]
{zip : Zipper d Γ_in eff tys} {vs}
{newCom : Com d zip.Γ_mid .pure newTys} {V_in : Valuation Γ_in}
(h : ∀ V : zip.top.ValidDenotation,
newCom.denote V.val = vs.map V.val) :
(zip.insertPureCom vs newCom).denote V_in = zip.denote V_in := | := by
simp only [denote_insertPureCom, Valuation.comap_with,
Valuation.comap_outContextHom_denoteLets, Com.denoteLets_returnVars]
unfold Zipper.denote
simp [Lets.denote_eq_denoteIntoSubtype, h] | 12 | 152 | false | Compiler |
349 | R.coeff_fromTensor | theorem R.coeff_fromTensor (tensor : List Int)
(htensorlen : tensor.length < 2^n) :
(R.fromTensor (q := q) (n := n) tensor).coeff i = (tensor.getD i 0) | lean-mlir | SSA/Projects/FullyHomomorphicEncryption/Basic.lean | [
"import Mathlib.Data.List.Basic",
"import Mathlib.Data.List.ToFinsupp",
"import Mathlib.RingTheory.Polynomial.Quotient",
"import Mathlib.Data.ZMod.Defs",
"import Mathlib.RingTheory.Ideal.Defs",
"import Mathlib.RingTheory.Ideal.Basic",
"import Mathlib.Data.ZMod.Basic",
"import Mathlib.Algebra.MonoidAlgebra.Basic",
"import LeanMLIR.Framework",
"import Mathlib.Tactic.Cases",
"import Mathlib.Algebra.Polynomial.RingDivision",
"import Mathlib.Data.Finset.Sort"
] | [
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Ideal",
"module": "Mathlib.RingTheory.Ideal.Defs"
},
{
"name": "Ideal.Quotient.mk",
"module": "Mathlib.RingTheory.Ideal.Quotient.Defs"
},
{
"name": "Ideal.span",
"module": "Mathlib.RingTheory.Ideal.Span"
},
{
"name": "Polynomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.monomial",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Function.surjInv",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "Polynomial.coeff",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Int.cast",
"module": "Init.Data.Int.Basic"
},
{
"name": "List.toFinsupp",
"module": "Mathlib.Data.List.ToFinsupp"
},
{
"name": "Polynomial.ofFinsupp",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "List.length",
"module": "Init.Prelude"
},
{
"name": "Polynomial.degree",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "WithBot",
"module": "Mathlib.Order.TypeTags"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "List.zipIdx",
"module": "Init.Data.List.Basic"
},
{
"name": "Polynomial.Monic",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "List.getD",
"module": "Init.Data.List.BasicAux"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "OfNat",
"module": "Init.Prelude"
},
{
"name": "OfNat.ofNat",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Polynomial.toFinsupp",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Semiring",
"module": "Mathlib.Algebra.Ring.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Nat.cast",
"module": "Init.Data.Cast"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "List.length_map",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.map_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.map_cons",
"module": "Init.Data.List.Basic"
},
{
"name": "List.map_nil",
"module": "Init.Data.List.Basic"
},
{
"name": "List.toFinsupp_concat_eq_toFinsupp_add_single",
"module": "Mathlib.Data.List.ToFinsupp"
},
{
"name": "Polynomial.ofFinsupp_add",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Polynomial.ofFinsupp_single",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "List.foldl_append",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.foldl_cons",
"module": "Init.Data.List.Basic"
},
{
"name": "List.foldl_nil",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zipIdx_append",
"module": "Init.Data.List.Nat.Range"
},
{
"name": "List.zipIdx_cons",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zipIdx_nil",
"module": "Init.Data.List.Basic"
},
{
"name": "map_add",
"module": "Mathlib.Algebra.Group.Hom.Defs"
},
{
"name": "zero_add",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "Nat.one_le_two_pow",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.sub_add_cancel",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Polynomial.monic_X_pow_add",
"module": "Mathlib.Algebra.Polynomial.Monic"
},
{
"name": "Function.surjInv_eq",
"module": "Mathlib.Logic.Function.Basic"
},
{
"name": "Ideal.mem_span_singleton",
"module": "Mathlib.RingTheory.Ideal.Span"
},
{
"name": "Polynomial.modByMonic_eq_of_dvd_sub",
"module": "Mathlib.Algebra.Polynomial.Div"
},
{
"name": "Polynomial.modByMonic_eq_self_iff",
"module": "Mathlib.Algebra.Polynomial.Div"
},
{
"name": "List.getD_map",
"module": "Mathlib.Data.List.GetD"
},
{
"name": "List.toFinsupp_apply",
"module": "Mathlib.Data.List.ToFinsupp"
},
{
"name": "Polynomial.coeff_ofFinsupp",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "Fin.pos'",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.cast_ofNat",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.cast_pow",
"module": "Mathlib.Data.Nat.Cast.Basic"
},
{
"name": "Polynomial.degree_X_pow",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Polynomial.degree_add_eq_left_of_degree_lt",
"module": "Mathlib.Algebra.Polynomial.Degree.Operations"
},
{
"name": "Polynomial.degree_one",
"module": "Mathlib.Algebra.Polynomial.Degree.Definitions"
},
{
"name": "Finset.max_le",
"module": "Mathlib.Data.Finset.Max"
},
{
"name": "Finset.mem_filter",
"module": "Mathlib.Data.Finset.Filter"
},
{
"name": "Finset.mem_insert",
"module": "Mathlib.Data.Finset.Insert"
},
{
"name": "Finset.mem_range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Finset.range_add_one",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "List.length_cons",
"module": "Init.Data.List.Basic"
},
{
"name": "Nat.cast_add",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.cast_one",
"module": "Mathlib.Data.Nat.Cast.Defs"
},
{
"name": "Nat.le_add_one_iff",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.le_of_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Polynomial.support_ofFinsupp",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "WithBot.coe_le_coe",
"module": "Mathlib.Order.WithBot"
},
{
"name": "Nat.lt_of_le_of_lt",
"module": "Init.Prelude"
},
{
"name": "WithBot.coe_strictMono",
"module": "Mathlib.Order.WithBot"
},
{
"name": "WithBot.lt_def",
"module": "Mathlib.Order.WithBot"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "R.fromPoly",
"content": "abbrev R.fromPoly {q n : Nat} : (ZMod q)[X] →+* R q n := Ideal.Quotient.mk (Ideal.span {f q n})"
},
{
"name": "R.representative'",
"content": "private noncomputable def R.representative' :\n R q n → (ZMod q)[X] := Function.surjInv (R.surjective_fromPoly q n)"
},
{
"name": "R.representative",
"content": "noncomputable def R.representative :\n R q n → (ZMod q)[X] := fun x => R.representative' q n x %ₘ (f q n)"
},
{
"name": "R.coeff",
"content": "noncomputable def R.coeff {q n} (a : R q n) (i : Nat) : ZMod q :=\n Polynomial.coeff a.representative i"
},
{
"name": "R.monomial",
"content": "noncomputable def R.monomial {q n : Nat} (c : ZMod q) (i : Nat): R q n :=\n R.fromPoly (Polynomial.monomial i c)"
},
{
"name": "R.fromTensor",
"content": "noncomputable def R.fromTensor {q n} (coeffs : List Int) : R q n :=\n coeffs.zipIdx.foldl (init := 0) fun res (c, i) =>\n res + R.monomial ↑c i"
},
{
"name": "R.fromTensorFinsupp",
"content": "noncomputable def R.fromTensorFinsupp (q : Nat) (coeffs : List Int) : (ZMod q)[X] :=\n Polynomial.ofFinsupp (List.toFinsupp (coeffs.map Int.cast))"
}
] | [
{
"name": "f_deg_eq",
"content": "theorem f_deg_eq : (f q n).degree = 2^n"
},
{
"name": "f_monic",
"content": "theorem f_monic : Monic (f q n)"
},
{
"name": "R.fromPoly_rep'_eq_ideal",
"content": "theorem R.fromPoly_rep'_eq_ideal :\n forall a : (ZMod q)[X],\n ∃ i ∈ Ideal.span {f q n}, (R.fromPoly (n:=n) a).representative' = a + i"
},
{
"name": "R.representative_fromPoly",
"content": "theorem R.representative_fromPoly :\n forall a : (ZMod q)[X], (R.fromPoly (n:=n) a).representative = a %ₘ (f q n)"
},
{
"name": "R.representative_fromPoly_eq",
"content": "@[simp]\ntheorem R.representative_fromPoly_eq (x : (ZMod q)[X]) (DEGREE: x.degree < (f q n).degree) :\n R.representative q n (R.fromPoly (n:=n) x) = x"
},
{
"name": "Polynomial.degree_toFinsupp",
"content": "theorem Polynomial.degree_toFinsupp [Semiring M] [DecidableEq M]\n (xs : List M) :\n degree { toFinsupp := List.toFinsupp (l := xs) } ≤ List.length xs"
},
{
"name": "R.fromTensorFinsupp_degree",
"content": "theorem R.fromTensorFinsupp_degree (q : Nat) (coeffs : List Int):\n (R.fromTensorFinsupp q coeffs).degree ≤ coeffs.length"
},
{
"name": "R.fromTensorFinsupp_coeffs",
"content": "theorem R.fromTensorFinsupp_coeffs (coeffs : List Int) :\n Polynomial.coeff (fromTensorFinsupp q coeffs) i = ↑(List.getD coeffs i 0)"
},
{
"name": "R.fromTensorFinsupp_concat_monomial",
"content": "theorem R.fromTensorFinsupp_concat_monomial (c : Int) (cs : List Int) :\n (R.fromTensorFinsupp q (cs ++ [c])) =\n (R.fromTensorFinsupp q cs) +\n (Polynomial.monomial cs.length (Int.cast c : (ZMod q)))"
},
{
"name": "R.fromTensor_eq_fromTensorFinsupp_fromPoly",
"content": "theorem R.fromTensor_eq_fromTensorFinsupp_fromPoly {coeffs : List Int} :\n R.fromTensor (q := q) (n := n) coeffs =\n R.fromPoly (q := q) (n := n) (R.fromTensorFinsupp q coeffs)"
}
] | import Mathlib.RingTheory.Polynomial.Quotient
import Mathlib.RingTheory.Ideal.Defs
import Mathlib.RingTheory.Ideal.Basic
import Mathlib.Data.ZMod.Defs
import Mathlib.Data.ZMod.Basic
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.Data.Finset.Sort
import Mathlib.Data.List.ToFinsupp
import Mathlib.Data.List.Basic
import Mathlib.Tactic.Cases
import LeanMLIR.Framework
open Polynomial -- for R[X] notation
section CommRing
variable (q t : Nat) [Fact (q > 1)] (n : Nat)
noncomputable def f : (ZMod q)[X] := X^(2^n) + 1
abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})
abbrev R.fromPoly {q n : Nat} : (ZMod q)[X] →+* R q n := Ideal.Quotient.mk (Ideal.span {f q n})
end CommRing
section Representative
variable (q t n : Nat)
private noncomputable def R.representative' :
R q n → (ZMod q)[X] := Function.surjInv (R.surjective_fromPoly q n)
noncomputable def R.representative :
R q n → (ZMod q)[X] := fun x => R.representative' q n x %ₘ (f q n)
variable [Fact (q > 1)]
end Representative
section Coeff
noncomputable def R.coeff {q n} (a : R q n) (i : Nat) : ZMod q :=
Polynomial.coeff a.representative i
noncomputable def R.monomial {q n : Nat} (c : ZMod q) (i : Nat): R q n :=
R.fromPoly (Polynomial.monomial i c)
noncomputable def R.fromTensor {q n} (coeffs : List Int) : R q n :=
coeffs.zipIdx.foldl (init := 0) fun res (c, i) =>
res + R.monomial ↑c i
end Coeff
section FinnSupp
variable {q n : Nat}
noncomputable def R.fromTensorFinsupp (q : Nat) (coeffs : List Int) : (ZMod q)[X] :=
Polynomial.ofFinsupp (List.toFinsupp (coeffs.map Int.cast))
end FinnSupp
section Tensor
variable {q n : Nat} [Fact (q > 1)] | theorem R.coeff_fromTensor (tensor : List Int)
(htensorlen : tensor.length < 2^n) :
(R.fromTensor (q := q) (n := n) tensor).coeff i = (tensor.getD i 0) := | := by
rw [fromTensor_eq_fromTensorFinsupp_fromPoly]
have hfromTensorFinsuppDegree := fromTensorFinsupp_degree q tensor
rw [coeff, representative_fromPoly_eq]
apply fromTensorFinsupp_coeffs
case DEGREE =>
generalize htensor_degree : degree (fromTensorFinsupp q tensor) = tensor_degree
rw [f_deg_eq]
cases tensor_degree
case bot =>
rw [WithBot.lt_def]
simp
exists 2^n
norm_cast
case coe tensor_degree =>
/- I hate this coercion stuff -/
apply WithBot.coe_strictMono
norm_cast
have htrans : tensor_degree ≤ List.length tensor := by
rw [htensor_degree] at hfromTensorFinsuppDegree
rw [← WithBot.coe_le_coe]
assumption
apply Nat.lt_of_le_of_lt htrans htensorlen | 4 | 95 | false | Compiler |
350 | BitStream.ofBitVec_add | theorem ofBitVec_add : ofBitVecSext (x + y) ≈ʷ (ofBitVecSext x) + (ofBitVecSext y) | lean-mlir | Blase/Blase/Fast/BitStream.lean | [
"import Mathlib.Logic.Function.Iterate",
"import Mathlib.Tactic.NormNum"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Add",
"module": "Init.Prelude"
},
{
"name": "Add.add",
"module": "Init.Prelude"
},
{
"name": "BitVec.carry",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "BitVec.getLsbD",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "HAdd",
"module": "Init.Prelude"
},
{
"name": "HAdd.hAdd",
"module": "Init.Prelude"
},
{
"name": "Int.succ",
"module": "Mathlib.Data.Int.Init"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Nat.add_mod",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "Nat.mod_two_eq_zero_or_one",
"module": "Init.Data.Nat.Lemmas"
},
{
"name": "BitVec.add_eq",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.carry_succ",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "BitVec.getElem_add",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Nat.add_eq",
"module": "Init.Data.Nat.Basic"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "BitStream.ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "BitStream.addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitStream.add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "BitStream.zero",
"content": "abbrev zero : BitStream := fun _ => false"
}
] | [
{
"name": "BitStream.two_le_add_iff_odd_and_odd",
"content": "private theorem two_le_add_iff_odd_and_odd (n m : Nat) :\n 2 ≤ n % 2 + m % 2 ↔ n % 2 = 1 ∧ m % 2 = 1"
},
{
"name": "BitStream.add_odd_iff_neq",
"content": "private theorem add_odd_iff_neq (n m : Nat) :\n (n + m) % 2 = 1 ↔ (n % 2 = 1) ≠ (m % 2 = 1)"
}
] | import Mathlib.Tactic.NormNum
import Mathlib.Logic.Function.Iterate
section UpStream
namespace Int
end Int
end UpStream
def BitStream : Type := Nat → Bool
namespace BitStream
section Basic
section Lemmas
end Lemmas
end Basic
section OfNat
end OfNat
section ToBitVec
abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=
fun i => if i < w then x.getLsbD i else x.msb
section Lemmas
end Lemmas
end ToBitVec
section BitwiseOps
section Lemmas
variable {w : Nat}
variable (x y : BitStream) (i : Nat)
variable (x y : BitVec (w+1))
end Lemmas
end BitwiseOps
section Scan
end Scan
section FindIndex
section Arith
def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=
let carryIn : Bool := match i with
| 0 => false
| i + 1 => (addAux x y i).2
Prod.swap (BitVec.adcb (x i) (y i) carryIn)
def add (x y : BitStream) : BitStream :=
fun n => (addAux x y n).1
abbrev zero : BitStream := fun _ => false
section Lemmas
variable {w : Nat} {x y : BitVec w} {a b a' b' : BitStream}
local infix:20 " ≈ʷ " => EqualUpTo w | theorem ofBitVec_add : ofBitVecSext (x + y) ≈ʷ (ofBitVecSext x) + (ofBitVecSext y) := | := by
intros n a
have add_lemma : ⟨(x + y).getLsbD n, BitVec.carry (n + 1) x y false ⟩ = (ofBitVecSext x).addAux (ofBitVecSext y) n := by
induction n
case zero =>
simp [addAux, BitVec.adcb, BitVec.carry, BitVec.getLsbD, a,
two_le_add_iff_odd_and_odd, add_odd_iff_neq]
bv_decide
case succ i ih =>
simp [addAux, ← ih (by omega), BitVec.adcb, a, BitVec.carry_succ, BitVec.getElem_add];
simp [HAdd.hAdd, Add.add, BitStream.add, ← add_lemma, a, -BitVec.add_eq, -Nat.add_eq] | 3 | 24 | false | Compiler |
351 | Predicate.evalUlt_denote_true_iff | theorem Predicate.evalUlt_denote_true_iff {w : Nat} (a b : Term) (vars : List (BitVec w)) :
evalUlt (a.eval (List.map .ofBitVecSext vars)) (b.eval (List.map .ofBitVecSext vars)) w = true ↔
(Term.denote w b vars) ≤ (Term.denote w a vars) | lean-mlir | Blase/Blase/Fast/Defs.lean | [
"import Blase.SingleWidth.Defs",
"import Mathlib.Data.Fin.Basic",
"import Mathlib.Data.Bool.Basic",
"import Blase.Fast.BitStream",
"import Blase.Blase.Fast.BitStream"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "BitVec.ult",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "BitVec.carry",
"module": "Init.Data.BitVec.Bitblast"
}
] | [
{
"name": "syntax \"slt\" : MLIR.Pretty.uniform_op",
"content": "syntax \"slt\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "Term.denote",
"content": "def Term.denote (w : Nat) (t : Term) (vars : List (BitVec w)) : BitVec w :=\n match t with\n | ofNat n => BitVec.ofNat w n\n | var n => vars.getD n default\n | zero => 0#w\n | negOne => -1#w\n | one => 1#w\n | and a b => (a.denote w vars) &&& (b.denote w vars)\n | or a b => (a.denote w vars) ||| (b.denote w vars)\n | xor a b => (a.denote w vars) ^^^ (b.denote w vars)\n | not a => ~~~ (a.denote w vars)\n | add a b => (a.denote w vars) + (b.denote w vars)\n | sub a b => (a.denote w vars) - (b.denote w vars)\n | neg a => - (a.denote w vars)\n \n \n | shiftL a n => (a.denote w vars) <<< n"
},
{
"name": "Predicate.denote",
"content": "def Predicate.denote (p : Predicate) (w : Nat) (vars : List (BitVec w)) : Prop :=\n match p with\n | .width .ge k => k ≤ w \n | .width .gt k => k < w \n | .width .le k => w ≤ k\n | .width .lt k => w < k\n | .width .neq k => w ≠ k\n | .width .eq k => w = k\n | .binary .eq t₁ t₂ => t₁.denote w vars = t₂.denote w vars\n | .binary .neq t₁ t₂ => t₁.denote w vars ≠ t₂.denote w vars\n | .binary .sle t₁ t₂ => ((t₁.denote w vars).sle (t₂.denote w vars)) = true\n | .binary .slt t₁ t₂ => ((t₁.denote w vars).slt (t₂.denote w vars)) = true\n | .binary .ule t₁ t₂ => ((t₁.denote w vars).ule (t₂.denote w vars)) = true\n | .binary .ult t₁ t₂ => (t₁.denote w vars).ult (t₂.denote w vars) = true\n | .land p q => p.denote w vars ∧ q.denote w vars\n | .lor p q => p.denote w vars ∨ q.denote w vars"
},
{
"name": "Predicate",
"content": "inductive Predicate : Type where\n \n| width (wp : WidthPredicate) (n : Nat) : Predicate\n| binary (p : BinaryPredicate) (t₁ t₂ : Term)\n| land (p q : Predicate) : Predicate\n| lor (p q : Predicate) : Predicate\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "WidthPredicate",
"content": "inductive WidthPredicate\n| eq\n| neq\n| lt\n| le\n| gt\n| ge\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "toBitVec",
"content": "def toBitVec (w : Nat) (x : BitStream) : BitVec w :=\n match w with\n | 0 => 0#0\n | w+1 => (x.toBitVec w).cons (x w)"
}
] | [
{
"name": "BitVec.lt_def",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.of_length_zero",
"module": "Init.Data.BitVec.Lemmas"
},
{
"name": "BitVec.ult_eq_not_carry",
"module": "Init.Data.BitVec.Bitblast"
}
] | [
{
"name": "subAux_eq_BitVec_carry",
"content": "@[simp] theorem subAux_eq_BitVec_carry (a b : BitStream) (w i : Nat) (hi : i < w) :\n (a.subAux b i).2 = !(BitVec.carry (i + 1) (a.toBitVec w) ((~~~b).toBitVec w) true)"
}
] | [
{
"name": "Term.eval",
"content": "def Term.eval (t : Term) (vars : List BitStream) : BitStream :=\n match t with\n | var n => vars.getD n default\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ => (t₁.eval vars) &&& (t₂.eval vars)\n | or t₁ t₂ => (t₁.eval vars) ||| (t₂.eval vars)\n | xor t₁ t₂ => (t₁.eval vars) ^^^ (t₂.eval vars)\n | not t => ~~~(t.eval vars)\n | add t₁ t₂ => (Term.eval t₁ vars) + (Term.eval t₂ vars)\n | sub t₁ t₂ => (Term.eval t₁ vars) - (Term.eval t₂ vars)\n | neg t => -(Term.eval t vars)\n\n\n | shiftL t n => BitStream.shiftLeft (Term.eval t vars) n"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.eval",
"content": "def Predicate.eval (p : Predicate) (vars : List BitStream) : BitStream :=\n match p with\n | .width .eq n => BitStream.falseIffEq n\n | .width .neq n => BitStream.falseIffNeq n\n | .width .lt n => BitStream.falseIffLt n\n | .width .le n => BitStream.falseIffLe n\n | .width .gt n => BitStream.falseIffGt n\n | .width .ge n => BitStream.falseIffGe n\n | lor p q => Predicate.evalLor (p.eval vars) (q.eval vars)\n | land p q => Predicate.evalLand (p.eval vars) (q.eval vars)\n | binary .eq t₁ t₂ => Predicate.evalEq (t₁.eval vars) (t₂.eval vars)\n \n | binary .neq t1 t2 => Predicate.evalNeq (t1.eval vars) (t2.eval vars)\n | binary .ult t₁ t₂ => Predicate.evalUlt (t₁.eval vars) (t₂.eval vars)\n | binary .ule t₁ t₂ =>\n Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalUlt (t₁.eval vars) (t₂.eval vars))\n | binary .slt t₁ t₂ => Predicate.evalSlt (t₁.eval vars) (t₂.eval vars)\n | binary .sle t₁ t₂ => Predicate.evalLor\n (Predicate.evalEq (t₁.eval vars) (t₂.eval vars))\n (Predicate.evalSlt (t₁.eval vars) (t₂.eval vars))"
}
] | [
{
"name": "BitVec.lt_eq_decide_ult",
"content": "private theorem BitVec.lt_eq_decide_ult {x y : BitVec w} : (x < y) = decide (x.ult y)"
},
{
"name": "Predicate.evalUlt_denote_false_iff",
"content": "theorem Predicate.evalUlt_denote_false_iff {w : Nat} (a b : Term) (vars : List (BitVec w)) :\n evalUlt (a.eval (List.map .ofBitVecSext vars)) (b.eval (List.map .ofBitVecSext vars)) w = false ↔\n (Term.denote w a vars < Term.denote w b vars)"
}
] | import Mathlib.Data.Bool.Basic
import Mathlib.Data.Fin.Basic
import Blase.Fast.BitStream
import Blase.SingleWidth.Defs
open Term
open BitStream in
def Term.eval (t : Term) (vars : List BitStream) : BitStream :=
match t with
| var n => vars.getD n default
| zero => BitStream.zero
| one => BitStream.one
| negOne => BitStream.negOne
| ofNat n => BitStream.ofNat n
| and t₁ t₂ => (t₁.eval vars) &&& (t₂.eval vars)
| or t₁ t₂ => (t₁.eval vars) ||| (t₂.eval vars)
| xor t₁ t₂ => (t₁.eval vars) ^^^ (t₂.eval vars)
| not t => ~~~(t.eval vars)
| add t₁ t₂ => (Term.eval t₁ vars) + (Term.eval t₂ vars)
| sub t₁ t₂ => (Term.eval t₁ vars) - (Term.eval t₂ vars)
| neg t => -(Term.eval t vars)
| shiftL t n => BitStream.shiftLeft (Term.eval t vars) n
def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr
def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd
def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)
def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)
def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true
def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=
(t₁ ^^^ t₂).concat false
def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=
(((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))
open BitStream in
def Predicate.eval (p : Predicate) (vars : List BitStream) : BitStream :=
match p with
| .width .eq n => BitStream.falseIffEq n
| .width .neq n => BitStream.falseIffNeq n
| .width .lt n => BitStream.falseIffLt n
| .width .le n => BitStream.falseIffLe n
| .width .gt n => BitStream.falseIffGt n
| .width .ge n => BitStream.falseIffGe n
| lor p q => Predicate.evalLor (p.eval vars) (q.eval vars)
| land p q => Predicate.evalLand (p.eval vars) (q.eval vars)
| binary .eq t₁ t₂ => Predicate.evalEq (t₁.eval vars) (t₂.eval vars)
| binary .neq t1 t2 => Predicate.evalNeq (t1.eval vars) (t2.eval vars)
| binary .ult t₁ t₂ => Predicate.evalUlt (t₁.eval vars) (t₂.eval vars)
| binary .ule t₁ t₂ =>
Predicate.evalLor
(Predicate.evalEq (t₁.eval vars) (t₂.eval vars))
(Predicate.evalUlt (t₁.eval vars) (t₂.eval vars))
| binary .slt t₁ t₂ => Predicate.evalSlt (t₁.eval vars) (t₂.eval vars)
| binary .sle t₁ t₂ => Predicate.evalLor
(Predicate.evalEq (t₁.eval vars) (t₂.eval vars))
(Predicate.evalSlt (t₁.eval vars) (t₂.eval vars))
section Predicate
end Predicate | theorem Predicate.evalUlt_denote_true_iff {w : Nat} (a b : Term) (vars : List (BitVec w)) :
evalUlt (a.eval (List.map .ofBitVecSext vars)) (b.eval (List.map .ofBitVecSext vars)) w = true ↔
(Term.denote w b vars) ≤ (Term.denote w a vars) := | := by
obtain ⟨h₁, h₂⟩ := evalUlt_denote_false_iff a b vars
constructor
· intros h
by_contra h'
simp at h'
specialize (h₂ h')
simp [h₂] at h
· intros h
by_contra h'
simp at h'
specialize (h₁ h')
bv_omega | 6 | 50 | false | Compiler |
352 | Ctxt.Valuation.reassignVars_eq | @[simp] theorem Valuation.reassignVars_eq [DecidableEq Ty] (V : Γ.Valuation) :
V.reassignVars vs (vs.map V) = V | lean-mlir | LeanMLIR/LeanMLIR/ErasedContext.lean | [
"import LeanMLIR.HVector",
"import LeanMLIR/LeanMLIR/Tests/Tactic/ElimValuation.lean",
"import SSA/Projects/PaperExamples/VariadicExample.lean",
"import SSA/Projects/Tensor2D/Tensor2D.lean",
"import Mathlib.Data.Fintype.Basic",
"import SSA/Projects/RISCV64/Base.lean",
"import SSA/Tests/Core/Print.lean",
"import SSA/Projects/ModArith/Basic.lean",
"import SSA/Projects/PaperExamples/PaperExamples.lean",
"import SSA/Projects/Scf/ScfFunctor.lean",
"import SSA/Projects/ISL/Explicit/Base.lean",
"import SSA/Projects/CIRCT/Handshake/Handshake.lean",
"import SSA/Projects/CIRCT/DC/DCSync.lean",
"import SSA/Projects/CIRCT/Comb/Comb.lean",
"import LeanMLIR/LeanMLIR/Transforms/CSE.lean",
"import SSA/Projects/CIRCT/DCPlus/DCPlus.lean",
"import LeanMLIR/LeanMLIR/Examples.lean",
"import LeanMLIR/LeanMLIR/Transforms/DCE.lean",
"import LeanMLIR.LeanMLIR.HVector",
"import LeanMLIR/LeanMLIR/Dialects/LLVM/Basic.lean",
"import SSA/Projects/Tensor1D/Tensor1D.lean",
"import SSA/Projects/LLVMRiscV/LLVMAndRiscv.lean",
"import SSA/Projects/SLLVM/Dialect/Basic.lean"
] | [
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "StateM",
"module": "Init.Control.State"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.Expr",
"module": "Lean.Expr"
},
{
"name": "Stream'",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Stream'.tail",
"module": "Mathlib.Data.Stream.Defs"
},
{
"name": "Id.run",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "bool",
"module": "Init.Control.Basic"
},
{
"name": "List.replicate",
"module": "Init.Data.List.Basic"
},
{
"name": "BitVec.ofInt",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "inferInstanceAs",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
}
] | [
{
"name": "HVector.decidableEqReg",
"content": "protected instance HVector.decidableEqReg [DecidableEq d.Op] [DecidableEq d.Ty] :\n ∀ {l : RegionSignature d.Ty}, DecidableEq (HVector (fun t => Com d t.1 .impure t.2) l)\n | _, .nil, .nil => isTrue rfl\n | _, .cons x₁ v₁, .cons x₂ v₂ =>\n letI := HVector.decidableEqReg v₁ v₂\n letI := Com.decidableEq x₁ x₂\n decidable_of_iff (x₁ = x₂ ∧ v₁ = v₂) (by admit /- proof elided -/\n )"
},
{
"name": "idxOf?",
"content": "def idxOf? (x : A a) {as} [DecidableEq α] [∀ a, DecidableEq (A a)] :\n HVector A as → Option { i : Fin <| as.length // as.get i = a }\n | .nil => none\n | .cons (a:=b) y ys =>\n if h : ∃ h : a = b, x = h ▸ y then\n some ⟨(0 : Fin <| _ + 1), h.1 ▸ rfl⟩\n else\n (ys.idxOf? x).map fun ⟨i, h⟩ =>\n ⟨i.succ, by admit /- proof elided -/\n ⟩"
},
{
"name": "map",
"content": "def map (f : ∀ (a : α), A a → B a) :\n ∀ {l : List α}, HVector A l → HVector B l\n | [], .nil => .nil\n | t::_, .cons a as => .cons (f t a) (map f as)"
},
{
"name": "HVectorLiteral",
"content": "structure HVectorLiteral where\n u : Level\n v : Level\n α : Q(Type $u)\n A : Q($α → Type $v)\n elems : Array ((a : Q($α)) × Q($A $a))"
},
{
"name": "",
"content": "instance : TyDenote Unit where toType := fun _ => Unit"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "Ty",
"content": "inductive Ty (q : Nat) (n : Nat)\n | index : Ty q n\n | integer : Ty q n\n | tensor : Ty q n\n | polynomialLike : Ty q n\n deriving DecidableEq, Repr"
},
{
"name": "",
"content": "instance : TyDenote ISL.Ty where\n toType := fun\n | .regIndex => RegIndex\n | .bits w => BitVec w\n\n \ndef_denote for ISL\n | .regConst r => [r]ₕ\n | .regRead => fun r regFile => ([regFile.read r]ₕ, regFile)\n | .regWrite => fun r v regFile => ([]ₕ, regFile.write r v)\n | .bitsConst x => [x]ₕ\n | .bitsAdd _ => fun (x y : BitVec _) => [x + y]ₕ"
},
{
"name": "ExplicitISL",
"content": "def ExplicitISL : Dialect where\n Op := ISLOp\n Ty := ExpTy\n m := Id "
},
{
"name": "ExpTy",
"content": "inductive ExpTy where\n | isl : ISL.Ty → ExpTy\n | regFile"
},
{
"name": "ISL",
"content": "def ISL : Dialect where\n Ty := ISLTy\n Op := ISLOp\n m := StateM RegFile"
},
{
"name": "ISLTy",
"content": "inductive ISLTy\n | regIndex\n | bits (w : Nat)\n deriving DecidableEq, ToExpr, Repr"
},
{
"name": "ISLOp",
"content": "inductive ISLOp\n | regConst (r : RegIndex)\n | regRead\n | regWrite\n | bitsConst {w : Nat} (x : BitVec w)\n | bitsAdd (w : Nat)\n deriving DecidableEq, ToExpr, Repr"
},
{
"name": "RegIndex",
"content": "def RegIndex := Fin RegFile.numRegisters"
},
{
"name": "RegFile.numRegisters",
"content": "def RegFile.numRegisters := 32"
},
{
"name": "Dialect",
"content": "structure Dialect where\n (Op : Type)\n (Ty : Type)\n (m : Type → Type := Id)"
},
{
"name": "Op",
"content": "inductive Op (q : Nat) (n : Nat)\n | add : Op q n\n | sub : Op q n\n | mul : Op q n\n | mul_constant : Op q n\n \n \n | leading_term : Op q n\n | monomial : Op q n\n | monomial_mul : Op q n\n | from_tensor : Op q n\n | to_tensor : Op q n\n | const (c : R q n) : Op q n\n | const_int (c : Int) : Op q n\n | const_idx (i : Nat) : Op q n"
},
{
"name": "RegFile",
"content": "structure RegFile where\n regs : Vector (BitVec RegFile.registerWidth) RegFile.numRegisters"
},
{
"name": "RegFile.registerWidth",
"content": "def RegFile.registerWidth := 64"
},
{
"name": "read",
"content": "def read (self : RegFile) (r : RegIndex) : BitVec registerWidth :=\n self.regs[r.val]"
},
{
"name": "write",
"content": "def write (self : RegFile) (r : RegIndex) (v : BitVec registerWidth) : RegFile :=\n RegFile.mk <| self.regs.set r.val v"
},
{
"name": "instDCTyDenote",
"content": "instance instDCTyDenote : TyDenote Ty where\ntoType := fun\n| Ty.tokenstream => CIRCTStream.DCPlusOp.TokenStream\n| Ty.tokenstream2 => CIRCTStream.DCPlusOp.TokenStream × CIRCTStream.DCPlusOp.TokenStream\n| Ty.valuestream w => CIRCTStream.DCPlusOp.ValueStream (BitVec w)\n| Ty.valuestream2 w => CIRCTStream.DCPlusOp.ValueStream (BitVec w) × CIRCTStream.DCPlusOp.ValueStream (BitVec w)\n| Ty.valuetokenstream w => CIRCTStream.DCPlusOp.ValueStream (BitVec w) × CIRCTStream.DCPlusOp.TokenStream\n| Ty.variadicvaluetokenstream w => CIRCTStream.DCPlusOp.VariadicValueStream w × CIRCTStream.DCPlusOp.TokenStream\n\n\ndef_denote for DCPlus where\n | .fst => fun s => [s.fst]ₕ\n | .fstVal _ => fun s => [s.fst]ₕ\n | .fstValPure _ => fun s => [s.fst]ₕ\n | .fstVal' _ => fun s => [s.fst.mapOpt (·[0]?)]ₕ\n | .snd => fun s => [s.snd]ₕ\n | .sndValPure _ => fun s => [s.snd]ₕ\n | .pair _ => fun s₁ s₂ => [(s₁, s₂)]ₕ\n | .sndVal _ => fun s => [s.snd]ₕ\n | .sndVal' _ => fun s => [s.fst.mapOpt (·[0]?)]ₕ\n | .tokVal' _ => fun s => [s.snd]ₕ\n | .merge => fun s₁ s₂ => [CIRCTStream.DCPlusOp.merge s₁ s₂]ₕ\n | .branch => fun s₁ s₂ => [CIRCTStream.DCPlusOp.branch s₁ s₂]ₕ\n | .fork => fun s => [CIRCTStream.DCPlusOp.fork s]ₕ\n | .forkVal => fun s => [CIRCTStream.DCPlusOp.forkVal s]ₕ\n | .join => fun s₁ s₂ => [CIRCTStream.DCPlusOp.join s₁ s₂]ₕ\n | .mux => fun s₁ s₂ c => [CIRCTStream.DCPlusOp.mux s₁ s₂ c]ₕ\n | .muxVal => fun s₁ s₂ c => [CIRCTStream.DCPlusOp.muxVal s₁ s₂ c]ₕ\n | .sink => fun s => [CIRCTStream.DCPlusOp.sink s]ₕ\n | .source => [CIRCTStream.DCPlusOp.source]ₕ\n | .sourceOnes => [CIRCTStream.DCPlusOp.sourceOnes]ₕ\n | .cMerge => fun s₁ s₂ => [CIRCTStream.DCPlusOp.cMerge s₁ s₂]ₕ\n | .supp => fun s₁ s₂ => [CIRCTStream.DCPlusOp.supp s₁ s₂]ₕ\n | .not => fun s₁ => [CIRCTStream.DCPlusOp.not s₁]ₕ"
},
{
"name": "DCPlus",
"content": "abbrev DCPlus : Dialect where\n Op := Op\n Ty := Ty"
},
{
"name": "def_signature for DCPlus where",
"content": "def_signature for DCPlus where\n | .fst => (Ty.tokenstream2) → (Ty.tokenstream)\n | .fstVal t => (Ty.valuetokenstream t) → Ty.valuestream t\n | .fstVal' t => (Ty.variadicvaluetokenstream t) → Ty.valuestream t\n | .fstValPure t => (Ty.valuestream2 t) → Ty.valuestream t\n | .snd => (Ty.tokenstream2) → (Ty.tokenstream)\n | .sndValPure t => (Ty.valuestream2 t) → Ty.valuestream t\n | .pair w => (Ty.valuestream w, Ty.valuestream w) → Ty.valuestream2 w\n | .sndVal t => (Ty.valuetokenstream t) → Ty.tokenstream\n | .sndVal' t => (Ty.variadicvaluetokenstream t) → Ty.valuestream t\n | .tokVal' t => (Ty.variadicvaluetokenstream t) → Ty.tokenstream\n | .merge => (Ty.tokenstream, Ty.tokenstream) → Ty.valuestream 1\n | .branch => (Ty.valuestream 1, Ty.tokenstream) → Ty.tokenstream2\n | .fork => (Ty.tokenstream) → Ty.tokenstream2\n | .forkVal => (Ty.valuestream 1) → Ty.valuestream2 1\n | .join => (Ty.tokenstream, Ty.tokenstream) → Ty.tokenstream\n | .mux => (Ty.tokenstream, Ty.tokenstream, Ty.valuestream 1) → Ty.tokenstream\n | .muxVal => (Ty.valuestream 1, Ty.valuestream 1, Ty.valuestream 1) → Ty.valuestream 1\n | .sink => (Ty.tokenstream) → Ty.tokenstream\n | .source => () → Ty.tokenstream\n | .sourceOnes => () → Ty.valuestream 1\n | .cMerge => (Ty.tokenstream, Ty.tokenstream) → Ty.valuetokenstream 1\n | .supp => (Ty.valuestream 1, Ty.tokenstream) → Ty.tokenstream\n | .not => (Ty.valuestream 1) → Ty.valuestream 1"
},
{
"name": "sndVal",
"content": "def sndVal {Γ} (a : Γ.Var (MLIR2DCPlus.Ty.valuetokenstream r)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .sndVal r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "Ty",
"content": "inductive Ty\n| tokenstream : Ty\n| tokenstream2 : Ty\n| valuestream (w : Nat) : Ty \n| valuestream2 (w : Nat) : Ty \n| valuetokenstream (w : Nat) : Ty \n| variadicvaluetokenstream (w : Nat) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "Context",
"content": "def Context (Ty : Type) : Type :=\n List (VarName × Ty)"
},
{
"name": "VarName",
"content": "def VarName : Type := String"
},
{
"name": "hasType",
"content": "def hasType (Γ : Context Ty) (v : VarName) (ty : Ty) : Prop :=\n Γ.lookup v = some ty"
},
{
"name": "Expr.decidableEq",
"content": "protected instance Expr.decidableEq [DecidableEq d.Op] [DecidableEq d.Ty] :\n {Γ : Ctxt d.Ty} → {ty : List d.Ty} → DecidableEq (Expr d Γ eff ty)\n | Γ, _, .mk op₁ rfl eff_le₁ arg₁ regArgs₁, .mk op₂ eq eff_le₂ arg₂ regArgs₂ =>\n if ho : op₁ = op₂ then by\n subst ho\n letI := HVector.decidableEq arg₁ arg₂\n letI := HVector.decidableEqReg regArgs₁ regArgs₂\n exact decidable_of_iff (arg₁ = arg₂ ∧ regArgs₁ = regArgs₂) (by admit /- proof elided -/\n )\n else isFalse (by admit /- proof elided -/\n )"
},
{
"name": "AffineExpr",
"content": "inductive AffineExpr\n | Var: String -> AffineExpr\n deriving DecidableEq, Repr"
},
{
"name": "mux",
"content": "def mux {Γ : Ctxt _} (a b : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) (c : Γ.Var (MLIR2DCPlus.Ty.valuestream 1)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .mux)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .cons c <| .nil)\n (regArgs := .nil)"
},
{
"name": "branch",
"content": "def branch {Γ : Ctxt _} (c : Γ.Var (MLIR2DCPlus.Ty.valuestream 1)) (a : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) : Expr (DCPlus) Γ .pure (.tokenstream2) :=\n Expr.mk\n (op := .branch)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons c <| .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "merge",
"content": "def merge {Γ : Ctxt _} (a b : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) : Expr (DCPlus) Γ .pure (.valuestream 1) :=\n Expr.mk\n (op := .merge)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "cMerge",
"content": "def cMerge {Γ : Ctxt _} (a b : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) : Expr (DCPlus) Γ .pure (.valuetokenstream 1) :=\n Expr.mk\n (op := .cMerge)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "fork",
"content": "def fork {Γ : Ctxt _} (a : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) : Expr (DCPlus) Γ .pure (.tokenstream2) :=\n Expr.mk\n (op := .fork)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "fstVal",
"content": "def fstVal (a : Γ.Var (MLIR2DCPlus.Ty.valuetokenstream r)) : Expr (DCPlus) Γ .pure (.valuestream r) :=\n Expr.mk\n (op := .fstVal r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "forkVal",
"content": "def forkVal {Γ : Ctxt _} (a : Γ.Var (MLIR2DCPlus.Ty.valuestream 1)) : Expr (DCPlus) Γ .pure (.valuestream2 1) :=\n Expr.mk\n (op := .forkVal)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "join",
"content": "def join {Γ : Ctxt _} (a b : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .join)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "Op",
"content": "inductive Op\n| fst\n| snd\n| pair (w : Nat)\n| fstVal (w : Nat)\n| fstValPure (w : Nat)\n| sndVal (w : Nat)\n| sndValPure (w : Nat)\n| fstVal' (w : Nat)\n| sndVal' (w : Nat)\n| tokVal' (w : Nat)\n| fork\n| forkVal\n| join\n| merge\n| mux\n| muxVal\n| cMerge\n| branch\n| source\n| sourceOnes\n| sink\n| supp\n| not\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "fstValPure",
"content": "def fstValPure (a : Γ.Var (MLIR2DCPlus.Ty.valuestream2 r)) : Expr (DCPlus) Γ .pure (.valuestream r) :=\n Expr.mk\n (op := .fstValPure r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "sink",
"content": "def sink {Γ : Ctxt _} (a : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .sink)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "supp",
"content": "def supp {Γ : Ctxt _} (a : Γ.Var (MLIR2DCPlus.Ty.tokenstream)) (c : Γ.Var (MLIR2DCPlus.Ty.valuestream 1)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .supp)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons c <| .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "muxVal",
"content": "def muxVal {Γ : Ctxt _} (a b c : Γ.Var (MLIR2DCPlus.Ty.valuestream 1)) : Expr (DCPlus) Γ .pure (.valuestream 1) :=\n Expr.mk\n (op := .muxVal)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .cons c <| .nil)\n (regArgs := .nil)"
},
{
"name": "sndValPure",
"content": "def sndValPure (a : Γ.Var (MLIR2DCPlus.Ty.valuestream2 r)) : Expr (DCPlus) Γ .pure (.valuestream r) :=\n Expr.mk\n (op := .sndValPure r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "sourceOnes",
"content": "def sourceOnes : Expr (DCPlus) Γ .pure (.valuestream 1) :=\n Expr.mk\n (op := .sourceOnes)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "snd",
"content": "def snd {Γ} (a : Γ.Var (MLIR2DCPlus.Ty.tokenstream2)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .snd)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "source",
"content": "def source : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .source)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "fst",
"content": "def fst (a : Γ.Var (MLIR2DCPlus.Ty.tokenstream2)) : Expr (DCPlus) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .fst)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "TokenStream",
"content": "def TokenStream := Stream Unit"
},
{
"name": "Stream",
"content": "def Stream (β : Type) := Stream' (Option β)"
},
{
"name": "ValueStream",
"content": "def ValueStream := Stream"
},
{
"name": "VariadicValueStream",
"content": "def VariadicValueStream (w : Nat) := CIRCTStream.Stream (List (BitVec w))"
},
{
"name": "branch",
"content": "def branch (c : ValueStream (BitVec 1)) (x : TokenStream) : TokenStream × TokenStream :=\n Stream.corec₂ (β := ValueStream (BitVec 1) × TokenStream) (c, x) fun ⟨c, x⟩ =>\n Id.run <| do\n match c 0 with\n | none => (none, none, (c.tail, x))\n | some x₀ =>\n if x₀.msb then\n (some (), none, (c.tail, x.tail))\n else\n (none, some (), (c.tail, x.tail))"
},
{
"name": "tail",
"content": "def tail : Stream α → Stream α := Stream'.tail"
},
{
"name": "corec₂",
"content": "def corec₂ {β} (s0 : β) (f : β → (Option α × Option γ × β)) : Stream α × Stream γ :=\n let f' := fun b =>\n let x := f b\n (x.fst, x.snd.fst)\n let g := (f · |>.snd.snd)\n let x := Stream'.corec f' g s0\n (\n fun i => (x i).fst,\n fun i => (x i).snd,\n )"
},
{
"name": "cMerge",
"content": "def cMerge (x y : TokenStream) : ValueStream (BitVec 1) × TokenStream :=\n Stream.corec₂ (β := TokenStream × TokenStream) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some x', some _ => (some 1, some x', (x.tail, y))\n | some x', none => (some 1, some x', (x.tail, y.tail))\n | none, some y' => (some 0, some y', (x.tail, y.tail))\n | none, none => (none, none, (x.tail, y.tail))"
},
{
"name": "fork",
"content": "def fork (x : TokenStream) : TokenStream × TokenStream :=\n Stream.corec₂ (β := TokenStream) x\n fun x => Id.run <| do\n (x 0, x 0, x.tail)"
},
{
"name": "forkVal",
"content": "def forkVal (x : ValueStream (BitVec 1)) : ValueStream (BitVec 1) × ValueStream (BitVec 1) :=\n Stream.corec₂ (β := ValueStream (BitVec 1)) x\n fun x => Id.run <| do\n (x 0, x 0, x.tail)"
},
{
"name": "join",
"content": "def join (x y : TokenStream) : TokenStream :=\n Stream.corec (β := TokenStream × TokenStream) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some _, some _ => (some (), (x.tail, y.tail))\n | some _, none => (none, (x, y.tail))\n | none, some _ => (none, (x.tail, y))\n | none, none => (none, (x.tail, y.tail))"
},
{
"name": "corec",
"content": "def corec {α} {β} (s0 : β) (f : β → (Option α × β)) : Stream α :=\n Stream'.corec (f · |>.fst) (f · |>.snd) s0"
},
{
"name": "merge",
"content": "def merge (x y : TokenStream) : ValueStream (BitVec 1) :=\n Stream.corec (β := TokenStream × TokenStream) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some _, some _ => (some 1, (x.tail, y))\n | some _, none => (some 1, (x.tail, y.tail))\n | none, some _ => (some 0, (x.tail, y.tail))\n | none, none => (none, (x.tail, y.tail))"
},
{
"name": "mux",
"content": "def mux (x y : TokenStream) (c : ValueStream (BitVec 1)): TokenStream :=\n Stream.corec (β := TokenStream × TokenStream × ValueStream (BitVec 1)) (x, y, c)\n fun ⟨x, y, c⟩ =>\n match (c 0) with\n | none => (none, x, y, c.tail) \n | some 1#1 =>\n match (x 0) with\n | none => (none, x.tail, y, c) \n | some _ => (some (), x.tail, y, c.tail) \n | some 0#1 =>\n match (y 0) with\n | none => (none, x, y.tail, c) \n | some _ => (some (), x, y.tail, c.tail) "
},
{
"name": "muxVal",
"content": "def muxVal (x y c : ValueStream (BitVec 1)): ValueStream (BitVec 1) :=\n Stream.corec (β := ValueStream (BitVec 1) × ValueStream (BitVec 1) × ValueStream (BitVec 1)) (x, y, c)\n fun ⟨x, y, c⟩ =>\n match (c 0) with\n | none => (none, x, y, c.tail) \n | some 1#1 =>\n match (x 0) with\n | none => (none, x.tail, y, c) \n | some e => (some e, x.tail, y, c.tail) \n | some 0#1 =>\n match (y 0) with\n | none => (none, x, y.tail, c) \n | some e => (some e, x, y.tail, c.tail) "
},
{
"name": "not",
"content": "def not (c : ValueStream (BitVec 1)) : (ValueStream (BitVec 1)) :=\n Stream.corec (β := ValueStream (BitVec 1)) c fun c =>\n match c 0 with\n | some 1 => (some 0, c.tail)\n | some 0 => (some 1, c.tail)\n | _ => (none, c.tail)"
},
{
"name": "sink",
"content": "def sink (x : TokenStream) : TokenStream :=\n Stream.corec (β := TokenStream) x fun x => (none, x.tail)"
},
{
"name": "source",
"content": "def source : TokenStream :=\n Stream.corec () fun () => (some (), ())"
},
{
"name": "sourceOnes",
"content": "def sourceOnes : ValueStream (BitVec 1) :=\n Stream.corec () fun () => (1#1, ())"
},
{
"name": "supp",
"content": "def supp (c : ValueStream (BitVec 1)) (x : TokenStream) : TokenStream := (branch c x).snd"
},
{
"name": "mapOpt",
"content": "def mapOpt {α β : Type} (s : Stream α) (f : α → (Option β)) : Stream β :=\n fun i => (s i).bind f"
},
{
"name": "",
"content": "instance : TyDenote Ty where toType\n | .felt => Fin BabyBear"
},
{
"name": "BabyBear",
"content": "def BabyBear := 2^31 - 2^27 + 1"
},
{
"name": "Ty",
"content": "inductive Ty\n | felt"
},
{
"name": "instDCTyDenote",
"content": "instance instDCTyDenote : TyDenote Ty where\ntoType := fun\n| Ty.tokenstream => CIRCTStream.DCOp.TokenStream\n| Ty.tokenstream2 => CIRCTStream.DCOp.TokenStream × CIRCTStream.DCOp.TokenStream\n| Ty.valuestream w => CIRCTStream.DCOp.ValueStream (BitVec w)\n| Ty.valuestream2 w => CIRCTStream.DCOp.ValueStream (BitVec w) × CIRCTStream.DCOp.ValueStream (BitVec w)\n| Ty.valuetokenstream w => CIRCTStream.DCOp.ValueStream (BitVec w) × CIRCTStream.DCOp.TokenStream\n| Ty.variadicvaluetokenstream w => CIRCTStream.DCOp.VariadicValueStream w × CIRCTStream.DCOp.TokenStream\n\n\ndef_denote for DC where\n | .fst => fun s => [s.fst]ₕ\n | .fstVal _ => fun s => [s.fst]ₕ\n | .fstVal' _ => fun s => [s.fst.mapOpt (·[0]?)]ₕ\n | .snd => fun s => [s.snd]ₕ\n | .pair _ => fun s₁ s₂ => [(s₁, s₂)]ₕ\n | .sndVal _ => fun s => [s.snd]ₕ\n | .sndVal' _ => fun s => [s.fst.mapOpt (·[0]?)]ₕ\n | .tokVal' _ => fun s => [s.snd]ₕ\n | .merge => fun s₁ s₂ => [CIRCTStream.DCOp.merge s₁ s₂]ₕ\n | .branch => fun s => [CIRCTStream.DCOp.branch s]ₕ\n | .fork => fun s => [CIRCTStream.DCOp.fork s]ₕ\n | .join => fun s₁ s₂ => [CIRCTStream.DCOp.join s₁ s₂]ₕ\n | .select => fun s₁ s₂ c => [CIRCTStream.DCOp.select s₁ s₂ c]ₕ\n | .sink => fun s => [CIRCTStream.DCOp.sink s]ₕ\n | .source => [CIRCTStream.DCOp.source]ₕ\n | .pack _ => fun s₁ s₂ => [CIRCTStream.DCOp.pack s₁ s₂]ₕ\n | .pack2 _ => fun s₁ => [CIRCTStream.DCOp.pack2 s₁]ₕ\n | .unpack _ => fun s => [CIRCTStream.DCOp.unpack s]ₕ\n | .unpack2 _ => fun s₁ s₂ => [CIRCTStream.DCOp.unpack2 s₁ s₂]ₕ"
},
{
"name": "branch",
"content": "def branch (x : ValueStream (BitVec 1)): TokenStream × TokenStream :=\n Stream.corec₂ (β := ValueStream (BitVec 1)) x fun x =>\n Id.run <| do\n match x 0 with\n | none => (none, none, (x.tail))\n | some x₀ =>\n if x₀.msb then\n (some (), none, (x.tail))\n else\n (none, some (), (x.tail))"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "pack",
"content": "def pack (x : ValueStream α) (y : TokenStream) : ValueStream α :=\n Stream.corec (β := ValueStream α × TokenStream) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some x₀, some _ => (x₀, (x.tail, y.tail))\n | some _, none => (none, (x, y.tail)) \n | none, some _ => (none, (x.tail, y)) \n | none, none => (none, (x.tail, y.tail))"
},
{
"name": "select",
"content": "def select (x y : TokenStream) (c : ValueStream (BitVec 1)): TokenStream :=\n Stream.corec (β := TokenStream × TokenStream × Stream (BitVec 1)) (x, y, c)\n fun ⟨x, y, c⟩ =>\n match (c 0) with\n | none => (none, x, y, c.tail) \n | some 1#1 =>\n match (x 0) with\n | none => (none, x.tail, y, c) \n | some _ => (some (), x.tail, y, c.tail) \n | some 0#1 =>\n match (y 0) with\n | none => (none, x, y.tail, c) \n | some _ => (some (), x, y.tail, c.tail) "
},
{
"name": "unpack",
"content": "def unpack (x : ValueStream (BitVec w)) : ValueStream (BitVec w) × TokenStream :=\n Stream.corec₂ (β := Stream (BitVec w)) (x)\n fun x => Id.run <| do\n match x 0 with\n | some _ => return (x 0, some (), x.tail)\n | none => return (none, none, x.tail)"
},
{
"name": "DC",
"content": "abbrev DC : Dialect where\n Op := Op\n Ty := Ty"
},
{
"name": "def_signature for DC where",
"content": "def_signature for DC where\n | .fst => (Ty.tokenstream2) → (Ty.tokenstream)\n | .fstVal t => (Ty.valuetokenstream t) → Ty.valuestream t\n | .fstVal' t => (Ty.variadicvaluetokenstream t) → Ty.valuestream t\n | .snd => (Ty.tokenstream2) → (Ty.tokenstream)\n | .pair w => (Ty.valuestream w, Ty.valuestream w) → Ty.valuestream2 w\n | .sndVal t => (Ty.valuetokenstream t) → Ty.tokenstream\n | .sndVal' t => (Ty.variadicvaluetokenstream t) → Ty.valuestream t\n | .tokVal' t => (Ty.variadicvaluetokenstream t) → Ty.tokenstream\n | .merge => (Ty.tokenstream, Ty.tokenstream) → Ty.valuestream 1\n | .branch => (Ty.valuestream 1) → Ty.tokenstream2\n | .fork => (Ty.tokenstream) → Ty.tokenstream2\n | .join => (Ty.tokenstream, Ty.tokenstream) → Ty.tokenstream\n | .select => (Ty.tokenstream, Ty.tokenstream, Ty.valuestream 1) → Ty.tokenstream\n | .sink => (Ty.tokenstream) → Ty.tokenstream\n | .source => () → Ty.tokenstream\n | .pack t => (Ty.valuestream t, Ty.tokenstream) → Ty.valuestream t\n | .pack2 t => (Ty.variadicvaluetokenstream t) → Ty.valuestream2 t\n | .unpack t => (Ty.valuestream t) → Ty.valuetokenstream t\n | .unpack2 t => (Ty.valuestream t, Ty.valuestream t) → Ty.variadicvaluetokenstream t"
},
{
"name": "Op",
"content": "inductive Op\n| fst\n| snd\n| pair (w : Nat)\n| fstVal (w : Nat)\n| sndVal (w : Nat)\n| fstVal' (w : Nat)\n| sndVal' (w : Nat)\n| tokVal' (w : Nat)\n| merge\n| branch\n| fork\n| join\n| select\n| sink\n| source\n| pack (w : Nat)\n| pack2 (w : Nat)\n| unpack (w : Nat)\n| unpack2 (w : Nat)\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "branch",
"content": "def branch {Γ : Ctxt _} (a : Γ.Var (.valuestream 1)) : Expr (DC) Γ .pure (.tokenstream2) :=\n Expr.mk\n (op := .branch)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "fork",
"content": "def fork (a : Γ.Var (.tokenstream)) : Expr (DC) Γ .pure (.tokenstream2) :=\n Expr.mk\n (op := .fork)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "unpack2",
"content": "def unpack2 {r} {Γ : Ctxt _} (a : Γ.Var (.valuestream r)) (b : Γ.Var (.valuestream r)) : Expr (DC) Γ .pure (.variadicvaluetokenstream r) :=\n Expr.mk\n (op := .unpack2 r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "fst",
"content": "def fst {Γ : Ctxt _} (a : Γ.Var (.tokenstream2)) : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .fst)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "sink",
"content": "def sink {Γ : Ctxt _} (a : Γ.Var (.tokenstream)) : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .sink)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "merge",
"content": "def merge {Γ : Ctxt _} (a b : Γ.Var (.tokenstream)) : Expr (DC) Γ .pure (.valuestream 1) :=\n Expr.mk\n (op := .merge)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "pack",
"content": "def pack {r} {Γ : Ctxt _} (a : Γ.Var (.valuestream r)) (b : Γ.Var (.tokenstream)) : Expr (DC) Γ .pure (.valuestream r) :=\n Expr.mk\n (op := .pack r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "select",
"content": "def select {Γ : Ctxt _} (a b : Γ.Var (.tokenstream)) (c : Γ.Var (.valuestream 1)) : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .select)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .cons c <| .nil)\n (regArgs := .nil)"
},
{
"name": "source",
"content": "def source : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .source)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .nil)\n (regArgs := .nil)"
},
{
"name": "join",
"content": "def join {Γ : Ctxt _} (a b : Γ.Var (.tokenstream)) : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .join)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "pack2",
"content": "def pack2 {r} {Γ : Ctxt _} (a : Γ.Var (.variadicvaluetokenstream r)) : Expr (DC) Γ .pure (.valuestream2 r) :=\n Expr.mk\n (op := .pack2 r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "fstVal",
"content": "def fstVal {r} {Γ : Ctxt _} (a : Γ.Var (.valuetokenstream r)) : Expr (DC) Γ .pure (.valuestream r) :=\n Expr.mk\n (op := .fstVal r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "snd",
"content": "def snd {Γ : Ctxt _} (a : Γ.Var (.tokenstream2)) : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .snd)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "unpack",
"content": "def unpack {r} {Γ : Ctxt _} (a : Γ.Var (.valuestream r)) : Expr (DC) Γ .pure (.valuetokenstream r) :=\n Expr.mk\n (op := .unpack r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "sndVal",
"content": "def sndVal {r} {Γ : Ctxt _} (a : Γ.Var (.valuetokenstream r)) : Expr (DC) Γ .pure (.tokenstream) :=\n Expr.mk\n (op := .sndVal r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "pair",
"content": "def pair {r} {Γ : Ctxt _} (a b: Γ.Var (.valuestream r)) : Expr (DC) Γ .pure (.valuestream2 r) :=\n Expr.mk\n (op := .pair r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "pack2",
"content": "def pack2 (x : VariadicValueStream α × TokenStream) : (ValueStream (BitVec α)) × (ValueStream (BitVec α)) :=\n Stream.corec₂ (β := VariadicValueStream α × TokenStream) (x) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some x', some _ => (x'[0]?, x'[1]?, (x.tail, y.tail))\n | some _, none => (none, none, (x, y.tail))\n | none, some _ => (none, none, (x.tail, y)) \n | none, none => (none, none, (x.tail, y.tail)) "
},
{
"name": "unpack2",
"content": "def unpack2 (x : ValueStream (BitVec w)) (y : ValueStream (BitVec w)) : VariadicValueStream w × TokenStream :=\n Stream.corec₂ (β := CIRCTStream.Stream (BitVec w) × CIRCTStream.Stream (BitVec w)) (x, y)\n fun (x, y) => Id.run <| do\n match x 0, y 0 with\n | some x', some y' => return (some [x', y'], some .unit, (x.tail, y.tail))\n | some _, none => return (none, none, (x, y.tail))\n | none, some _ => return (none, none, (x.tail, y)) \n | none, none => return (none, none, (x.tail, y.tail))"
},
{
"name": "",
"content": "@[reducible]\ninstance : TyDenote ExTy where\n toType\n | .nat => Nat\n | .bool => Bool"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq"
},
{
"name": "",
"content": "instance : TyDenote Ty where toType := Ty.toType"
},
{
"name": "Ty.toType",
"content": "def Ty.toType : Ty → Type\n| .int => Int\n| .ix => Index\n| .tensor2d => Tensor2d' Int "
},
{
"name": "",
"content": "instance : TyDenote Ty where\n toType\n | .int => Int\n | .ix => Index\n | .tensor1d => Tensor1d Int"
},
{
"name": "Index",
"content": "abbrev Index := ℕ"
},
{
"name": "Tensor1d",
"content": "structure Tensor1d (α : Type) [Inhabited α] where\n size : Index\n val : Index → α\n spec : ∀ (ix: Index), ix >= size -> val ix = default"
},
{
"name": "Tensor2d",
"content": "structure Tensor2d (α : Type) where\n size0 : Nat\n size1 : Nat\n val : Fin size0 → Fin size1 → α"
},
{
"name": "",
"content": "instance : TyDenote TestDialect.Ty where toType\n | .int => Int\n | .int2 => Int × Int"
},
{
"name": "def_signature for TestDialect",
"content": "def_signature for TestDialect\n | .noop => () -> []\n | .mkPair => (.int, .int) -> .int2\n | .unPair => (.int2) -> [.int, .int]"
},
{
"name": "def_denote for TestDialect",
"content": "def_denote for TestDialect\n | .noop => []ₕ\n | .unPair => fun (x, y) => [x, y]ₕ\n | .mkPair => fun x y => [(x, y)]ₕ"
},
{
"name": "Op",
"content": "inductive Op\n | noop\n | mkPair\n | unPair\n deriving Lean.ToExpr"
},
{
"name": "TestDialect",
"content": "def TestDialect : Dialect where\n Ty := Ty\n Op := Op"
},
{
"name": "Ty",
"content": "inductive Ty\n | int\n \n | int2\n deriving DecidableEq, Lean.ToExpr"
},
{
"name": "",
"content": "instance : TyDenote Ty where\n toType\n | Ty.bv => BitVec 64"
},
{
"name": "Ty",
"content": "inductive Ty\n | bv : Ty\n deriving DecidableEq, Repr, Inhabited, Lean.ToExpr"
},
{
"name": "",
"content": "instance : TyDenote LLVM.Ty where\n toType := fun\n | bitvec w => LLVM.IntW w"
},
{
"name": "IntW",
"content": "def IntW w := PoisonOr <| BitVec w"
},
{
"name": "PoisonOr",
"content": "structure PoisonOr (α : Type) where\n val : α\n poisonous : Bool\nderiving Inhabited, DecidableEq"
},
{
"name": "",
"content": "@[reducible]\ninstance : TyDenote Ty where\n toType\n | .int => BitVec 32"
},
{
"name": "SimpleReg.int",
"content": "abbrev SimpleReg.int : SimpleReg.Ty := .int"
},
{
"name": "",
"content": "instance : TyDenote Ty where toType\n | .int => BitVec 32"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n | bool\n deriving DecidableEq, Repr"
},
{
"name": "",
"content": "instance : TyDenote Ty2 where\ntoType := fun\n| Ty2.bitvec w => BitVec w"
},
{
"name": "Ty2",
"content": "inductive Ty2\n | bitvec (w : Nat) : Ty2\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "instHandshakeTyDenote",
"content": "instance instHandshakeTyDenote : TyDenote Ty where\ntoType := fun\n| Ty.stream ty2 => CIRCTStream.Stream (TyDenote.toType ty2)\n| Ty.stream2 ty2 => CIRCTStream.Stream (TyDenote.toType ty2) × CIRCTStream.Stream (TyDenote.toType ty2)\n| Ty.stream2token ty2 => CIRCTStream.Stream (TyDenote.toType ty2) × CIRCTStream.Stream (TyDenote.toType (Ty2.bitvec 1))"
},
{
"name": "def_denote for Handshake where",
"content": "def_denote for Handshake where\n| .fst _ => fun s => [s.fst]ₕ\n| .snd _ => fun s => [s.snd]ₕ\n| .branch _ => fun s c => [HandshakeOp.branch s c]ₕ\n| .merge _ => fun s₁ s₂ => [HandshakeOp.merge s₁ s₂]ₕ\n| .altMerge _ => fun s₁ s₂ => [HandshakeOp.altMerge s₁ s₂]ₕ\n| .fork _ => fun s => [HandshakeOp.fork s]ₕ\n| .controlMerge _ => fun s₁ s₂ => [HandshakeOp.controlMerge s₁ s₂]ₕ\n| .join _ => fun s₁ s₂ => [HandshakeOp.join s₁ s₂]ₕ\n| .mux _ => fun s₁ s₂ c => [HandshakeOp.mux s₁ s₂ c]ₕ\n| .sink _ => fun s => [HandshakeOp.sink s]ₕ\n| .sync _ => fun s₁ s₂ => [HandshakeOp.sync s₁ s₂]ₕ\n| .supp _ => fun s₁ s₂ => [HandshakeOp.supp s₁ s₂]ₕ\n| .not => fun s₁ => [HandshakeOp.not s₁]ₕ"
},
{
"name": "Handshake",
"content": "abbrev Handshake : Dialect where\n Op := Op\n Ty := Ty"
},
{
"name": "def_signature for Handshake where",
"content": "def_signature for Handshake where\n| .fst t => (Ty.stream2 t) → Ty.stream t\n| .snd t => (Ty.stream2 t) → Ty.stream t\n| .branch t => (Ty.stream t, Ty.stream (Ty2.bitvec 1)) → Ty.stream2 t\n| .merge t => (Ty.stream t, Ty.stream t) → Ty.stream t\n| .altMerge t => (Ty.stream t, Ty.stream t) → Ty.stream t\n| .fork t => (Ty.stream t) → Ty.stream2 t \n| .controlMerge t => (Ty.stream t, Ty.stream t) → (Ty.stream2token t)\n| .join t => (Ty.stream t, Ty.stream t) → (Ty.stream (Ty2.bitvec 1))\n| .mux t => (Ty.stream t, Ty.stream t, Ty.stream (Ty2.bitvec 1)) → Ty.stream t\n| .sink t => (Ty.stream t) → (Ty.stream (Ty2.bitvec 1))\n| .sync t => (Ty.stream t, Ty.stream t) → Ty.stream2 t\n| .supp t => (Ty.stream t, Ty.stream (Ty2.bitvec 1)) → Ty.stream t\n| .not => (Ty.stream (Ty2.bitvec 1)) → Ty.stream (Ty2.bitvec 1)"
},
{
"name": "Ty",
"content": "inductive Ty\n| stream (ty2 : Ty2) : Ty \n| stream2 (ty2 : Ty2) : Ty \n| stream2token (ty2 : Ty2) : Ty \nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "sync",
"content": "def sync {Γ : Ctxt _} (a b : Var Γ (.stream r)) : Expr (Handshake) Γ .pure (.stream2 r) :=\n Expr.mk\n (op := .sync r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "snd",
"content": "def snd {Γ : Ctxt _} (a : Var Γ (.stream2 r)) : Expr (Handshake) Γ .pure (.stream r) :=\n Expr.mk\n (op := .snd r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "Op",
"content": "inductive Op\n| fst (t : Ty2)\n| snd (t : Ty2)\n| branch (t : Ty2)\n| merge (t : Ty2)\n| altMerge (t : Ty2)\n| fork (t : Ty2)\n| controlMerge (t : Ty2)\n| join (t : Ty2)\n| mux (t : Ty2)\n| sink (t : Ty2)\n| sync (t : Ty2)\n| supp (t : Ty2)\n| not\nderiving Inhabited, DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "merge",
"content": "def merge {Γ : Ctxt _} (a b : Var Γ (.stream r)) : Expr (Handshake) Γ .pure (.stream r) :=\n Expr.mk\n (op := .merge r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "supp",
"content": "def supp {Γ : Ctxt _} (a : Var Γ (.stream r)) (b : Var Γ (.stream (.bitvec 1))) : Expr (Handshake) Γ .pure (.stream r) :=\n Expr.mk\n (op := .supp r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons b <| .nil)\n (regArgs := .nil)"
},
{
"name": "branch",
"content": "def branch {r} {Γ : Ctxt _} (a : Var Γ (.stream r)) (c : Var Γ (.stream (.bitvec 1))) : Expr (Handshake) Γ .pure (.stream2 r) :=\n Expr.mk\n (op := .branch r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .cons c <| .nil)\n (regArgs := .nil)"
},
{
"name": "fst",
"content": "def fst {Γ : Ctxt _} (a : Var Γ (.stream2 r)) : Expr (Handshake) Γ .pure (.stream r) :=\n Expr.mk\n (op := .fst r)\n (ty_eq := rfl)\n (eff_le := by admit /- proof elided -/\n )\n (args := .cons a <| .nil)\n (regArgs := .nil)"
},
{
"name": "altMerge",
"content": "def altMerge (x y : Stream α) : Stream α :=\n Stream.corec (β := Stream α × Stream α × ConsumeFrom) (x, y, .left) fun ⟨x, y, consume⟩ =>\n match consume with\n | .left =>\n let x0 := x.head\n let x := x.tail\n let nextConsume := match x0 with\n | some _ => .right\n | none => .left\n (x0, x, y, nextConsume)\n | .right =>\n let y0 := y.head\n let y := y.tail\n let nextConsume := match y0 with\n | some _ => .left\n | none => .right\n (y0, x, y, nextConsume)"
},
{
"name": "branch",
"content": "def branch (x : Stream α) (c : Stream (BitVec 1)) : Stream α × Stream α :=\n Stream.corec₂ (β := Stream α × Stream (BitVec 1)) (x, c)\n fun ⟨x, c⟩ => Id.run <| do\n let c₀ := c 0\n let c' := c.tail\n let x₀ := x 0\n let x' := x.tail\n match c₀, x₀ with\n | none, _ => (none, none, (x, c'))\n | _, none => (none, none, (x', c))\n | some c₀, some x₀ =>\n if c₀ = 1 then\n (some x₀, none, (x', c'))\n else\n (none, some x₀, (x', c'))"
},
{
"name": "controlMerge",
"content": "def controlMerge (x y : Stream α) : Stream α × Stream (BitVec 1) :=\n Stream.corec₂ (β := Stream α × Stream α) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some x', some _ => (some x', some 1, (x.tail, y))\n | some x', none => (some x', some 1, (x.tail, y.tail))\n | none, some y' => (some y', some 0, (x.tail, y.tail))\n | none, none => (none, none, (x.tail, y.tail))"
},
{
"name": "fork",
"content": "def fork (x : Stream α) : Stream α × Stream α :=\n Stream.corec₂ (β := Stream α) x\n fun x => Id.run <| do\n let x0 := x 0\n let x' := x.tail\n (x0, x0, x')"
},
{
"name": "join",
"content": "def join (x y : Stream α) : Stream (BitVec 1) :=\n Stream.corec (β := Stream α × Stream α) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some _, some _ => (some 1, (x.tail, y.tail))\n | some _, none => (none, (x, y.tail))\n | none, some _ => (none, (x.tail, y))\n | none, none => (none, (x.tail, y.tail))"
},
{
"name": "merge",
"content": "def merge (x y : Stream α) : Stream α :=\n Stream.corec (β := Stream α × Stream α) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some x', some _ => (some x', (x.tail, y))\n | some x', none => (some x', (x.tail, y.tail))\n | none, some y' => (some y', (x.tail, y.tail))\n | none, none => (none, (x.tail, y.tail))"
},
{
"name": "mux",
"content": "def mux (x y : Stream α) (c : Stream (BitVec 1)) : Stream α :=\n Stream.corec (β := Stream α × Stream α × Stream (BitVec 1)) (x, y, c) fun ⟨x, y, c⟩ => Id.run <| do\n match x 0, y 0, c 0 with\n | none, _, some 1 => (none, (x.tail, y, c)) \n | some _, _, some 1 => (x 0, (x.tail, y, c.tail)) \n | _, none, some 0 => (none, (x, y.tail, c)) \n | _, some _, some 0 => (y 0, (x, y.tail, c.tail)) \n | _, _, none => (none, (x, y, c.tail)) "
},
{
"name": "not",
"content": "def not (x : Stream (BitVec 1)) : Stream (BitVec 1) :=\n Stream.corec (β := Stream (BitVec 1)) x fun x =>\n match x 0 with\n | some 1 => (some 0, (x.tail))\n | some 0 => (some 0, (x.tail))\n | none => (none, (x.tail))"
},
{
"name": "sink",
"content": "def sink (x : Stream α) : Stream (BitVec 1) :=\n Stream.corec (β := Stream α) (x) fun (x) => (none, x.tail)"
},
{
"name": "supp",
"content": "def supp (x : Stream α) (c : Stream (BitVec 1)) : Stream α := (branch x c).snd"
},
{
"name": "sync",
"content": "def sync (x y : Stream α) : Stream α × Stream α :=\n Stream.corec₂ (β := Stream α × Stream α) (x, y) fun ⟨x, y⟩ =>\n match x 0, y 0 with\n | some x', some y' => (some x', some y', (x.tail, y.tail))\n | some _, none => (none, none, (x, y.tail))\n | none, some _ => (none, none, (x.tail, y))\n | none, none => (none, none, (x.tail, y.tail))"
},
{
"name": "",
"content": "@[simp]\ninstance : TyDenote LLVMPlusRiscV.Ty where\n toType := fun\n | .llvm llvmTy => TyDenote.toType llvmTy\n | .riscv riscvTy => TyDenote.toType riscvTy"
},
{
"name": "Op",
"content": "inductive Op where\n | llvm : LLVM.Op -> Op\n | riscv : RISCV64.RV64.Op -> Op\n | castRiscv : Nat → Op\n | castLLVM : Nat → Op\n deriving DecidableEq, Repr, Lean.ToExpr"
},
{
"name": "ExTy",
"content": "inductive ExTy\n | nat\n deriving DecidableEq, Repr"
},
{
"name": "",
"content": "@[reducible]\ninstance : TyDenote ExTy where\n toType\n | .nat => Nat"
},
{
"name": "",
"content": "instance : TyDenote (Dialect.Ty VariadicDialect) where\n toType := fun | .int => BitVec 32"
},
{
"name": "def_denote for VariadicDialect where",
"content": "def_denote for VariadicDialect where\n | .const z => BitVec.ofInt _ z\n | .add _ => fun xs => xs.foldl (fun ⟨⟩ => (· + ·)) 0#32"
},
{
"name": "Op",
"content": "inductive Op : Type\n| add (n : Nat) : Op\n| const : (val : ℤ) → Op\nderiving DecidableEq, Repr"
},
{
"name": "VariadicDialect",
"content": "def VariadicDialect : Dialect where\n Op := Op\n Ty := Ty"
},
{
"name": "def_signature for VariadicDialect where",
"content": "def_signature for VariadicDialect where\n | .const _ => () -> .int\n | .add n => ${List.replicate n .int} → .int"
},
{
"name": "Ty",
"content": "inductive Ty\n| int\nderiving DecidableEq, Repr"
},
{
"name": "",
"content": "instance : TyDenote (Dialect.Ty Comb) where\n toType := fun\n | .bitvec w => BitVec w"
},
{
"name": "",
"content": "instance : TyDenote (Scf d).Ty := inferInstanceAs (TyDenote d.Ty)"
},
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "",
"content": "instance : TyDenote Ty where\n toType\n | .int => ℤ\n | .bool => Bool\n | .nat => Nat"
},
{
"name": "Ty",
"content": "inductive Ty\n| int\n| bool\n| nat\n deriving DecidableEq, Repr"
},
{
"name": "",
"content": "instance : TyDenote SLLVM.Ty where\n toType\n | .arith t => ⟦t⟧\n | .ptr => SLLVM.Ptr\n | .mem => MemorySSAState"
},
{
"name": "SLLVMOp",
"content": "inductive SLLVMOp where\n | arith (o : LLVM.Op)\n | ptradd\n | load (w : Nat)\n | store (w : Nat)\n | alloca (w : Nat)\n | loadPure (w : Nat)\n | storePure (w : Nat)\n deriving DecidableEq, Lean.ToExpr"
},
{
"name": "Ty.mem",
"content": "@[match_pattern] abbrev Ty.mem : SLLVM.Ty := .mem\n\n@[match_pattern] nonrec abbrev Op.arith : LLVM.Op → SLLVM.Op := .arith\n\n@[match_pattern] nonrec abbrev Op.neg (w : Nat) : SLLVM.Op := arith <| Op.neg w\n@[match_pattern] nonrec abbrev Op.not (w : Nat) : SLLVM.Op := arith <| Op.not w\n@[match_pattern] nonrec abbrev Op.copy (w : Nat) : SLLVM.Op := arith <| Op.copy w\n@[match_pattern] nonrec abbrev Op.freeze (w : Nat) : SLLVM.Op := arith <| Op.freeze w\n@[match_pattern] nonrec abbrev Op.sext (w w' : Nat) : SLLVM.Op := arith <| Op.sext w w'\n@[match_pattern] nonrec abbrev Op.zext (w w' : Nat) (flag : LLVM.NonNegFlag := { }) : SLLVM.Op := arith <| Op.zext w w' flag\n@[match_pattern] nonrec abbrev Op.trunc (w w' : Nat) (flags : LLVM.NoWrapFlags := { }) : SLLVM.Op := arith <| Op.trunc w w' flags\n\n@[match_pattern] nonrec abbrev Op.and (w : Nat) : SLLVM.Op := arith <| Op.and w\n@[match_pattern] nonrec abbrev Op.or (w : Nat) (flag : LLVM.DisjointFlag := { }) : SLLVM.Op := arith <| Op.or w flag\n@[match_pattern] nonrec abbrev Op.xor (w : Nat) : SLLVM.Op := arith <| Op.xor w\n@[match_pattern] nonrec abbrev Op.shl (w : Nat) (flags : LLVM.NoWrapFlags := { }) : SLLVM.Op := arith <| Op.shl w flags\n@[match_pattern] nonrec abbrev Op.lshr (w : Nat) (flag : LLVM.ExactFlag := { }) : SLLVM.Op := arith <| Op.lshr w flag\n@[match_pattern] nonrec abbrev Op.ashr (w : Nat) (flag : LLVM.ExactFlag := { }) : SLLVM.Op := arith <| Op.ashr w flag\n@[match_pattern] nonrec abbrev Op.add (w : Nat) (flags : LLVM.NoWrapFlags := { }) : SLLVM.Op := arith <| Op.add w flags\n@[match_pattern] nonrec abbrev Op.mul (w : Nat) (flags : LLVM.NoWrapFlags := { }) : SLLVM.Op := arith <| Op.mul w flags\n@[match_pattern] nonrec abbrev Op.sub (w : Nat) (flags : LLVM.NoWrapFlags := { }) : SLLVM.Op := arith <| Op.sub w flags\n\n@[match_pattern] nonrec abbrev Op.icmp (c : LLVM.IntPred) (w : Nat) : SLLVM.Op := arith <| Op.icmp c w\n@[match_pattern] nonrec abbrev Op.const (w : Nat) (val : Int) : SLLVM.Op := arith <| Op.const w val\n@[match_pattern] nonrec abbrev Op.select (w : Nat) : SLLVM.Op := arith <| Op.select w\n\n@[match_pattern] nonrec abbrev Op.udiv (w : Nat) (flag : LLVM.ExactFlag := { }) : SLLVM.Op := arith <| Op.udiv w flag\n@[match_pattern] nonrec abbrev Op.sdiv (w : Nat) (flag : LLVM.ExactFlag := { }) : SLLVM.Op := arith <| Op.sdiv w flag\n@[match_pattern] nonrec abbrev Op.urem : Nat → SLLVM.Op := arith ∘ Op.urem\n@[match_pattern] nonrec abbrev Op.srem : Nat → SLLVM.Op := arith ∘ Op.srem"
},
{
"name": "Ty.ptr",
"content": "@[match_pattern] abbrev Ty.ptr : SLLVM.Ty := .ptr"
},
{
"name": "MemorySSAState",
"content": "def MemorySSAState := PoisonOr MemoryState"
},
{
"name": "PoisonOr",
"content": "structure PoisonOr (α : Type) where\n ofOption :: toOption : Option α\n deriving DecidableEq"
},
{
"name": "MemoryState",
"content": "structure MemoryState where\n mem : Std.HashMap BlockId Block\n deriving Inhabited"
},
{
"name": "GlobalState",
"content": "structure GlobalState where\n alloc : AllocState\n mem : MemoryState"
},
{
"name": "BlockId",
"content": "structure BlockId where\n id : Nat\n deriving DecidableEq, Hashable, Inhabited"
},
{
"name": "Block",
"content": "inductive Block where\n \n | dead\n \n | live (b : LiveBlock)"
},
{
"name": "LiveBlock",
"content": "structure LiveBlock where\n (length : Nat)\n (bytes : BitVec (8 * length))"
},
{
"name": "Ptr",
"content": "def Ptr : Type := PoisonOr Pointer"
},
{
"name": "infixr:50 \"::ₕ\" => HVector.cons",
"content": "infixr:50 \"::ₕ\" => HVector.cons"
}
] | [
{
"name": "List.get_eq_getElem",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.length_cons",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "map_cons",
"content": "@[simp] theorem map_cons {A B : α → Type u} {as : List α} {f : (a : α) → A a → B a}\n {x : A a} {xs : HVector A as} :\n map f (cons x xs) = cons (f _ x) (map f xs)"
}
] | [
{
"name": "TyDenote",
"content": "class TyDenote (β : Type) : Type 1 where\n toType : β → Type"
},
{
"name": "Ctxt",
"content": "structure Ctxt (Ty : Type) : Type where\n ofList :: toList : List Ty\n \n deriving Repr, Lean.ToExpr, DecidableEq"
},
{
"name": "Ctxt.cons",
"content": "@[match_pattern]\ndef cons (hd : Ty) : Ctxt Ty → Ctxt Ty\n| ⟨tl⟩ => ⟨hd :: tl⟩"
},
{
"name": "Ctxt.Var",
"content": "def Var (Γ : Ctxt Ty) (t : Ty) : Type :=\n { i : Nat // Γ[i]? = some t }"
},
{
"name": "Ctxt.Valuation",
"content": "def Valuation (Γ : Ctxt Ty) : Type :=\n ⦃t : Ty⦄ → Γ.Var t → (toType t)"
},
{
"name": "Ctxt.Valuation.nil",
"content": "def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim"
},
{
"name": "Ctxt.Valuation",
"content": "@[simp]\ninstance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :\n HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where\n hAppend vals V :=\n (Valuation.ofHVector vals) ++ V"
},
{
"name": "Ctxt.Valuation.reassignVars",
"content": "def Valuation.reassignVars [DecidableEq Ty] {ts : List Ty} {Γ : Ctxt Ty}\n (V : Γ.Valuation) (var : HVector Γ.Var ts) (val : HVector toType ts) : Γ.Valuation :=\n fun _ vneedle =>\n match var.idxOf? vneedle with\n | none => V vneedle\n | some ⟨i, h⟩ => h ▸ val.get i"
}
] | [] | import Mathlib.Data.Fintype.Basic
import LeanMLIR.HVector
class TyDenote (β : Type) : Type 1 where
toType : β → Type
notation "⟦" x "⟧" => TyDenote.toType x
structure Ctxt (Ty : Type) : Type where
ofList :: toList : List Ty
deriving Repr, Lean.ToExpr, DecidableEq
variable {Ty : Type} {Γ Δ : Ctxt Ty}
namespace Ctxt
section Instances
open Lean in
end Instances
@[match_pattern]
def cons (hd : Ty) : Ctxt Ty → Ctxt Ty
| ⟨tl⟩ => ⟨hd :: tl⟩
section GetElemLemmas
end GetElemLemmas
section Lemmas
variable (Γ : Ctxt Ty) (ts us : List Ty)
variable {m} [Monad m] [LawfulMonad m] (t u : m _) in
section Lemmas
variable {Γ Δ : Ctxt Ty} {tys : List Ty}
end Lemmas
end Lemmas
section Rec
end Rec
def Var (Γ : Ctxt Ty) (t : Ty) : Type :=
{ i : Nat // Γ[i]? = some t }
namespace Var
section Lemmas
variable {Γ : Ctxt Ty} {t : Ty}
end Lemmas
section Lemmas
variable {t} (v : Var Γ t)
end Lemmas
section Lemmas
variable {t : Ty} {v : Γ.Var t}
end Lemmas
section Lemmas
end Lemmas
end Var
end Ctxt
open Ctxt
namespace HVector
variable {A : α → _} {as : List α} (xs : HVector A as) {Γ : Ctxt α}
end HVector
namespace Ctxt
section Comp
variable {Γ Δ Ξ : Ctxt Ty} (f : Hom Γ Δ) (g : Hom Δ Ξ)
end Comp
section Lemmas
end Lemmas
variable {Γ Δ Δ' : Ctxt Ty} in
section Valuation
variable [TyDenote Ty]
def Valuation (Γ : Ctxt Ty) : Type :=
⦃t : Ty⦄ → Γ.Var t → (toType t)
def Valuation.nil : Ctxt.Valuation (∅ : Ctxt Ty) := fun _ v => v.emptyElim
infixr:67 "::ᵥ" => Valuation.cons
variable {m} [Monad m] [LawfulMonad m] in
variable {V : Γ.Valuation} {W : Δ.Valuation}
@[simp]
instance Valuation.instAppendHVector (Γ : Ctxt Ty) (ts : List Ty) :
HAppend (HVector toType ts) (Valuation Γ) (Valuation <| ⟨ts⟩ ++ Γ) where
hAppend vals V :=
(Valuation.ofHVector vals) ++ V
section Lemmas
variable {ts : List Ty}
end Lemmas
def Valuation.reassignVars [DecidableEq Ty] {ts : List Ty} {Γ : Ctxt Ty}
(V : Γ.Valuation) (var : HVector Γ.Var ts) (val : HVector toType ts) : Γ.Valuation :=
fun _ vneedle =>
match var.idxOf? vneedle with
| none => V vneedle
| some ⟨i, h⟩ => h ▸ val.get i | @[simp] theorem Valuation.reassignVars_eq [DecidableEq Ty] (V : Γ.Valuation) :
V.reassignVars vs (vs.map V) = V := | := by
funext t w
unfold reassignVars
induction vs
case nil => rfl
case cons v vs ih =>
by_cases h_eq : w.eq v
· have := h_eq.ty_eq
subst this
have := h_eq.to_eq
subst this
simp
· unfold Var.eq at h_eq
simp only [HVector.idxOf?, h_eq, ↓reduceDIte, List.get_eq_getElem, List.length_cons,
HVector.map_cons]
split at ih <;> simp_all | 6 | 23 | false | Compiler |
353 | autOfTermBinop_bv_language | lemma autOfTermBinop_bv_language op {t₁ t₂ : Term} (m₁ : CNFA (t₁.arity + 1)) (m₂ : CNFA (t₂.arity + 1)) :
m₁.bv_recognizes t₁.language →
m₂.bv_recognizes t₂.language →
(autOfTermBinop op m₁ m₂ |>.bv_recognizes (op.subst_arity' ▸ (op.subst t₁ t₂).language)) | lean-mlir | Blase/Blase/AutoStructs/FormulaToAuto.lean | [
"import Blase.SingleWidth.Defs",
"import Blase.Blase.AutoStructs.Basic",
"import Blase.AutoStructs.Constructions",
"import Blase.Blase.Fast.BitStream",
"import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use",
"import Blase.Blase.AutoStructs.ForMathlib",
"import Blase.AutoStructs.Defs",
"import Mathlib.Tactic.FinCases",
"import Mathlib.Data.BitVec",
"import Mathlib.Tactic.Ring",
"import Blase.Blase.AutoStructs.Constructions",
"import Blase.AutoStructs.FiniteStateMachine",
"import Batteries.Data.Fin.Lemmas",
"import Batteries.Data.Fin.Basic"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BitVec.adcb",
"module": "Init.Data.BitVec.Bitblast"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "BitVec.iunfoldr",
"module": "Init.Data.BitVec.Folds"
},
{
"name": "FinEnum",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.card",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "Polynomial.X",
"module": "Mathlib.Algebra.Polynomial.Basic"
},
{
"name": "ZMod",
"module": "Mathlib.Data.ZMod.Defs"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "List.map",
"module": "Init.Prelude"
},
{
"name": "Array.foldl",
"module": "Init.Data.Array.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Array.size",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Field",
"module": "Mathlib.Algebra.Field.Defs"
},
{
"name": "Int.xor",
"module": "Mathlib.Data.Int.Bitwise"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Empty",
"module": "Init.Prelude"
},
{
"name": "Empty.elim",
"module": "Init.Core"
},
{
"name": "Sum.inr",
"module": "Init.Core"
},
{
"name": "Sum.inl",
"module": "Init.Core"
},
{
"name": "Sum",
"module": "Init.Core"
},
{
"name": "Sum.elim",
"module": "Init.Data.Sum.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Fin.castLE",
"module": "Init.Data.Fin.Basic"
},
{
"name": "cond",
"module": "Init.Prelude"
},
{
"name": "Nat.testBit",
"module": "Init.Data.Nat.Bitwise.Basic"
},
{
"name": "Fin.last",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Array.emptyWithCapacity",
"module": "Init.Prelude"
},
{
"name": "Prod.mk",
"module": "Init.Prelude"
},
{
"name": "Array.empty",
"module": "Init.Prelude"
},
{
"name": "FinEnum.toList",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "FinEnum.equiv",
"module": "Mathlib.Data.FinEnum"
},
{
"name": "NFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.accept",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.start",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.step",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.Vector",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "NFA.stepSet",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Subsingleton",
"module": "Init.Core"
},
{
"name": "reduceDIte",
"module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core"
},
{
"name": "BitVec.ofNat",
"module": "Init.Prelude"
},
{
"name": "BitVec.zero",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "Language",
"module": "Mathlib.Computability.Language"
},
{
"name": "BitVec.cons",
"module": "Init.Data.BitVec.Basic"
},
{
"name": "List.Vector.ofFn",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.replicate",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.finRange",
"module": "Init.Data.List.FinRange"
},
{
"name": "List.reverseRecOn",
"module": "Mathlib.Data.List.Induction"
},
{
"name": "SetRel",
"module": "Mathlib.Data.Rel"
},
{
"name": "Array.back?",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.isEmpty",
"module": "Init.Data.Array.Basic"
},
{
"name": "List.next",
"module": "Mathlib.Data.List.Cycle"
},
{
"name": "L",
"module": "Archive.Hairer"
},
{
"name": "Fin.mk",
"module": "Init.Prelude"
},
{
"name": "Fin.cast",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.castLT",
"module": "Init.Data.Fin.Basic"
},
{
"name": "Fin.subNat",
"module": "Init.Data.Fin.Basic"
},
{
"name": "List.Vector.get",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "List.Vector.nil",
"module": "Mathlib.Data.Vector.Defs"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "DFA",
"module": "Mathlib.Computability.DFA"
},
{
"name": "NFA.toDFA",
"module": "Mathlib.Computability.NFA"
},
{
"name": "List.range",
"module": "Init.Data.List.Basic"
},
{
"name": "Vector.ofFn",
"module": "Init.Data.Vector.Basic"
}
] | [
{
"name": "syntax \"max\" : MLIR.Pretty.uniform_op",
"content": "syntax \"max\" : MLIR.Pretty.uniform_op\n\nsyntax \"slt\" : MLIR.Pretty.uniform_op\n\nsyntax \"xor\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "carry",
"content": "def carry (initCarry : Bool) (x y : BitStream) : BitStream :=\n fun n => (addAux' initCarry x y n).2"
},
{
"name": "BitStream",
"content": "def BitStream : Type := Nat → Bool"
},
{
"name": "addAux'",
"content": "def addAux' (carryIn : Bool) (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => carryIn\n | i + 1 => (addAux' carryIn x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "BitVec.ofFn",
"content": "def BitVec.ofFn {w : Nat} (f : Fin w → Bool) : BitVec w :=\n BitVec.iunfoldr (fun i _ => ((), f i)) () |>.2"
},
{
"name": "f",
"content": "noncomputable def f : (ZMod q)[X] := X^(2^n) + 1"
},
{
"name": "worklistRun",
"content": "def worklistRun (final : S → Bool) (inits : Array S)\n (hinits : inits.toList.Nodup) (f : S → Array (BitVec n × S)) : CNFA n :=\n ⟨worklistRun' _ S final inits hinits f, worklistRun'_wf (BitVec n) S⟩"
},
{
"name": "worklistRun'",
"content": "def worklistRun' (final : S → Bool) (inits : Array S) (hinits : inits.toList.Nodup) (f : S → Array (A × S)) : RawCNFA A :=\n let st0 := worklist.initState _ _ inits hinits final\n go st0\nwhere go (st0 : worklist.St A S) : RawCNFA A :=\n if hemp : st0.worklist.isEmpty then st0.m else\n let sa? := st0.worklist.back?\n match heq : sa? with\n | some sa =>\n let wl := st0.worklist.pop\n let st1 := { st0 with worklist := wl,\n worklist_nodup := by admit /- proof elided -/"
},
{
"name": "worklist.St",
"content": "structure worklist.St where\n m : RawCNFA A\n map : Std.HashMap S State := ∅\n worklist : Array S := ∅\n worklist_nodup : worklist.toList.Nodup\n worklist_incl : ∀ sa ∈ worklist, sa ∈ map"
},
{
"name": "worklist.initState",
"content": "def worklist.initState (inits : Array S) (hinits : inits.toList.Nodup) (final? : S → Bool) : worklist.St A S :=\n let m := RawCNFA.empty (A := A)\n let mapm := inits.foldl (init := (Std.HashMap.emptyWithCapacity, m)) fun (map, m) sa =>\n let (s, m) := m.newState\n let m := m.addInitial s\n let m := if final? sa then m.addFinal s else m\n (map.insert sa s, m)\n let map := mapm.1\n let m := mapm.2\n let worklist_incl : ∀ sa ∈ inits, sa ∈ map :="
},
{
"name": "RawCNFA.statesFinset",
"content": "instance RawCNFA.statesFinset (m : RawCNFA A) : Fintype m.states := (Finset.range m.stateMax).fintypeCoeSort"
},
{
"name": "State",
"content": "abbrev State := Nat"
},
{
"name": "RawCNFA.empty",
"content": "def RawCNFA.empty : RawCNFA A := {\n stateMax := 0\n initials := ∅\n finals := ∅\n trans := ∅\n}"
},
{
"name": "processOneElem",
"content": "def processOneElem (final : S → Bool) (s : State) (st : worklist.St A S) : A × S → worklist.St A S :=\n fun (a', sa') =>\n let (s', st') := st.addOrCreateState _ _ (final sa') sa'\n let m := st'.m.addTrans a' s s'\n { st' with m }"
},
{
"name": "worklist.St.addOrCreateState",
"content": "def worklist.St.addOrCreateState (st : worklist.St A S) (final? : Bool) (sa : S) : State × worklist.St A S :=\n match heq : st.map[sa]? with\n | some s => (s, st)\n | none =>\n let (s, m) := st.m.newState\n let m := if final? then m.addFinal s else m\n let map := st.map.insert sa s\n let worklist := st.worklist.push sa\n have worklist_nodup : worklist.toList.Nodup := by admit /- proof elided -/"
},
{
"name": "CNFA",
"content": "structure CNFA (n : Nat) where\n m : RawCNFA (BitVec n)\n wf : m.WF"
},
{
"name": "FSM",
"content": "structure FSM (arity : Type) : Type 1 where\n \n ( α : Type )\n [ i : FinEnum α ]\n [ h : Hashable α ]\n [ dec_eq : DecidableEq α ]\n \n ( initCarry : α → Bool )\n \n outputCirc : Circuit (α ⊕ arity)\n nextStateCirc : α → Circuit (α ⊕ arity)"
},
{
"name": "Circuit",
"content": "inductive Circuit (α : Type u) : Type u\n | tru : Circuit α\n | fals : Circuit α\n \n | var : (positive: Bool) → α → Circuit α\n | and : Circuit α → Circuit α → Circuit α\n | or : Circuit α → Circuit α → Circuit α\n | xor : Circuit α → Circuit α → Circuit α\nderiving Repr, DecidableEq"
},
{
"name": "Var",
"content": "def Var (Γ : Context Ty) (ty : Ty) : Type := { v : VarName // Γ.hasType v ty }"
},
{
"name": "sub",
"content": "def sub (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).1"
},
{
"name": "subAux",
"content": "def subAux (x y : BitStream) : Nat → Bool × Bool\n | 0 => (xor (x 0) (y 0), !(x 0) && y 0)\n | n+1 =>\n let borrow := (subAux x y n).2\n let a := x (n + 1)\n let b := y (n + 1)\n (xor a (xor b borrow), !a && b || ((!(xor a b)) && borrow))"
},
{
"name": "ofTerm",
"content": "abbrev ofTerm (t : Term) : FSM (Fin t.arity) := termEvalEqFSM t |>.toFSM"
},
{
"name": "Term",
"content": "inductive Term : Type\n| var : Nat → Term\n \n| zero : Term\n \n| negOne : Term\n \n| one : Term\n \n| ofNat (n : Nat) : Term\n \n| and : Term → Term → Term\n \n| or : Term → Term → Term\n \n| xor : Term → Term → Term\n \n| not : Term → Term\n \n| add : Term → Term → Term\n \n| sub : Term → Term → Term\n \n| neg : Term → Term\n\n\n \n| shiftL : Term → Nat → Term\n\n\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "termEvalEqFSM",
"content": "def termEvalEqFSM : ∀ (t : Term), FSMTermSolution t\n | ofNat n =>\n { toFSM := FSM.ofNat n,\n good := by admit /- proof elided -/"
},
{
"name": "or",
"content": "def or : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ||| Circuit.var true (inr false),\n nextStateCirc := fun a => a.elim\n }"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (n : Nat) : FSM Unit :=\n match n with\n | 0 => FSM.id\n | n + 1 => composeUnaryAux (FSM.ls false) (shiftLeft n)"
},
{
"name": "id",
"content": "def id : FSM Unit := {\n α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr ()),\n nextStateCirc := Empty.elim\n}"
},
{
"name": "ls",
"content": "def ls (b : Bool) : FSM Unit :=\n { α := Unit,\n initCarry := fun _ => b,\n nextStateCirc := fun () => Circuit.var true (inr ()),\n outputCirc := Circuit.var true (inl ())\n }"
},
{
"name": "composeUnaryAux",
"content": "def composeUnaryAux\n (p : FSM Unit)\n (q : FSM arity) :\n FSM arity :=\n p.compose\n arity\n _\n (λ _ => id)\n (λ _ => q)"
},
{
"name": "compose",
"content": "def compose [FinEnum arity] [DecidableEq arity] [Hashable arity]\n (new_arity : Type) \n (q_arity : arity → Type) \n (vars : ∀ (a : arity), q_arity a → new_arity)\n \n \n (q : ∀ (a : arity), FSM (q_arity a)) : \n FSM new_arity :=\n { α := p.α ⊕ (Σ a, (q a).α),\n i := by admit /- proof elided -/"
},
{
"name": "and",
"content": "def and : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := fun a => a.elim,\n outputCirc := Circuit.var true (inr true) &&& Circuit.var true (inr false),\n }"
},
{
"name": "xor",
"content": "def xor : FSM Bool :=\n { α := Empty,\n initCarry := Empty.elim,\n outputCirc := Circuit.var true (inr true) ^^^ Circuit.var true (inr false),\n nextStateCirc := Empty.elim\n }"
},
{
"name": "neg",
"content": "def neg : FSM Unit :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "composeBinary",
"content": "def composeBinary\n (p : FSM Bool)\n {t₁ t₂ : Term}\n (q₁ : FSMTermSolution t₁)\n (q₂ : FSMTermSolution t₂) :\n FSM (Fin (max t₁.arity t₂.arity)) := composeBinaryAux p q₁.toFSM q₂.toFSM"
},
{
"name": "composeBinaryAux",
"content": "def composeBinaryAux\n (p : FSM Bool)\n (q₁ : FSM (Fin a₁))\n (q₂ : FSM (Fin a₂)) :\n FSM (Fin (max a₁ a₂)) :=\n p.compose (Fin (max a₁ a₂))\n (λ b => Fin (cond b a₁ a₂))\n (λ b i => Fin.castLE (by admit /- proof elided -/\n ) i)\n (λ b => match b with\n | true => q₁\n | false => q₂)"
},
{
"name": "FSMTermSolution",
"content": "structure FSMTermSolution (t : Term) extends FSM (Fin t.arity) where\n ( good : t.evalFin = toFSM.eval )"
},
{
"name": "Term.evalFin",
"content": "@[simp] def Term.evalFin (t : Term) (vars : Fin (arity t) → BitStream) : BitStream :=\n match t with\n | var n => vars (Fin.last n)\n | zero => BitStream.zero\n | one => BitStream.one\n | negOne => BitStream.negOne\n | ofNat n => BitStream.ofNat n\n | and t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | or t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | xor t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | not t => ~~~(t.evalFin vars)\n | add t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | sub t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | neg t => -(Term.evalFin t vars)\n \n \n | shiftL t n => BitStream.shiftLeft (Term.evalFin t vars) n"
},
{
"name": "Predicate.evalFin",
"content": "@[simp] def Predicate.evalFin (p : Predicate) (vars : Fin (arity p) → BitStream) : BitStream :=\nmatch p with\n| .width .eq n => BitStream.falseIffEq n\n| .width .neq n => BitStream.falseIffNeq n\n| .width .lt n => BitStream.falseIffLt n\n| .width .le n => BitStream.falseIffLe n\n| .width .gt n => BitStream.falseIffGt n\n| .width .ge n => BitStream.falseIffGe n\n| .binary .eq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalEq x₁ x₂\n| .binary .neq t₁ t₂ =>\n let x₁ := t₁.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalNeq x₁ x₂\n| .land p q =>\n \n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLand x₁ x₂\n| .lor p q =>\n \n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor x₁ x₂\n| .binary .slt p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalSlt x₁ x₂\n| .binary .sle p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalSlt x₁ x₂) (Predicate.evalEq x₁ x₂)\n| .binary .ult p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n (Predicate.evalUlt x₁ x₂)\n| .binary .ule p q =>\n let x₁ := p.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := q.evalFin (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n Predicate.evalLor (Predicate.evalUlt x₁ x₂) (Predicate.evalEq x₁ x₂)"
},
{
"name": "Predicate.evalUlt",
"content": "def Predicate.evalUlt (t₁ t₂ : BitStream) : BitStream := (~~~ (t₁.borrow t₂)).concat true"
},
{
"name": "borrow",
"content": "def borrow (x y : BitStream) : BitStream :=\n fun n => (subAux x y n).2"
},
{
"name": "Predicate.evalLor",
"content": "def Predicate.evalLor (t₁ t₂ : BitStream) : BitStream := (t₁ &&& t₂)"
},
{
"name": "Predicate.evalSlt",
"content": "def Predicate.evalSlt (t₁ t₂ : BitStream) : BitStream :=\n (((Predicate.evalUlt t₁ t₂)) ^^^ (Predicate.evalMsbEq t₁ t₂))"
},
{
"name": "Predicate.evalMsbEq",
"content": "def Predicate.evalMsbEq (t₁ t₂ : BitStream) : BitStream :=\n (t₁ ^^^ t₂).concat false"
},
{
"name": "Predicate.evalLand",
"content": "def Predicate.evalLand (t₁ t₂ : BitStream) : BitStream := (t₁ ||| t₂)"
},
{
"name": "Predicate.evalNeq",
"content": "def Predicate.evalNeq (t₁ t₂ : BitStream) : BitStream := (t₁.nxor t₂).concat true |>.scanAnd"
},
{
"name": "nxor",
"content": "def nxor (a b : BitStream) : BitStream := fun i => a i == b i"
},
{
"name": "scanAnd",
"content": "def scanAnd (s : BitStream) : BitStream := scanl true Bool.and s"
},
{
"name": "scanl",
"content": "abbrev scanl (init : Bool) (f : Bool → Bool → Bool) (s : BitStream) : BitStream :=\n fun n => match n with\n | 0 => f init (s 0)\n | n+1 => f (scanl init f s n) (s (n + 1))"
},
{
"name": "Predicate.evalEq",
"content": "def Predicate.evalEq (t₁ t₂ : BitStream) : BitStream := (t₁ ^^^ t₂).concat false |>.scanOr"
},
{
"name": "scanOr",
"content": "def scanOr (s : BitStream) : BitStream := scanl false Bool.or s"
},
{
"name": "Predicate",
"content": "inductive Predicate : Type where\n \n| width (wp : WidthPredicate) (n : Nat) : Predicate\n| binary (p : BinaryPredicate) (t₁ t₂ : Term)\n| land (p q : Predicate) : Predicate\n| lor (p q : Predicate) : Predicate\nderiving Repr, Inhabited, Lean.ToExpr"
},
{
"name": "falseIffNeq",
"content": "abbrev falseIffNeq (n : Nat) : BitStream := fun i => decide (i == n)"
},
{
"name": "falseIffLt",
"content": "abbrev falseIffLt (n : Nat) : BitStream := fun i => decide (i ≥ n)"
},
{
"name": "falseIffLe",
"content": "abbrev falseIffLe (n : Nat) : BitStream := fun i => decide (i > n)"
},
{
"name": "falseIffGe",
"content": "abbrev falseIffGe (n : Nat) : BitStream := fun i => decide (i < n)"
},
{
"name": "falseIffEq",
"content": "abbrev falseIffEq (n : Nat) : BitStream := fun i => decide (i != n)"
},
{
"name": "falseIffGt",
"content": "abbrev falseIffGt (n : Nat) : BitStream := fun i => decide (i ≤ n)"
},
{
"name": "Term.width",
"content": "def Term.width (t : Term) : WidthExpr :=\n match t with\n\n | .ofNat w _n => w\n | .var _v w => w\n | .add w _a _b => w\n | .zext _a wnew => wnew\n | .setWidth _a wnew => wnew\n | .sext _a wnew => wnew\n | .bor w _a _b => w\n | .band w _a _b => w\n | .bxor w _a _b => w\n | .bnot w _a => w\n | .boolVar _v => WidthExpr.const 1 \n | .boolConst _b => WidthExpr.const 1\n | .shiftl w _a _k => w\n | .bvOfBool _b => WidthExpr.const 1\n | binWidthRel _k wa wb => WidthExpr.const 0\n | binRel _k w _a _b => w\n | or _p1 _p2 => WidthExpr.const 0\n | and _p1 _p2 => WidthExpr.const 0\n | pvar _v => WidthExpr.const 0\n | boolBinRel _k _a _b => WidthExpr.const 0"
},
{
"name": "Term.arity",
"content": "@[simp] def Term.arity : Term → Nat\n| (var n) => n+1\n| zero => 0\n| one => 0\n| negOne => 0\n| ofNat _ => 0\n| Term.and t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.or t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.xor t₁ t₂ => max (arity t₁) (arity t₂)\n| Term.not t => arity t\n| add t₁ t₂ => max (arity t₁) (arity t₂)\n| sub t₁ t₂ => max (arity t₁) (arity t₂)\n| neg t => arity t\n\n\n| shiftL t .. => arity t"
},
{
"name": "negOne",
"content": "abbrev negOne : BitStream := fun _ => true"
},
{
"name": "shiftLeft",
"content": "def shiftLeft (x : BitStream) (k : Nat) : BitStream :=\n fun i => if i < k then false else x (i - k) "
},
{
"name": "ofNat",
"content": "def ofNat (x : Nat) : BitStream :=\n Nat.testBit x"
},
{
"name": "one",
"content": "abbrev one : BitStream := (· == 0)"
},
{
"name": "zero",
"content": "abbrev zero : BitStream := fun _ => false"
},
{
"name": "ofNat",
"content": "def ofNat (n : Nat) : FSM (Fin 0) :=\n match hn : n with\n | 0 => FSM.zero\n\n | n' + 1 =>\n let bit := n.testBit 0\n let m := n / 2\n have h : m < n := by admit /- proof elided -/"
},
{
"name": "zero",
"content": "def zero : FSM (Fin 0) :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.fals\n }"
},
{
"name": "composeUnary",
"content": "def composeUnary\n (p : FSM Unit)\n {t : Term}\n (q : FSMTermSolution t) :\n FSM (Fin t.arity) := composeUnaryAux p q.toFSM"
},
{
"name": "one",
"content": "def one : FSM (Fin 0) :=\n { α := Unit,\n i := by admit /- proof elided -/"
},
{
"name": "var",
"content": "def var (n : ℕ) : FSM (Fin (n+1)) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "add",
"content": "def add : FSM Bool :=\n { α := Unit,\n initCarry := λ _ => false,\n nextStateCirc := fun () =>\n Circuit.var true (inr true) &&& Circuit.var true (inr false) |||\n Circuit.var true (inr true) &&& Circuit.var true (inl ()) |||\n Circuit.var true (inr false) &&& Circuit.var true (inl ()),\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n }"
},
{
"name": "negOne",
"content": "def negOne : FSM (Fin 0) :=\n { α := Empty,\n i := by admit /- proof elided -/"
},
{
"name": "sub",
"content": "def sub : FSM Bool :=\n { α := Unit,\n initCarry := fun _ => false,\n outputCirc := Circuit.var true (inr true) ^^^\n Circuit.var true (inr false) ^^^\n Circuit.var true (inl ()),\n nextStateCirc := fun _ =>\n (Circuit.var false (inr true) &&& Circuit.var true (inr false)) |||\n (Circuit.var false (inr true) ^^^ Circuit.var true (inr false)) &&&\n (Circuit.var true (inl ()))\n }"
},
{
"name": "not",
"content": "def not : FSM Unit :=\n { α := Empty,\n initCarry := Empty.elim,\n nextStateCirc := Empty.elim,\n outputCirc := Circuit.var false (inr ())\n }"
},
{
"name": "add",
"content": "def add (x y : BitStream) : BitStream :=\n fun n => (addAux x y n).1"
},
{
"name": "addAux",
"content": "def addAux (x y : BitStream) (i : Nat) : Bool × Bool :=\n let carryIn : Bool := match i with\n | 0 => false\n | i + 1 => (addAux x y i).2\n Prod.swap (BitVec.adcb (x i) (y i) carryIn)"
},
{
"name": "neg",
"content": "def neg (x : BitStream) : BitStream :=\n fun n => (negAux x n).1"
},
{
"name": "negAux",
"content": "def negAux (x : BitStream) : Nat → Bool × Bool\n | 0 => (x 0, !(x 0))\n | n+1 =>\n let borrow := (negAux x n).2\n let a := x (n + 1)\n (xor (!a) borrow, !a && borrow)"
},
{
"name": "liftMaxSuccSucc2",
"content": "def liftMaxSuccSucc2 (n m : Nat) : Fin (m + 1) → Fin (max n m + 3) :=\n fun k => if _ : k = Fin.last m then max n m + 1 else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftMaxSuccSucc1",
"content": "def liftMaxSuccSucc1 (n m : Nat) : Fin (n + 1) → Fin (max n m + 3) :=\n fun k => if _ : k = Fin.last n then (max n m).cast else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftLast3",
"content": "def liftLast3 n : Fin 3 → Fin (n + 3)\n| 0 => n\n| 1 => n + 1\n| 2 => Fin.last (n + 2)"
},
{
"name": "CNFA.inter",
"content": "def CNFA.inter (m1 m2 : CNFA n) : CNFA n := product (fun b1 b2 => b1 && b2) m1 m2"
},
{
"name": "product",
"content": "def product (final? : Bool → Bool → Bool) (m₁ m₂ : CNFA n) : CNFA n :=\n worklistRun (m₁.m.states × m₂.m.states) final (product.inits m₁ m₂)\n (by admit /- proof elided -/\n ) f\nwhere final (ss : m₁.m.states × m₂.m.states) := final? (ss.1 ∈ m₁.m.finals) (ss.2 ∈ m₂.m.finals)\n f (ss : m₁.m.states × m₂.m.states) :=\n let (s1, s2) := ss\n (FinEnum.toList (α := BitVec n)).foldl (init := Array.empty) fun as a =>\n product.prodArray' (λ s₁ s₂ ↦ (a, (s₁, s₂)))\n (fun s' => m₁.wf.trans_tgt_lt (s := s1) (a := a)) (fun s' => m₂.wf.trans_tgt_lt (s := s2) (a := a)) as"
},
{
"name": "product.prodArray'",
"content": "@[inline]\ndef product.prodArray' (a : Array γ) :=\n m₁.attachWith _ hm₁ |>.fold (init := a) fun is s1 =>\n m₂.attachWith _ hm₂ |>.fold (init := is) fun is s2 =>\n is.push (f s1 s2)"
},
{
"name": "product.inits_nodup",
"content": "def product.inits_nodup : inits m₁ m₂ |>.toList.Nodup :="
},
{
"name": "product.inits",
"content": "def product.inits (m₁ m₂ : CNFA n) :=\n product.prodArray Prod.mk @m₁.wf.initials_lt @m₂.wf.initials_lt"
},
{
"name": "product.prodArray",
"content": "@[inline]\ndef product.prodArray := prodArray' f hm₁ hm₂ (Array.emptyWithCapacity <| m₁.size * m₂.size)"
},
{
"name": "CNFA.inter_bv_language",
"content": "def CNFA.inter_bv_language (m₁ m₂ : CNFA n) :\n m₁.bv_recognizes L₁ →\n m₂.bv_recognizes L₂ →\n (m₁.inter m₂).bv_recognizes (L₁ ∩ L₂) :="
},
{
"name": "HashSet.inter",
"content": "def HashSet.inter [BEq A] [Hashable A] (m1 m2 : Std.HashSet A) : Std.HashSet A :=\n m1.fold (init := ∅) fun mi x => if m2.contains x then mi.insert x else mi"
},
{
"name": "NFA'",
"content": "structure NFA' (n : Nat) where\n σ : Type\n M : NFA (BitVec n) σ"
},
{
"name": "BitVecs",
"content": "structure BitVecs (n : Nat) where\n w : Nat\n bvs : List.Vector (BitVec w) n"
},
{
"name": "eval",
"content": "def eval (x : arity → BitStream) : BitStream :=\n fun n => (p.nextBit (p.carry x n) (fun i => x i n)).2"
},
{
"name": "nextBit",
"content": "def nextBit : p.State → (arity → Bool) → p.State × Bool :=\n fun carry inputBits =>\n let input := Sum.elim carry inputBits\n let newState : p.State := fun (a : p.α) => (p.nextStateCirc a).eval input\n let outBit : Bool := (p.outputCirc).eval input\n (newState, outBit)"
},
{
"name": "State",
"content": "abbrev State : Type := p.α → Bool"
},
{
"name": "carry",
"content": "def carry (x : arity → BitStream) : ℕ → p.State\n | 0 => p.initCarry\n | n+1 => (p.nextBit (carry x n) (fun i => x i n)).1"
},
{
"name": "carryBV",
"content": "def carryBV (x : ar → BitVec w) : p.State :=\n p.carry (fun ar => .ofBitVecSext (x ar)) w"
},
{
"name": "evalBV",
"content": "def evalBV {w} (x : ar → BitVec w) : BitVec w :=\n BitVec.ofFn fun k => p.eval (fun ar => .ofBitVecSext (x ar)) k"
},
{
"name": "ofBitVecSext",
"content": "abbrev ofBitVecSext {w} (x : BitVec w) : BitStream :=\n fun i => if i < w then x.getLsbD i else x.msb"
},
{
"name": "Term.language",
"content": "def Term.language (t : Term) : Set (BitVecs (t.arity + 1)) :=\n { bvs : BitVecs (t.arity + 1) | t.evalFinBV (fun n => bvs.bvs.get n) = bvs.bvs.get t.arity }"
},
{
"name": "Formula.arity",
"content": "@[simp]\ndef Formula.arity : Formula → Nat\n| width _ _ => 0\n| atom _ t1 t2 => max t1.arity t2.arity\n| msbSet t => t.arity\n| unop _ φ => φ.arity\n| binop _ φ1 φ2 => max φ1.arity φ2.arity"
},
{
"name": "Term.evalFinBV",
"content": "@[simp] def Term.evalFinBV (t : Term) (vars : Fin (arity t) → BitVec w) : BitVec w :=\n match t with\n | .var n => vars (Fin.last n)\n | .zero => BitVec.zero w\n | .one => 1\n | .negOne => -1\n | .ofNat n => BitVec.ofNat _ n\n | .and t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ &&& x₂\n | .or t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ||| x₂\n | .xor t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ ^^^ x₂\n | .not t => ~~~(t.evalFinBV vars)\n \n | .add t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ + x₂\n | .sub t₁ t₂ =>\n let x₁ := t₁.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n let x₂ := t₂.evalFinBV (fun i => vars (Fin.castLE (by admit /- proof elided -/\n ) i))\n x₁ - x₂\n | .neg t => -(t.evalFinBV vars)\n | .shiftL a n => (a.evalFinBV vars) <<< n"
},
{
"name": "enc",
"content": "def enc (bvs : BitVecs n) : BitVecs' n :=\n (List.finRange bvs.w).map (fun i =>\n BitVec.ofFn (fun (k : Fin n) => (bvs.bvs.get k)[i]))"
},
{
"name": "BitVecs'",
"content": "abbrev BitVecs' (n : Nat) := List (BitVec n)"
},
{
"name": "dec",
"content": "@[simps]\ndef dec (bvs' : BitVecs' n) : BitVecs n where\n w := bvs'.length\n bvs := List.Vector.ofFn fun k => BitVec.ofFn fun i => bvs'[i].getLsbD k"
},
{
"name": "accepts",
"content": "def accepts (M : NFA' n) : Set (BitVecs n) := dec '' M.accepts'"
},
{
"name": "accepts'",
"content": "def accepts' (M : NFA' n) : Set (BitVecs' n) := M.M.accepts"
},
{
"name": "worklistRun_spec",
"content": "def worklistRun_spec : (worklistRun S final inits hinits f |>.Sim $ nfa' inits final f) :=\n worklistRun'_spec inits final f"
},
{
"name": "nfa'",
"content": "def nfa' : NFA' n :=\n { σ := _, M := nfa inits final f }"
},
{
"name": "nfa",
"content": "def nfa : NFA A S where\n start := { sa | sa ∈ inits }\n accept := { sa | final sa }\n step sa a := { sa' | (a, sa') ∈ f sa }"
},
{
"name": "worklistRun'_spec",
"content": "def worklistRun'_spec :\n (worklistRun' A S final inits hinits f |>.Sim $ nfa inits final f) :="
},
{
"name": "StInv",
"content": "structure StInv (m : RawCNFA A) (map : Std.HashMap S State) where\n wf : m.WF\n map_states : ∀ (sa : S) s, map[sa]? = some s → s ∈ m.states\n map_surj : ∀ s : m.states, ∃ (sa : S), map[sa]? = some s.val\n map_inj : ∀ {s} {sa sa' : S}, map[sa]? = some s → map[sa']? = some s → sa = sa'"
},
{
"name": "worklist.St.D",
"content": "def worklist.St.D (st : worklist.St A S) : Set S := st.visited"
},
{
"name": "worklist.St.visited",
"content": "def worklist.St.visited (st : worklist.St A S) : Set S := { s : S | s ∈ st.map ∧ s ∉ st.worklist }"
},
{
"name": "worklistGo_spec",
"content": "def worklistGo_spec {st : worklist.St A S} (inv : StInv A S st.m st.map) :\n st.sim inits final f ∅ →\n (worklistRun'.go A S final f st |>.Sim $ nfa inits final f) :="
},
{
"name": "worklist.St.rel",
"content": "def worklist.St.rel (st : worklist.St A S) : SetRel State S := {(s, sa) | st.map[sa]? = some s }"
},
{
"name": "processOneElem_mot",
"content": "def processOneElem_mot (s : State) (sa : S) (n : ℕ) (st : worklist.St A S) : Prop :=\n st.map[sa]? = some s ∧\n sa ∈ st.visited ∧\n StInv A S st.m st.map ∧\n st.sim inits final f {(sa1, a, sa') | sa1 = sa ∧ ∃ k ≥ n, (f sa)[k]? = some (a, sa') }"
},
{
"name": "worklist.St.sim",
"content": "abbrev worklist.St.sim {st : worklist.St A S} (T : Set (S × A × S)) :=\n st.m.Simul (nfa inits final f) st.rel st.D T"
},
{
"name": "RawCNFA.Sim",
"content": "def RawCNFA.Sim (m : RawCNFA A) (A : NFA A S) := ∃ R, RawCNFA.Simul m A R ⊤ ∅"
},
{
"name": "RawCNFA.Simul",
"content": "structure RawCNFA.Simul (m : RawCNFA A) (M : NFA A Q) (R : SetRel State Q) (D : Set Q) (T : Set (Q × A × Q)) where\n accept {s q} : s ~[R] q → (s ∈ m.finals ↔ q ∈ M.accept)\n initial₁ {s} : s ∈ m.initials → ∃ q ∈ M.start, s ~[R] q\n initial₂ {q} : q ∈ M.start → ∃ s ∈ m.initials, s ~[R] q\n trans_match₁ {s s' a q} : s ~[R] q → s' ∈ m.tr s a → ∃ q', q' ∈ M.step q a ∧ s' ~[R] q'\n trans_match₂ {s a q q'} : s ~[R] q → q' ∈ M.step q a → q ∈ D → (q, a, q') ∉ T → ∃ s', s' ∈ m.tr s a ∧ s' ~[R] q'"
},
{
"name": "RawCNFA.SimulFun",
"content": "structure RawCNFA.SimulFun (m : RawCNFA A) (M : NFA A Q) (f : m.states ≃ Q) where\n accept {q} : ((f.invFun q).val ∈ m.finals ↔ q ∈ M.accept)\n initial {q} : q ∈ M.start ↔ (f.invFun q).val ∈ m.initials\n trans_match {a q q'} : q' ∈ M.step q a ↔ (f.invFun q').val ∈ m.tr (f.invFun q) a"
},
{
"name": "RawCNFA.tr",
"content": "@[inline]\ndef RawCNFA.tr (m : RawCNFA A) s a := m.trans.getD (s, a) ∅"
},
{
"name": "R",
"content": "abbrev R := (ZMod q)[X] ⧸ (Ideal.span {f q n})"
},
{
"name": "CNFA.Sim",
"content": "def CNFA.Sim (m : CNFA n) (M : NFA' n) :=\n m.m.Sim M.M"
},
{
"name": "CNFA.bv_recognizes",
"content": "def CNFA.bv_recognizes (m : CNFA n) (L : Set (BitVecs n)) :=\n ∃ L', m.recognizes L' ∧ L = dec '' L'"
},
{
"name": "RawCNFA.recognizes",
"content": "def RawCNFA.recognizes (m : RawCNFA A) (L : Language A) :=\n ∃ (σ : Type) (M : NFA A σ), m.Sim M ∧ M.accepts = L"
},
{
"name": "CNFA.recognizes",
"content": "def CNFA.recognizes (m : CNFA n) (L : Language (BitVec n)) :=\n ∃ (M : NFA' n), m.Sim M ∧ M.M.accepts = L"
},
{
"name": "BitVecs.cast",
"content": "def BitVecs.cast (bvs : BitVecs n) (h : n = n') : BitVecs n' :=\n { w := bvs.w, bvs := h ▸ bvs.bvs }"
},
{
"name": "Valuation.cons",
"content": "def Valuation.cons {Γ : Ctxt Ty} {t : Ty} (x : toType t) (V : Γ.Valuation) :\n (Γ.cons t).Valuation :="
},
{
"name": "CNFA.minimize",
"content": "def CNFA.minimize (m : CNFA n) : CNFA n :=\n let mᵣ := m.reverse.determinize\n mᵣ.reverse.determinize"
},
{
"name": "CNFA.determinize",
"content": "def CNFA.determinize (m : CNFA n) : CNFA n :=\n worklistRun (BitVec m.m.stateMax)\n (fun ss => ss.any fun n b => b == true && n ∈ m.m.finals)\n (determinize.inits m)\n (by admit /- proof elided -/\n )\n f\nwhere\n f := fun (ss : BitVec m.m.stateMax) =>\n (FinEnum.toList (BitVec n)).foldl (init := Array.empty) fun ts a =>\n let ss' := m.m.transSetBV ss a\n ts.push (a, ss')"
},
{
"name": "CNFA.determinize.inits",
"content": "def CNFA.determinize.inits (m : CNFA n) : Array (BitVec m.m.stateMax) :=\n #[BitVec.ofFn (fun n => n ∈ m.m.initials)]"
},
{
"name": "CNFA.reverse",
"content": "def CNFA.reverse (m : CNFA n) : CNFA n :=\n ⟨m.m.reverse, RawCNFA.reverse_spec m.wf |>.1⟩"
},
{
"name": "RawCNFA.reverse",
"content": "def RawCNFA.reverse (m : RawCNFA A) : RawCNFA A :=\n let m' := { stateMax := m.stateMax, trans := Std.HashMap.emptyWithCapacity m.trans.size, initials := m.finals, finals := m.initials}\n m.trans.fold (init := m') processState\nwhere\n processState := fun m' (s, a) ss' =>\n ss'.fold (init := m') fun m' s' => m'.addTrans a s' s"
},
{
"name": "CNFA.toNFA'",
"content": "def CNFA.toNFA' (m : CNFA n) : NFA' n := ⟨_, m.toNFA⟩"
},
{
"name": "CNFA.toNFA",
"content": "def CNFA.toNFA (m : CNFA n) : NFA (BitVec n) m.m.states where\n start := { s | s.val ∈ m.m.initials }\n accept := { s | s.val ∈ m.m.finals }\n step s₁ a := { s₂ | s₂.val ∈ m.m.tr s₁.val a }"
},
{
"name": "RawCNFA.states",
"content": "def RawCNFA.states (m : RawCNFA A) : Finset State := Finset.range m.stateMax"
},
{
"name": "reverse",
"content": "def reverse (M : NFA' n) : NFA' n where\n σ := _\n M := M.M.reverse"
},
{
"name": "CNFA.determinize_spec",
"content": "def CNFA.determinize_spec (m : CNFA n)\n {M : NFA' n} (hsim : m.Sim M) :\n m.determinize.Sim M.determinize :="
},
{
"name": "bv_to_set",
"content": "private def bv_to_set (bv : BitVec w) : Set State :=\n { s | bv.getLsbD s }"
},
{
"name": "_root_.SetRel.set_eq",
"content": "structure _root_.SetRel.set_eq (R : SetRel α β) (A : Set α) (B : Set β) where\n fwd : a ∈ A → ∃ b ∈ B, a ~[R] b\n bwd : b ∈ B → ∃ a ∈ A, a ~[R] b"
},
{
"name": "RawCNFA.lift",
"content": "@[inline]\ndef RawCNFA.lift (m₁: RawCNFA (BitVec n1)) (f : Fin n1 → Fin n2) : RawCNFA (BitVec n2) :=\n let trans := (List.range m₁.stateMax).foldl (init := ∅) fun m2 s => processState m2 s\n { m₁ with trans }\nwhere"
},
{
"name": "CNFA.lift",
"content": "@[inline]\ndef CNFA.lift (m: CNFA n1) (f : Fin n1 → Fin n2) : CNFA n2 :=\n ⟨m.m.lift f, m.m.lift_wf m.wf⟩"
},
{
"name": "BitVecs.transport",
"content": "def BitVecs.transport (f : Fin n → Fin m) (bvs : BitVecs m) : BitVecs n :=\n { w := bvs.w, bvs := bvs.bvs.transport f }"
},
{
"name": "BitVec.transport",
"content": "def BitVec.transport (f : Fin n2 → Fin n1) (bv : BitVec n1) : BitVec n2 :=\n BitVec.ofFn fun i => bv.getLsbD (f i)"
},
{
"name": "List.Vector.transport",
"content": "def List.Vector.transport (v : Vector α m) (f : Fin n → Fin m) : Vector α n :=\n Vector.ofFn fun i => v.get (f i)"
},
{
"name": "BitVecs'.transport",
"content": "def BitVecs'.transport (f : Fin n → Fin m) (bvs' : BitVecs' m): BitVecs' n :=\n bvs'.map fun bv => bv.transport f"
},
{
"name": "RawCNFA.proj",
"content": "@[inline]\ndef RawCNFA.proj (m1: RawCNFA (BitVec n1)) (f : Fin n2 → Fin n1) : RawCNFA (BitVec n2) :=\n let trans := m1.trans.keysArray.foldl (init := Std.HashMap.emptyWithCapacity) process\n { m1 with trans }\nwhere"
},
{
"name": "CNFA.proj_spec",
"content": "def CNFA.proj_spec (m : CNFA n2) (f : Fin n1 → Fin n2) {M : NFA' n2} :\n m.Sim M → (m.proj f |>.Sim (M.proj f)) :="
},
{
"name": "CNFA.proj",
"content": "@[inline]\ndef CNFA.proj (m: CNFA n2) (f : Fin n1 → Fin n2) : CNFA n1 :=\n ⟨m.m.proj f, m.m.proj_wf m.wf⟩"
},
{
"name": "infixr:67 \"::ᵥ\" => Valuation.cons",
"content": "infixr:67 \"::ᵥ\" => Valuation.cons"
}
] | [
{
"name": "List.nodup_singleton",
"module": "Mathlib.Data.List.Nodup"
},
{
"name": "NFA.eval_append_singleton",
"module": "Mathlib.Computability.NFA"
},
{
"name": "NFA.eval_nil",
"module": "Mathlib.Computability.NFA"
},
{
"name": "Set.mem_setOf_eq",
"module": "Mathlib.Data.Set.Operations"
},
{
"name": "Nat.add_comm",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Fin.add_def",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Fin.castLE_castLE",
"module": "Init.Data.Fin.Lemmas"
},
{
"name": "Nat.le_of_eq",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.mod_eq_of_lt",
"module": "Init.Data.Nat.Div.Basic"
}
] | [
{
"name": "ext",
"content": "@[ext]\ntheorem ext {x y : BitStream} (h : ∀ i, x i = y i) : x = y"
},
{
"name": "bisim_comp",
"content": "lemma bisim_comp (m : RawCNFA A) :\n m.Sim M₁ → M₁.Bisim M₂ → m.Sim M₂"
},
{
"name": "bisimul_comp",
"content": "lemma bisimul_comp {m : RawCNFA A} :\n m.Simul M₁ R₁ ⊤ ∅ → M₁.Bisimul R₂ M₂ →\n m.Simul M₂ (R₁.comp R₂) ⊤ ∅"
},
{
"name": "CNFA.bv_recognizes_equiv",
"content": "lemma CNFA.bv_recognizes_equiv {m : CNFA n} :\n m.bv_recognizes L ↔ ∃ (M : NFA' n), m.Sim M ∧ M.accepts = L"
},
{
"name": "List.Vector.append_get_ge",
"content": "@[simp]\nlemma List.Vector.append_get_ge {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: n ≤ i) :\n (x ++ y).get i = y.get ((i.cast (Nat.add_comm n m) |>.subNat n hlt))"
},
{
"name": "List.Vector.append_get_lt",
"content": "@[simp]\nlemma List.Vector.append_get_lt {x : List.Vector α n} {y : List.Vector α m} {i : Fin (n+m)} (hlt: i < n) :\n (x ++ y).get i = x.get (i.castLT hlt)"
},
{
"name": "CNFA.minimize_bv_language",
"content": "lemma CNFA.minimize_bv_language {m : CNFA n} :\n m.bv_recognizes L → m.minimize.bv_recognizes L"
},
{
"name": "CNFA.minimize_language",
"content": "lemma CNFA.minimize_language {m : CNFA n} :\n m.recognizes L → m.minimize.recognizes L"
},
{
"name": "CNFA.reverse_language",
"content": "lemma CNFA.reverse_language {m : CNFA n} (hl : m.recognizes L) : m.reverse.recognizes L.reverse"
},
{
"name": "CNFA.reverse_spec",
"content": "lemma CNFA.reverse_spec {m : CNFA n} : m.reverse.Sim m.toNFA'.reverse"
},
{
"name": "RawCNFA.reverse_spec",
"content": "lemma RawCNFA.reverse_spec {m : RawCNFA A} (hwf : m.WF) :\n let m'"
},
{
"name": "RawCNFA.reverse_spec_procesState",
"content": "lemma RawCNFA.reverse_spec_procesState {m : RawCNFA A} (hwf : m.WF) s₀ a₀ ss' (hs₀ : s₀ ∈ m.states) :\n let motive m' ss'"
},
{
"name": "CNFA.determinize_language",
"content": "lemma CNFA.determinize_language {m : CNFA n} :\n m.recognizes L → m.determinize.recognizes L"
},
{
"name": "CNFA.lift_bv_language",
"content": "@[simp]\nlemma CNFA.lift_bv_language {m : CNFA n1} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.lift f |>.bv_recognizes (BitVecs.transport f ⁻¹' L))"
},
{
"name": "CNFA.lift_spec",
"content": "lemma CNFA.lift_spec (m : CNFA n1) (f : Fin n1 → Fin n2) {M : NFA' n1} :\n m.Sim M → (m.lift f |>.Sim (M.lift f))"
},
{
"name": "CNFA.proj_bv_language",
"content": "lemma CNFA.proj_bv_language {m : CNFA n2} {f : Fin n1 → Fin n2} :\n m.bv_recognizes L → (m.proj f |>.bv_recognizes (BitVecs.transport f '' L))"
}
] | [
{
"name": "NFA.sa",
"content": "def NFA.sa (_ : NFA α σ) := σ → Language α"
},
{
"name": "NFA.correct",
"content": "structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where\n cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)\n cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q"
},
{
"name": "BVNRel",
"content": "abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop"
},
{
"name": "NFA'.sa",
"content": "def NFA'.sa (M : NFA' n) := M.σ → BVNRel n"
},
{
"name": "langRel",
"content": "def langRel (R : BVNRel n) : Set (BitVecs n) :=\n { bvs | R bvs.bvs }"
},
{
"name": "NFA'.correct",
"content": "structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where\n cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)\n cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)\n cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔\n ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))"
},
{
"name": "NFA'.correct2",
"content": "structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where\n cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)\n cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil\n cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔\n ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)"
},
{
"name": "Alphabet",
"content": "abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)"
},
{
"name": "finFunToBitVec",
"content": "def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=\n BitVec.ofFn fun i => c (fe.equiv.invFun i)"
},
{
"name": "bitVecToFinFun",
"content": "def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=\n fun c => bv[FinEnum.equiv.toFun c]"
},
{
"name": "NFA.ofFSM",
"content": "def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where\n start := { q | q = p.initCarry }\n accept := ⊤\n step s a := {s' |\n let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))\n s' = s'' ∧ a.msb = b }"
},
{
"name": "inFSMRel",
"content": "@[simp]\nabbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=\n bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_sa",
"content": "def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>\n inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))"
},
{
"name": "NFA'.ofFSM_correct",
"content": "def NFA'.ofFSM_correct (p : FSM arity) :\n (NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :="
},
{
"name": "CNFA.ofFSM",
"content": "def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=\n worklistRun (BitVec (FinEnum.card p.α))\n (fun _ => true)\n #[finFunToBitVec p.initCarry]\n (by admit /- proof elided -/\n )\n f\n where"
},
{
"name": "NFA.msbState",
"content": "inductive NFA.msbState : Type where\n| i | f\nderiving DecidableEq, Fintype"
},
{
"name": "liftOp",
"content": "def liftOp n : Fin (n + 1) → Fin (n + 3) :=\n fun k =>\n if k = n then Fin.last (n+2) else k.castLE (by admit /- proof elided -/\n )"
},
{
"name": "liftOp_unchanged",
"content": "@[simp]\ndef liftOp_unchanged (k : Fin n) : liftOp n k.castSucc = k.castLE (by simp) :="
},
{
"name": "TermBinop",
"content": "inductive TermBinop where\n| and | or | xor | add | sub"
},
{
"name": "TermBinop.subst",
"content": "def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=\n match op with\n | .and => .and t₁ t₂\n | .or => .or t₁ t₂\n | .xor => .xor t₁ t₂\n | .add => .add t₁ t₂\n | .sub => .sub t₁ t₂"
},
{
"name": "TermBinop.openTerm",
"content": "def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)"
},
{
"name": "TermBinop.openTerm_arity",
"content": "@[simp]\ndef TermBinop.openTerm_arity (op : TermBinop) : op.openTerm.arity + 1 = 3 :="
},
{
"name": "TermBinop.termGadget",
"content": "def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=\n match t with\n | .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM\n | .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM\n | .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM\n | .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM\n | .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM"
},
{
"name": "autOfTermBinop",
"content": "def autOfTermBinop (op : TermBinop) (m₁ : CNFA (n + 1)) (m₂ : CNFA (m + 1)) : CNFA ((n ⊔ m) + 1 ) :=\n let mop : CNFA 3 := op.termGadget\n let f₁ := liftMaxSuccSucc1 n m\n let m1' := m₁.lift f₁\n let f₂ := liftMaxSuccSucc2 n m\n let m2' := m₂.lift f₂\n let mop := mop.lift $ liftLast3 (max (FinEnum.card (Fin n)) (FinEnum.card (Fin m)))\n let m := CNFA.inter m1' m2' |> CNFA.inter mop\n let mfinal := m.proj (liftOp _)\n mfinal.minimize"
},
{
"name": "swapLastTwoBlock",
"content": "def swapLastTwoBlock (x : Fin (n + 3)) : Fin (n + 3) :=\n if x = Fin.last (n+2) then n\n else if x = n+1 then Fin.last (n + 2)\n else if x = n then n + 1\n else x"
},
{
"name": "TermUnop",
"content": "inductive TermUnop where\n| neg | not | shiftL (k : Nat)"
},
{
"name": "TermUnop.openTerm",
"content": "def TermUnop.openTerm (op : TermUnop) : Term :=\n match op with\n | .neg => .neg (.var 0)\n | .not => .not (.var 0)\n | .shiftL k => .shiftL (.var 0) k"
},
{
"name": "TermUnop.openTerm_arity",
"content": "def TermUnop.openTerm_arity (op : TermUnop) : op.openTerm.arity = 1 :="
},
{
"name": "TermUnop.subst",
"content": "def TermUnop.subst (op : TermUnop) (t : Term) : Term :=\n match op with\n | .neg => .neg t\n | .not => .not t\n | .shiftL k => .shiftL t k"
}
] | [
{
"name": "NFA.correct_spec",
"content": "lemma NFA.correct_spec {M : NFA α σ} {ζ : M.sa} {L : Language α} :\n M.correct ζ L → M.accepts = L"
},
{
"name": "in_enc",
"content": "@[simp]\nlemma in_enc : x ∈ enc '' S ↔ dec x ∈ S"
},
{
"name": "dec_snoc_in_langRel",
"content": "@[simp]\nlemma dec_snoc_in_langRel {n} {R : BVNRel n} {w : BitVecs' n} {a : BitVec n} :\n dec (w ++ [a]) ∈ langRel R ↔\n R (List.Vector.ofFn fun k => .cons (a.getLsbD k) ((dec w).bvs.get k))"
},
{
"name": "NFA'.correct_spec",
"content": "lemma NFA'.correct_spec {M : NFA' n} {ζ : M.sa} {L : BVNRel n} :\n M.correct ζ L → M.accepts = langRel L"
},
{
"name": "NFA'.ofFSM_spec",
"content": "@[simp]\nlemma NFA'.ofFSM_spec (t : Term) :\n (ofFSM (FSM.ofTerm t)).accepts = t.language"
},
{
"name": "CNFA.ofFSM_spec",
"content": "lemma CNFA.ofFSM_spec (p : FSM arity) :\n (CNFA.ofFSM p).Sim (NFA'.ofFSM p)"
},
{
"name": "CNFA.ofFSM_bv_language",
"content": "lemma CNFA.ofFSM_bv_language :\n (CNFA.ofFSM (FSM.ofTerm t)).bv_recognizes t.language"
},
{
"name": "TermBinop.subst_arity'",
"content": "lemma TermBinop.subst_arity' {op : TermBinop} : (op.subst t₁ t₂).arity + 1= t₁.arity ⊔ t₂.arity + 1"
},
{
"name": "BitVecs.cast_eq",
"content": "@[simp]\nlemma BitVecs.cast_eq (x : BitVecs n) (h : n = n') : h ▸ x = x.cast h"
},
{
"name": "TermBinop.alt_lang",
"content": "lemma TermBinop.alt_lang {t₁ t₂ : Term} (op : TermBinop) :\n (op.subst_arity' ▸ (op.subst t₁ t₂).language) =\n let lop : Set (BitVecs 3) := op.openTerm_arity ▸ op.openTerm.language\n let lop' : Set (BitVecs ((t₁.arity ⊔ t₂.arity) + 3)) := lop.lift (liftLast3 (max t₁.arity t₂.arity))\n let l₁ := t₁.language.lift (liftMaxSuccSucc1 t₁.arity t₂.arity)\n let l₂ := t₂.language.lift (liftMaxSuccSucc2 t₁.arity t₂.arity)\n let l := l₁ ∩ l₂ ∩ lop'\n l.proj (liftOp _)"
},
{
"name": "TermUnop.subst_arity'",
"content": "@[simp]\nlemma TermUnop.subst_arity' {op : TermUnop} : (op.subst t).arity + 1 = t.arity + 1"
}
] | import Batteries.Data.Fin.Basic
import Batteries.Data.Fin.Lemmas
import Blase.SingleWidth.Defs
import Blase.AutoStructs.Constructions
import Blase.AutoStructs.Defs
import Blase.AutoStructs.FiniteStateMachine
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Size -- TODO: remove and get rid of shiftLeft_eq_mul_pow use
import Mathlib.Data.BitVec
import Mathlib.Tactic.FinCases
open Fin.NatCast
open Mathlib
def NFA.sa (_ : NFA α σ) := σ → Language α
structure NFA.correct (M : NFA α σ) (ζ : M.sa) (L : Language α) where
cond1 : ∀ w, (w ∈ L ↔ ∃ q ∈ M.accept, w ∈ ζ q)
cond2 : ∀ w q, q ∈ M.eval w ↔ w ∈ ζ q
abbrev BVNRel n := ∀ ⦃w⦄, List.Vector (BitVec w) n → Prop
def NFA'.sa (M : NFA' n) := M.σ → BVNRel n
def langRel (R : BVNRel n) : Set (BitVecs n) :=
{ bvs | R bvs.bvs }
structure NFA'.correct (M : NFA' n) (ζ : M.sa) (L : BVNRel n) where
cond1 : ∀ ⦃w⦄ (bvn : List.Vector (BitVec w) n), (L bvn ↔ ∃ q ∈ M.M.accept, ζ q bvn)
cond2 q : q ∈ M.M.start ↔ ζ q (List.Vector.replicate n .nil)
cond3 q a {w} (bvn : List.Vector (BitVec w) n) : q ∈ M.M.stepSet { q | ζ q bvn } a ↔
ζ q (List.Vector.ofFn fun k => BitVec.cons (a.getLsbD k) (bvn.get k))
structure NFA'.correct2 (M : NFA' 2) (ζ : M.sa2) (L : BVRel) where
cond1 : ∀ (bv1 bv2 : BitVec w), (L bv1 bv2 ↔ ∃ q ∈ M.M.accept, ζ q bv1 bv2)
cond2 q : q ∈ M.M.start ↔ ζ q .nil .nil
cond3 q a w (bv1 bv2 : BitVec w) : q ∈ M.M.stepSet { q | ζ q bv1 bv2 } a ↔
ζ q (BitVec.cons (a.getLsbD 0) bv1) (BitVec.cons (a.getLsbD 1) bv2)
section fsm
abbrev Alphabet (arity: Type) [FinEnum arity] := BitVec (FinEnum.card arity + 1)
variable {arity : Type} [FinEnum arity]
def finFunToBitVec [fe : FinEnum carry] (c : carry → Bool) : BitVec (FinEnum.card carry) :=
BitVec.ofFn fun i => c (fe.equiv.invFun i)
def bitVecToFinFun [FinEnum ar] (bv : BitVec $ FinEnum.card ar) : ar → Bool :=
fun c => bv[FinEnum.equiv.toFun c]
def NFA.ofFSM (p : FSM arity) : NFA (Alphabet arity) (p.α → Bool) where
start := { q | q = p.initCarry }
accept := ⊤
step s a := {s' |
let (s'', b) := p.nextBit s (bitVecToFinFun (a.truncate $ FinEnum.card arity))
s' = s'' ∧ a.msb = b }
@[simp]
abbrev inFSMRel (p : FSM arity) {w} (bvn : List.Vector (BitVec w) _) :=
bvn.get (Fin.last (FinEnum.card arity)) = p.evalBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_sa (p : FSM arity) : (NFA'.ofFSM' p).sa := fun q _ bvn =>
inFSMRel p bvn ∧ q = p.carryBV (fun ar => bvn.get (FinEnum.equiv.toFun ar))
def NFA'.ofFSM_correct (p : FSM arity) :
(NFA'.ofFSM' p).correct (ofFSM_sa p) (fun _ bvn => inFSMRel p bvn) :=
open BitStream in
def CNFA.ofFSM (p : FSM arity) : CNFA (FinEnum.card arity + 1) :=
worklistRun (BitVec (FinEnum.card p.α))
(fun _ => true)
#[finFunToBitVec p.initCarry]
(by admit /- proof elided -/
)
f
where
end fsm
section nfas_relations
inductive NFA.msbState : Type where
| i | f
deriving DecidableEq, Fintype
end nfas_relations
def liftOp n : Fin (n + 1) → Fin (n + 3) :=
fun k =>
if k = n then Fin.last (n+2) else k.castLE (by admit /- proof elided -/
)
@[simp]
def liftOp_unchanged (k : Fin n) : liftOp n k.castSucc = k.castLE (by simp) :=
inductive TermBinop where
| and | or | xor | add | sub
def TermBinop.subst (op : TermBinop) (t₁ t₂ : Term) : Term :=
match op with
| .and => .and t₁ t₂
| .or => .or t₁ t₂
| .xor => .xor t₁ t₂
| .add => .add t₁ t₂
| .sub => .sub t₁ t₂
def TermBinop.openTerm (op : TermBinop) : Term := op.subst (.var 0) (.var 1)
@[simp]
def TermBinop.openTerm_arity (op : TermBinop) : op.openTerm.arity + 1 = 3 :=
def TermBinop.termGadget (t : TermBinop) : CNFA 3 :=
match t with
| .and => FSM.ofTerm (.and (.var 0) (.var 1)) |> CNFA.ofFSM
| .or => FSM.ofTerm (.or (.var 0) (.var 1)) |> CNFA.ofFSM
| .xor => FSM.ofTerm (.xor (.var 0) (.var 1)) |> CNFA.ofFSM
| .add => FSM.ofTerm (.add (.var 0) (.var 1)) |> CNFA.ofFSM
| .sub => FSM.ofTerm (.sub (.var 0) (.var 1)) |> CNFA.ofFSM
def autOfTermBinop (op : TermBinop) (m₁ : CNFA (n + 1)) (m₂ : CNFA (m + 1)) : CNFA ((n ⊔ m) + 1 ) :=
let mop : CNFA 3 := op.termGadget
let f₁ := liftMaxSuccSucc1 n m
let m1' := m₁.lift f₁
let f₂ := liftMaxSuccSucc2 n m
let m2' := m₂.lift f₂
let mop := mop.lift $ liftLast3 (max (FinEnum.card (Fin n)) (FinEnum.card (Fin m)))
let m := CNFA.inter m1' m2' |> CNFA.inter mop
let mfinal := m.proj (liftOp _)
mfinal.minimize
def swapLastTwoBlock (x : Fin (n + 3)) : Fin (n + 3) :=
if x = Fin.last (n+2) then n
else if x = n+1 then Fin.last (n + 2)
else if x = n then n + 1
else x
inductive TermUnop where
| neg | not | shiftL (k : Nat)
def TermUnop.openTerm (op : TermUnop) : Term :=
match op with
| .neg => .neg (.var 0)
| .not => .not (.var 0)
| .shiftL k => .shiftL (.var 0) k
def TermUnop.openTerm_arity (op : TermUnop) : op.openTerm.arity = 1 :=
def TermUnop.subst (op : TermUnop) (t : Term) : Term :=
match op with
| .neg => .neg t
| .not => .not t
| .shiftL k => .shiftL t k | lemma autOfTermBinop_bv_language op {t₁ t₂ : Term} (m₁ : CNFA (t₁.arity + 1)) (m₂ : CNFA (t₂.arity + 1)) :
m₁.bv_recognizes t₁.language →
m₂.bv_recognizes t₂.language →
(autOfTermBinop op m₁ m₂ |>.bv_recognizes (op.subst_arity' ▸ (op.subst t₁ t₂).language)) := | := by
rintro hrec₁ hrec₂
simp [autOfTermBinop]
rw [TermBinop.alt_lang]
simp
apply CNFA.minimize_bv_language
apply CNFA.proj_bv_language
ac_nf
apply CNFA.inter_bv_language
· apply CNFA.lift_bv_language
rcases op <;> simp [TermBinop.termGadget, TermBinop.openTerm] <;> apply CNFA.ofFSM_bv_language
· apply CNFA.inter_bv_language
· apply CNFA.lift_bv_language; assumption
· apply CNFA.lift_bv_language; assumption | 10 | 292 | false | Compiler |
354 | Tensor1D.extractslice_insertslice | theorem extractslice_insertslice [Inhabited α]
(t: Tensor1d α)
(sliceix: Nat)
(slice: Tensor1d α)
(CORRECT: ((t.insertslice sliceix slice).extract sliceix slice.size).size ≠ 0)
: (t.insertslice sliceix slice).extract sliceix slice.size = slice | lean-mlir | SSA/Projects/Tensor1D/Tensor1D.lean | [
"import LeanMLIR.Util",
"import LeanMLIR.Framework",
"import Mathlib.Tactic.Linarith"
] | [
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
}
] | [
{
"name": "syntax \"neg\" : MLIR.Pretty.uniform_op",
"content": "syntax \"neg\" : MLIR.Pretty.uniform_op"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = const ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _)\n `(mlir_op| $res:mlir_op_operand = \"const\"()\n {val = $x:num : $outer_type} : ($outer_type) -> ($outer_type) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(mlir_op| $res:mlir_op_operand = li ($x)\n $[: $outer_type]? ) => do\n let outer_type ← outer_type.getDM `(mlir_type| _ )\n `(mlir_op| $res:mlir_op_operand = \"li\"()\n {imm = $x:num : $outer_type } : ($outer_type) -> ($outer_type))"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithImmediate $reg1 , $x : $t) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {imm = $x:num : $t} : ($t) -> ($t) )"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(mlir_op| $res:mlir_op_operand = $op1:MLIR.Pretty.RV.opWithShamt $reg1 , $x : $t ) => do\n let some opName := MLIR.EDSL.Pretty.extractOpName op1.raw\n | Macro.throwUnsupported\n `(mlir_op| $res:mlir_op_operand = $opName ($reg1) {shamt = $x:num : $t} : ($t) -> ($t) )"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Tensor1D.Index",
"content": "abbrev Index := ℕ"
},
{
"name": "Tensor1D.Tensor1d",
"content": "structure Tensor1d (α : Type) [Inhabited α] where\n size : Index\n val : Index → α\n spec : ∀ (ix: Index), ix >= size -> val ix = default"
},
{
"name": "Tensor1D.Tensor1d.extract",
"content": "def Tensor1d.extract [Inhabited α] (t: Tensor1d α)\n (left: Index) (len: Index) : Tensor1d α :=\n let right := if (left + len) < t.size then left + len else 0\n let size := right - left\n { size := size,\n val := fun ix =>\n if left + len < t.size\n then if (ix < len) then t.val (ix + left) else default\n else default,\n spec := by admit /- proof elided -/"
},
{
"name": "Tensor1D.Tensor1d.insertslice",
"content": "def Tensor1d.insertslice [Inhabited α] (t: Tensor1d α)\n (sliceix: Nat)\n (slice : Tensor1d α) : Tensor1d α where\n size := if sliceix > t.size then 0 else t.size + slice.size\n val := fun ix =>\n if sliceix > t.size then default \n else if ix >= t.size + slice.size then default \n else\n let go (ix: Nat) : α :=\n if ix < sliceix then t.val sliceix\n else if ix < sliceix + slice.size then slice.val (ix - sliceix)\n else t.val (ix - (sliceix + slice.size))\n go ix\n spec := by admit /- proof elided -/"
}
] | [
{
"name": "Tensor1D.not_lt_is_geq",
"content": "theorem not_lt_is_geq {a b: Nat} (NOT_LT: ¬ (a < b)): a >= b"
}
] | import LeanMLIR.Framework
import LeanMLIR.Util
import Mathlib.Tactic.Linarith
namespace Tensor1D
abbrev Index := ℕ
structure Tensor1d (α : Type) [Inhabited α] where
size : Index
val : Index → α
spec : ∀ (ix: Index), ix >= size -> val ix = default
def Tensor1d.extract [Inhabited α] (t: Tensor1d α)
(left: Index) (len: Index) : Tensor1d α :=
let right := if (left + len) < t.size then left + len else 0
let size := right - left
{ size := size,
val := fun ix =>
if left + len < t.size
then if (ix < len) then t.val (ix + left) else default
else default,
spec := by admit /- proof elided -/
def Tensor1d.insertslice [Inhabited α] (t: Tensor1d α)
(sliceix: Nat)
(slice : Tensor1d α) : Tensor1d α where
size := if sliceix > t.size then 0 else t.size + slice.size
val := fun ix =>
if sliceix > t.size then default
else if ix >= t.size + slice.size then default
else
let go (ix: Nat) : α :=
if ix < sliceix then t.val sliceix
else if ix < sliceix + slice.size then slice.val (ix - sliceix)
else t.val (ix - (sliceix + slice.size))
go ix
spec := by admit /- proof elided -/ | theorem extractslice_insertslice [Inhabited α]
(t: Tensor1d α)
(sliceix: Nat)
(slice: Tensor1d α)
(CORRECT: ((t.insertslice sliceix slice).extract sliceix slice.size).size ≠ 0)
: (t.insertslice sliceix slice).extract sliceix slice.size = slice := | := by {
simp[Tensor1d.insertslice, Tensor1d.extract]
cases slice
simp;
rename_i slicesize sliceval spec
by_cases A : (t.size < sliceix) <;> simp[A]
case pos => simp[Tensor1d.insertslice, Tensor1d.extract, A] at CORRECT ;
case neg =>
have B : t.size >= sliceix := not_lt_is_geq A
by_cases C:(sliceix < t.size) <;> simp[C]
case neg => simp [Tensor1d.insertslice, Tensor1d.extract, A, C] at CORRECT
case pos =>
funext ix
by_cases D: (ix < slicesize) <;> simp[D]
case neg =>
-- here we fail, because we do not know that 'slice' behaves like a
-- real tensor that returns 'default' outside of its range.
-- This is something we need to add into the spec of a Tensor.
have E : ix >= slicesize := by simp[Index] at *; linarith
simp[spec _ E]
case pos =>
try simp
by_cases E:(t.size + slicesize <= ix + sliceix) <;> simp[E]
case pos =>
have CONTRA : False := by simp[Index] at *; linarith;
simp at CONTRA;
case neg =>
intros K
have CONTRA : False := by simp[Index] at *; linarith
simp at CONTRA
} | 2 | 8 | false | Compiler |
355 | TLA.wf1 | @[tla_derive]
theorem wf1 (p q : pred σ) (next a : action σ) :
((p ∧ ⟨next⟩ ⇒ ◯ p ∨ ◯ q) ∧
(p ∧ ⟨next⟩ ∧ ⟨a⟩ ⇒ ◯ q) ∧
(p ⇒ Enabled a ∨ q) ∧
(□ ⟨next⟩ ∧ 𝒲ℱ a)) |-tla- (p ↝ q) | Lentil | Lentil/Rules/WF.lean | [
"import Lentil.Tactics.Structural",
"import Lentil.Gadgets.TheoremDeriving",
"import Lentil.Rules.Basic"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Std.Associative",
"module": "Init.Core"
},
{
"name": "Std.Commutative",
"module": "Init.Core"
}
] | [
{
"name": "syntax:15 tlafml:16 \" → \" tlafml:15 : tlafml",
"content": "syntax:15 tlafml:16 \" → \" tlafml:15 : tlafml\n\nsyntax:35 tlafml:36 \" ∧ \" tlafml:35 : tlafml\n\nsyntax:30 tlafml:31 \" ∨ \" tlafml:30 : tlafml\n\nsyntax:20 tlafml:21 \" ↝ \" tlafml:20 : tlafml\n\nsyntax:25 tlafml:26 \" 𝑈 \" tlafml:25 : tlafml\n\nsyntax:17 tlafml:18 \" ⇒ \" tlafml:17 : tlafml\n\nsyntax:max tlafml:max \" |-tla- \" tlafml:max : term\n\nsyntax:max tlafml:max \" =tla= \" tlafml:max : term\n\nsyntax \"∀ \" extBinder \", \" tlafml:51 : tlafml\n\nsyntax tlafml_heading_op := \"¬\" <|> \"□\" <|> \"◇\" <|> \"◯\"\n\nsyntax:max tlafml_heading_op tlafml:40 : tlafml\n\nsyntax \"[tlafml|\" tlafml \"]\" : term\n\nsyntax \"∃ \" extBinder \", \" tlafml:51 : tlafml\n\nsyntax:max \"Enabled\" term:40 : tlafml\n\nsyntax \"⟨ \" term \" ⟩\" : tlafml"
},
{
"name": "macro \"tla_unfold_simp\" : tactic => `(tactic| (simp [tlasimp",
"content": "macro \"tla_unfold_simp\" : tactic => `(tactic| (simp [tlasimp_def] at *))\n\nsyntax:max \"|-tla- \" tlafml:max : term\n\nsyntax:arg \"𝒲ℱ\" term:max : tlafml\n\nsyntax (name := tlaDerive) \"tla_derive\" : attr"
},
{
"name": "macro \"tla_unfold_simp'\" : tactic => `(tactic| (tla_unfold_s",
"content": "macro \"tla_unfold_simp'\" : tactic => `(tactic| (tla_unfold_simp ; (try simp only [execsimp] at *)))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `([tlafml| ( $f:tlafml ) ]) => `([tlafml| $f ])\n | `([tlafml| ⌜ $t:term ⌝ ]) => `(TLA.state_pred $t)\n | `([tlafml| ⌞ $t:term ⌟ ]) => `(TLA.pure_pred $t)\n | `([tlafml| ⟨ $t:term ⟩ ]) => `(TLA.action_pred $t)\n | `([tlafml| ⊤ ]) => `(TLA.tla_true)\n | `([tlafml| ⊥ ]) => `(TLA.tla_false)\n | `([tlafml| $op:tlafml_heading_op $f:tlafml ]) => do\n let opterm ← match op with\n | `(tlafml_heading_op|¬) => `(TLA.tla_not)\n | `(tlafml_heading_op|□) => `(TLA.always)\n | `(tlafml_heading_op|◇) => `(TLA.eventually)\n | `(tlafml_heading_op|◯) => `(TLA.later)\n | _ => Macro.throwUnsupported\n `($opterm [tlafml| $f ])\n | `([tlafml| Enabled $t:term ]) => `(TLA.tla_enabled $t)\n | `([tlafml| $f1:tlafml → $f2:tlafml ]) => `(TLA.tla_implies [tlafml| $f1 ] [tlafml| $f2 ])\n | `([tlafml| $f1:tlafml ∧ $f2:tlafml ]) => `(TLA.tla_and [tlafml| $f1 ] [tlafml| $f2 ])\n | `([tlafml| $f1:tlafml ∨ $f2:tlafml ]) => `(TLA.tla_or [tlafml| $f1 ] [tlafml| $f2 ])\n | `([tlafml| $f1:tlafml 𝑈 $f2:tlafml ]) => `(TLA.tla_until [tlafml| $f1 ] [tlafml| $f2 ])\n | `([tlafml| ∀ $x:ident, $f:tlafml]) => `(TLA.tla_forall fun $x:ident => [tlafml| $f ])\n | `([tlafml| ∀ $x:ident : $t, $f:tlafml]) => `(TLA.tla_forall fun $x:ident : $t => [tlafml| $f ])\n | `([tlafml| ∃ $x:ident, $f:tlafml]) => `(TLA.tla_exists fun $x:ident => [tlafml| $f ])\n | `([tlafml| ∃ $x:ident : $t, $f:tlafml]) => `(TLA.tla_exists fun $x:ident : $t => [tlafml| $f ])\n | `([tlafml| $op:tlafml_bigop $x:binderIdent ∈ $l:term, $f:tlafml]) =>\n \n match op with\n | `(tlafml_bigop|⋀ ) => do `(TLA.tla_bigwedge (fun $(← binderIdentToFunBinder x) => [tlafml| $f ]) $l)\n | `(tlafml_bigop|⋁ ) => do `(TLA.tla_bigvee (fun $(← binderIdentToFunBinder x) => [tlafml| $f ]) $l)\n | _ => Macro.throwUnsupported\n | `([tlafml| $t:term ]) => `($t)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `([tlafml| $f1:tlafml ↝ $f2:tlafml ]) => `(TLA.leads_to [tlafml| $f1 ] [tlafml| $f2 ])\n | `([tlafml| $f1:tlafml ⇒ $f2:tlafml ]) => `(TLA.always_implies [tlafml| $f1 ] [tlafml| $f2 ])\n | `([tlafml| 𝒲ℱ $t:term ]) => `(TLA.weak_fairness $t)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `($f1:tlafml |-tla- $f2:tlafml) => `(TLA.pred_implies [tlafml| $f1 ] [tlafml| $f2 ])\n | `(|-tla- $f1:tlafml) => `(TLA.valid [tlafml| $f1 ])\n | `($f1:tlafml =tla= $f2:tlafml) => `([tlafml| $f1 ] = [tlafml| $f2 ])\n | `($e:term |=tla= $f:tlafml) => `(TLA.exec.satisfies [tlafml| $f ] $e)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(tactic| try_unfold_at_all $idt:ident ) => `(tactic| (try unfold $idt at *) )\n | `(tactic| try_unfold_at_all $idt:ident $idts:ident* ) => `(tactic| (try unfold $idt at *) ; try_unfold_at_all $idts* )"
},
{
"name": "exec.drop",
"content": "def exec.drop {α : Type u} (k : Nat) (σ : exec α) : exec α := λ n => σ (n + k)"
},
{
"name": "tla_true",
"content": "def tla_true {α : Type u} : pred α := pure_pred True"
},
{
"name": "pred",
"content": "def pred (σ : Type u) := exec σ → Prop"
},
{
"name": "valid",
"content": "def valid {α : Type u} (p : pred α) : Prop := ∀ (σ : exec α), σ.satisfies p"
},
{
"name": "tla_until",
"content": "def tla_until {α : Type u} (p q : pred α) : pred α := λ σ => ∃ i, (q <| σ.drop i) ∧ ∀ j < i, (p <| σ.drop j)"
},
{
"name": "tla_false",
"content": "def tla_false {α : Type u} : pred α := pure_pred False"
},
{
"name": "pure_pred",
"content": "def pure_pred {α : Type u} (p : Prop) : pred α := state_pred (fun _ => p)"
},
{
"name": "state_pred",
"content": "def state_pred {σ : Type u} (f : σ → Prop) : pred σ :=\n fun e => f (e 0)"
},
{
"name": "tla_and",
"content": "def tla_and {α : Type u} (p q : pred α) : pred α := fun σ => p σ ∧ q σ"
},
{
"name": "tla_exists",
"content": "def tla_exists {α : Sort u} {β : Type v} (p : α → pred β) : pred β := fun σ => ∃ x, p x σ"
},
{
"name": "tla_forall",
"content": "def tla_forall {α : Sort u} {β : Type v} (p : α → pred β) : pred β := fun σ => ∀ x, p x σ"
},
{
"name": "TLA.always_implies",
"content": "def TLA.always_implies {α : Type u} (p q : TLA.pred α) : TLA.pred α := [tlafml| □ (p → q) ]"
},
{
"name": "tla_bigwedge",
"content": "def tla_bigwedge {α : Type u} {β : Type v} {c} [Foldable c] (f : β → pred α) (s : c β) : pred α :=\n Foldable.fold tla_and tla_true f s"
},
{
"name": "TLA.weak_fairness",
"content": "def TLA.weak_fairness {α : Type u} (a : action α) : pred α := [tlafml| □ ((□ (Enabled a)) → ◇ ⟨a⟩)]"
},
{
"name": "action",
"content": "def action (σ : Type u) := σ → σ → Prop"
},
{
"name": "eventually",
"content": "def eventually {α : Type u} (p : pred α) : pred α := λ σ => ∃ k, p <| σ.drop k"
},
{
"name": "tla_not",
"content": "def tla_not {α : Type u} (p : pred α) : pred α := fun σ => ¬ p σ"
},
{
"name": "tla_or",
"content": "def tla_or {α : Type u} (p q : pred α) : pred α := fun σ => p σ ∨ q σ"
},
{
"name": "pred_implies",
"content": "def pred_implies {α : Type u} (p q : pred α) : Prop := ∀ (σ : exec α), σ.satisfies p → σ.satisfies q"
},
{
"name": "exec",
"content": "def exec (σ : Type u) := Nat → σ"
},
{
"name": "exec.satisfies",
"content": "def exec.satisfies {α : Type u} (p : pred α) (σ : exec α) : Prop := p σ"
},
{
"name": "tla_enabled",
"content": "def tla_enabled {α : Type u} (a : action α) : pred α := state_pred (enabled a)"
},
{
"name": "enabled",
"content": "def enabled {α : Type u} (a : action α) (s : α) : Prop := ∃ s', a s s'"
},
{
"name": "TLA.leads_to",
"content": "def TLA.leads_to {α : Type u} (p q : TLA.pred α) : TLA.pred α := [tlafml| □ (p → ◇ q) ]"
},
{
"name": "action_pred",
"content": "def action_pred {σ : Type u} (a : action σ) : pred σ :=\n fun e => a (e 0) (e 1)"
},
{
"name": "tla_implies",
"content": "def tla_implies {α : Type u} (p q : pred α) : pred α := fun σ => p σ → q σ"
},
{
"name": "later",
"content": "def later {α : Type u} (p : pred α) : pred α := λ σ => p <| σ.drop 1"
},
{
"name": "always",
"content": "def always {α : Type u} (p : pred α) : pred α := λ σ => ∀ k, p <| σ.drop k"
},
{
"name": "tla_bigvee",
"content": "def tla_bigvee {α : Type u} {β : Type v} {c} [Foldable c] (f : β → pred α) (s : c β) : pred α :=\n Foldable.fold tla_or tla_false f s"
},
{
"name": "Foldable",
"content": "class Foldable (c : Type u → Type v) where\n fold {α : Type u} {β : Type w} (op : β → β → β) [Std.Commutative op] [Std.Associative op]\n (b : β) (f : α → β) (s : c α) : β"
}
] | [
{
"name": "Nat.add_assoc",
"module": "Init.Data.Nat.Basic"
}
] | [
{
"name": "always_eventually_or_distrib",
"content": "@[tladual]\ntheorem always_eventually_or_distrib : (□ ◇ (p ∨ q)) =tla= (□ ◇ p ∨ □ ◇ q)"
},
{
"name": "dual_lemma",
"content": "theorem dual_lemma (p q : pred σ) : ¬ p =tla= ¬ q → (p) =tla= (q)"
},
{
"name": "eventually_always_and_distrib",
"content": "theorem eventually_always_and_distrib : (◇ □ (p ∧ q)) =tla= (◇ □ p ∧ ◇ □ q)"
},
{
"name": "always_and",
"content": "theorem always_and : (□ (p ∧ q)) =tla= (□ p ∧ □ q)"
},
{
"name": "pred_eq_iff_iff",
"content": "theorem pred_eq_iff_iff (p q : pred σ) : (p) =tla= (q) ↔ (p) |-tla- (q) ∧ (q) |-tla- (p)"
},
{
"name": "eventually_and_split",
"content": "@[tladual]\ntheorem eventually_and_split : (◇ (p ∧ q)) |-tla- (◇ p ∧ ◇ q)"
},
{
"name": "eventually_or",
"content": "@[tladual]\ntheorem eventually_or : (◇ (p ∨ q)) =tla= (◇ p ∨ ◇ q)"
},
{
"name": "wf1'",
"content": "theorem wf1' (p q init inv : σ → Prop) (next a : action σ)\n (hpuntilq : ∀ s s', p s → next s s' → p s' ∨ q s')\n (haq : ∀ s s', p s → next s s' → a s s' → q s')\n (henable : ∀ s, inv s → p s → enabled a s ∨ q s)\n (hinit_inv : ∀ s, init s → inv s)\n (hnext_inv : ∀ s s', next s s' → inv s → inv s') :\n (⌜ init ⌝ ∧ □ ⟨next⟩ ∧ 𝒲ℱ a) |-tla- (⌜ p ⌝ ↝ ⌜ q ⌝)"
}
] | [] | [
{
"name": "TLA.wf_alt1",
"content": "theorem wf_alt1 : (𝒲ℱ a) =tla= □ ◇ ((¬ Enabled a) ∨ □ ◇ ⟨a⟩)"
},
{
"name": "TLA.wf_alt1'",
"content": "theorem wf_alt1' : (𝒲ℱ a) =tla= □ ◇ ((¬ Enabled a) ∨ ⟨a⟩)"
}
] | import Lentil.Rules.Basic
import Lentil.Tactics.Structural
import Lentil.Gadgets.TheoremDeriving
open Classical
namespace TLA
section wf
variable {σ : Type u}
section wf_def
variable {a : action σ}
end wf_def | @[tla_derive]
theorem wf1 (p q : pred σ) (next a : action σ) :
((p ∧ ⟨next⟩ ⇒ ◯ p ∨ ◯ q) ∧
(p ∧ ⟨next⟩ ∧ ⟨a⟩ ⇒ ◯ q) ∧
(p ⇒ Enabled a ∨ q) ∧
(□ ⟨next⟩ ∧ 𝒲ℱ a)) |-tla- (p ↝ q) := | := by
rw [wf_alt1']
intro e ⟨hpuntilq, haq, henable, hnext, hwf_alt⟩ k hp
specialize hwf_alt k ; rcases hwf_alt with ⟨k1, hwf_alt⟩
-- know that: either `q` holds between `k` and `k + k1`, or `p` holds at `k1`
-- use `henable` to know that if it is the latter case, then `q` must hold in the next step
have htmp : (∃ k' ≤ k1, q <| e.drop (k + k')) ∨ (p <| e.drop (k + k1)) := by
clear hwf_alt
induction k1 with
| zero => right ; assumption
| succ n ih => {
rw [← Nat.add_assoc]
rcases ih with ⟨k', hle, ih⟩ | ih
· left ; exists k' ; constructor ; omega ; apply ih
· specialize hpuntilq _ ⟨ih, (hnext _)⟩
rcases hpuntilq with hq | hq <;> tla_unfold_simp'
· right ; apply hq
· left ; exists (n + 1) ; aesop
}
rcases htmp with ⟨k', _, hq⟩ | hq <;> tla_unfold_simp'
· aesop
· rcases hwf_alt with hq2 | hq2
· specialize henable _ hq ; aesop
· exists (k1 + 1)
specialize haq (k + k1) hq ; rw [← Nat.add_assoc] ; apply haq <;> aesop | 27 | 17 | false | Framework |
356 | simulation_step | theorem simulation_step :
∀ C impconf1 impconf2 machconf1,
step impconf1 impconf2 ->
match_config C impconf1 machconf1 ->
∃ machconf2,
(plus (transition C) machconf1 machconf2
\/ (star (transition C) machconf1 machconf2
/\ (measure' impconf2 < measure' impconf1)))
/\ match_config C impconf2 machconf2 | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Exists",
"module": "Init.Core"
},
{
"name": "Or",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "cont",
"content": "@[grind] inductive cont where\n| Kstop\n| Kseq (c : com) (k : cont)\n| Kwhile (b : bexp) (c : com) (k : cont)"
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "plus",
"content": "@[grind cases]\ninductive plus (R : α → α → Prop) : α → α → Prop where\n| plus_left : ∀ {a b c}, R a b → star R b c → plus R a c\n\n\ngrind_pattern plus.plus_left => star R b c, plus R a c"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "step",
"content": "inductive step : com × cont × store -> com × cont × store -> Prop where\n | step_assign : ∀ x a k s,\n step (.ASSIGN x a, k, s) (.SKIP, k, update x (aeval s a) s)\n \n | step_seq : ∀ c1 c2 s k,\n step (.SEQ c1 c2, k, s) (c1, .Kseq c2 k, s)\n \n | step_ifthenelse : ∀ b c1 c2 k s,\n step (.IFTHENELSE b c1 c2, k, s) ((if beval s b then c1 else c2), k, s)\n \n | step_while_done : ∀ b c k s,\n beval s b = false ->\n step (.WHILE b c, k, s) (.SKIP, k, s)\n \n | step_while_true : ∀ b c k s,\n beval s b = true ->\n step (.WHILE b c, k, s) (c, .Kwhile b c k, s)\n \n | step_skip_seq : ∀ c k s,\n step (.SKIP, .Kseq c k, s) (c, k, s)\n \n | step_skip_while : ∀ b c k s,\n step (.SKIP, .Kwhile b c k, s) (.WHILE b c, k, s)"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Exists.elim",
"module": "Init.Core"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "Or.intro_left",
"module": "Init.Prelude"
},
{
"name": "Or.intro_right",
"module": "Init.Prelude"
}
] | [
{
"name": "star_one",
"content": "@[grind] theorem star_one (R : α → α → Prop) {a b : α} (h : R a b) : star R a b"
},
{
"name": "plus_star",
"content": "@[grind] theorem plus_star {a b} (h : plus R a b) : star R a b"
},
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
},
{
"name": "plus_right",
"content": "theorem plus_right : star R a b -> R b c -> plus R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "compile_com",
"content": "@[grind] def compile_com (c : com) : List instr :=\n match c with\n | .SKIP =>\n []\n | .ASSIGN x a =>\n compile_aexp a ++ .Isetvar x :: []\n | .SEQ c1 c2 =>\n compile_com c1 ++ compile_com c2\n | .IFTHENELSE b ifso ifnot =>\n let code_ifso := compile_com ifso\n let code_ifnot := compile_com ifnot\n compile_bexp b 0 (codelen code_ifso + 1)\n ++ code_ifso\n ++ .Ibranch (codelen code_ifnot)\n :: code_ifnot\n | .WHILE b body =>\n let code_body := compile_com body\n let code_test := compile_bexp b 0 (codelen code_body + 1)\n code_test\n ++ code_body\n ++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
},
{
"name": "compile_cont",
"content": "inductive compile_cont (C : List instr) : cont -> Int -> Prop where\n | ccont_stop : ∀ pc,\n instr_at C pc = .some .Ihalt ->\n compile_cont C .Kstop pc\n | ccont_seq : ∀ c k pc pc',\n code_at C pc (compile_com c) ->\n pc' = pc + codelen (compile_com c) ->\n compile_cont C k pc' ->\n compile_cont C (.Kseq c k) pc\n | ccont_while : ∀ b c k pc d pc' pc'',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n code_at C pc' (compile_com (.WHILE b c)) ->\n pc'' = pc' + codelen (compile_com (.WHILE b c)) ->\n compile_cont C k pc'' ->\n compile_cont C (.Kwhile b c k) pc\n | ccont_branch : ∀ d k pc pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n compile_cont C k pc' ->\n compile_cont C k pc"
},
{
"name": "match_config",
"content": "inductive match_config (C : List instr) : com × cont × store -> config -> Prop where\n | match_config_intro : ∀ c k st pc,\n code_at C pc (compile_com c) ->\n compile_cont C k (pc + codelen (compile_com c)) ->\n match_config C (c, k, st) (pc, [], st)"
},
{
"name": "com_size",
"content": "def com_size (c : com) : Nat :=\n match c with\n | .SKIP => 1\n | .ASSIGN _ _ => 1\n | (c1 ;; c2) => (com_size c1 + com_size c2 + 1)\n | .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)\n | .WHILE _ c1 => (com_size c1 + 1)"
},
{
"name": "cont_size",
"content": "def cont_size (k : cont) : Nat :=\n match k with\n | .Kstop => 0\n | .Kseq c k' => (com_size c + cont_size k')\n | .Kwhile _ _ k' => cont_size k'"
},
{
"name": "measure'",
"content": "def measure' (impconf : com × cont × store) : Nat :=\n match impconf with\n | (c, k, _) => (com_size c + cont_size k)"
}
] | [
{
"name": "codelen_cons",
"content": "@[grind =] theorem codelen_cons :\n ∀ i c, codelen (i :: c) = codelen c + 1"
},
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_app_right",
"content": "@[grind] theorem code_at_app_right :\n ∀ C pc C1 C2,\n code_at C pc (C1 ++ C2) ->\n code_at C (pc + codelen C1) C2"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
},
{
"name": "compile_bexp_correct",
"content": "theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :\n transitions C\n (pc, stk, s)\n (pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s)"
},
{
"name": "compile_cont_Kseq_inv",
"content": "theorem compile_cont_Kseq_inv (C : List instr) (c : com) (k :cont) (pc : Int) (s : store) (H : compile_cont C (.Kseq c k) pc) :\n ∃ pc',\n star (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com c)\n ∧ compile_cont C k (pc' + codelen (compile_com c))"
},
{
"name": "compile_cont_Kwhile_inv",
"content": "theorem compile_cont_Kwhile_inv (C : List instr) (b : bexp) (c : com) (k : cont) (pc : Int) (s : store) (H : compile_cont C (.Kwhile b c k) pc) :\n ∃ pc',\n plus (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com (.WHILE b c))\n ∧ compile_cont C k (pc' + codelen (compile_com (.WHILE b c)))"
},
{
"name": "match_config_skip",
"content": "theorem match_config_skip (C : List instr) (k : cont) (s : store) (pc : Int) (H : compile_cont C k pc) :\n match_config C (.SKIP, k, s) (pc, [], s)"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] def compile_com (c : com) : List instr :=
match c with
| .SKIP =>
[]
| .ASSIGN x a =>
compile_aexp a ++ .Isetvar x :: []
| .SEQ c1 c2 =>
compile_com c1 ++ compile_com c2
| .IFTHENELSE b ifso ifnot =>
let code_ifso := compile_com ifso
let code_ifnot := compile_com ifnot
compile_bexp b 0 (codelen code_ifso + 1)
++ code_ifso
++ .Ibranch (codelen code_ifnot)
:: code_ifnot
| .WHILE b body =>
let code_body := compile_com body
let code_test := compile_bexp b 0 (codelen code_body + 1)
code_test
++ code_body
++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2
inductive compile_cont (C : List instr) : cont -> Int -> Prop where
| ccont_stop : ∀ pc,
instr_at C pc = .some .Ihalt ->
compile_cont C .Kstop pc
| ccont_seq : ∀ c k pc pc',
code_at C pc (compile_com c) ->
pc' = pc + codelen (compile_com c) ->
compile_cont C k pc' ->
compile_cont C (.Kseq c k) pc
| ccont_while : ∀ b c k pc d pc' pc'',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
code_at C pc' (compile_com (.WHILE b c)) ->
pc'' = pc' + codelen (compile_com (.WHILE b c)) ->
compile_cont C k pc'' ->
compile_cont C (.Kwhile b c k) pc
| ccont_branch : ∀ d k pc pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
compile_cont C k pc' ->
compile_cont C k pc
inductive match_config (C : List instr) : com × cont × store -> config -> Prop where
| match_config_intro : ∀ c k st pc,
code_at C pc (compile_com c) ->
compile_cont C k (pc + codelen (compile_com c)) ->
match_config C (c, k, st) (pc, [], st)
def com_size (c : com) : Nat :=
match c with
| .SKIP => 1
| .ASSIGN _ _ => 1
| (c1 ;; c2) => (com_size c1 + com_size c2 + 1)
| .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)
| .WHILE _ c1 => (com_size c1 + 1)
def cont_size (k : cont) : Nat :=
match k with
| .Kstop => 0
| .Kseq c k' => (com_size c + cont_size k')
| .Kwhile _ _ k' => cont_size k'
def measure' (impconf : com × cont × store) : Nat :=
match impconf with
| (c, k, _) => (com_size c + cont_size k) | theorem simulation_step :
∀ C impconf1 impconf2 machconf1,
step impconf1 impconf2 ->
match_config C impconf1 machconf1 ->
∃ machconf2,
(plus (transition C) machconf1 machconf2
\/ (star (transition C) machconf1 machconf2
/\ (measure' impconf2 < measure' impconf1)))
/\ match_config C impconf2 machconf2 := | := by
intro C impconf1 impconf2 matchconf1 STEP MATCH
cases MATCH
case match_config_intro c k st pc h₁ h₂ =>
rcases impconf2 with ⟨c' , k', s'⟩
cases STEP
next x a =>
constructor
constructor
case h.left =>
apply Or.intro_left
apply plus_right
apply compile_aexp_correct
rotate_left
exact a
rotate_left
· grind
· apply transition.trans_setvar
rotate_left
exact x
grind
apply match_config_skip
grind
next c2 =>
constructor
constructor
apply Or.intro_right
constructor
apply star.star_refl
simp [measure', com_size, cont_size]
grind
constructor
simp [compile_com] at h₁
grind
apply compile_cont.ccont_seq
· grind
rotate_right
· exact pc + codelen (compile_com c') + codelen (compile_com c2)
· rfl
· grind
next b c1 c2 =>
generalize h₃ : compile_com c1 = code1
generalize h₄ : compile_bexp b 0 (codelen code1 + 1) = codeb
generalize h₅ : compile_com c2 = code2
simp [compile_com, h₃, h₄, h₅] at h₁ h₂
constructor
constructor
apply Or.intro_right
constructor
· apply compile_bexp_correct
rotate_left
· exact b
· exact 0
· exact (codelen code1 + 1)
· grind
· simp [measure', com_size]
grind
· rw [h₄]
constructor
· by_cases beval st b = true
case pos isTrue =>
simp [isTrue] at *
grind
case neg isFalse =>
simp [isFalse] at *
rw [h₅]
have := @code_at_app_right C pc (codeb ++ code1 ++ [instr.Ibranch (codelen code2)]) code2 (by grind)
simp [codelen_cons, codelen_app] at this
simp [codelen] at *
grind
· by_cases beval st b = true
case pos isTrue =>
simp [isTrue] at *
apply compile_cont.ccont_branch
rotate_right
· exact (pc + codelen (codeb ++ (code1 ++ instr.Ibranch (codelen code2) :: code2)))
rotate_right
· exact codelen code2
any_goals grind
case neg isFalse =>
simp [isFalse] at *
grind
next b c isFalse =>
generalize h₃ : compile_com c = codec
generalize h₄ : (compile_bexp b 0 (codelen codec + 1)) = codeb
constructor
constructor
apply Or.intro_right
constructor
· apply compile_bexp_correct
rotate_left
· exact b
· exact 0
· exact (codelen codec + 1)
· grind
· simp [measure', com_size]
fun_induction com_size with grind
· simp [isFalse]
rw [h₄]
simp [compile_com] at h₂ h₁
rw [h₃, h₄] at h₂ h₁
constructor
· grind
· grind
next b isTrue =>
generalize h₃ : compile_com c' = codec
generalize h₄ : compile_bexp b 0 (codelen codec + 1) = codeb
constructor
constructor
· apply Or.intro_right
constructor
· apply compile_bexp_correct
rotate_left
· exact b
· exact 0
· exact (codelen codec + 1)
· grind
· simp [measure', cont_size, com_size]
· simp [isTrue]
rw [h₄]
constructor
· simp [compile_com] at h₁
rw [h₃, h₄] at h₁
grind
· simp [compile_com, h₃, h₄] at h₁ h₂
apply compile_cont.ccont_while
rotate_left 4
· exact h₂
· exact (-(codelen codeb + codelen codec + 1))
rotate_left 3
· simp [compile_com, h₃, h₄]
exact h₁
· grind
· grind
· grind
next =>
have := compile_cont_Kseq_inv C c' k' pc st (by simp [compile_com, codelen] at h₂; grind)
apply Exists.elim this
intro pc'
intro ⟨w₁, w₂⟩
exists (pc', [], st)
constructor
· apply Or.intro_right
constructor
· exact w₁
· simp [measure', cont_size, com_size]
· constructor
· exact w₂.1
· simp [compile_com, codelen] at h₂
grind
next b c =>
have := compile_cont_Kwhile_inv C b c k' pc st (by simp [compile_com, codelen] at h₂; grind)
apply Exists.elim this
intro pc'
intro ⟨ w₁, w₂ ⟩
exists (pc', [], st)
constructor
· apply Or.intro_left
· exact w₁
· constructor
· exact w₂.1
· exact w₂.2 | 4 | 64 | true | Compiler |
357 | compile_com_correct_terminating | theorem compile_com_correct_terminating (s s' : store) (c : com) (h₁ : cexec s c s') :
∀ C pc stk, code_at C pc (compile_com c) →
transitions C
(pc, stk, s)
(pc + codelen (compile_com c), stk, s') | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "cexec",
"content": "@[grind] inductive cexec : store → com → store → Prop where\n | cexec_skip :\n cexec s .SKIP s\n | cexec_assign :\n cexec s (.ASSIGN x a) (update x (aeval s a) s)\n | cexec_seq :\n cexec s c1 s' -> cexec s' c2 s'' ->\n cexec s (.SEQ c1 c2) s''\n | cexec_ifthenelse :\n cexec s (if beval s b then c1 else c2) s' ->\n cexec s (.IFTHENELSE b c1 c2) s'\n | cexec_while_done :\n beval s b = false ->\n cexec s (.WHILE b c) s\n | cexec_while_loop :\n beval s b = true -> cexec s c s' -> cexec s' (.WHILE b c) s'' ->\n cexec s (.WHILE b c) s''"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "Int.add_zero",
"module": "Init.Data.Int.Lemmas"
}
] | [
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "compile_com",
"content": "@[grind] def compile_com (c : com) : List instr :=\n match c with\n | .SKIP =>\n []\n | .ASSIGN x a =>\n compile_aexp a ++ .Isetvar x :: []\n | .SEQ c1 c2 =>\n compile_com c1 ++ compile_com c2\n | .IFTHENELSE b ifso ifnot =>\n let code_ifso := compile_com ifso\n let code_ifnot := compile_com ifnot\n compile_bexp b 0 (codelen code_ifso + 1)\n ++ code_ifso\n ++ .Ibranch (codelen code_ifnot)\n :: code_ifnot\n | .WHILE b body =>\n let code_body := compile_com body\n let code_test := compile_bexp b 0 (codelen code_body + 1)\n code_test\n ++ code_body\n ++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
}
] | [
{
"name": "codelen_cons",
"content": "@[grind =] theorem codelen_cons :\n ∀ i c, codelen (i :: c) = codelen c + 1"
},
{
"name": "codelen_singleton",
"content": "@[grind =] theorem codelen_singleton : codelen [i] = 1"
},
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_app_right",
"content": "@[grind] theorem code_at_app_right :\n ∀ C pc C1 C2,\n code_at C pc (C1 ++ C2) ->\n code_at C (pc + codelen C1) C2"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
},
{
"name": "compile_bexp_correct",
"content": "theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :\n transitions C\n (pc, stk, s)\n (pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s)"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] def compile_com (c : com) : List instr :=
match c with
| .SKIP =>
[]
| .ASSIGN x a =>
compile_aexp a ++ .Isetvar x :: []
| .SEQ c1 c2 =>
compile_com c1 ++ compile_com c2
| .IFTHENELSE b ifso ifnot =>
let code_ifso := compile_com ifso
let code_ifnot := compile_com ifnot
compile_bexp b 0 (codelen code_ifso + 1)
++ code_ifso
++ .Ibranch (codelen code_ifnot)
:: code_ifnot
| .WHILE b body =>
let code_body := compile_com body
let code_test := compile_bexp b 0 (codelen code_body + 1)
code_test
++ code_body
++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2 | theorem compile_com_correct_terminating (s s' : store) (c : com) (h₁ : cexec s c s') :
∀ C pc stk, code_at C pc (compile_com c) →
transitions C
(pc, stk, s)
(pc + codelen (compile_com c), stk, s') := | := by
induction h₁
case cexec_skip =>
intro C pc stk h
unfold compile_com
dsimp [codelen]
simp only [Int.add_zero]
apply star.star_refl
case cexec_assign s' x a =>
intro C pc stk h
unfold compile_com
apply star_trans
· apply compile_aexp_correct (a := a)
grind
· apply star_one
· have := @transition.trans_setvar C
grind
case cexec_seq s'2 c1 s1 c2 s2 cexec1 cexec2 c1_ih c2_ih =>
intro C pc stk h
apply star_trans
· apply c1_ih
grind
· specialize c2_ih C (pc + codelen (compile_com c1)) stk
simp [compile_com, codelen_app]
simp [Int.add_assoc] at c2_ih
apply c2_ih
grind
case cexec_ifthenelse s b c1 c2 s' cexec_h ih =>
intro C pc stk
generalize heq1 : compile_com c1 = code1
generalize heq2 : compile_com c2 = code2
generalize heq3 : compile_bexp b 0 (codelen code1 + 1) = code3
simp [compile_com]
rw [heq1, heq2, heq3]
intro h
apply star_trans
· have := compile_bexp_correct C s b 0 (codelen code1 + 1) pc stk (by grind)
apply this
· by_cases beval s b = true
case pos isTrue =>
simp [isTrue]
apply star_trans
· apply ih
grind
· apply star_one
· apply transition.trans_branch (d := codelen code2) <;> grind
case neg isFalse =>
simp [isFalse]
rw [heq3]
specialize ih C (pc + codelen code3 + (codelen code1 + 1)) stk
simp [isFalse] at ih
suffices h2 : code_at C (pc + codelen code3 + (codelen code1 + 1)) (compile_com c2) from by
specialize ih h2
simp [codelen_app, codelen_cons]
have : (pc + codelen code3 + (codelen code1 + 1) + codelen (compile_com c2)) = (pc + (codelen code3 + (codelen code1 + (codelen code2 + 1)))) := by grind
rw [this] at ih
apply ih
have := @code_at_app_right C pc (code3 ++ code1 ++ [instr.Ibranch (codelen code2)]) code2 (by simp[h])
grind
case cexec_while_done s b c1 isFalse =>
intro C pc stk h
generalize heq1 : compile_com c1 = code_body
generalize heq2 : compile_bexp b 0 (codelen code_body + 1) = code_branch
generalize heq3 : - (codelen code_branch + codelen code_body + 1) = d
simp [compile_com]
rw [heq1, heq2, heq3]
simp [codelen_app, codelen_singleton]
apply star_trans
· apply compile_bexp_correct C s b 0 (codelen code_body + 1) pc stk (by grind)
· grind
case cexec_while_loop s b c1 s_intermediate s' isTrue cexec1 cexec2 ih1 ih2 =>
intro C pc stk
generalize heq1 : compile_com c1 = code_body
generalize heq2 : compile_bexp b 0 (codelen code_body + 1) = code_branch
generalize heq3 : - (codelen code_branch + codelen code_body + 1) = d
simp [compile_com]
rw [heq1, heq2, heq3]
intro h
apply star_trans
· apply compile_bexp_correct C s b 0 (codelen code_body + 1) pc stk (by grind)
· apply star_trans
· apply ih1
grind
· apply star_trans
· apply star_one
apply transition.trans_branch (d := d)
rotate_left
rotate_left
· exact (pc + codelen code_branch + codelen code_body + 1 + d)
· grind
· grind
· specialize ih2 C (pc + codelen code_branch + codelen code_body + 1 + d) stk
suffices h2 : code_at C (pc + codelen code_branch + codelen code_body + 1 + d) (compile_com (com.WHILE b c1)) from by
specialize ih2 h2
simp [compile_com] at ih2
rw [heq1, heq2, heq3] at ih2
simp [codelen_app]
simp [codelen_app] at ih2
have : (pc + codelen code_branch + codelen code_body + 1 + d +
(codelen code_branch + (codelen code_body + codelen [instr.Ibranch d])) ) = (pc + (codelen code_branch + (codelen code_body + codelen [instr.Ibranch d]))) := by grind
rw [←this]
apply ih2
grind | 5 | 48 | true | Compiler |
358 | fixpoint_join_increasing | theorem fixpoint_join_increasing (_ : Store) (F : Store → Store) (F_mon : ∀ x y, le x y → le (F x) (F y)) (S1 S2 : Store) : le S1 S2 → le (fixpoint_join' S1 F F_mon) (fixpoint_join' S2 F F_mon) | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Fixpoints.lean | [
"import LeroyCompilerVerificationCourse.Constprop",
"import LeroyCompilerVerificationCourse.Imp",
"import Batteries.Data.List.Perm"
] | [
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "WellFounded",
"module": "Init.WF"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "k",
"module": "QqTest.matching"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Equiv",
"module": "Mathlib.Logic.Equiv.Defs"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Std.HashMap.Equiv.getElem?_eq",
"module": "Std.Data.HashMap.Lemmas"
}
] | [
{
"name": "Le_Join_l",
"content": "theorem Le_Join_l : ∀ S1 S2, Le S1 (Join S1 S2)"
}
] | [
{
"name": "OrderStruct",
"content": "@[grind] class OrderStruct (α : Sort u) where\n eq : α → α → Prop\n le : α → α → Prop\n beq : α → α → Bool\n le_trans : ∀ x y z, le x y -> le y z -> le x z\n beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/"
},
{
"name": "Monotone",
"content": "class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where\n F_mon : ∀ {x y : α}, le x y → le (F x) (F y)"
},
{
"name": "iterate",
"content": "@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=\n if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/\n ) (by admit /- proof elided -/\n )\n termination_by x\n decreasing_by\n grind [beq_false']"
},
{
"name": "Eq'",
"content": "@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2"
},
{
"name": "Eq'_sym",
"content": "def Eq'_sym : ∀ S1 S2, Eq' S1 S2 → Eq' S2 S1 :="
},
{
"name": "_inst_OrderStruct",
"content": "noncomputable instance : OrderStruct Store where\n eq := Equal\n le := Le\n beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)\n le_trans := Le_trans\n gt_wf := Gt_wf"
},
{
"name": "_inst_Monotone",
"content": "instance : Monotone Store (fun x => Join Init (F x)) where\n F_mon := by admit /- proof elided -/"
},
{
"name": "fixpoint_join",
"content": "noncomputable def fixpoint_join : Store :="
},
{
"name": "wrapper",
"content": "noncomputable instance wrapper (F : Store → Store) (F_mon : ∀ x y, le x y → le (F x) (F y)) : Monotone Store F where\n F_mon := by admit /- proof elided -/"
},
{
"name": "fixpoint_join'",
"content": "noncomputable def fixpoint_join' (S : Store) (F : Store → Store) (F_mon : ∀ x y, le x y → le (F x) (F y)) :="
}
] | [
{
"name": "iterate_correct",
"content": "@[grind] theorem iterate_correct (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) (heq : y = iterate _ F x PRE SMALL ) : eq y (F y) ∧ ∀ z, le (F z) z → le y z"
},
{
"name": "Eq_Le",
"content": "@[grind] theorem Eq_Le : ∀ S1 S2, Eq' S1 S2 → Le S1 S2"
},
{
"name": "Le_trans",
"content": "@[grind] theorem Le_trans : ∀ S1 S2 S3, Le S1 S2 → Le S2 S3 → Le S1 S3"
},
{
"name": "fixpoint_join_eq",
"content": "theorem fixpoint_join_eq : Eq' (Join Init (F (fixpoint_join Init F) )) (fixpoint_join Init F)"
},
{
"name": "fixpoint_join_smallest",
"content": "theorem fixpoint_join_smallest :\n ∀ S, Le (Join Init (F S)) S -> Le (fixpoint_join Init F) S"
},
{
"name": "Join_increasing",
"content": "@[grind] theorem Join_increasing :\n ∀ S1 S2 S3 S4,\n Le S1 S2 -> Le S3 S4 -> Le (Join S1 S3) (Join S2 S4)"
}
] | import LeroyCompilerVerificationCourse.Imp
import LeroyCompilerVerificationCourse.Constprop
import Batteries.Data.List.Perm
@[grind] class OrderStruct (α : Sort u) where
eq : α → α → Prop
le : α → α → Prop
beq : α → α → Bool
le_trans : ∀ x y z, le x y -> le y z -> le x z
beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/
open OrderStruct
class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where
F_mon : ∀ {x y : α}, le x y → le (F x) (F y)
open Monotone
section FixpointExistence
variable (α : Sort u) (F : α → α) [OrderWithBot α]
open OrderStruct OrderWithBot
end FixpointExistence
section Iterate
variable (α : Sort u) [inst : OrderStruct α] (F : α → α) [Monotone α F]
open OrderStruct
@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=
if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/
) (by admit /- proof elided -/
)
termination_by x
decreasing_by
grind [beq_false']
end Iterate
section Fixpoint
open OrderWithBot
variable {α : Sort u} [i : OrderWithBot α] (F : α → α) [Monotone α F]
end Fixpoint
section Constprop
open Std.HashMap
@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2
def Eq'_sym : ∀ S1 S2, Eq' S1 S2 → Eq' S2 S1 :=
open OrderStruct
noncomputable instance : OrderStruct Store where
eq := Equal
le := Le
beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)
le_trans := Le_trans
gt_wf := Gt_wf
end Constprop
section FixpointJoin
variable (Init : Store)
variable (F : Store → Store) [Monotone Store F]
instance : Monotone Store (fun x => Join Init (F x)) where
F_mon := by admit /- proof elided -/
noncomputable def fixpoint_join : Store :=
end FixpointJoin
noncomputable instance wrapper (F : Store → Store) (F_mon : ∀ x y, le x y → le (F x) (F y)) : Monotone Store F where
F_mon := by admit /- proof elided -/
noncomputable def fixpoint_join' (S : Store) (F : Store → Store) (F_mon : ∀ x y, le x y → le (F x) (F y)) := | theorem fixpoint_join_increasing (_ : Store) (F : Store → Store) (F_mon : ∀ x y, le x y → le (F x) (F y)) (S1 S2 : Store) : le S1 S2 → le (fixpoint_join' S1 F F_mon) (fixpoint_join' S2 F F_mon) := | := by
intro hyp
apply @fixpoint_join_smallest S1 F (by grind [wrapper]) (fixpoint_join' S2 F F_mon)
generalize heq : fixpoint_join' S2 F F_mon = fix2
have : (Le (Join S2 (F fix2)) fix2) := by
apply Eq_Le
· have := @fixpoint_join_eq S2 F (by grind [wrapper])
rw [←heq]
apply this
apply Le_trans
rotate_left
· apply this
· apply Join_increasing
· exact hyp
· grind | 4 | 27 | false | Compiler |
359 | cp_com_correct_terminating | theorem cp_com_correct_terminating :
∀ c s1 s2 S1,
cexec s1 c s2 -> matches' s1 S1 -> cexec s1 (cp_com S1 c) s2 | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Constprop.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import Std.Data.HashMap"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "cexec",
"content": "@[grind] inductive cexec : store → com → store → Prop where\n | cexec_skip :\n cexec s .SKIP s\n | cexec_assign :\n cexec s (.ASSIGN x a) (update x (aeval s a) s)\n | cexec_seq :\n cexec s c1 s' -> cexec s' c2 s'' ->\n cexec s (.SEQ c1 c2) s''\n | cexec_ifthenelse :\n cexec s (if beval s b then c1 else c2) s' ->\n cexec s (.IFTHENELSE b c1 c2) s'\n | cexec_while_done :\n beval s b = false ->\n cexec s (.WHILE b c) s\n | cexec_while_loop :\n beval s b = true -> cexec s c s' -> cexec s' (.WHILE b c) s'' ->\n cexec s (.WHILE b c) s''"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Std.HashMap.Equiv.getElem?_eq",
"module": "Std.Data.HashMap.Lemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "mk_PLUS_CONST",
"content": "@[grind] def mk_PLUS_CONST (a : aexp) (n : Int) : aexp :=\n if n = 0 then a else\n match a with\n | .CONST m => .CONST (m + n)\n | .PLUS a (.CONST m) => .PLUS a (.CONST (m + n))\n | _ => .PLUS a (.CONST n)"
},
{
"name": "mk_PLUS",
"content": "@[grind] def mk_PLUS (a1 a2 : aexp) : aexp :=\n match a1, a2 with\n | .CONST m, _ => mk_PLUS_CONST a2 m\n | _, .CONST m => mk_PLUS_CONST a1 m\n | .PLUS a1 (.CONST m1), .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.PLUS a1 a2) (m1 + m2)\n | .PLUS a1 (.CONST m1), _ => mk_PLUS_CONST (.PLUS a1 a2) m1\n | _, .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.PLUS a1 a2) m2\n | _, _ => .PLUS a1 a2"
},
{
"name": "mk_MINUS",
"content": "@[grind] def mk_MINUS (a1 a2 : aexp) : aexp :=\n match a1, a2 with\n | _, .CONST m => mk_PLUS_CONST a1 (-m)\n | .PLUS a1 (.CONST m1), .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.MINUS a1 a2) (m1 - m2)\n | .PLUS a1 (.CONST m1), _ => mk_PLUS_CONST (.MINUS a1 a2) m1\n | _, .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.MINUS a1 a2) (-m2)\n | _, _ => .MINUS a1 a2"
},
{
"name": "mk_EQUAL",
"content": "@[grind] def mk_EQUAL (a1 a2 : aexp) : bexp :=\n match a1, a2 with\n | .CONST n1, .CONST n2 => if n1 = n2 then .TRUE else .FALSE\n | .PLUS a1 (.CONST n1), .CONST n2 => .EQUAL a1 (.CONST (n2 - n1))\n | _, _ => .EQUAL a1 a2"
},
{
"name": "mk_LESSEQUAL",
"content": "@[grind] def mk_LESSEQUAL (a1 a2 : aexp) : bexp :=\n match a1, a2 with\n | .CONST n1, .CONST n2 => if n1 <= n2 then .TRUE else .FALSE\n | .PLUS a1 (.CONST n1), .CONST n2 => .LESSEQUAL a1 (.CONST (n2 - n1))\n | _, _ => .LESSEQUAL a1 a2"
},
{
"name": "mk_NOT",
"content": "@[grind] def mk_NOT (b : bexp) : bexp :=\n match b with\n | .TRUE => .FALSE\n | .FALSE => .TRUE\n | .NOT b => b\n | _ => .NOT b"
},
{
"name": "mk_AND",
"content": "@[grind] def mk_AND (b1 b2 : bexp) : bexp :=\n match b1, b2 with\n | .TRUE, _ => b2\n | _, .TRUE => b1\n | .FALSE, _ => .FALSE\n | _, .FALSE => .FALSE\n | _, _ => .AND b1 b2"
},
{
"name": "mk_IFTHENELSE",
"content": "@[grind] def mk_IFTHENELSE (b : bexp) (c1 c2 : com) : com :=\n match b with\n | .TRUE => c1\n | .FALSE => c2\n | _ => .IFTHENELSE b c1 c2"
},
{
"name": "mk_WHILE",
"content": "@[grind] def mk_WHILE (b : bexp) (c : com) : com :=\n match b with\n | .FALSE => .SKIP\n | _ => .WHILE b c"
},
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "matches'",
"content": "@[grind] def matches' (s : store) (S : Store) : Prop :=\n ∀ x n, S.get? x = .some n -> s x = n"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Top",
"content": "@[grind] def Top : Store := Std.HashMap.emptyWithCapacity"
},
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "fixpoint_rec",
"content": "@[grind] noncomputable def fixpoint_rec (F : Store -> Store) (fuel : Nat) (S : Store) : Store :=\n match fuel with\n | 0 => Top\n | fuel + 1 =>\n let S' := F S\n if Equal S' S then S else fixpoint_rec F fuel S'"
},
{
"name": "num_iter",
"content": "@[grind] def num_iter : Nat := 20"
},
{
"name": "fixpoint",
"content": "@[grind] noncomputable def fixpoint (F : Store -> Store) (init_S : Store) : Store :=\n fixpoint_rec F num_iter init_S"
},
{
"name": "Cexec",
"content": "@[grind] noncomputable def Cexec (S : Store) (c : com) : Store :=\n match c with\n | .SKIP => S\n | .ASSIGN x a => Update x (Aeval S a) S\n | .SEQ c1 c2 => Cexec (Cexec S c1) c2\n | .IFTHENELSE b c1 c2 =>\n match Beval S b with\n | .some true => Cexec S c1\n | .some false => Cexec S c2\n | .none => Join (Cexec S c1) (Cexec S c2)\n | .WHILE _ c1 =>\n fixpoint (fun x => Join S (Cexec x c1)) S"
},
{
"name": "cp_aexp",
"content": "@[grind =] def cp_aexp (S : Store) (a : aexp) : aexp :=\n match a with\n | .CONST n => .CONST n\n | .VAR x => match S.get? x with\n | .some n => .CONST n\n | .none => .VAR x\n | .PLUS a1 a2 => mk_PLUS (cp_aexp S a1) (cp_aexp S a2)\n | .MINUS a1 a2 => mk_MINUS (cp_aexp S a1) (cp_aexp S a2)"
},
{
"name": "cp_bexp",
"content": "@[grind] def cp_bexp (S : Store) (b : bexp) : bexp :=\n match b with\n | .TRUE => .TRUE\n | .FALSE => .FALSE\n | .EQUAL a1 a2 => mk_EQUAL (cp_aexp S a1) (cp_aexp S a2)\n | .LESSEQUAL a1 a2 => mk_LESSEQUAL (cp_aexp S a1) (cp_aexp S a2)\n | .NOT b => mk_NOT (cp_bexp S b)\n | .AND b1 b2 => mk_AND (cp_bexp S b1) (cp_bexp S b2)"
},
{
"name": "cp_com",
"content": "@[grind] noncomputable def cp_com (S : Store) (c : com) : com :=\n match c with\n | .SKIP => .SKIP\n | .ASSIGN x a =>\n .ASSIGN x (cp_aexp S a)\n | .SEQ c1 c2 =>\n .SEQ (cp_com S c1) (cp_com (Cexec S c1) c2)\n | .IFTHENELSE b c1 c2 =>\n mk_IFTHENELSE (cp_bexp S b) (cp_com S c1) (cp_com S c2)\n | .WHILE b c =>\n let sfix := Cexec S (.WHILE b c)\n mk_WHILE (cp_bexp sfix b) (cp_com sfix c)"
}
] | [
{
"name": "mk_EQUAL_sound",
"content": "theorem mk_EQUAL_sound :\n ∀ s a1 a2, beval s (mk_EQUAL a1 a2) = (aeval s a1 = aeval s a2)"
},
{
"name": "mk_LESSEQUAL_sound",
"content": "theorem mk_LESSEQUAL_sound :\n ∀ s a1 a2, beval s (mk_LESSEQUAL a1 a2) = (aeval s a1 <= aeval s a2)"
},
{
"name": "mk_NOT_sound",
"content": "theorem mk_NOT_sound :\n ∀ s b, beval s (mk_NOT b) = ¬ (beval s b)"
},
{
"name": "mk_AND_sound",
"content": "theorem mk_AND_sound :\n ∀ s b1 b2, beval s (mk_AND b1 b2) = (beval s b1 ∧ beval s b2)"
},
{
"name": "cexec_mk_IFTHENELSE",
"content": "theorem cexec_mk_IFTHENELSE : ∀ s1 b c1 c2 s2,\n cexec s1 (if beval s1 b then c1 else c2) s2 ->\n cexec s1 (mk_IFTHENELSE b c1 c2) s2"
},
{
"name": "cexec_mk_WHILE_done",
"content": "theorem cexec_mk_WHILE_done : ∀ s1 b c,\n beval s1 b = false ->\n cexec s1 (mk_WHILE b c) s1"
},
{
"name": "cexec_mk_WHILE_loop",
"content": "theorem cexec_mk_WHILE_loop : ∀ b c s1 s2 s3,\n beval s1 b = true -> cexec s1 c s2 -> cexec s2 (mk_WHILE b c) s3 ->\n cexec s1 (mk_WHILE b c) s3"
},
{
"name": "matches_Le",
"content": "theorem matches_Le : ∀ s S1 S2, Le S1 S2 -> matches' s S1 -> matches' s S2"
},
{
"name": "Le_Join_l",
"content": "theorem Le_Join_l : ∀ S1 S2, Le S1 (Join S1 S2)"
},
{
"name": "Le_Join_r",
"content": "theorem Le_Join_r : ∀ S1 S2, Le S2 (Join S1 S2)"
},
{
"name": "Equal_Le",
"content": "theorem Equal_Le : ∀ S1 S2, Equal S1 S2 -> Le S1 S2"
},
{
"name": "Beval_sound",
"content": "theorem Beval_sound :\n ∀ s S, matches' s S ->\n ∀ b n, Beval S b = .some n -> beval s b = n"
},
{
"name": "fixpoint_sound",
"content": "theorem fixpoint_sound (F : Store → Store) (init_S : Store) (h : S = fixpoint F init_S) :\n Le (F S) S"
},
{
"name": "Cexec_sound",
"content": "@[grind] theorem Cexec_sound :\n ∀ c s1 s2 S1,\n cexec s1 c s2 -> matches' s1 S1 -> matches' s2 (Cexec S1 c)"
},
{
"name": "cp_bexp_sound",
"content": "theorem cp_bexp_sound :\n ∀ s S, matches' s S ->\n ∀ b, beval s (cp_bexp S b) = beval s b"
}
] | import LeroyCompilerVerificationCourse.Imp
import Std.Data.HashMap
open Classical in
@[grind] def mk_PLUS_CONST (a : aexp) (n : Int) : aexp :=
if n = 0 then a else
match a with
| .CONST m => .CONST (m + n)
| .PLUS a (.CONST m) => .PLUS a (.CONST (m + n))
| _ => .PLUS a (.CONST n)
@[grind] def mk_PLUS (a1 a2 : aexp) : aexp :=
match a1, a2 with
| .CONST m, _ => mk_PLUS_CONST a2 m
| _, .CONST m => mk_PLUS_CONST a1 m
| .PLUS a1 (.CONST m1), .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.PLUS a1 a2) (m1 + m2)
| .PLUS a1 (.CONST m1), _ => mk_PLUS_CONST (.PLUS a1 a2) m1
| _, .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.PLUS a1 a2) m2
| _, _ => .PLUS a1 a2
@[grind] def mk_MINUS (a1 a2 : aexp) : aexp :=
match a1, a2 with
| _, .CONST m => mk_PLUS_CONST a1 (-m)
| .PLUS a1 (.CONST m1), .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.MINUS a1 a2) (m1 - m2)
| .PLUS a1 (.CONST m1), _ => mk_PLUS_CONST (.MINUS a1 a2) m1
| _, .PLUS a2 (.CONST m2) => mk_PLUS_CONST (.MINUS a1 a2) (-m2)
| _, _ => .MINUS a1 a2
@[grind] def mk_EQUAL (a1 a2 : aexp) : bexp :=
match a1, a2 with
| .CONST n1, .CONST n2 => if n1 = n2 then .TRUE else .FALSE
| .PLUS a1 (.CONST n1), .CONST n2 => .EQUAL a1 (.CONST (n2 - n1))
| _, _ => .EQUAL a1 a2
@[grind] def mk_LESSEQUAL (a1 a2 : aexp) : bexp :=
match a1, a2 with
| .CONST n1, .CONST n2 => if n1 <= n2 then .TRUE else .FALSE
| .PLUS a1 (.CONST n1), .CONST n2 => .LESSEQUAL a1 (.CONST (n2 - n1))
| _, _ => .LESSEQUAL a1 a2
@[grind] def mk_NOT (b : bexp) : bexp :=
match b with
| .TRUE => .FALSE
| .FALSE => .TRUE
| .NOT b => b
| _ => .NOT b
@[grind] def mk_AND (b1 b2 : bexp) : bexp :=
match b1, b2 with
| .TRUE, _ => b2
| _, .TRUE => b1
| .FALSE, _ => .FALSE
| _, .FALSE => .FALSE
| _, _ => .AND b1 b2
@[grind] def mk_IFTHENELSE (b : bexp) (c1 c2 : com) : com :=
match b with
| .TRUE => c1
| .FALSE => c2
| _ => .IFTHENELSE b c1 c2
@[grind] def mk_WHILE (b : bexp) (c : com) : com :=
match b with
| .FALSE => .SKIP
| _ => .WHILE b c
def Store := Std.HashMap ident Int
@[grind] def matches' (s : store) (S : Store) : Prop :=
∀ x n, S.get? x = .some n -> s x = n
@[grind] def Le (S1 S2 : Store) : Prop :=
∀ x n, S2.get? x = .some n -> S1.get? x = .some n
@[grind] def Top : Store := Std.HashMap.emptyWithCapacity
@[grind] def Join (S1 S2 : Store) : Store :=
S1.filter (fun key _ => S2.get? key == S1.get? key)
def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2
@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=
match o with
| .some x => .some (f x)
| .none => .none
@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=
match o1, o2 with
| .some x1, .some x2 => .some (f x1 x2) | _, _ => .none
@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=
match a with
| .CONST n => .some n
| .VAR x => S.get? x
| .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)
| .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)
@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=
match b with
| .TRUE => .some true
| .FALSE => .some false
| .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)
| .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)
| .NOT b1 => lift1 (fun m => !m) (Beval S b1)
| .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)
@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=
match N with
| .none => S.erase x
| .some n => S.insert x n
@[grind] noncomputable def fixpoint_rec (F : Store -> Store) (fuel : Nat) (S : Store) : Store :=
match fuel with
| 0 => Top
| fuel + 1 =>
let S' := F S
if Equal S' S then S else fixpoint_rec F fuel S'
@[grind] def num_iter : Nat := 20
@[grind] noncomputable def fixpoint (F : Store -> Store) (init_S : Store) : Store :=
fixpoint_rec F num_iter init_S
@[grind] noncomputable def Cexec (S : Store) (c : com) : Store :=
match c with
| .SKIP => S
| .ASSIGN x a => Update x (Aeval S a) S
| .SEQ c1 c2 => Cexec (Cexec S c1) c2
| .IFTHENELSE b c1 c2 =>
match Beval S b with
| .some true => Cexec S c1
| .some false => Cexec S c2
| .none => Join (Cexec S c1) (Cexec S c2)
| .WHILE _ c1 =>
fixpoint (fun x => Join S (Cexec x c1)) S
@[grind =] def cp_aexp (S : Store) (a : aexp) : aexp :=
match a with
| .CONST n => .CONST n
| .VAR x => match S.get? x with
| .some n => .CONST n
| .none => .VAR x
| .PLUS a1 a2 => mk_PLUS (cp_aexp S a1) (cp_aexp S a2)
| .MINUS a1 a2 => mk_MINUS (cp_aexp S a1) (cp_aexp S a2)
@[grind] def cp_bexp (S : Store) (b : bexp) : bexp :=
match b with
| .TRUE => .TRUE
| .FALSE => .FALSE
| .EQUAL a1 a2 => mk_EQUAL (cp_aexp S a1) (cp_aexp S a2)
| .LESSEQUAL a1 a2 => mk_LESSEQUAL (cp_aexp S a1) (cp_aexp S a2)
| .NOT b => mk_NOT (cp_bexp S b)
| .AND b1 b2 => mk_AND (cp_bexp S b1) (cp_bexp S b2)
@[grind] noncomputable def cp_com (S : Store) (c : com) : com :=
match c with
| .SKIP => .SKIP
| .ASSIGN x a =>
.ASSIGN x (cp_aexp S a)
| .SEQ c1 c2 =>
.SEQ (cp_com S c1) (cp_com (Cexec S c1) c2)
| .IFTHENELSE b c1 c2 =>
mk_IFTHENELSE (cp_bexp S b) (cp_com S c1) (cp_com S c2)
| .WHILE b c =>
let sfix := Cexec S (.WHILE b c)
mk_WHILE (cp_bexp sfix b) (cp_com sfix c) | theorem cp_com_correct_terminating :
∀ c s1 s2 S1,
cexec s1 c s2 -> matches' s1 S1 -> cexec s1 (cp_com S1 c) s2 := | := by
intro c s1 s2 S1 EXEC AG
induction c generalizing s1 s2 S1
any_goals grind
case ASSIGN x a =>
cases EXEC
next =>
have := @cexec.cexec_assign s1 x (cp_aexp S1 a)
grind
case IFTHENELSE b c1 c2 c1_ih c2_ih =>
cases EXEC
next =>
apply cexec_mk_IFTHENELSE
grind [cp_bexp_sound]
case WHILE b c c_ih =>
generalize heq1 : com.WHILE b c = loop
generalize heq2 : Cexec S1 (.WHILE b c) = X
have INNER : ∀ s1 c1 s2,
cexec s1 c1 s2 ->
c1 = .WHILE b c ->
matches' s1 X ->
cexec s1 (mk_WHILE (cp_bexp X b) (cp_com X c)) s2 := by
intro s1 c1
induction c1 generalizing s1 c
any_goals grind
case WHILE b1 c1 c1_ih =>
intro s2 EXEC EQ AG1
injections heq1' heq2'
generalize heq : (com.WHILE b1 c1) = loop
rw [heq] at EXEC
induction EXEC
any_goals grind
case cexec_while_done isFalse =>
apply cexec_mk_WHILE_done
· grind [cp_bexp_sound]
case cexec_while_loop s3 b' c' s4 s5 isTrue EXEC2 EXEC3 a_ih a_ih2 =>
apply cexec_mk_WHILE_loop
· grind [cp_bexp_sound]
· apply c_ih
· injections heq4 heq5
rw [heq2'] at heq5
rw [←heq5] at EXEC2
exact EXEC2
· exact AG1
· apply a_ih2
rotate_left
· grind
· apply matches_Le
rw [←heq2]
simp [Cexec]
apply fixpoint_sound
rotate_left
· exact (fun x => Join S1 (Cexec x c))
· exact S1
rotate_left
· grind
· apply matches_Le
· apply Le_Join_r
· apply Cexec_sound
· rw [←heq2']
injections heq3 heq4
rw [heq4]
exact EXEC2
· grind
rw [heq1] at EXEC
induction EXEC
any_goals grind
case cexec_while_loop s3 b' c' s4 s5 isTrue EXEC1 EXEC2 ih1 ih2 =>
injections heq3 heq4
simp [cp_com]
specialize INNER s3 (.WHILE b' c') s5
rw [←heq3, ←heq4, heq2]
apply INNER
any_goals grind
· rw [←heq2]
simp [Cexec]
apply matches_Le
· apply fixpoint_sound
rotate_left
· exact (fun x => Join S1 (Cexec x c))
· exact S1
· grind
· grind | 5 | 71 | true | Compiler |
360 | Cexec_sound | @[grind] theorem Cexec_sound :
∀ c s1 s2 S1,
cexec s1 c s2 -> matches' s1 S1 -> matches' s2 (Cexec S1 c) | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Constprop.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import Std.Data.HashMap"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "cexec",
"content": "@[grind] inductive cexec : store → com → store → Prop where\n | cexec_skip :\n cexec s .SKIP s\n | cexec_assign :\n cexec s (.ASSIGN x a) (update x (aeval s a) s)\n | cexec_seq :\n cexec s c1 s' -> cexec s' c2 s'' ->\n cexec s (.SEQ c1 c2) s''\n | cexec_ifthenelse :\n cexec s (if beval s b then c1 else c2) s' ->\n cexec s (.IFTHENELSE b c1 c2) s'\n | cexec_while_done :\n beval s b = false ->\n cexec s (.WHILE b c) s\n | cexec_while_loop :\n beval s b = true -> cexec s c s' -> cexec s' (.WHILE b c) s'' ->\n cexec s (.WHILE b c) s''"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Std.HashMap.Equiv.getElem?_eq",
"module": "Std.Data.HashMap.Lemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "matches'",
"content": "@[grind] def matches' (s : store) (S : Store) : Prop :=\n ∀ x n, S.get? x = .some n -> s x = n"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Top",
"content": "@[grind] def Top : Store := Std.HashMap.emptyWithCapacity"
},
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "fixpoint_rec",
"content": "@[grind] noncomputable def fixpoint_rec (F : Store -> Store) (fuel : Nat) (S : Store) : Store :=\n match fuel with\n | 0 => Top\n | fuel + 1 =>\n let S' := F S\n if Equal S' S then S else fixpoint_rec F fuel S'"
},
{
"name": "num_iter",
"content": "@[grind] def num_iter : Nat := 20"
},
{
"name": "fixpoint",
"content": "@[grind] noncomputable def fixpoint (F : Store -> Store) (init_S : Store) : Store :=\n fixpoint_rec F num_iter init_S"
},
{
"name": "Cexec",
"content": "@[grind] noncomputable def Cexec (S : Store) (c : com) : Store :=\n match c with\n | .SKIP => S\n | .ASSIGN x a => Update x (Aeval S a) S\n | .SEQ c1 c2 => Cexec (Cexec S c1) c2\n | .IFTHENELSE b c1 c2 =>\n match Beval S b with\n | .some true => Cexec S c1\n | .some false => Cexec S c2\n | .none => Join (Cexec S c1) (Cexec S c2)\n | .WHILE _ c1 =>\n fixpoint (fun x => Join S (Cexec x c1)) S"
}
] | [
{
"name": "matches_Le",
"content": "theorem matches_Le : ∀ s S1 S2, Le S1 S2 -> matches' s S1 -> matches' s S2"
},
{
"name": "Le_Join_l",
"content": "theorem Le_Join_l : ∀ S1 S2, Le S1 (Join S1 S2)"
},
{
"name": "Le_Join_r",
"content": "theorem Le_Join_r : ∀ S1 S2, Le S2 (Join S1 S2)"
},
{
"name": "Equal_Le",
"content": "theorem Equal_Le : ∀ S1 S2, Equal S1 S2 -> Le S1 S2"
},
{
"name": "Beval_sound",
"content": "theorem Beval_sound :\n ∀ s S, matches' s S ->\n ∀ b n, Beval S b = .some n -> beval s b = n"
},
{
"name": "fixpoint_sound",
"content": "theorem fixpoint_sound (F : Store → Store) (init_S : Store) (h : S = fixpoint F init_S) :\n Le (F S) S"
}
] | import LeroyCompilerVerificationCourse.Imp
import Std.Data.HashMap
open Classical in
def Store := Std.HashMap ident Int
@[grind] def matches' (s : store) (S : Store) : Prop :=
∀ x n, S.get? x = .some n -> s x = n
@[grind] def Le (S1 S2 : Store) : Prop :=
∀ x n, S2.get? x = .some n -> S1.get? x = .some n
@[grind] def Top : Store := Std.HashMap.emptyWithCapacity
@[grind] def Join (S1 S2 : Store) : Store :=
S1.filter (fun key _ => S2.get? key == S1.get? key)
def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2
@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=
match o with
| .some x => .some (f x)
| .none => .none
@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=
match o1, o2 with
| .some x1, .some x2 => .some (f x1 x2) | _, _ => .none
@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=
match a with
| .CONST n => .some n
| .VAR x => S.get? x
| .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)
| .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)
@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=
match b with
| .TRUE => .some true
| .FALSE => .some false
| .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)
| .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)
| .NOT b1 => lift1 (fun m => !m) (Beval S b1)
| .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)
@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=
match N with
| .none => S.erase x
| .some n => S.insert x n
@[grind] noncomputable def fixpoint_rec (F : Store -> Store) (fuel : Nat) (S : Store) : Store :=
match fuel with
| 0 => Top
| fuel + 1 =>
let S' := F S
if Equal S' S then S else fixpoint_rec F fuel S'
@[grind] def num_iter : Nat := 20
@[grind] noncomputable def fixpoint (F : Store -> Store) (init_S : Store) : Store :=
fixpoint_rec F num_iter init_S
@[grind] noncomputable def Cexec (S : Store) (c : com) : Store :=
match c with
| .SKIP => S
| .ASSIGN x a => Update x (Aeval S a) S
| .SEQ c1 c2 => Cexec (Cexec S c1) c2
| .IFTHENELSE b c1 c2 =>
match Beval S b with
| .some true => Cexec S c1
| .some false => Cexec S c2
| .none => Join (Cexec S c1) (Cexec S c2)
| .WHILE _ c1 =>
fixpoint (fun x => Join S (Cexec x c1)) S | @[grind] theorem Cexec_sound :
∀ c s1 s2 S1,
cexec s1 c s2 -> matches' s1 S1 -> matches' s2 (Cexec S1 c) := | := by
intro c
induction c
next =>
intro s1 s2 S1 EXEC
cases EXEC
grind
next x a =>
intro s1 s2 S1 EXEC
cases EXEC
grind
next c1 c2 c1_ih c2_ih =>
grind
next b c1 c2 c1_ih c2_ih =>
intro s1 s2 S1 EXEC
cases EXEC
next EXEC =>
by_cases beval s1 b
case pos h =>
unfold Cexec
intro h2
have := Beval_sound s1 S1 h2 b
split <;> grind
case neg h =>
simp [h] at EXEC
intro h2
unfold Cexec
have := Beval_sound s1 S1 h2 b
split <;> grind
case WHILE b c c1_ih =>
intro s1 s2 S1 EXEC MATCHES
generalize eq1 : (fun x => Join S1 (Cexec x c)) = F
generalize eq2 : fixpoint F S1 = X
have INNER : ∀ s1 c1 s2,
cexec s1 c1 s2 ->
c1 = .WHILE b c ->
matches' s1 X ->
matches' s2 X := by
intro s3 c1 s4 EXEC2 EQ AG
induction EXEC2
any_goals grind
case cexec_while_loop s' b' c' s5 s6 EXEC2 EXEC3 EXEC4 _ a_ih2 =>
apply a_ih2
· grind
· apply matches_Le
rotate_right
· exact F X
· exact @fixpoint_sound X F S1 (by grind)
· rw [←eq2, ←eq1]
simp
apply matches_Le
apply Le_Join_r
rw [eq1, eq2]
apply c1_ih
injections EQ
rename_i eq1 eq2
rw [eq2] at EXEC3
exact EXEC3
exact AG
unfold Cexec
rw [eq1, eq2]
apply INNER
· apply EXEC
· rfl
· apply matches_Le
have := @fixpoint_sound X F
apply this
rotate_left
· exact S1
rotate_left
· grind
· rw [←eq1]
simp
apply matches_Le
· apply Le_Join_l
· exact MATCHES | 5 | 50 | false | Compiler |
361 | compile_bexp_correct | theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :
transitions C
(pc, stk, s)
(pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s) | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
}
] | [
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
}
] | [
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
}
] | [
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
}
] | [
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2 | theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :
transitions C
(pc, stk, s)
(pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s) := | := by
induction b generalizing d1 d0 pc
next =>
simp [compile_bexp, beval]
by_cases d1 = 0
case pos is_zero =>
simp [is_zero, codelen]
apply star.star_refl
case neg is_not_zero =>
apply star_one
grind
next =>
simp [compile_bexp, beval]
by_cases d0 = 0
case pos is_zero =>
simp [is_zero, codelen]
apply star.star_refl
case neg is_not_zero =>
apply star_one
simp [is_not_zero, codelen]
grind
next a1 a2 =>
simp [compile_bexp, beval]
apply star_trans
· apply compile_aexp_correct (a := a1)
grind
· apply star_trans
· apply compile_aexp_correct (a := a2)
grind
· apply star_one
· apply transition.trans_beq (d1 := d1) (d0 := d0) <;> grind
next a1 a2 =>
simp [compile_bexp, beval]
apply star_trans
· apply compile_aexp_correct (a := a1)
grind
· apply star_trans
· apply compile_aexp_correct (a := a2)
grind
· apply star_one
· apply transition.trans_ble (d1 := d1) (d0 := d0) <;> grind
next b1 ih =>
grind
next b1 b2 b1_ih b2_ih =>
generalize heq1 : compile_bexp b2 d1 d0 = code2
generalize heq2 : compile_bexp b1 0 (codelen code2 + d0) = code1
unfold compile_bexp
simp [heq1, heq2]
apply star_trans
· apply b1_ih (d1 := 0) (d0 := codelen code2 + d0)
grind
· by_cases beval s b1 = true
case pos isTrue =>
simp [isTrue]
rw [heq2]
simp [beval, isTrue]
specialize b2_ih d1 d0 (pc + codelen code1)
rw [heq1] at b2_ih
simp [compile_bexp, heq1, heq2] at h
specialize b2_ih (by grind)
simp [codelen_app]
simp [Int.add_assoc] at *
exact b2_ih
case neg isFalse =>
grind | 5 | 34 | true | Compiler |
362 | dce_correct_terminating | theorem dce_correct_terminating :
∀ s c s', cexec s c s' ->
∀ L s1, agree (live c L) s s1 ->
∃ s1', cexec s1 (dce c L) s1' /\ agree L s' s1' | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Deadcode.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import Std.Data.HashSet"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Std.HashSet",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Std.HashSet.instSingleton",
"module": "Std.Data.HashSet.Basic"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Iff",
"module": "Init.Core"
}
] | [
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "cexec",
"content": "@[grind] inductive cexec : store → com → store → Prop where\n | cexec_skip :\n cexec s .SKIP s\n | cexec_assign :\n cexec s (.ASSIGN x a) (update x (aeval s a) s)\n | cexec_seq :\n cexec s c1 s' -> cexec s' c2 s'' ->\n cexec s (.SEQ c1 c2) s''\n | cexec_ifthenelse :\n cexec s (if beval s b then c1 else c2) s' ->\n cexec s (.IFTHENELSE b c1 c2) s'\n | cexec_while_done :\n beval s b = false ->\n cexec s (.WHILE b c) s\n | cexec_while_loop :\n beval s b = true -> cexec s c s' -> cexec s' (.WHILE b c) s'' ->\n cexec s (.WHILE b c) s''"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "IdentSet",
"content": "abbrev IdentSet := Std.HashSet ident"
},
{
"name": "fv_aexp",
"content": "@[grind] def fv_aexp (a : aexp) : IdentSet :=\n match a with\n | .CONST _ => ∅\n | .VAR v => Std.HashSet.instSingleton.singleton v\n | .PLUS a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)\n | .MINUS a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)"
},
{
"name": "fv_bexp",
"content": "@[grind] def fv_bexp (b : bexp) : IdentSet :=\n match b with\n | .TRUE => ∅\n | .FALSE => ∅\n | .EQUAL a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)\n | .LESSEQUAL a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)\n | .NOT b1 => fv_bexp b1\n | .AND b1 b2 => (fv_bexp b1) ∪ (fv_bexp b2)"
},
{
"name": "fv_com",
"content": "@[grind] def fv_com (c : com) : IdentSet :=\n match c with\n | .SKIP => ∅\n | .ASSIGN _ a => fv_aexp a\n | .SEQ c1 c2 => (fv_com c1) ∪ (fv_com c2)\n | .IFTHENELSE b c1 c2 => (fv_bexp b) ∪ ((fv_com c1) ∪ (fv_com c2))\n | .WHILE b c => (fv_bexp b) ∪ (fv_com c)"
},
{
"name": "deadcode_fixpoint_rec",
"content": "@[grind] noncomputable def deadcode_fixpoint_rec (F : IdentSet → IdentSet) (default : IdentSet) (fuel : Nat) (x : IdentSet) : IdentSet :=\n match fuel with\n | 0 => default\n | fuel + 1 =>\n let x' := F x\n if x' ⊆ x then x else deadcode_fixpoint_rec F default fuel x'"
},
{
"name": "deadcode_fixpoint",
"content": "@[grind] noncomputable def deadcode_fixpoint (F : IdentSet → IdentSet) (default : IdentSet) : IdentSet :=\n deadcode_fixpoint_rec F default 20 ∅"
},
{
"name": "live",
"content": "@[grind] noncomputable def live (c : com) (L : IdentSet) : IdentSet :=\n match c with\n | .SKIP => L\n | .ASSIGN x a =>\n if x ∈ L\n then (L.erase x) ∪ (fv_aexp a)\n else L\n | .SEQ c1 c2 =>\n live c1 (live c2 L)\n | .IFTHENELSE b c1 c2 =>\n (fv_bexp b) ∪ ((live c1 L) ∪ (live c2 L))\n | .WHILE b c =>\n let L' := (fv_bexp b) ∪ L\n let default := (fv_com (.WHILE b c)) ∪ L\n deadcode_fixpoint (fun x => L' ∪ (live c x)) default"
},
{
"name": "dce",
"content": "@[grind] noncomputable def dce (c : com) (L : IdentSet) : com :=\n match c with\n | .SKIP => .SKIP\n | .ASSIGN x a => if x ∈ L then .ASSIGN x a else .SKIP\n | .SEQ c1 c2 => .SEQ (dce c1 (live c2 L)) (dce c2 L)\n | .IFTHENELSE b c1 c2 => .IFTHENELSE b (dce c1 L) (dce c2 L)\n | .WHILE b c => .WHILE b (dce c (live (.WHILE b c) L))"
},
{
"name": "agree",
"content": "@[grind] def agree (L : IdentSet) (s1 s2 : store) : Prop :=\n ∀ x, x ∈ L -> s1 x = s2 x"
}
] | [
{
"name": "subset_def",
"content": "@[grind =] theorem subset_def (a b : IdentSet) : a ⊆ b ↔ ∀ x ∈ a, x ∈ b"
},
{
"name": "live_while_charact",
"content": "theorem live_while_charact (b : bexp) (c : com) (L L' : IdentSet)\n (eq : L' = live (.WHILE b c) L) :\n (fv_bexp b) ⊆ L' ∧ L ⊆ L' ∧ (live c L') ⊆ L'"
},
{
"name": "beval_agree",
"content": "theorem beval_agree :\n ∀ L s1 s2, agree L s1 s2 ->\n ∀ b, (fv_bexp b) ⊆ L -> beval s1 b = beval s2 b"
}
] | import LeroyCompilerVerificationCourse.Imp
import Std.Data.HashSet
abbrev IdentSet := Std.HashSet ident
@[grind] def fv_aexp (a : aexp) : IdentSet :=
match a with
| .CONST _ => ∅
| .VAR v => Std.HashSet.instSingleton.singleton v
| .PLUS a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)
| .MINUS a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)
@[grind] def fv_bexp (b : bexp) : IdentSet :=
match b with
| .TRUE => ∅
| .FALSE => ∅
| .EQUAL a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)
| .LESSEQUAL a1 a2 => (fv_aexp a1) ∪ (fv_aexp a2)
| .NOT b1 => fv_bexp b1
| .AND b1 b2 => (fv_bexp b1) ∪ (fv_bexp b2)
@[grind] def fv_com (c : com) : IdentSet :=
match c with
| .SKIP => ∅
| .ASSIGN _ a => fv_aexp a
| .SEQ c1 c2 => (fv_com c1) ∪ (fv_com c2)
| .IFTHENELSE b c1 c2 => (fv_bexp b) ∪ ((fv_com c1) ∪ (fv_com c2))
| .WHILE b c => (fv_bexp b) ∪ (fv_com c)
@[grind] noncomputable def deadcode_fixpoint_rec (F : IdentSet → IdentSet) (default : IdentSet) (fuel : Nat) (x : IdentSet) : IdentSet :=
match fuel with
| 0 => default
| fuel + 1 =>
let x' := F x
if x' ⊆ x then x else deadcode_fixpoint_rec F default fuel x'
@[grind] noncomputable def deadcode_fixpoint (F : IdentSet → IdentSet) (default : IdentSet) : IdentSet :=
deadcode_fixpoint_rec F default 20 ∅
@[grind] noncomputable def live (c : com) (L : IdentSet) : IdentSet :=
match c with
| .SKIP => L
| .ASSIGN x a =>
if x ∈ L
then (L.erase x) ∪ (fv_aexp a)
else L
| .SEQ c1 c2 =>
live c1 (live c2 L)
| .IFTHENELSE b c1 c2 =>
(fv_bexp b) ∪ ((live c1 L) ∪ (live c2 L))
| .WHILE b c =>
let L' := (fv_bexp b) ∪ L
let default := (fv_com (.WHILE b c)) ∪ L
deadcode_fixpoint (fun x => L' ∪ (live c x)) default
@[grind] noncomputable def dce (c : com) (L : IdentSet) : com :=
match c with
| .SKIP => .SKIP
| .ASSIGN x a => if x ∈ L then .ASSIGN x a else .SKIP
| .SEQ c1 c2 => .SEQ (dce c1 (live c2 L)) (dce c2 L)
| .IFTHENELSE b c1 c2 => .IFTHENELSE b (dce c1 L) (dce c2 L)
| .WHILE b c => .WHILE b (dce c (live (.WHILE b c) L))
@[grind] def agree (L : IdentSet) (s1 s2 : store) : Prop :=
∀ x, x ∈ L -> s1 x = s2 x | theorem dce_correct_terminating :
∀ s c s', cexec s c s' ->
∀ L s1, agree (live c L) s s1 ->
∃ s1', cexec s1 (dce c L) s1' /\ agree L s' s1' := | := by
intro s c s' EXEC
induction EXEC
any_goals grind
case cexec_while_loop s1 b c1 s2 s3 isTrue EX1 EX2 a_ih a_ih2 =>
intro L s4 hyp
have ⟨t1, ht1, ht2⟩ := a_ih (live (.WHILE b c1) L) s4 (by grind)
have ⟨u1, hu1, hu2⟩ := a_ih2 L t1 ht2
exists u1
constructor
rotate_right
· exact hu2
· apply cexec.cexec_while_loop
· have := beval_agree (live (com.WHILE b c1) L) s1 s4
grind
· exact ht1
· grind
case cexec_assign s2 x a=>
intro L s3 AG
simp [live] at AG
by_cases x ∈ L
case neg notIn =>
exists s3
grind
case pos isIn =>
exists (update x (aeval s3 a) s3)
grind
case cexec_ifthenelse s2 b c1 c2 s3 EXEC ih =>
intro L s4 AG
simp [dce]
have EQ : beval s2 b = beval s4 b := by
apply beval_agree
· apply AG
· grind
by_cases beval s2 b = true
case pos isTrue =>
specialize ih L s4
grind
case neg isFalse =>
specialize ih L s4
grind
case cexec_while_done s2 b c isFalse =>
intro L s1 AG
have ⟨h1, h2, h3⟩ := live_while_charact b c L (live (com.WHILE b c) L) (by grind)
have EQ : beval s2 b = beval s1 b := by
apply beval_agree
· apply AG
· grind
exists s1
grind
case cexec_seq => grind [-subset_def] -- TODO: what does wrong? | 5 | 38 | false | Compiler |
363 | compile_aexp_correct | theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :
code_at C pc (compile_aexp a) →
transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s) | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
}
] | [
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
}
] | [
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
}
] | [
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
}
] | [
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2 | theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :
code_at C pc (compile_aexp a) →
transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s) := | := by
induction a generalizing C pc stk
next =>
unfold transitions
grind
next =>
intro a
apply star_one
grind
next a1 a2 a1_ih a2_ih =>
simp [aeval, compile_aexp]
intro a
apply star_trans
· apply a1_ih
grind
· apply star_trans
· apply a2_ih
grind
· apply star_one
cases a
next c1 c3 a =>
have h1 := instr_a
have h2 := @transition.trans_add
grind
next a1 a2 a1_ih a2_ih =>
simp [aeval, compile_aexp]
intro a
apply star_trans
· apply a1_ih
grind
· apply star_trans
· apply a2_ih
grind
· apply star_trans
· apply star_one
· apply transition.trans_opp
grind
· apply star_one
· have := @code_at_to_instr_at C pc (compile_aexp a1 ++ compile_aexp a2 ++ [instr.Iopp])
have := @transition.trans_add
grind | 5 | 27 | false | Compiler |
364 | cexec_to_reds | theorem cexec_to_reds (s s' : store) (c : com) : cexec s c s' → star red (c, s) (.SKIP, s') | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Imp.lean | [
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Bool",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
}
] | [
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
}
] | [
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
}
] | [
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp)"
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp)"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com)"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "cexec",
"content": "@[grind] inductive cexec : store → com → store → Prop where\n | cexec_skip :\n cexec s .SKIP s\n | cexec_assign :\n cexec s (.ASSIGN x a) (update x (aeval s a) s)\n | cexec_seq :\n cexec s c1 s' -> cexec s' c2 s'' ->\n cexec s (.SEQ c1 c2) s''\n | cexec_ifthenelse :\n cexec s (if beval s b then c1 else c2) s' ->\n cexec s (.IFTHENELSE b c1 c2) s'\n | cexec_while_done :\n beval s b = false ->\n cexec s (.WHILE b c) s\n | cexec_while_loop :\n beval s b = true -> cexec s c s' -> cexec s' (.WHILE b c) s'' ->\n cexec s (.WHILE b c) s''"
},
{
"name": "red",
"content": "@[grind] inductive red : com × store → com × store → Prop where\n | red_assign : ∀ x a s,\n red (.ASSIGN x a, s) (.SKIP, update x (aeval s a) s)\n | red_seq_done : ∀ c s,\n red (.SEQ .SKIP c, s) (c, s)\n | red_seq_step : ∀ c1 c s1 c2 s2,\n red (c1, s1) (c2, s2) →\n red (.SEQ c1 c, s1) (.SEQ c2 c, s2)\n | red_ifthenelse : ∀ b c1 c2 s,\n red (.IFTHENELSE b c1 c2, s) ((if beval s b then c1 else c2), s)\n | red_while_done : ∀ b c s,\n beval s b = false →\n red (.WHILE b c, s) (.SKIP, s)\n | red_while_loop : ∀ b c s,\n beval s b = true →\n red (.WHILE b c, s) (.SEQ c (.WHILE b c), s)"
}
] | [
{
"name": "red_seq_steps",
"content": "@[grind] theorem red_seq_steps (c2 c c' : com) (s s' : store) : star red (c, s) (c', s') → star red ((c;;c2), s) ((c';;c2), s')"
}
] | import LeroyCompilerVerificationCourse.Sequences
def ident := String deriving BEq, Repr, Hashable
inductive aexp : Type where
| CONST (n : Int)
| VAR (x : ident)
| PLUS (a1 : aexp) (a2 : aexp)
| MINUS (a1 : aexp) (s2 : aexp)
def store : Type := ident → Int
@[grind] def aeval (s : store) (a : aexp) : Int :=
match a with
| .CONST n => n
| .VAR x => s x
| .PLUS a1 a2 => aeval s a1 + aeval s a2
| .MINUS a1 a2 => aeval s a1 - aeval s a2
inductive bexp : Type where
| TRUE
| FALSE
| EQUAL (a1 : aexp) (a2 : aexp)
| LESSEQUAL (a1 : aexp) (a2 : aexp)
| NOT (b1 : bexp)
| AND (b1 : bexp) (b2 : bexp)
@[grind] def beval (s : store) (b : bexp) : Bool :=
match b with
| .TRUE => true
| .FALSE => false
| .EQUAL a1 a2 => aeval s a1 = aeval s a2
| .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2
| .NOT b1 => !(beval s b1)
| .AND b1 b2 => beval s b1 && beval s b2
inductive com : Type where
| SKIP
| ASSIGN (x : ident) (a : aexp)
| SEQ (c1 : com) (c2 : com)
| IFTHENELSE (b : bexp) (c1 : com) (c2 : com)
| WHILE (b : bexp) (c1 : com)
notation:10 l:10 " ;; " r:11 => com.SEQ l r
@[grind] def update (x : ident) (v : Int) (s : store) : store :=
fun y => if x == y then v else s y
@[grind] inductive cexec : store → com → store → Prop where
| cexec_skip :
cexec s .SKIP s
| cexec_assign :
cexec s (.ASSIGN x a) (update x (aeval s a) s)
| cexec_seq :
cexec s c1 s' -> cexec s' c2 s'' ->
cexec s (.SEQ c1 c2) s''
| cexec_ifthenelse :
cexec s (if beval s b then c1 else c2) s' ->
cexec s (.IFTHENELSE b c1 c2) s'
| cexec_while_done :
beval s b = false ->
cexec s (.WHILE b c) s
| cexec_while_loop :
beval s b = true -> cexec s c s' -> cexec s' (.WHILE b c) s'' ->
cexec s (.WHILE b c) s''
@[grind] inductive red : com × store → com × store → Prop where
| red_assign : ∀ x a s,
red (.ASSIGN x a, s) (.SKIP, update x (aeval s a) s)
| red_seq_done : ∀ c s,
red (.SEQ .SKIP c, s) (c, s)
| red_seq_step : ∀ c1 c s1 c2 s2,
red (c1, s1) (c2, s2) →
red (.SEQ c1 c, s1) (.SEQ c2 c, s2)
| red_ifthenelse : ∀ b c1 c2 s,
red (.IFTHENELSE b c1 c2, s) ((if beval s b then c1 else c2), s)
| red_while_done : ∀ b c s,
beval s b = false →
red (.WHILE b c, s) (.SKIP, s)
| red_while_loop : ∀ b c s,
beval s b = true →
red (.WHILE b c, s) (.SEQ c (.WHILE b c), s) | theorem cexec_to_reds (s s' : store) (c : com) : cexec s c s' → star red (c, s) (.SKIP, s') := | := by
intro h
induction h
any_goals grind
case cexec_seq ih1 ih2 =>
apply star_trans
· apply red_seq_steps
exact ih1
· apply star.star_step
apply red.red_seq_done
grind
case cexec_while_loop ih1 ih2 =>
apply star_trans
· apply star_one
· apply red.red_while_loop
· grind
· apply star_trans
· apply red_seq_steps
· exact ih1
· apply star_trans
rotate_left
· apply ih2
· grind | 3 | 20 | false | Compiler |
365 | compile_program_correct_terminating_2 | theorem compile_program_correct_terminating_2 :
∀ c s s',
star step (c, .Kstop, s) (.SKIP, .Kstop, s') ->
machine_terminates (compile_program c) s s' | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Exists",
"module": "Init.Core"
},
{
"name": "Or",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "cont",
"content": "@[grind] inductive cont where\n| Kstop\n| Kseq (c : com) (k : cont)\n| Kwhile (b : bexp) (c : com) (k : cont)"
},
{
"name": "step",
"content": "inductive step : com × cont × store -> com × cont × store -> Prop where\n | step_assign : ∀ x a k s,\n step (.ASSIGN x a, k, s) (.SKIP, k, update x (aeval s a) s)\n \n | step_seq : ∀ c1 c2 s k,\n step (.SEQ c1 c2, k, s) (c1, .Kseq c2 k, s)\n \n | step_ifthenelse : ∀ b c1 c2 k s,\n step (.IFTHENELSE b c1 c2, k, s) ((if beval s b then c1 else c2), k, s)\n \n | step_while_done : ∀ b c k s,\n beval s b = false ->\n step (.WHILE b c, k, s) (.SKIP, k, s)\n \n | step_while_true : ∀ b c k s,\n beval s b = true ->\n step (.WHILE b c, k, s) (c, .Kwhile b c k, s)\n \n | step_skip_seq : ∀ c k s,\n step (.SKIP, .Kseq c k, s) (c, k, s)\n \n | step_skip_while : ∀ b c k s,\n step (.SKIP, .Kwhile b c k, s) (.WHILE b c, k, s)"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "plus",
"content": "@[grind cases]\ninductive plus (R : α → α → Prop) : α → α → Prop where\n| plus_left : ∀ {a b c}, R a b → star R b c → plus R a c\n\n\ngrind_pattern plus.plus_left => star R b c, plus R a c"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Exists.elim",
"module": "Init.Core"
},
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "Or.intro_left",
"module": "Init.Prelude"
},
{
"name": "Or.intro_right",
"module": "Init.Prelude"
}
] | [
{
"name": "plus_star",
"content": "@[grind] theorem plus_star {a b} (h : plus R a b) : star R a b"
},
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
},
{
"name": "plus_right",
"content": "theorem plus_right : star R a b -> R b c -> plus R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "machine_terminates",
"content": "def machine_terminates (C : List instr) (s_init : store) (s_final : store) : Prop :=\n ∃ pc, transitions C (0, [], s_init) (pc, [], s_final)\n ∧ instr_at C pc = .some .Ihalt"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "compile_com",
"content": "@[grind] def compile_com (c : com) : List instr :=\n match c with\n | .SKIP =>\n []\n | .ASSIGN x a =>\n compile_aexp a ++ .Isetvar x :: []\n | .SEQ c1 c2 =>\n compile_com c1 ++ compile_com c2\n | .IFTHENELSE b ifso ifnot =>\n let code_ifso := compile_com ifso\n let code_ifnot := compile_com ifnot\n compile_bexp b 0 (codelen code_ifso + 1)\n ++ code_ifso\n ++ .Ibranch (codelen code_ifnot)\n :: code_ifnot\n | .WHILE b body =>\n let code_body := compile_com body\n let code_test := compile_bexp b 0 (codelen code_body + 1)\n code_test\n ++ code_body\n ++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []"
},
{
"name": "compile_program",
"content": "def compile_program (p : com) : List instr :=\n compile_com p ++ .Ihalt :: []"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
},
{
"name": "compile_cont",
"content": "inductive compile_cont (C : List instr) : cont -> Int -> Prop where\n | ccont_stop : ∀ pc,\n instr_at C pc = .some .Ihalt ->\n compile_cont C .Kstop pc\n | ccont_seq : ∀ c k pc pc',\n code_at C pc (compile_com c) ->\n pc' = pc + codelen (compile_com c) ->\n compile_cont C k pc' ->\n compile_cont C (.Kseq c k) pc\n | ccont_while : ∀ b c k pc d pc' pc'',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n code_at C pc' (compile_com (.WHILE b c)) ->\n pc'' = pc' + codelen (compile_com (.WHILE b c)) ->\n compile_cont C k pc'' ->\n compile_cont C (.Kwhile b c k) pc\n | ccont_branch : ∀ d k pc pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n compile_cont C k pc' ->\n compile_cont C k pc"
},
{
"name": "match_config",
"content": "inductive match_config (C : List instr) : com × cont × store -> config -> Prop where\n | match_config_intro : ∀ c k st pc,\n code_at C pc (compile_com c) ->\n compile_cont C k (pc + codelen (compile_com c)) ->\n match_config C (c, k, st) (pc, [], st)"
},
{
"name": "com_size",
"content": "def com_size (c : com) : Nat :=\n match c with\n | .SKIP => 1\n | .ASSIGN _ _ => 1\n | (c1 ;; c2) => (com_size c1 + com_size c2 + 1)\n | .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)\n | .WHILE _ c1 => (com_size c1 + 1)"
},
{
"name": "cont_size",
"content": "def cont_size (k : cont) : Nat :=\n match k with\n | .Kstop => 0\n | .Kseq c k' => (com_size c + cont_size k')\n | .Kwhile _ _ k' => cont_size k'"
},
{
"name": "measure'",
"content": "def measure' (impconf : com × cont × store) : Nat :=\n match impconf with\n | (c, k, _) => (com_size c + cont_size k)"
}
] | [
{
"name": "codelen_cons",
"content": "@[grind =] theorem codelen_cons :\n ∀ i c, codelen (i :: c) = codelen c + 1"
},
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_app_right",
"content": "@[grind] theorem code_at_app_right :\n ∀ C pc C1 C2,\n code_at C pc (C1 ++ C2) ->\n code_at C (pc + codelen C1) C2"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
},
{
"name": "compile_bexp_correct",
"content": "theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :\n transitions C\n (pc, stk, s)\n (pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s)"
},
{
"name": "compile_cont_Kstop_inv",
"content": "theorem compile_cont_Kstop_inv (C : List instr) (pc : Int) (s : store) :\n compile_cont C .Kstop pc →\n ∃ pc',\n star (transition C) (pc, [], s) (pc', [], s)\n ∧ instr_at C pc' = .some .Ihalt"
},
{
"name": "compile_cont_Kseq_inv",
"content": "theorem compile_cont_Kseq_inv (C : List instr) (c : com) (k :cont) (pc : Int) (s : store) (H : compile_cont C (.Kseq c k) pc) :\n ∃ pc',\n star (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com c)\n ∧ compile_cont C k (pc' + codelen (compile_com c))"
},
{
"name": "compile_cont_Kwhile_inv",
"content": "theorem compile_cont_Kwhile_inv (C : List instr) (b : bexp) (c : com) (k : cont) (pc : Int) (s : store) (H : compile_cont C (.Kwhile b c k) pc) :\n ∃ pc',\n plus (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com (.WHILE b c))\n ∧ compile_cont C k (pc' + codelen (compile_com (.WHILE b c)))"
},
{
"name": "match_config_skip",
"content": "theorem match_config_skip (C : List instr) (k : cont) (s : store) (pc : Int) (H : compile_cont C k pc) :\n match_config C (.SKIP, k, s) (pc, [], s)"
},
{
"name": "simulation_step",
"content": "theorem simulation_step :\n ∀ C impconf1 impconf2 machconf1,\n step impconf1 impconf2 ->\n match_config C impconf1 machconf1 ->\n ∃ machconf2,\n (plus (transition C) machconf1 machconf2\n \\/ (star (transition C) machconf1 machconf2\n /\\ (measure' impconf2 < measure' impconf1)))\n /\\ match_config C impconf2 machconf2"
},
{
"name": "simulation_steps",
"content": "theorem simulation_steps :\n ∀ C impconf1 impconf2, star step impconf1 impconf2 ->\n ∀ machconf1, match_config C impconf1 machconf1 ->\n ∃ machconf2,\n star (transition C) machconf1 machconf2\n /\\ match_config C impconf2 machconf2"
},
{
"name": "match_initial_configs",
"content": "theorem match_initial_configs :\n ∀ c s,\n match_config (compile_program c) (c, .Kstop, s) (0, [], s)"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
def machine_terminates (C : List instr) (s_init : store) (s_final : store) : Prop :=
∃ pc, transitions C (0, [], s_init) (pc, [], s_final)
∧ instr_at C pc = .some .Ihalt
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] def compile_com (c : com) : List instr :=
match c with
| .SKIP =>
[]
| .ASSIGN x a =>
compile_aexp a ++ .Isetvar x :: []
| .SEQ c1 c2 =>
compile_com c1 ++ compile_com c2
| .IFTHENELSE b ifso ifnot =>
let code_ifso := compile_com ifso
let code_ifnot := compile_com ifnot
compile_bexp b 0 (codelen code_ifso + 1)
++ code_ifso
++ .Ibranch (codelen code_ifnot)
:: code_ifnot
| .WHILE b body =>
let code_body := compile_com body
let code_test := compile_bexp b 0 (codelen code_body + 1)
code_test
++ code_body
++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []
def compile_program (p : com) : List instr :=
compile_com p ++ .Ihalt :: []
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2
inductive compile_cont (C : List instr) : cont -> Int -> Prop where
| ccont_stop : ∀ pc,
instr_at C pc = .some .Ihalt ->
compile_cont C .Kstop pc
| ccont_seq : ∀ c k pc pc',
code_at C pc (compile_com c) ->
pc' = pc + codelen (compile_com c) ->
compile_cont C k pc' ->
compile_cont C (.Kseq c k) pc
| ccont_while : ∀ b c k pc d pc' pc'',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
code_at C pc' (compile_com (.WHILE b c)) ->
pc'' = pc' + codelen (compile_com (.WHILE b c)) ->
compile_cont C k pc'' ->
compile_cont C (.Kwhile b c k) pc
| ccont_branch : ∀ d k pc pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
compile_cont C k pc' ->
compile_cont C k pc
inductive match_config (C : List instr) : com × cont × store -> config -> Prop where
| match_config_intro : ∀ c k st pc,
code_at C pc (compile_com c) ->
compile_cont C k (pc + codelen (compile_com c)) ->
match_config C (c, k, st) (pc, [], st)
def com_size (c : com) : Nat :=
match c with
| .SKIP => 1
| .ASSIGN _ _ => 1
| (c1 ;; c2) => (com_size c1 + com_size c2 + 1)
| .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)
| .WHILE _ c1 => (com_size c1 + 1)
def cont_size (k : cont) : Nat :=
match k with
| .Kstop => 0
| .Kseq c k' => (com_size c + cont_size k')
| .Kwhile _ _ k' => cont_size k'
def measure' (impconf : com × cont × store) : Nat :=
match impconf with
| (c, k, _) => (com_size c + cont_size k) | theorem compile_program_correct_terminating_2 :
∀ c s s',
star step (c, .Kstop, s) (.SKIP, .Kstop, s') ->
machine_terminates (compile_program c) s s' := | := by
intro c s s' STAR
generalize heq : compile_program c = C
have ⟨ ms, A, B ⟩ := simulation_steps C (c, cont.Kstop, s) (com.SKIP, cont.Kstop, s') STAR (0, [], s) (by grind [match_initial_configs])
cases B
case match_config_intro pc w1 w2 =>
have ⟨pc', D, E ⟩ := compile_cont_Kstop_inv C (pc + codelen (compile_com com.SKIP)) s' w2
exists pc'
constructor
· apply star_trans
· exact A
· simp [compile_com, codelen] at D
exact D
· exact E | 5 | 70 | false | Compiler |
366 | simulation_steps | theorem simulation_steps :
∀ C impconf1 impconf2, star step impconf1 impconf2 ->
∀ machconf1, match_config C impconf1 machconf1 ->
∃ machconf2,
star (transition C) machconf1 machconf2
/\ match_config C impconf2 machconf2 | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Exists",
"module": "Init.Core"
},
{
"name": "Or",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "cont",
"content": "@[grind] inductive cont where\n| Kstop\n| Kseq (c : com) (k : cont)\n| Kwhile (b : bexp) (c : com) (k : cont)"
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "step",
"content": "inductive step : com × cont × store -> com × cont × store -> Prop where\n | step_assign : ∀ x a k s,\n step (.ASSIGN x a, k, s) (.SKIP, k, update x (aeval s a) s)\n \n | step_seq : ∀ c1 c2 s k,\n step (.SEQ c1 c2, k, s) (c1, .Kseq c2 k, s)\n \n | step_ifthenelse : ∀ b c1 c2 k s,\n step (.IFTHENELSE b c1 c2, k, s) ((if beval s b then c1 else c2), k, s)\n \n | step_while_done : ∀ b c k s,\n beval s b = false ->\n step (.WHILE b c, k, s) (.SKIP, k, s)\n \n | step_while_true : ∀ b c k s,\n beval s b = true ->\n step (.WHILE b c, k, s) (c, .Kwhile b c k, s)\n \n | step_skip_seq : ∀ c k s,\n step (.SKIP, .Kseq c k, s) (c, k, s)\n \n | step_skip_while : ∀ b c k s,\n step (.SKIP, .Kwhile b c k, s) (.WHILE b c, k, s)"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "plus",
"content": "@[grind cases]\ninductive plus (R : α → α → Prop) : α → α → Prop where\n| plus_left : ∀ {a b c}, R a b → star R b c → plus R a c\n\n\ngrind_pattern plus.plus_left => star R b c, plus R a c"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Exists.elim",
"module": "Init.Core"
},
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "Or.intro_left",
"module": "Init.Prelude"
},
{
"name": "Or.intro_right",
"module": "Init.Prelude"
}
] | [
{
"name": "plus_star",
"content": "@[grind] theorem plus_star {a b} (h : plus R a b) : star R a b"
},
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
},
{
"name": "plus_right",
"content": "theorem plus_right : star R a b -> R b c -> plus R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "compile_com",
"content": "@[grind] def compile_com (c : com) : List instr :=\n match c with\n | .SKIP =>\n []\n | .ASSIGN x a =>\n compile_aexp a ++ .Isetvar x :: []\n | .SEQ c1 c2 =>\n compile_com c1 ++ compile_com c2\n | .IFTHENELSE b ifso ifnot =>\n let code_ifso := compile_com ifso\n let code_ifnot := compile_com ifnot\n compile_bexp b 0 (codelen code_ifso + 1)\n ++ code_ifso\n ++ .Ibranch (codelen code_ifnot)\n :: code_ifnot\n | .WHILE b body =>\n let code_body := compile_com body\n let code_test := compile_bexp b 0 (codelen code_body + 1)\n code_test\n ++ code_body\n ++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
},
{
"name": "compile_cont",
"content": "inductive compile_cont (C : List instr) : cont -> Int -> Prop where\n | ccont_stop : ∀ pc,\n instr_at C pc = .some .Ihalt ->\n compile_cont C .Kstop pc\n | ccont_seq : ∀ c k pc pc',\n code_at C pc (compile_com c) ->\n pc' = pc + codelen (compile_com c) ->\n compile_cont C k pc' ->\n compile_cont C (.Kseq c k) pc\n | ccont_while : ∀ b c k pc d pc' pc'',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n code_at C pc' (compile_com (.WHILE b c)) ->\n pc'' = pc' + codelen (compile_com (.WHILE b c)) ->\n compile_cont C k pc'' ->\n compile_cont C (.Kwhile b c k) pc\n | ccont_branch : ∀ d k pc pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n compile_cont C k pc' ->\n compile_cont C k pc"
},
{
"name": "match_config",
"content": "inductive match_config (C : List instr) : com × cont × store -> config -> Prop where\n | match_config_intro : ∀ c k st pc,\n code_at C pc (compile_com c) ->\n compile_cont C k (pc + codelen (compile_com c)) ->\n match_config C (c, k, st) (pc, [], st)"
},
{
"name": "com_size",
"content": "def com_size (c : com) : Nat :=\n match c with\n | .SKIP => 1\n | .ASSIGN _ _ => 1\n | (c1 ;; c2) => (com_size c1 + com_size c2 + 1)\n | .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)\n | .WHILE _ c1 => (com_size c1 + 1)"
},
{
"name": "cont_size",
"content": "def cont_size (k : cont) : Nat :=\n match k with\n | .Kstop => 0\n | .Kseq c k' => (com_size c + cont_size k')\n | .Kwhile _ _ k' => cont_size k'"
},
{
"name": "measure'",
"content": "def measure' (impconf : com × cont × store) : Nat :=\n match impconf with\n | (c, k, _) => (com_size c + cont_size k)"
}
] | [
{
"name": "codelen_cons",
"content": "@[grind =] theorem codelen_cons :\n ∀ i c, codelen (i :: c) = codelen c + 1"
},
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_app_right",
"content": "@[grind] theorem code_at_app_right :\n ∀ C pc C1 C2,\n code_at C pc (C1 ++ C2) ->\n code_at C (pc + codelen C1) C2"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
},
{
"name": "compile_bexp_correct",
"content": "theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :\n transitions C\n (pc, stk, s)\n (pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s)"
},
{
"name": "compile_cont_Kseq_inv",
"content": "theorem compile_cont_Kseq_inv (C : List instr) (c : com) (k :cont) (pc : Int) (s : store) (H : compile_cont C (.Kseq c k) pc) :\n ∃ pc',\n star (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com c)\n ∧ compile_cont C k (pc' + codelen (compile_com c))"
},
{
"name": "compile_cont_Kwhile_inv",
"content": "theorem compile_cont_Kwhile_inv (C : List instr) (b : bexp) (c : com) (k : cont) (pc : Int) (s : store) (H : compile_cont C (.Kwhile b c k) pc) :\n ∃ pc',\n plus (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com (.WHILE b c))\n ∧ compile_cont C k (pc' + codelen (compile_com (.WHILE b c)))"
},
{
"name": "match_config_skip",
"content": "theorem match_config_skip (C : List instr) (k : cont) (s : store) (pc : Int) (H : compile_cont C k pc) :\n match_config C (.SKIP, k, s) (pc, [], s)"
},
{
"name": "simulation_step",
"content": "theorem simulation_step :\n ∀ C impconf1 impconf2 machconf1,\n step impconf1 impconf2 ->\n match_config C impconf1 machconf1 ->\n ∃ machconf2,\n (plus (transition C) machconf1 machconf2\n \\/ (star (transition C) machconf1 machconf2\n /\\ (measure' impconf2 < measure' impconf1)))\n /\\ match_config C impconf2 machconf2"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] def compile_com (c : com) : List instr :=
match c with
| .SKIP =>
[]
| .ASSIGN x a =>
compile_aexp a ++ .Isetvar x :: []
| .SEQ c1 c2 =>
compile_com c1 ++ compile_com c2
| .IFTHENELSE b ifso ifnot =>
let code_ifso := compile_com ifso
let code_ifnot := compile_com ifnot
compile_bexp b 0 (codelen code_ifso + 1)
++ code_ifso
++ .Ibranch (codelen code_ifnot)
:: code_ifnot
| .WHILE b body =>
let code_body := compile_com body
let code_test := compile_bexp b 0 (codelen code_body + 1)
code_test
++ code_body
++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2
inductive compile_cont (C : List instr) : cont -> Int -> Prop where
| ccont_stop : ∀ pc,
instr_at C pc = .some .Ihalt ->
compile_cont C .Kstop pc
| ccont_seq : ∀ c k pc pc',
code_at C pc (compile_com c) ->
pc' = pc + codelen (compile_com c) ->
compile_cont C k pc' ->
compile_cont C (.Kseq c k) pc
| ccont_while : ∀ b c k pc d pc' pc'',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
code_at C pc' (compile_com (.WHILE b c)) ->
pc'' = pc' + codelen (compile_com (.WHILE b c)) ->
compile_cont C k pc'' ->
compile_cont C (.Kwhile b c k) pc
| ccont_branch : ∀ d k pc pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
compile_cont C k pc' ->
compile_cont C k pc
inductive match_config (C : List instr) : com × cont × store -> config -> Prop where
| match_config_intro : ∀ c k st pc,
code_at C pc (compile_com c) ->
compile_cont C k (pc + codelen (compile_com c)) ->
match_config C (c, k, st) (pc, [], st)
def com_size (c : com) : Nat :=
match c with
| .SKIP => 1
| .ASSIGN _ _ => 1
| (c1 ;; c2) => (com_size c1 + com_size c2 + 1)
| .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)
| .WHILE _ c1 => (com_size c1 + 1)
def cont_size (k : cont) : Nat :=
match k with
| .Kstop => 0
| .Kseq c k' => (com_size c + cont_size k')
| .Kwhile _ _ k' => cont_size k'
def measure' (impconf : com × cont × store) : Nat :=
match impconf with
| (c, k, _) => (com_size c + cont_size k) | theorem simulation_steps :
∀ C impconf1 impconf2, star step impconf1 impconf2 ->
∀ machconf1, match_config C impconf1 machconf1 ->
∃ machconf2,
star (transition C) machconf1 machconf2
/\ match_config C impconf2 machconf2 := | := by
intro C impconf1 impconf2 STAR machconf1 MATCH
induction STAR generalizing machconf1
case star_refl x =>
exists machconf1
constructor
· apply star.star_refl
· exact MATCH
case star_step x y z STEP STAR ih =>
have ⟨ machconf2, steps2, match2 ⟩ := simulation_step C x y machconf1 STEP MATCH
specialize ih machconf2 match2
rcases ih with ⟨ machconf3, steps3, match3⟩
exists machconf3
have w : star (transition C) machconf1 machconf2 := by
cases steps2
case inl h =>
apply plus_star
exact h
case inr h =>
exact h.1
constructor
· apply star_trans
· exact w
· exact steps3
· exact match3 | 5 | 65 | false | Compiler |
367 | fixpoint_join_sound | theorem fixpoint_join_sound : Le Init (fixpoint_join Init F) /\ Le (F (fixpoint_join Init F)) (fixpoint_join Init F) | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Fixpoints.lean | [
"import LeroyCompilerVerificationCourse.Constprop",
"import LeroyCompilerVerificationCourse.Imp",
"import Batteries.Data.List.Perm"
] | [
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "k",
"module": "QqTest.matching"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Equiv",
"module": "Mathlib.Logic.Equiv.Defs"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "WellFounded",
"module": "Init.WF"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Std.HashMap.Equiv.getElem?_eq",
"module": "Std.Data.HashMap.Lemmas"
}
] | [
{
"name": "Equal_Le",
"content": "theorem Equal_Le : ∀ S1 S2, Equal S1 S2 -> Le S1 S2"
},
{
"name": "Le_Join_l",
"content": "theorem Le_Join_l : ∀ S1 S2, Le S1 (Join S1 S2)"
},
{
"name": "Le_Join_r",
"content": "theorem Le_Join_r : ∀ S1 S2, Le S2 (Join S1 S2)"
}
] | [
{
"name": "OrderStruct",
"content": "@[grind] class OrderStruct (α : Sort u) where\n eq : α → α → Prop\n le : α → α → Prop\n beq : α → α → Bool\n le_trans : ∀ x y z, le x y -> le y z -> le x z\n beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/"
},
{
"name": "Monotone",
"content": "class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where\n F_mon : ∀ {x y : α}, le x y → le (F x) (F y)"
},
{
"name": "iterate",
"content": "@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=\n if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/\n ) (by admit /- proof elided -/\n )\n termination_by x\n decreasing_by\n grind [beq_false']"
},
{
"name": "Eq'",
"content": "@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2"
},
{
"name": "Eq'_sym",
"content": "def Eq'_sym : ∀ S1 S2, Eq' S1 S2 → Eq' S2 S1 :="
},
{
"name": "_inst_OrderStruct",
"content": "noncomputable instance : OrderStruct Store where\n eq := Equal\n le := Le\n beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)\n le_trans := Le_trans\n gt_wf := Gt_wf"
},
{
"name": "_inst_Monotone",
"content": "instance : Monotone Store (fun x => Join Init (F x)) where\n F_mon := by admit /- proof elided -/"
},
{
"name": "fixpoint_join",
"content": "noncomputable def fixpoint_join : Store :="
}
] | [
{
"name": "iterate_correct",
"content": "@[grind] theorem iterate_correct (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) (heq : y = iterate _ F x PRE SMALL ) : eq y (F y) ∧ ∀ z, le (F z) z → le y z"
},
{
"name": "Eq_Le",
"content": "@[grind] theorem Eq_Le : ∀ S1 S2, Eq' S1 S2 → Le S1 S2"
},
{
"name": "Le_trans",
"content": "@[grind] theorem Le_trans : ∀ S1 S2 S3, Le S1 S2 → Le S2 S3 → Le S1 S3"
},
{
"name": "fixpoint_join_eq",
"content": "theorem fixpoint_join_eq : Eq' (Join Init (F (fixpoint_join Init F) )) (fixpoint_join Init F)"
}
] | import LeroyCompilerVerificationCourse.Imp
import LeroyCompilerVerificationCourse.Constprop
import Batteries.Data.List.Perm
@[grind] class OrderStruct (α : Sort u) where
eq : α → α → Prop
le : α → α → Prop
beq : α → α → Bool
le_trans : ∀ x y z, le x y -> le y z -> le x z
beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/
open OrderStruct
class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where
F_mon : ∀ {x y : α}, le x y → le (F x) (F y)
open Monotone
section FixpointExistence
variable (α : Sort u) (F : α → α) [OrderWithBot α]
open OrderStruct OrderWithBot
end FixpointExistence
section Iterate
variable (α : Sort u) [inst : OrderStruct α] (F : α → α) [Monotone α F]
open OrderStruct
@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=
if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/
) (by admit /- proof elided -/
)
termination_by x
decreasing_by
grind [beq_false']
end Iterate
section Fixpoint
open OrderWithBot
variable {α : Sort u} [i : OrderWithBot α] (F : α → α) [Monotone α F]
end Fixpoint
section Constprop
open Std.HashMap
@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2
def Eq'_sym : ∀ S1 S2, Eq' S1 S2 → Eq' S2 S1 :=
open OrderStruct
noncomputable instance : OrderStruct Store where
eq := Equal
le := Le
beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)
le_trans := Le_trans
gt_wf := Gt_wf
end Constprop
section FixpointJoin
variable (Init : Store)
variable (F : Store → Store) [Monotone Store F]
instance : Monotone Store (fun x => Join Init (F x)) where
F_mon := by admit /- proof elided -/
noncomputable def fixpoint_join : Store := | theorem fixpoint_join_sound : Le Init (fixpoint_join Init F) /\ Le (F (fixpoint_join Init F)) (fixpoint_join Init F) := | := by
have LE : Le (Join Init (F (fixpoint_join Init F))) (fixpoint_join Init F) := by
apply Eq_Le
apply fixpoint_join_eq
constructor
· apply Le_trans
rotate_left
· exact LE
· apply Le_Join_l
· apply Le_trans
rotate_left
· exact LE
· apply Le_Join_r | 4 | 22 | false | Compiler |
368 | compile_program_correct_diverging | theorem compile_program_correct_diverging :
∀ c s,
infseq step (c, .Kstop, s) ->
machine_diverges (compile_program c) s | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Exists",
"module": "Init.Core"
},
{
"name": "Or",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "cont",
"content": "@[grind] inductive cont where\n| Kstop\n| Kseq (c : com) (k : cont)\n| Kwhile (b : bexp) (c : com) (k : cont)"
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "infseq",
"content": "def infseq {α} (R : α → α → Prop) : α → Prop :=\n λ x : α => ∃ y, R x y ∧ infseq R y\n coinductive_fixpoint"
},
{
"name": "step",
"content": "inductive step : com × cont × store -> com × cont × store -> Prop where\n | step_assign : ∀ x a k s,\n step (.ASSIGN x a, k, s) (.SKIP, k, update x (aeval s a) s)\n \n | step_seq : ∀ c1 c2 s k,\n step (.SEQ c1 c2, k, s) (c1, .Kseq c2 k, s)\n \n | step_ifthenelse : ∀ b c1 c2 k s,\n step (.IFTHENELSE b c1 c2, k, s) ((if beval s b then c1 else c2), k, s)\n \n | step_while_done : ∀ b c k s,\n beval s b = false ->\n step (.WHILE b c, k, s) (.SKIP, k, s)\n \n | step_while_true : ∀ b c k s,\n beval s b = true ->\n step (.WHILE b c, k, s) (c, .Kwhile b c k, s)\n \n | step_skip_seq : ∀ c k s,\n step (.SKIP, .Kseq c k, s) (c, k, s)\n \n | step_skip_while : ∀ b c k s,\n step (.SKIP, .Kwhile b c k, s) (.WHILE b c, k, s)"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "plus",
"content": "@[grind cases]\ninductive plus (R : α → α → Prop) : α → α → Prop where\n| plus_left : ∀ {a b c}, R a b → star R b c → plus R a c\n\n\ngrind_pattern plus.plus_left => star R b c, plus R a c"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Exists.elim",
"module": "Init.Core"
},
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "Or.intro_left",
"module": "Init.Prelude"
},
{
"name": "Or.intro_right",
"module": "Init.Prelude"
}
] | [
{
"name": "plus_star",
"content": "@[grind] theorem plus_star {a b} (h : plus R a b) : star R a b"
},
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
},
{
"name": "plus_right",
"content": "theorem plus_right : star R a b -> R b c -> plus R a c"
},
{
"name": "star_plus_trans",
"content": "theorem star_plus_trans :\n ∀ a b c, star R a b -> plus R b c -> plus R a c"
},
{
"name": "infseq_coinduction_principle_2",
"content": "theorem infseq_coinduction_principle_2\n (X : α → Prop) (h₁ : ∀ (a : α), X a → ∃ b, plus R a b ∧ X b) (a : α) (rel : X a) : infseq R a"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "machine_diverges",
"content": "def machine_diverges (C : List instr) (s_init : store) : Prop :=\n infseq (transition C) (0, [], s_init)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "compile_com",
"content": "@[grind] def compile_com (c : com) : List instr :=\n match c with\n | .SKIP =>\n []\n | .ASSIGN x a =>\n compile_aexp a ++ .Isetvar x :: []\n | .SEQ c1 c2 =>\n compile_com c1 ++ compile_com c2\n | .IFTHENELSE b ifso ifnot =>\n let code_ifso := compile_com ifso\n let code_ifnot := compile_com ifnot\n compile_bexp b 0 (codelen code_ifso + 1)\n ++ code_ifso\n ++ .Ibranch (codelen code_ifnot)\n :: code_ifnot\n | .WHILE b body =>\n let code_body := compile_com body\n let code_test := compile_bexp b 0 (codelen code_body + 1)\n code_test\n ++ code_body\n ++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []"
},
{
"name": "compile_program",
"content": "def compile_program (p : com) : List instr :=\n compile_com p ++ .Ihalt :: []"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
},
{
"name": "compile_cont",
"content": "inductive compile_cont (C : List instr) : cont -> Int -> Prop where\n | ccont_stop : ∀ pc,\n instr_at C pc = .some .Ihalt ->\n compile_cont C .Kstop pc\n | ccont_seq : ∀ c k pc pc',\n code_at C pc (compile_com c) ->\n pc' = pc + codelen (compile_com c) ->\n compile_cont C k pc' ->\n compile_cont C (.Kseq c k) pc\n | ccont_while : ∀ b c k pc d pc' pc'',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n code_at C pc' (compile_com (.WHILE b c)) ->\n pc'' = pc' + codelen (compile_com (.WHILE b c)) ->\n compile_cont C k pc'' ->\n compile_cont C (.Kwhile b c k) pc\n | ccont_branch : ∀ d k pc pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n compile_cont C k pc' ->\n compile_cont C k pc"
},
{
"name": "match_config",
"content": "inductive match_config (C : List instr) : com × cont × store -> config -> Prop where\n | match_config_intro : ∀ c k st pc,\n code_at C pc (compile_com c) ->\n compile_cont C k (pc + codelen (compile_com c)) ->\n match_config C (c, k, st) (pc, [], st)"
},
{
"name": "com_size",
"content": "def com_size (c : com) : Nat :=\n match c with\n | .SKIP => 1\n | .ASSIGN _ _ => 1\n | (c1 ;; c2) => (com_size c1 + com_size c2 + 1)\n | .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)\n | .WHILE _ c1 => (com_size c1 + 1)"
},
{
"name": "cont_size",
"content": "def cont_size (k : cont) : Nat :=\n match k with\n | .Kstop => 0\n | .Kseq c k' => (com_size c + cont_size k')\n | .Kwhile _ _ k' => cont_size k'"
},
{
"name": "measure'",
"content": "def measure' (impconf : com × cont × store) : Nat :=\n match impconf with\n | (c, k, _) => (com_size c + cont_size k)"
}
] | [
{
"name": "codelen_cons",
"content": "@[grind =] theorem codelen_cons :\n ∀ i c, codelen (i :: c) = codelen c + 1"
},
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_app_right",
"content": "@[grind] theorem code_at_app_right :\n ∀ C pc C1 C2,\n code_at C pc (C1 ++ C2) ->\n code_at C (pc + codelen C1) C2"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
},
{
"name": "compile_bexp_correct",
"content": "theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :\n transitions C\n (pc, stk, s)\n (pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s)"
},
{
"name": "compile_cont_Kseq_inv",
"content": "theorem compile_cont_Kseq_inv (C : List instr) (c : com) (k :cont) (pc : Int) (s : store) (H : compile_cont C (.Kseq c k) pc) :\n ∃ pc',\n star (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com c)\n ∧ compile_cont C k (pc' + codelen (compile_com c))"
},
{
"name": "compile_cont_Kwhile_inv",
"content": "theorem compile_cont_Kwhile_inv (C : List instr) (b : bexp) (c : com) (k : cont) (pc : Int) (s : store) (H : compile_cont C (.Kwhile b c k) pc) :\n ∃ pc',\n plus (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com (.WHILE b c))\n ∧ compile_cont C k (pc' + codelen (compile_com (.WHILE b c)))"
},
{
"name": "match_config_skip",
"content": "theorem match_config_skip (C : List instr) (k : cont) (s : store) (pc : Int) (H : compile_cont C k pc) :\n match_config C (.SKIP, k, s) (pc, [], s)"
},
{
"name": "simulation_step",
"content": "theorem simulation_step :\n ∀ C impconf1 impconf2 machconf1,\n step impconf1 impconf2 ->\n match_config C impconf1 machconf1 ->\n ∃ machconf2,\n (plus (transition C) machconf1 machconf2\n \\/ (star (transition C) machconf1 machconf2\n /\\ (measure' impconf2 < measure' impconf1)))\n /\\ match_config C impconf2 machconf2"
},
{
"name": "match_initial_configs",
"content": "theorem match_initial_configs :\n ∀ c s,\n match_config (compile_program c) (c, .Kstop, s) (0, [], s)"
},
{
"name": "simulation_infseq_inv",
"content": "theorem simulation_infseq_inv :\n ∀ C n impconf1 machconf1,\n infseq step impconf1 -> match_config C impconf1 machconf1 ->\n (measure' impconf1 < n) ->\n ∃ impconf2 machconf2,\n infseq step impconf2\n /\\ plus (transition C) machconf1 machconf2\n /\\ match_config C impconf2 machconf2"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
def machine_diverges (C : List instr) (s_init : store) : Prop :=
infseq (transition C) (0, [], s_init)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] def compile_com (c : com) : List instr :=
match c with
| .SKIP =>
[]
| .ASSIGN x a =>
compile_aexp a ++ .Isetvar x :: []
| .SEQ c1 c2 =>
compile_com c1 ++ compile_com c2
| .IFTHENELSE b ifso ifnot =>
let code_ifso := compile_com ifso
let code_ifnot := compile_com ifnot
compile_bexp b 0 (codelen code_ifso + 1)
++ code_ifso
++ .Ibranch (codelen code_ifnot)
:: code_ifnot
| .WHILE b body =>
let code_body := compile_com body
let code_test := compile_bexp b 0 (codelen code_body + 1)
code_test
++ code_body
++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []
def compile_program (p : com) : List instr :=
compile_com p ++ .Ihalt :: []
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2
inductive compile_cont (C : List instr) : cont -> Int -> Prop where
| ccont_stop : ∀ pc,
instr_at C pc = .some .Ihalt ->
compile_cont C .Kstop pc
| ccont_seq : ∀ c k pc pc',
code_at C pc (compile_com c) ->
pc' = pc + codelen (compile_com c) ->
compile_cont C k pc' ->
compile_cont C (.Kseq c k) pc
| ccont_while : ∀ b c k pc d pc' pc'',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
code_at C pc' (compile_com (.WHILE b c)) ->
pc'' = pc' + codelen (compile_com (.WHILE b c)) ->
compile_cont C k pc'' ->
compile_cont C (.Kwhile b c k) pc
| ccont_branch : ∀ d k pc pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
compile_cont C k pc' ->
compile_cont C k pc
inductive match_config (C : List instr) : com × cont × store -> config -> Prop where
| match_config_intro : ∀ c k st pc,
code_at C pc (compile_com c) ->
compile_cont C k (pc + codelen (compile_com c)) ->
match_config C (c, k, st) (pc, [], st)
def com_size (c : com) : Nat :=
match c with
| .SKIP => 1
| .ASSIGN _ _ => 1
| (c1 ;; c2) => (com_size c1 + com_size c2 + 1)
| .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)
| .WHILE _ c1 => (com_size c1 + 1)
def cont_size (k : cont) : Nat :=
match k with
| .Kstop => 0
| .Kseq c k' => (com_size c + cont_size k')
| .Kwhile _ _ k' => cont_size k'
def measure' (impconf : com × cont × store) : Nat :=
match impconf with
| (c, k, _) => (com_size c + cont_size k) | theorem compile_program_correct_diverging :
∀ c s,
infseq step (c, .Kstop, s) ->
machine_diverges (compile_program c) s := | := by
intro c s H
generalize heq : compile_program c = C
unfold machine_diverges
apply infseq_coinduction_principle_2 (fun machconf => ∃ impconf, infseq step impconf /\ match_config C impconf machconf)
rotate_left
· exists (c, .Kstop, s)
constructor
· exact H
· have := match_initial_configs c s
grind
· intro machconf ⟨ impconf , ⟨INFSEQ, MATCH ⟩⟩
have ⟨impconf2 , machconf2, INFSEQ2 , PLUS , MATCH2⟩ := simulation_infseq_inv C (measure' impconf +1) impconf machconf INFSEQ MATCH (by omega)
exists machconf2
constructor
· exact PLUS
· exists impconf2 | 5 | 72 | false | Compiler |
369 | simulation_infseq_inv | theorem simulation_infseq_inv :
∀ C n impconf1 machconf1,
infseq step impconf1 -> match_config C impconf1 machconf1 ->
(measure' impconf1 < n) ->
∃ impconf2 machconf2,
infseq step impconf2
/\ plus (transition C) machconf1 machconf2
/\ match_config C impconf2 machconf2 | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Compil.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import LeroyCompilerVerificationCourse.Sequences"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "BitVec",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Exists",
"module": "Init.Core"
},
{
"name": "Or",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "cont",
"content": "@[grind] inductive cont where\n| Kstop\n| Kseq (c : com) (k : cont)\n| Kwhile (b : bexp) (c : com) (k : cont)"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "store",
"content": "def store : Type := ident → Int"
},
{
"name": "update",
"content": "@[grind] def update (x : ident) (v : Int) (s : store) : store :=\n fun y => if x == y then v else s y"
},
{
"name": "plus",
"content": "@[grind cases]\ninductive plus (R : α → α → Prop) : α → α → Prop where\n| plus_left : ∀ {a b c}, R a b → star R b c → plus R a c\n\n\ngrind_pattern plus.plus_left => star R b c, plus R a c"
},
{
"name": "star",
"content": "@[grind] inductive star (R : α → α → Prop) : α → α → Prop where\n | star_refl : ∀ x : α, star R x x\n | star_step : ∀ {x y z}, R x y → star R y z → star R x z"
},
{
"name": "infseq",
"content": "def infseq {α} (R : α → α → Prop) : α → Prop :=\n λ x : α => ∃ y, R x y ∧ infseq R y\n coinductive_fixpoint"
},
{
"name": "step",
"content": "inductive step : com × cont × store -> com × cont × store -> Prop where\n | step_assign : ∀ x a k s,\n step (.ASSIGN x a, k, s) (.SKIP, k, update x (aeval s a) s)\n \n | step_seq : ∀ c1 c2 s k,\n step (.SEQ c1 c2, k, s) (c1, .Kseq c2 k, s)\n \n | step_ifthenelse : ∀ b c1 c2 k s,\n step (.IFTHENELSE b c1 c2, k, s) ((if beval s b then c1 else c2), k, s)\n \n | step_while_done : ∀ b c k s,\n beval s b = false ->\n step (.WHILE b c, k, s) (.SKIP, k, s)\n \n | step_while_true : ∀ b c k s,\n beval s b = true ->\n step (.WHILE b c, k, s) (c, .Kwhile b c k, s)\n \n | step_skip_seq : ∀ c k s,\n step (.SKIP, .Kseq c k, s) (c, k, s)\n \n | step_skip_while : ∀ b c k s,\n step (.SKIP, .Kwhile b c k, s) (.WHILE b c, k, s)"
},
{
"name": "aeval",
"content": "@[grind] def aeval (s : store) (a : aexp) : Int :=\n match a with\n | .CONST n => n\n | .VAR x => s x\n | .PLUS a1 a2 => aeval s a1 + aeval s a2\n | .MINUS a1 a2 => aeval s a1 - aeval s a2"
},
{
"name": "beval",
"content": "@[grind] def beval (s : store) (b : bexp) : Bool :=\n match b with\n | .TRUE => true\n | .FALSE => false\n | .EQUAL a1 a2 => aeval s a1 = aeval s a2\n | .LESSEQUAL a1 a2 => aeval s a1 <= aeval s a2\n | .NOT b1 => !(beval s b1)\n | .AND b1 b2 => beval s b1 && beval s b2"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "Exists.elim",
"module": "Init.Core"
},
{
"name": "star_one",
"module": "Mathlib.Algebra.Star.Basic"
},
{
"name": "Int.add_assoc",
"module": "Init.Data.Int.Lemmas"
},
{
"name": "Or.intro_left",
"module": "Init.Prelude"
},
{
"name": "Or.intro_right",
"module": "Init.Prelude"
}
] | [
{
"name": "plus_star",
"content": "@[grind] theorem plus_star {a b} (h : plus R a b) : star R a b"
},
{
"name": "star_trans",
"content": "@[grind] theorem star_trans {α} (R : α → α → Prop) (a b : α) (sab : star R a b) : ∀ c : α, star R b c → star R a c"
},
{
"name": "plus_right",
"content": "theorem plus_right : star R a b -> R b c -> plus R a c"
},
{
"name": "star_plus_trans",
"content": "theorem star_plus_trans :\n ∀ a b c, star R a b -> plus R b c -> plus R a c"
}
] | [
{
"name": "instr",
"content": "@[grind] inductive instr : Type where\n | Iconst (n : Int) \n | Ivar (x : ident) \n | Isetvar (x : ident) \n | Iadd \n | Iopp \n | Ibranch (d : Int) \n | Ibeq (d1 : Int) (d0 : Int) \n | Ible (d1 : Int) (d0 : Int) \n | Ihalt \n deriving Repr"
},
{
"name": "codelen",
"content": "@[grind] def codelen (c : List instr) : Int := c.length"
},
{
"name": "stack",
"content": "def stack : Type := List Int"
},
{
"name": "config",
"content": "def config : Type := Int × stack × store"
},
{
"name": "instr_at",
"content": "@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=\n match C with\n | [] => .none\n | i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)"
},
{
"name": "transition",
"content": "@[grind] inductive transition (C : List instr) : config → config → Prop where\n | trans_const : ∀ pc stk s n,\n instr_at C pc = .some (.Iconst n) →\n transition C (pc , stk , s)\n (pc + 1, n :: stk, s)\n | trans_var : ∀ pc stk s x,\n instr_at C pc = .some (.Ivar x) ->\n transition C (pc , stk , s)\n (pc + 1, s x :: stk, s)\n | trans_setvar : ∀ pc stk s x n,\n instr_at C pc = .some (.Isetvar x) ->\n transition C (pc , n :: stk, s)\n (pc + 1, stk , update x n s)\n | trans_add : ∀ pc stk s n1 n2,\n instr_at C pc = .some (.Iadd) ->\n transition C (pc , n2 :: n1 :: stk , s)\n (pc + 1, (n1 + n2) :: stk, s)\n | trans_opp : ∀ pc stk s n,\n instr_at C pc = .some (.Iopp) ->\n transition C (pc , n :: stk , s)\n (pc + 1, (- n) :: stk, s)\n | trans_branch : ∀ pc stk s d pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n transition C (pc , stk, s)\n (pc', stk, s)\n | trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ibeq d1 d0) ->\n pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)\n | trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',\n instr_at C pc = .some (.Ible d1 d0) ->\n pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->\n transition C (pc , n2 :: n1 :: stk, s)\n (pc', stk , s)"
},
{
"name": "transitions",
"content": "@[grind] def transitions (C : List instr) : config → config → Prop :=\n star (transition C)"
},
{
"name": "compile_aexp",
"content": "@[grind] def compile_aexp (a : aexp) : List instr :=\n match a with\n | .CONST n => .Iconst n :: []\n | .VAR x => .Ivar x :: []\n | .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])\n | .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])"
},
{
"name": "compile_bexp",
"content": "@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=\n match b with\n | .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []\n | .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []\n | .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []\n | .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []\n | .NOT b1 => compile_bexp b1 d0 d1\n | .AND b1 b2 =>\n let code2 := compile_bexp b2 d1 d0\n let code1 := compile_bexp b1 0 (codelen code2 + d0)\n code1 ++ code2"
},
{
"name": "compile_com",
"content": "@[grind] def compile_com (c : com) : List instr :=\n match c with\n | .SKIP =>\n []\n | .ASSIGN x a =>\n compile_aexp a ++ .Isetvar x :: []\n | .SEQ c1 c2 =>\n compile_com c1 ++ compile_com c2\n | .IFTHENELSE b ifso ifnot =>\n let code_ifso := compile_com ifso\n let code_ifnot := compile_com ifnot\n compile_bexp b 0 (codelen code_ifso + 1)\n ++ code_ifso\n ++ .Ibranch (codelen code_ifnot)\n :: code_ifnot\n | .WHILE b body =>\n let code_body := compile_com body\n let code_test := compile_bexp b 0 (codelen code_body + 1)\n code_test\n ++ code_body\n ++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []"
},
{
"name": "code_at",
"content": "@[grind] inductive code_at : List instr → Int → List instr → Prop where\n | code_at_intro : ∀ C1 C2 C3 pc,\n pc = codelen C1 ->\n code_at (C1 ++ C2 ++ C3) pc C2"
},
{
"name": "compile_cont",
"content": "inductive compile_cont (C : List instr) : cont -> Int -> Prop where\n | ccont_stop : ∀ pc,\n instr_at C pc = .some .Ihalt ->\n compile_cont C .Kstop pc\n | ccont_seq : ∀ c k pc pc',\n code_at C pc (compile_com c) ->\n pc' = pc + codelen (compile_com c) ->\n compile_cont C k pc' ->\n compile_cont C (.Kseq c k) pc\n | ccont_while : ∀ b c k pc d pc' pc'',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n code_at C pc' (compile_com (.WHILE b c)) ->\n pc'' = pc' + codelen (compile_com (.WHILE b c)) ->\n compile_cont C k pc'' ->\n compile_cont C (.Kwhile b c k) pc\n | ccont_branch : ∀ d k pc pc',\n instr_at C pc = .some (.Ibranch d) ->\n pc' = pc + 1 + d ->\n compile_cont C k pc' ->\n compile_cont C k pc"
},
{
"name": "match_config",
"content": "inductive match_config (C : List instr) : com × cont × store -> config -> Prop where\n | match_config_intro : ∀ c k st pc,\n code_at C pc (compile_com c) ->\n compile_cont C k (pc + codelen (compile_com c)) ->\n match_config C (c, k, st) (pc, [], st)"
},
{
"name": "com_size",
"content": "def com_size (c : com) : Nat :=\n match c with\n | .SKIP => 1\n | .ASSIGN _ _ => 1\n | (c1 ;; c2) => (com_size c1 + com_size c2 + 1)\n | .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)\n | .WHILE _ c1 => (com_size c1 + 1)"
},
{
"name": "cont_size",
"content": "def cont_size (k : cont) : Nat :=\n match k with\n | .Kstop => 0\n | .Kseq c k' => (com_size c + cont_size k')\n | .Kwhile _ _ k' => cont_size k'"
},
{
"name": "measure'",
"content": "def measure' (impconf : com × cont × store) : Nat :=\n match impconf with\n | (c, k, _) => (com_size c + cont_size k)"
}
] | [
{
"name": "codelen_cons",
"content": "@[grind =] theorem codelen_cons :\n ∀ i c, codelen (i :: c) = codelen c + 1"
},
{
"name": "codelen_app",
"content": "@[grind =] theorem codelen_app :\n ∀ c1 c2, codelen (c1 ++ c2) = codelen c1 + codelen c2"
},
{
"name": "instr_a",
"content": "@[grind =>] theorem instr_a : ∀ i c2 c1 pc,\n pc = codelen c1 ->\n instr_at (c1 ++ (i :: c2) ) pc = .some i"
},
{
"name": "code_at_app_right",
"content": "@[grind] theorem code_at_app_right :\n ∀ C pc C1 C2,\n code_at C pc (C1 ++ C2) ->\n code_at C (pc + codelen C1) C2"
},
{
"name": "code_at_to_instr_at",
"content": "@[grind] theorem code_at_to_instr_at : code_at C pc (c1 ++ i :: c2) → instr_at C (pc + codelen c1) = .some i"
},
{
"name": "compile_aexp_correct",
"content": "theorem compile_aexp_correct (C : List instr) (s : store) (a : aexp) (pc : Int) (stk : stack) :\n code_at C pc (compile_aexp a) →\n transitions C (pc, stk, s) (pc + codelen (compile_aexp a), aeval s a :: stk, s)"
},
{
"name": "compile_bexp_correct",
"content": "theorem compile_bexp_correct (C : List instr) (s : store) (b : bexp) (d1 d0 : Int) (pc : Int) (stk : stack) (h : code_at C pc (compile_bexp b d1 d0)) :\n transitions C\n (pc, stk, s)\n (pc + codelen (compile_bexp b d1 d0) + (if beval s b then d1 else d0), stk, s)"
},
{
"name": "compile_cont_Kseq_inv",
"content": "theorem compile_cont_Kseq_inv (C : List instr) (c : com) (k :cont) (pc : Int) (s : store) (H : compile_cont C (.Kseq c k) pc) :\n ∃ pc',\n star (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com c)\n ∧ compile_cont C k (pc' + codelen (compile_com c))"
},
{
"name": "compile_cont_Kwhile_inv",
"content": "theorem compile_cont_Kwhile_inv (C : List instr) (b : bexp) (c : com) (k : cont) (pc : Int) (s : store) (H : compile_cont C (.Kwhile b c k) pc) :\n ∃ pc',\n plus (transition C) (pc, [], s) (pc', [], s)\n ∧ code_at C pc' (compile_com (.WHILE b c))\n ∧ compile_cont C k (pc' + codelen (compile_com (.WHILE b c)))"
},
{
"name": "match_config_skip",
"content": "theorem match_config_skip (C : List instr) (k : cont) (s : store) (pc : Int) (H : compile_cont C k pc) :\n match_config C (.SKIP, k, s) (pc, [], s)"
},
{
"name": "simulation_step",
"content": "theorem simulation_step :\n ∀ C impconf1 impconf2 machconf1,\n step impconf1 impconf2 ->\n match_config C impconf1 machconf1 ->\n ∃ machconf2,\n (plus (transition C) machconf1 machconf2\n \\/ (star (transition C) machconf1 machconf2\n /\\ (measure' impconf2 < measure' impconf1)))\n /\\ match_config C impconf2 machconf2"
}
] | import LeroyCompilerVerificationCourse.Imp
@[grind] inductive instr : Type where
| Iconst (n : Int)
| Ivar (x : ident)
| Isetvar (x : ident)
| Iadd
| Iopp
| Ibranch (d : Int)
| Ibeq (d1 : Int) (d0 : Int)
| Ible (d1 : Int) (d0 : Int)
| Ihalt
deriving Repr
@[grind] def codelen (c : List instr) : Int := c.length
def stack : Type := List Int
def config : Type := Int × stack × store
@[grind] def instr_at (C : List instr) (pc : Int) : Option instr :=
match C with
| [] => .none
| i :: C' => if pc = 0 then .some i else instr_at C' (pc - 1)
@[grind] inductive transition (C : List instr) : config → config → Prop where
| trans_const : ∀ pc stk s n,
instr_at C pc = .some (.Iconst n) →
transition C (pc , stk , s)
(pc + 1, n :: stk, s)
| trans_var : ∀ pc stk s x,
instr_at C pc = .some (.Ivar x) ->
transition C (pc , stk , s)
(pc + 1, s x :: stk, s)
| trans_setvar : ∀ pc stk s x n,
instr_at C pc = .some (.Isetvar x) ->
transition C (pc , n :: stk, s)
(pc + 1, stk , update x n s)
| trans_add : ∀ pc stk s n1 n2,
instr_at C pc = .some (.Iadd) ->
transition C (pc , n2 :: n1 :: stk , s)
(pc + 1, (n1 + n2) :: stk, s)
| trans_opp : ∀ pc stk s n,
instr_at C pc = .some (.Iopp) ->
transition C (pc , n :: stk , s)
(pc + 1, (- n) :: stk, s)
| trans_branch : ∀ pc stk s d pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
transition C (pc , stk, s)
(pc', stk, s)
| trans_beq : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ibeq d1 d0) ->
pc' = pc + 1 + (if n1 = n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
| trans_ble : ∀ pc stk s d1 d0 n1 n2 pc',
instr_at C pc = .some (.Ible d1 d0) ->
pc' = pc + 1 + (if n1 ≤ n2 then d1 else d0) ->
transition C (pc , n2 :: n1 :: stk, s)
(pc', stk , s)
@[grind] def transitions (C : List instr) : config → config → Prop :=
star (transition C)
@[grind] def compile_aexp (a : aexp) : List instr :=
match a with
| .CONST n => .Iconst n :: []
| .VAR x => .Ivar x :: []
| .PLUS a1 a2 => (compile_aexp a1) ++ (compile_aexp a2) ++ (.Iadd :: [])
| .MINUS a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ (.Iopp :: .Iadd :: [])
@[grind] def compile_bexp (b : bexp) (d1 : Int) (d0 : Int) : List instr :=
match b with
| .TRUE => if d1 = 0 then [] else .Ibranch d1 :: []
| .FALSE => if d0 = 0 then [] else .Ibranch d0 :: []
| .EQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ibeq d1 d0 :: []
| .LESSEQUAL a1 a2 => compile_aexp a1 ++ compile_aexp a2 ++ .Ible d1 d0 :: []
| .NOT b1 => compile_bexp b1 d0 d1
| .AND b1 b2 =>
let code2 := compile_bexp b2 d1 d0
let code1 := compile_bexp b1 0 (codelen code2 + d0)
code1 ++ code2
@[grind] def compile_com (c : com) : List instr :=
match c with
| .SKIP =>
[]
| .ASSIGN x a =>
compile_aexp a ++ .Isetvar x :: []
| .SEQ c1 c2 =>
compile_com c1 ++ compile_com c2
| .IFTHENELSE b ifso ifnot =>
let code_ifso := compile_com ifso
let code_ifnot := compile_com ifnot
compile_bexp b 0 (codelen code_ifso + 1)
++ code_ifso
++ .Ibranch (codelen code_ifnot)
:: code_ifnot
| .WHILE b body =>
let code_body := compile_com body
let code_test := compile_bexp b 0 (codelen code_body + 1)
code_test
++ code_body
++ .Ibranch (- (codelen code_test + codelen code_body + 1)) :: []
@[grind] inductive code_at : List instr → Int → List instr → Prop where
| code_at_intro : ∀ C1 C2 C3 pc,
pc = codelen C1 ->
code_at (C1 ++ C2 ++ C3) pc C2
inductive compile_cont (C : List instr) : cont -> Int -> Prop where
| ccont_stop : ∀ pc,
instr_at C pc = .some .Ihalt ->
compile_cont C .Kstop pc
| ccont_seq : ∀ c k pc pc',
code_at C pc (compile_com c) ->
pc' = pc + codelen (compile_com c) ->
compile_cont C k pc' ->
compile_cont C (.Kseq c k) pc
| ccont_while : ∀ b c k pc d pc' pc'',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
code_at C pc' (compile_com (.WHILE b c)) ->
pc'' = pc' + codelen (compile_com (.WHILE b c)) ->
compile_cont C k pc'' ->
compile_cont C (.Kwhile b c k) pc
| ccont_branch : ∀ d k pc pc',
instr_at C pc = .some (.Ibranch d) ->
pc' = pc + 1 + d ->
compile_cont C k pc' ->
compile_cont C k pc
inductive match_config (C : List instr) : com × cont × store -> config -> Prop where
| match_config_intro : ∀ c k st pc,
code_at C pc (compile_com c) ->
compile_cont C k (pc + codelen (compile_com c)) ->
match_config C (c, k, st) (pc, [], st)
def com_size (c : com) : Nat :=
match c with
| .SKIP => 1
| .ASSIGN _ _ => 1
| (c1 ;; c2) => (com_size c1 + com_size c2 + 1)
| .IFTHENELSE _ c1 c2 => (com_size c1 + com_size c2 + 1)
| .WHILE _ c1 => (com_size c1 + 1)
def cont_size (k : cont) : Nat :=
match k with
| .Kstop => 0
| .Kseq c k' => (com_size c + cont_size k')
| .Kwhile _ _ k' => cont_size k'
def measure' (impconf : com × cont × store) : Nat :=
match impconf with
| (c, k, _) => (com_size c + cont_size k) | theorem simulation_infseq_inv :
∀ C n impconf1 machconf1,
infseq step impconf1 -> match_config C impconf1 machconf1 ->
(measure' impconf1 < n) ->
∃ impconf2 machconf2,
infseq step impconf2
/\ plus (transition C) machconf1 machconf2
/\ match_config C impconf2 machconf2 := | := by
intro C n impconf1 h1 h2 h3 h4
induction n generalizing impconf1 h1
case zero => contradiction
case succ n' ih =>
rw [infseq] at h2
rcases h2 with ⟨impconf2 , STEP, INFSEQ⟩
have ⟨ machconf2, h5 , h6 ⟩ := simulation_step C impconf1 impconf2 h1 STEP h3
cases h5
next PLUS =>
exists impconf2
exists machconf2
next w =>
rcases w with ⟨ STAR, MEASURE ⟩
specialize ih impconf2 machconf2 INFSEQ h6 (by omega)
rcases ih with ⟨ c1, m1, w⟩
exists c1
exists m1
constructor
· exact w.1
· constructor
· apply star_plus_trans
· exact STAR
· exact w.2.1
· exact w.2.2 | 4 | 67 | false | Compiler |
370 | fixpoint_sound | theorem fixpoint_sound (F : Store → Store) (init_S : Store) (h : S = fixpoint F init_S) :
Le (F S) S | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Constprop.lean | [
"import LeroyCompilerVerificationCourse.Imp",
"import Std.Data.HashMap"
] | [
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.emptyWithCapacity",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
}
] | [
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
}
] | [
{
"name": "Std.HashMap.Equiv.getElem?_eq",
"module": "Std.Data.HashMap.Lemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Top",
"content": "@[grind] def Top : Store := Std.HashMap.emptyWithCapacity"
},
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "fixpoint_rec",
"content": "@[grind] noncomputable def fixpoint_rec (F : Store -> Store) (fuel : Nat) (S : Store) : Store :=\n match fuel with\n | 0 => Top\n | fuel + 1 =>\n let S' := F S\n if Equal S' S then S else fixpoint_rec F fuel S'"
},
{
"name": "num_iter",
"content": "@[grind] def num_iter : Nat := 20"
},
{
"name": "fixpoint",
"content": "@[grind] noncomputable def fixpoint (F : Store -> Store) (init_S : Store) : Store :=\n fixpoint_rec F num_iter init_S"
}
] | [
{
"name": "Equal_Le",
"content": "theorem Equal_Le : ∀ S1 S2, Equal S1 S2 -> Le S1 S2"
}
] | import LeroyCompilerVerificationCourse.Imp
import Std.Data.HashMap
open Classical in
def Store := Std.HashMap ident Int
@[grind] def Le (S1 S2 : Store) : Prop :=
∀ x n, S2.get? x = .some n -> S1.get? x = .some n
@[grind] def Top : Store := Std.HashMap.emptyWithCapacity
def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2
@[grind] noncomputable def fixpoint_rec (F : Store -> Store) (fuel : Nat) (S : Store) : Store :=
match fuel with
| 0 => Top
| fuel + 1 =>
let S' := F S
if Equal S' S then S else fixpoint_rec F fuel S'
@[grind] def num_iter : Nat := 20
@[grind] noncomputable def fixpoint (F : Store -> Store) (init_S : Store) : Store :=
fixpoint_rec F num_iter init_S | theorem fixpoint_sound (F : Store → Store) (init_S : Store) (h : S = fixpoint F init_S) :
Le (F S) S := | := by
have A : ∀ fuel S,
fixpoint_rec F fuel S = Top
\/ Equal (F (fixpoint_rec F fuel S)) (fixpoint_rec F fuel S) := by
intro fuel
induction fuel
case zero => grind
case succ fuel' ih =>
grind
have E : S = Top \/ Equal (F S) S = true := by grind
cases E <;> grind [Equal_Le] | 5 | 19 | false | Compiler |
371 | fixpoint_join_eq | theorem fixpoint_join_eq : Eq' (Join Init (F (fixpoint_join Init F) )) (fixpoint_join Init F) | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Fixpoints.lean | [
"import LeroyCompilerVerificationCourse.Constprop",
"import LeroyCompilerVerificationCourse.Imp",
"import Batteries.Data.List.Perm"
] | [
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "k",
"module": "QqTest.matching"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Equiv",
"module": "Mathlib.Logic.Equiv.Defs"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "WellFounded",
"module": "Init.WF"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "Le_Join_l",
"content": "theorem Le_Join_l : ∀ S1 S2, Le S1 (Join S1 S2)"
}
] | [
{
"name": "OrderStruct",
"content": "@[grind] class OrderStruct (α : Sort u) where\n eq : α → α → Prop\n le : α → α → Prop\n beq : α → α → Bool\n le_trans : ∀ x y z, le x y -> le y z -> le x z\n beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/"
},
{
"name": "Monotone",
"content": "class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where\n F_mon : ∀ {x y : α}, le x y → le (F x) (F y)"
},
{
"name": "iterate",
"content": "@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=\n if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/\n ) (by admit /- proof elided -/\n )\n termination_by x\n decreasing_by\n grind [beq_false']"
},
{
"name": "Eq'",
"content": "@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2"
},
{
"name": "Eq'_sym",
"content": "def Eq'_sym : ∀ S1 S2, Eq' S1 S2 → Eq' S2 S1 :="
},
{
"name": "_inst_OrderStruct",
"content": "noncomputable instance : OrderStruct Store where\n eq := Equal\n le := Le\n beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)\n le_trans := Le_trans\n gt_wf := Gt_wf"
},
{
"name": "_inst_Monotone",
"content": "instance : Monotone Store (fun x => Join Init (F x)) where\n F_mon := by admit /- proof elided -/"
},
{
"name": "fixpoint_join",
"content": "noncomputable def fixpoint_join : Store :="
}
] | [
{
"name": "iterate_correct",
"content": "@[grind] theorem iterate_correct (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) (heq : y = iterate _ F x PRE SMALL ) : eq y (F y) ∧ ∀ z, le (F z) z → le y z"
}
] | import LeroyCompilerVerificationCourse.Imp
import LeroyCompilerVerificationCourse.Constprop
import Batteries.Data.List.Perm
@[grind] class OrderStruct (α : Sort u) where
eq : α → α → Prop
le : α → α → Prop
beq : α → α → Bool
le_trans : ∀ x y z, le x y -> le y z -> le x z
beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/
open OrderStruct
class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where
F_mon : ∀ {x y : α}, le x y → le (F x) (F y)
open Monotone
section FixpointExistence
variable (α : Sort u) (F : α → α) [OrderWithBot α]
open OrderStruct OrderWithBot
end FixpointExistence
section Iterate
variable (α : Sort u) [inst : OrderStruct α] (F : α → α) [Monotone α F]
open OrderStruct
@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=
if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/
) (by admit /- proof elided -/
)
termination_by x
decreasing_by
grind [beq_false']
end Iterate
section Fixpoint
open OrderWithBot
variable {α : Sort u} [i : OrderWithBot α] (F : α → α) [Monotone α F]
end Fixpoint
section Constprop
open Std.HashMap
@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2
def Eq'_sym : ∀ S1 S2, Eq' S1 S2 → Eq' S2 S1 :=
open OrderStruct
noncomputable instance : OrderStruct Store where
eq := Equal
le := Le
beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)
le_trans := Le_trans
gt_wf := Gt_wf
end Constprop
section FixpointJoin
variable (Init : Store)
variable (F : Store → Store) [Monotone Store F]
instance : Monotone Store (fun x => Join Init (F x)) where
F_mon := by admit /- proof elided -/
noncomputable def fixpoint_join : Store := | theorem fixpoint_join_eq : Eq' (Join Init (F (fixpoint_join Init F) )) (fixpoint_join Init F) := | := by
generalize heq1 : fixpoint_join Init F = t
apply Eq'_sym
simp [fixpoint_join] at *
have := (@iterate_correct Store _ (fun x => Join Init (F x)) _ ?_ ?_ ?_ ?_ ?_ ).1
unfold Eq'
· exact this
· exact Init
· apply Le_Join_l
· intro z hyp x
specialize hyp x
grind
· rw [heq1] | 4 | 17 | false | Compiler |
372 | Gt_wf | theorem Gt_wf : WellFounded Gt | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Fixpoints.lean | [
"import LeroyCompilerVerificationCourse.Constprop",
"import LeroyCompilerVerificationCourse.Imp",
"import Batteries.Data.List.Perm"
] | [
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "k",
"module": "QqTest.matching"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "WellFounded",
"module": "Init.WF"
},
{
"name": "InvImage",
"module": "Init.Core"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Nat.lt",
"module": "Init.Prelude"
},
{
"name": "Nat.lt_wfRel",
"module": "Init.WF"
},
{
"name": "Subrelation",
"module": "Init.Core"
},
{
"name": "Equiv",
"module": "Mathlib.Logic.Equiv.Defs"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.Subperm",
"module": "Batteries.Data.List.Basic"
},
{
"name": "List.Pairwise",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
}
] | [
{
"name": "List.Pairwise.imp",
"module": "Init.Data.List.Pairwise"
},
{
"name": "List.subperm_of_subset",
"module": "Batteries.Data.List.Perm"
},
{
"name": "Std.HashMap.distinct_keys_toList",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "List.Subperm.length_le",
"module": "Batteries.Data.List.Perm"
},
{
"name": "List.Subperm.perm_of_length_le",
"module": "Batteries.Data.List.Perm"
},
{
"name": "Std.HashMap.Equiv.of_toList_perm",
"module": "Std.Data.HashMap.Lemmas"
},
{
"name": "InvImage.wf",
"module": "Init.WF"
},
{
"name": "Subrelation.wf",
"module": "Init.WF"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Eq'",
"content": "@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2"
},
{
"name": "Gt",
"content": "@[grind] def Gt (S1 S2 : Store) := Le S2 S1 ∧ ¬ Eq' S2 S1"
}
] | [
{
"name": "hash_set_incl_size_leq",
"content": "theorem hash_set_incl_size_leq (S1 S2 : Store) : Le S2 S1 → List.Subperm (S1.toList) (S2.toList)"
},
{
"name": "Le_cardinal",
"content": "@[grind] theorem Le_cardinal :\n ∀ S T : Store,\n Le T S ->\n S.size <= T.size ∧ (S.size = T.size → Equal S T)"
},
{
"name": "Gt_cardinal",
"content": "@[grind] theorem Gt_cardinal :\n ∀ S S', Gt S S' -> S.size < S'.size"
}
] | import LeroyCompilerVerificationCourse.Imp
import LeroyCompilerVerificationCourse.Constprop
import Batteries.Data.List.Perm
open OrderStruct
open Monotone
section FixpointExistence
variable (α : Sort u) (F : α → α) [OrderWithBot α]
open OrderStruct OrderWithBot
end FixpointExistence
section Iterate
variable (α : Sort u) [inst : OrderStruct α] (F : α → α) [Monotone α F]
open OrderStruct
end Iterate
section Fixpoint
open OrderWithBot
variable {α : Sort u} [i : OrderWithBot α] (F : α → α) [Monotone α F]
end Fixpoint
section Constprop
open Std.HashMap
@[grind] def Eq' (S1 S2 : Store) : Prop := Equal S1 S2
@[grind] def Gt (S1 S2 : Store) := Le S2 S1 ∧ ¬ Eq' S2 S1 | theorem Gt_wf : WellFounded Gt := | := by
have := @InvImage Store Nat Nat.lt fun x => x.size
have : ∀ (x y : Store), Gt x y → @InvImage Store Nat Nat.lt (fun x => x.size) x y := by
intro x y heq
unfold InvImage
simp
apply Gt_cardinal
exact heq
have subrel : Subrelation Gt (InvImage Nat.lt (fun x : Store => x.size)) := by
intro x y gt; grind
apply @Subrelation.wf Store (InvImage Nat.lt (fun x : Store => x.size)) Gt subrel
exact InvImage.wf (fun x : Store => x.size) (Nat.lt_wfRel.wf) | 5 | 30 | false | Compiler |
373 | fixpoint_correct | theorem fixpoint_correct :
eq (fixpoint' F) (F (fixpoint' F)) ∧ ∀ z : α, le (F z) z → le (fixpoint' F) z | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Fixpoints.lean | [
"import LeroyCompilerVerificationCourse.Constprop",
"import LeroyCompilerVerificationCourse.Imp",
"import Batteries.Data.List.Perm"
] | [
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "k",
"module": "QqTest.matching"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "WellFounded",
"module": "Init.WF"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "OrderStruct",
"content": "@[grind] class OrderStruct (α : Sort u) where\n eq : α → α → Prop\n le : α → α → Prop\n beq : α → α → Bool\n le_trans : ∀ x y z, le x y -> le y z -> le x z\n beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/"
},
{
"name": "OrderWithBot",
"content": "class OrderWithBot (α : Sort u) extends OrderStruct α where\n bot : α\n bot_smallest : ∀ x, le bot x"
},
{
"name": "Monotone",
"content": "class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where\n F_mon : ∀ {x y : α}, le x y → le (F x) (F y)"
},
{
"name": "iterate",
"content": "@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=\n if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/\n ) (by admit /- proof elided -/\n )\n termination_by x\n decreasing_by\n grind [beq_false']"
},
{
"name": "fixpoint'",
"content": "@[grind] def fixpoint' : α := iterate α F bot (by admit /- proof elided -/\n) (by admit /- proof elided -/\n)"
}
] | [
{
"name": "iterate_correct",
"content": "@[grind] theorem iterate_correct (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) (heq : y = iterate _ F x PRE SMALL ) : eq y (F y) ∧ ∀ z, le (F z) z → le y z"
}
] | import LeroyCompilerVerificationCourse.Imp
import LeroyCompilerVerificationCourse.Constprop
import Batteries.Data.List.Perm
@[grind] class OrderStruct (α : Sort u) where
eq : α → α → Prop
le : α → α → Prop
beq : α → α → Bool
le_trans : ∀ x y z, le x y -> le y z -> le x z
beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/
open OrderStruct
class OrderWithBot (α : Sort u) extends OrderStruct α where
bot : α
bot_smallest : ∀ x, le bot x
class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where
F_mon : ∀ {x y : α}, le x y → le (F x) (F y)
open Monotone
section FixpointExistence
variable (α : Sort u) (F : α → α) [OrderWithBot α]
open OrderStruct OrderWithBot
end FixpointExistence
section Iterate
variable (α : Sort u) [inst : OrderStruct α] (F : α → α) [Monotone α F]
open OrderStruct
@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=
if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/
) (by admit /- proof elided -/
)
termination_by x
decreasing_by
grind [beq_false']
end Iterate
section Fixpoint
open OrderWithBot
variable {α : Sort u} [i : OrderWithBot α] (F : α → α) [Monotone α F]
@[grind] def fixpoint' : α := iterate α F bot (by admit /- proof elided -/
) (by admit /- proof elided -/
) | theorem fixpoint_correct :
eq (fixpoint' F) (F (fixpoint' F)) ∧ ∀ z : α, le (F z) z → le (fixpoint' F) z := | := by
unfold fixpoint'
apply iterate_correct
rotate_left
· exact bot
· apply bot_smallest
· grind [bot_smallest]
· rfl | 4 | 6 | false | Compiler |
374 | fixpoint_join_smallest | theorem fixpoint_join_smallest :
∀ S, Le (Join Init (F S)) S -> Le (fixpoint_join Init F) S | LeroyCompilerVerificationCourse | LeroyCompilerVerificationCourse/Fixpoints.lean | [
"import LeroyCompilerVerificationCourse.Constprop",
"import LeroyCompilerVerificationCourse.Imp",
"import Batteries.Data.List.Perm"
] | [
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "k",
"module": "QqTest.matching"
},
{
"name": "Std.HashMap",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Std.HashMap.Equiv",
"module": "Std.Data.HashMap.Basic"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "WellFounded",
"module": "Init.WF"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "BEq",
"module": "Init.Prelude"
},
{
"name": "Hashable",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.add",
"module": "Init.Data.Int.Basic"
},
{
"name": "Int.sub",
"module": "Init.Data.Int.Basic"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "Fin",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.ToExpr",
"module": "Lean.ToExpr"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "BitVec",
"module": "Init.Prelude"
}
] | [
{
"name": "Join",
"content": "@[grind] def Join (S1 S2 : Store) : Store :=\n S1.filter (fun key _ => S2.get? key == S1.get? key)"
},
{
"name": "Store",
"content": "def Store := Std.HashMap ident Int"
},
{
"name": "Le",
"content": "@[grind] def Le (S1 S2 : Store) : Prop :=\n ∀ x n, S2.get? x = .some n -> S1.get? x = .some n"
},
{
"name": "Equal",
"content": "def Equal (S1 S2 : Store) := Std.HashMap.Equiv S1 S2"
},
{
"name": "com",
"content": "inductive com : Type where\n | SKIP \n | ASSIGN (x : ident) (a : aexp) \n | SEQ (c1 : com) (c2 : com) \n | IFTHENELSE (b : bexp) (c1 : com) (c2 : com) \n | WHILE (b : bexp) (c1 : com) "
},
{
"name": "Beval",
"content": "@[grind] def Beval (S : Store) (b : bexp) : Option Bool :=\n match b with\n | .TRUE => .some true\n | .FALSE => .some false\n | .EQUAL a1 a2 => lift2 (fun m n => m == n) (Aeval S a1) (Aeval S a2)\n | .LESSEQUAL a1 a2 => lift2 (fun m n => m <= n) (Aeval S a1) (Aeval S a2)\n | .NOT b1 => lift1 (fun m => !m) (Beval S b1)\n | .AND b1 b2 => lift2 (fun m n => m && n) (Beval S b1) (Beval S b2)"
},
{
"name": "lift1",
"content": "@[grind] def lift1 {A B : Type} (f : A -> B) (o : Option A) : Option B :=\n match o with\n | .some x => .some (f x)\n | .none => .none"
},
{
"name": "Aeval",
"content": "@[grind] def Aeval (S : Store) (a : aexp) : Option Int :=\n match a with\n | .CONST n => .some n\n | .VAR x => S.get? x\n | .PLUS a1 a2 => lift2 (Int.add) (Aeval S a1) (Aeval S a2)\n | .MINUS a1 a2 => lift2 (Int.sub) (Aeval S a1) (Aeval S a2)"
},
{
"name": "lift2",
"content": "@[grind] def lift2 {A B C : Type} (f : A -> B -> C) (o1 : Option A) (o2 : Option B) : Option C :=\n match o1, o2 with\n | .some x1, .some x2 => .some (f x1 x2) | _, _ => .none"
},
{
"name": "aexp",
"content": "inductive aexp : Type where\n | CONST (n : Int) \n | VAR (x : ident) \n | PLUS (a1 : aexp) (a2 : aexp) \n | MINUS (a1 : aexp) (s2 : aexp) "
},
{
"name": "ident",
"content": "def ident := String deriving BEq, Repr, Hashable"
},
{
"name": "bexp",
"content": "inductive bexp : Type where\n | TRUE \n | FALSE \n | EQUAL (a1 : aexp) (a2 : aexp) \n | LESSEQUAL (a1 : aexp) (a2 : aexp) \n | NOT (b1 : bexp) \n | AND (b1 : bexp) (b2 : bexp) "
},
{
"name": "Update",
"content": "@[grind] def Update (x : ident) (N : Option Int) (S : Store) : Store :=\n match N with\n | .none => S.erase x\n | .some n => S.insert x n"
},
{
"name": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r",
"content": "notation:10 l:10 \" ;; \" r:11 => com.SEQ l r"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "Le_Join_l",
"content": "theorem Le_Join_l : ∀ S1 S2, Le S1 (Join S1 S2)"
}
] | [
{
"name": "OrderStruct",
"content": "@[grind] class OrderStruct (α : Sort u) where\n eq : α → α → Prop\n le : α → α → Prop\n beq : α → α → Bool\n le_trans : ∀ x y z, le x y -> le y z -> le x z\n beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/"
},
{
"name": "Monotone",
"content": "class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where\n F_mon : ∀ {x y : α}, le x y → le (F x) (F y)"
},
{
"name": "iterate",
"content": "@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=\n if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/\n ) (by admit /- proof elided -/\n )\n termination_by x\n decreasing_by\n grind [beq_false']"
},
{
"name": "_inst_OrderStruct",
"content": "noncomputable instance : OrderStruct Store where\n eq := Equal\n le := Le\n beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)\n le_trans := Le_trans\n gt_wf := Gt_wf"
},
{
"name": "_inst_Monotone",
"content": "instance : Monotone Store (fun x => Join Init (F x)) where\n F_mon := by admit /- proof elided -/"
},
{
"name": "fixpoint_join",
"content": "noncomputable def fixpoint_join : Store :="
}
] | [
{
"name": "iterate_correct",
"content": "@[grind] theorem iterate_correct (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) (heq : y = iterate _ F x PRE SMALL ) : eq y (F y) ∧ ∀ z, le (F z) z → le y z"
}
] | import LeroyCompilerVerificationCourse.Imp
import LeroyCompilerVerificationCourse.Constprop
import Batteries.Data.List.Perm
@[grind] class OrderStruct (α : Sort u) where
eq : α → α → Prop
le : α → α → Prop
beq : α → α → Bool
le_trans : ∀ x y z, le x y -> le y z -> le x z
beq_true' : ∀ x y : α, beq x y = true → eq x y := by admit /- proof elided -/
open OrderStruct
class Monotone (α : Sort u) (F : α → α) [OrderStruct α] where
F_mon : ∀ {x y : α}, le x y → le (F x) (F y)
open Monotone
section FixpointExistence
variable (α : Sort u) (F : α → α) [OrderWithBot α]
open OrderStruct OrderWithBot
end FixpointExistence
section Iterate
variable (α : Sort u) [inst : OrderStruct α] (F : α → α) [Monotone α F]
open OrderStruct
@[grind] def iterate (x : α) (PRE : le x (F x)) (SMALL : ∀ z, le (F z) z -> le x z) : α :=
if beq x (F x) then x else iterate (F x) (by admit /- proof elided -/
) (by admit /- proof elided -/
)
termination_by x
decreasing_by
grind [beq_false']
end Iterate
section Fixpoint
open OrderWithBot
variable {α : Sort u} [i : OrderWithBot α] (F : α → α) [Monotone α F]
end Fixpoint
section Constprop
open Std.HashMap
open OrderStruct
noncomputable instance : OrderStruct Store where
eq := Equal
le := Le
beq (S1 S2 : Store) := Decidable.decide (Equal S1 S2)
le_trans := Le_trans
gt_wf := Gt_wf
end Constprop
section FixpointJoin
variable (Init : Store)
variable (F : Store → Store) [Monotone Store F]
instance : Monotone Store (fun x => Join Init (F x)) where
F_mon := by admit /- proof elided -/
noncomputable def fixpoint_join : Store := | theorem fixpoint_join_smallest :
∀ S, Le (Join Init (F S)) S -> Le (fixpoint_join Init F) S := | := by
intro S LE
unfold fixpoint_join
have := (@iterate_correct Store _ (fun x => Join Init (F x)) _ (fixpoint_join Init F) Init (?_) ?_ ?_).2 S LE
exact this
· apply Le_Join_l
· intro z hyp x
specialize hyp x
grind
· unfold fixpoint_join
dsimp | 4 | 11 | false | Compiler |
375 | spv_dot_pure_gen | theorem spv_dot_pure_gen (spv1: SpV Int) (spv2: SpV Int) (n pnt1 pnt2: ℕ)
(sz1: ∀ i < spv1.size, spv1.ind[i]! < n)
(sz2: ∀ i < spv2.size, spv2.ind[i]! < n):
spv_dot spv1 spv2 pnt1 pnt2 =
∑ i ∈ Finset.range n,
if max
(if spv1.size ≤ pnt1 then n else spv1.ind[pnt1]!)
(if spv2.size ≤ pnt2 then n else spv2.ind[pnt2]!) ≤ i then
spv1[i] * spv2[i]
else
0 | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Array.replicate",
"module": "Init.Data.Array.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" ",
"content": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" term \")\"\n (require_caluse )*\n (ensures_caluse)* \"do\" doSeq\n Termination.suffix : command\n\nsyntax \"ensures\" termBeforeReqEnsDo : ensures_caluse\n\nsyntax \"while_some\" term \":|\" termBeforeDo \"do\" doSeq : doElem\n\nsyntax \"while_some\" term \":|\" term\n (invariantClause)+\n (doneWith)?\n \"do\" doSeq : doElem\n\nsyntax \"let\" term \":|\" term : doElem\n\nsyntax \"done_with\" termBeforeDo : doneWith\n\nsyntax \"invariant\" termBeforeDo linebreak : invariantClause\n\nsyntax \"while\" term\n (invariantClause)*\n (doneWith)?\n (decreasingTerm)?\n \"do\" doSeq : doElem\n\nsyntax \"(mut\" ident \":\" term \")\" : leafny_binder"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| let $x:term :| $t) => `(doElem| let $x:term <- pickSuchThat _ (fun $x => type_with_name_prefix `choice $t))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t do $seq:doSeq) => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- withRef (<- getRef) `(invariants [])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done ¬$t:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match measure with\n | some measure_some =>\n let decr <- withRef measure_some `(decreasing type_with_name_prefix `decreasing $measure_some)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | none => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while_some $x:ident :| $t do $seq:doSeq) =>\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n while ∃ $x:ident, $t do\n let $x :| $t\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| while_some $x:ident :| $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]? do\n $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n let decr <- withRef (<- getRef) `(decreasing none)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if ∃ $x:ident, $t then\n let $x :| $t\n $[$seq:doElem]*\n else break)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| for $x:ident in $t\n $[invariant $inv:term\n ]*\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n for $x:ident in $t do\n $invs:term\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"for expects a sequence of do-elements\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(tactic|loom_solver) =>\n `(tactic|(\n try simp at *\n try aesop))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let balance := mkIdent `balance_name\n let balanceType <- `(term| Bal)\n let inv : Array Term <- inv.mapM fun (inv : Term) => withRef inv ``(fun ($(balance):ident : $balanceType)=> with_name_prefix `inv $inv)\n let invd_some <- match inv_done with\n | some invd_some => withRef invd_some ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done $invd_some)\n | none => ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done ¬$t:term)\n match measure with\n | some measure_some =>\n let measure_some ← withRef measure_some ``(type_with_name_prefix `decreasing ($measure_some:term))\n do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget ($measure_some:term)\n if $t then\n $seq:doSeq\n else break)\n | none => do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget none\n if $t then\n $seq:doSeq\n else break)"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(doElem|balance_set $t) => do\n let balId := mkIdent `balance\n `(doElem|do\n $balId:ident := $t\n set $balId:ident\n $balId:ident ← get)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem|$id:ident[$idx:term] := $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (fun _ => $val))\n | `(doElem|$id:ident[$idx:term] += $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (· + $val))"
}
] | [
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "em",
"module": "Mathlib.Logic.Basic"
},
{
"name": "if_pos",
"module": "Init.Core"
},
{
"name": "le_iff_eq_or_lt",
"module": "Mathlib.Order.Basic"
},
{
"name": "le_of_lt",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_of_lt_of_le",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "spv_dot",
"content": "def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=\n if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then\n 0\n else\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n (spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n spv_dot spv1 spv2 (pnt1 + 1) pnt2\n else\n spv_dot spv1 spv2 pnt1 (pnt2 + 1)\n termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)\n\n\nmethod SpVSpV\n (mut out: Array Int)\n (spv1: SpV Int)\n (spv2: SpV Int) return (u: Unit)\n ensures out.size = 1\n ensures out[0]! = spv_dot spv1 spv2 0 0\n do\n out := Array.replicate 1 0\n let mut pnt1 := 0\n let mut pnt2 := 0\n while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size\n invariant out.size = 1\n invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size\n invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0\n done_with pnt1 = spv1.size ∨ pnt2 = spv2.size\n do\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!\n pnt1 := pnt1 + 1\n pnt2 := pnt2 + 1\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n pnt1 := pnt1 + 1\n else\n pnt2 := pnt2 + 1\n return\n\n\nmethod SpMSpV\n (mut out: Array Int)\n (spm: Array (SpV Int))\n (spv: SpV Int) return (u: Unit)\n ensures out.size = spm.size\n ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0\n do\n out := Array.replicate spm.size 0\n let mut spmInd := Array.replicate spm.size 0\n let mut spvInd := Array.replicate spm.size 0\n while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size\n invariant spvInd.size = spm.size\n invariant spmInd.size = spm.size\n invariant out.size = spm.size\n invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size\n invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size\n invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0\n done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size\n do\n let ind_m := spmInd[i]!\n let ind_v := spvInd[i]!\n if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then\n out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!\n spmInd[i] += 1\n spvInd[i] += 1\n else\n if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then\n spmInd[i] += 1\n else\n spvInd[i] += 1\n return"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=
if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then
0
else
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
(spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
spv_dot spv1 spv2 (pnt1 + 1) pnt2
else
spv_dot spv1 spv2 pnt1 (pnt2 + 1)
termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)
method SpVSpV
(mut out: Array Int)
(spv1: SpV Int)
(spv2: SpV Int) return (u: Unit)
ensures out.size = 1
ensures out[0]! = spv_dot spv1 spv2 0 0
do
out := Array.replicate 1 0
let mut pnt1 := 0
let mut pnt2 := 0
while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size
invariant out.size = 1
invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size
invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0
done_with pnt1 = spv1.size ∨ pnt2 = spv2.size
do
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!
pnt1 := pnt1 + 1
pnt2 := pnt2 + 1
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
pnt1 := pnt1 + 1
else
pnt2 := pnt2 + 1
return
method SpMSpV
(mut out: Array Int)
(spm: Array (SpV Int))
(spv: SpV Int) return (u: Unit)
ensures out.size = spm.size
ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0
do
out := Array.replicate spm.size 0
let mut spmInd := Array.replicate spm.size 0
let mut spvInd := Array.replicate spm.size 0
while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size
invariant spvInd.size = spm.size
invariant spmInd.size = spm.size
invariant out.size = spm.size
invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size
invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size
invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0
done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size
do
let ind_m := spmInd[i]!
let ind_v := spvInd[i]!
if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then
out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!
spmInd[i] += 1
spvInd[i] += 1
else
if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then
spmInd[i] += 1
else
spvInd[i] += 1
return | theorem spv_dot_pure_gen (spv1: SpV Int) (spv2: SpV Int) (n pnt1 pnt2: ℕ)
(sz1: ∀ i < spv1.size, spv1.ind[i]! < n)
(sz2: ∀ i < spv2.size, spv2.ind[i]! < n):
spv_dot spv1 spv2 pnt1 pnt2 =
∑ i ∈ Finset.range n,
if max
(if spv1.size ≤ pnt1 then n else spv1.ind[pnt1]!)
(if spv2.size ≤ pnt2 then n else spv2.ind[pnt2]!) ≤ i then
spv1[i] * spv2[i]
else
0 := | := by
fun_induction spv_dot spv1 spv2 pnt1 pnt2 with
| case1 p1 p2 h =>
have all_zero: (∀ x ∈ Finset.range n, (if max (if spv1.size ≤ p1 then n else spv1.ind[p1]!) (if spv2.size ≤ p2 then n else spv2.ind[p2]!) ≤ x then spv1[x] * spv2[x] else 0) = 0) := by
intro x hx
simp
rcases h with ob1 | ob2
{ simp [ob1]
simp at hx
simp [hx] }
simp [ob2]
simp at hx
simp [hx]
rw [Finset.sum_eq_zero all_zero]
| case2 p1 p2 h1 eq ih =>
rw [ih, ←getValSpV_eq spv1 p1 (by omega), ←getValSpV_eq spv2 p2 (by omega)]
have sum_eq_single:
∑ i ∈ Finset.range n, (if i = spv1.ind[p1]! then spv1[spv1.ind[p1]!] * spv2[spv1.ind[p1]!] else 0) = (if spv1.ind[p1]! = spv1.ind[p1]! then spv1[spv1.ind[p1]!] * spv2[spv1.ind[p1]!] else 0) := by
have hb: ∀ i ∈ Finset.range n, i ≠ spv1.ind[p1]! → ((if i = spv1.ind[p1]! then spv1[spv1.ind[p1]!]! * spv2[spv1.ind[p1]!]! else 0) = 0) := by
intro i hi iq
simp at hi
simp [iq]
have hc: spv1.ind[p1]! ∉ Finset.range n → ((if spv1.ind[p1]! = spv1.ind[p1]! then spv1[spv1.ind[p1]!]! * spv2[spv1.ind[p1]!]! else 0) = 0) := by
intro nin
simp at nin
have bnd := sz1 p1 (by omega)
omega
apply Finset.sum_eq_single spv1.ind[p1]! hb hc
rw [if_pos] at sum_eq_single
rw [←eq, ←sum_eq_single]
rw [←Finset.sum_add_distrib]
apply Finset.sum_congr
{ rfl }
intro x hx
simp at hx
have h2: ¬spv1.size ≤ p1 ∧ ¬spv2.size ≤ p2 := by omega
simp [h2]
have hnx: ¬(n ≤ x) := by simp [hx]
by_cases xeq: x = spv1.ind[p1]! <;> simp [xeq]
{ intro in1 in2
by_cases edg1: spv1.size ≤ p1 + 1 <;> simp [edg1] at in1
{ omega }
have p1lt := (spv1.inc) p1 (p1 + 1) (by omega) (by omega) (by simp)
-- simp [getElem] at in1
omega }
have outb_lemma (spv: SpV Int) (pos: ℕ) (hsz: 1 ≤ spv.size) (hb: spv.ind[spv.size - 1]! < pos): spv[pos] = 0 := by
by_cases ex: ∃ i < spv.size, spv.ind[i]! = pos
{ rcases ex with ⟨i, hbi, hi⟩
by_cases heq: i = spv.size - 1
{ simp [heq] at hi
omega }
have contra := (spv.inc) i (spv.size - 1) (by omega) (by omega) (by omega)
simp at hb
-- simp [getElem] at hi
omega }
simp at ex
simp [getValSpV_empty spv pos ex]
by_cases edg1: spv1.size ≤ p1 + 1 <;> simp [edg1]
{ simp [hnx]
have p1eq : p1 = spv1.size - 1 := by omega
by_cases lex: spv1.ind[p1]! ≤ x <;> simp [lex]
have ltx: spv1.ind[p1]! < x := by omega
simp [p1eq] at ltx
simp [outb_lemma spv1 x (by omega) ltx] }
by_cases edg2: spv2.size ≤ p2 + 1 <;> simp [edg2]
{ simp [hnx]
by_cases lex: spv1.ind[p1]! ≤ x <;> simp [lex]
have ltx: spv1.ind[p1]! < x := by omega
have p2eq: p2 = spv2.size - 1 := by omega
simp [eq, p2eq] at ltx
simp [outb_lemma spv2 x (by omega) ltx] }
by_cases val: spv1.ind[p1 + 1]! ≤ x ∧ spv2.ind[p2 + 1]! ≤ x <;> simp [val]
{ have inc: spv1.ind[p1]! < spv1.ind[p1 + 1]! := (spv1.inc) p1 (p1 + 1) (by omega) (by omega) (by simp)
simp [le_of_lt (lt_of_lt_of_le inc val.left)] }
by_cases xb: spv1.ind[p1]! ≤ x <;> simp [xb]
have ltx: spv1.ind[p1]! < x := by omega
simp at val
have interm_lemma (spv: SpV Int) (pos idx: ℕ) (hsz: idx + 1 < spv.size) (inter: spv.ind[idx]! < pos ∧ pos < spv.ind[idx + 1]!): spv[pos] = 0 := by
by_cases ex: ∃ i < spv.size, spv.ind[i]! = pos
{ rcases ex with ⟨i, hbi, hi⟩
have lt_lemma (i1 i2: ℕ) (hi1: i1 < spv.size) (hi2: i2 < spv.size): spv.ind[i1]! < spv.ind[i2]! → i1 < i2 := by
intro hlt
by_cases contra_lt: i2 < i1
{ have inc := spv.inc i2 i1 hi2 hi1 contra_lt
simp at hlt
omega }
by_cases contra_eq: i1 = i2
{ simp [contra_eq] at hlt }
omega
have left_x := lt_lemma idx i (by omega) (by omega) (by omega)
have right_x := lt_lemma i (idx + 1) (by omega) (by omega) (by omega)
omega }
simp at ex
simp [getValSpV_empty spv pos ex]
rcases (em (spv1.ind[p1 + 1]! ≤ x)) with c1 | c2
{ simp [c1] at val
simp [interm_lemma spv2 x p2 (by omega) (by omega)] }
simp at c2
simp [interm_lemma spv1 x p1 (by omega) (by omega)]
rfl
| case3 p1 p2 h1 neq le ih =>
rw [ih]
apply Finset.sum_congr
{ rfl }
intro x hx
by_cases edg: spv1.size = p1 + 1
{ have sz_concl := sz1 p1 (by omega)
simp [edg]
simp at hx
have nx : ¬(n ≤ x) := by omega
by_cases b2: spv2.size ≤ p2 <;> simp [b2] <;> simp [nx]
intro ifc1 ifc2
by_cases ex: ∃ i < spv1.size, spv1.ind[i]! = x
{ rcases ex with ⟨i, ib, hi⟩
by_cases il: p1 < i
{ omega }
simp at il
rcases (le_iff_eq_or_lt.mp il) with ieq | ilt
{ simp [ieq] at hi
omega }
have contra := spv1.inc i p1 ib (by omega) ilt
omega }
simp at ex
simp [getValSpV_empty spv1 x ex] }
have inb: ¬(spv1.size ≤ p1 + 1) ∧ ¬(spv1.size ≤ p1):= by omega
simp [inb]
by_cases edg2: spv2.size ≤ p2 <;> simp [edg2]
{ simp at hx
have neg: ¬ (n ≤ x) := by omega
simp [neg] }
by_cases le2: spv2.ind[p2]! ≤ x <;> simp [le2]
by_cases upper: spv1.ind[p1 + 1]! ≤ x <;> simp [upper]
{ simp at inb
simp [getElem]
simp [le_trans (le_of_lt (spv1.inc p1 (p1 + 1) inb.right inb.left (by simp))) upper] }
by_cases lower: spv1.ind[p1]! ≤ x <;> simp [lower]
by_cases ex: ∃ i < spv1.size, spv1.ind[i]! = x
{ rcases ex with ⟨ind, indb, hind⟩
by_cases ind_x: ind = p1
{ simp [ind_x] at hind
omega }
rcases (lt_or_gt_of_ne ind_x) with ltc | gtc
{ have contra := spv1.inc ind p1 indb (by omega) ltc
-- simp [getElem] at lower
-- simp [getElem] at hind
omega }
by_cases indp1: ind = p1 + 1
{ simp [indp1] at hind
omega }
have indlt: p1 + 1 < ind := by omega
have contra := spv1.inc (p1 + 1) ind (by omega) indb indlt
-- simp [getElem] at upper
-- simp [getElem] at hind
omega }
simp at ex
simp [getValSpV_empty spv1 x ex]
| case4 p1 p2 h1 neq nle ih =>
rw [ih]
apply Finset.sum_congr
{ rfl }
intro x hx
by_cases edg: spv2.size = p2 + 1
{ have sz_concl := sz2 p2 (by omega)
simp [edg]
simp at hx
have nx : ¬(n ≤ x) := by omega
by_cases b1: spv1.size ≤ p1 <;> simp [b1] <;> simp [nx]
intro ifc1 ifc2
by_cases ex: ∃ i < spv2.size, spv2.ind[i]! = x
{ rcases ex with ⟨i, ib, hi⟩
by_cases il: p2 < i
{ omega }
simp at il
rcases (le_iff_eq_or_lt.mp il) with ieq | ilt
{ simp [ieq] at hi
omega }
have contra := (spv2.inc) i p2 ib (by omega) ilt
-- simp [getElem] at hi
-- simp [getElem] at ifc2
omega }
simp at ex
simp [getValSpV_empty spv2 x ex] }
have inb: ¬(spv2.size ≤ p2 + 1) ∧ ¬(spv2.size ≤ p2):= by omega
simp [inb]
by_cases edg1: spv1.size ≤ p1 <;> simp [edg1]
{ simp at hx
have neg: ¬ (n ≤ x) := by omega
simp [neg] }
by_cases le1: spv1.ind[p1]! ≤ x <;> simp [le1]
by_cases upper: spv2.ind[p2 + 1]! ≤ x <;> simp [upper]
{ simp at inb
simp [getElem]
simp [le_trans (le_of_lt ((spv2.inc) p2 (p2 + 1) inb.right inb.left (by simp))) upper] }
by_cases lower: spv2.ind[p2]! ≤ x <;> simp [lower]
by_cases ex: ∃ i < spv2.size, spv2.ind[i]! = x
{ rcases ex with ⟨ind, indb, hind⟩
by_cases ind_x: ind = p2
{ simp [ind_x] at hind
omega }
rcases (lt_or_gt_of_ne ind_x) with ltc | gtc
{ have contra := (spv2.inc) ind p2 indb (by omega) ltc
-- simp [getElem] at lower
-- simp [getElem] at hind
omega }
by_cases indp2: ind = p2 + 1
{ simp [indp2] at hind
omega }
have indlt: p2 + 1 < ind := by omega
have contra := (spv2.inc) (p2 + 1) ind (by omega) indb indlt
-- simp [getElem] at upper
-- simp [getElem] at hind
omega }
simp at ex
simp [getValSpV_empty spv2 x ex] | 2 | 23 | false | Framework |
376 | VelvetM.total_decompose | lemma VelvetM.total_decompose {α : Type} (x : VelvetM α) (post₁ post₂ : α -> Prop):
[totl| wp x post₁] ⊓ [part| wp x post₂] = [totl| wp x (post₁ ⊓ post₂)] | loom | CaseStudies/Velvet/VelvetTheory.lean | [
"import Loom.MonadAlgebras.NonDetT.Basic",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.NonDetT'.Basic",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "ForInStep",
"module": "Init.Core"
},
{
"name": "ForInStep.yield",
"module": "Init.Core"
},
{
"name": "LE",
"module": "Init.Prelude"
},
{
"name": "OrderBot",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "OrderTop",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "measure",
"module": "Init.WF"
},
{
"name": "And",
"module": "Init.Prelude"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadEnv",
"module": "Lean.Environment"
},
{
"name": "Lean.SimpleScopedEnvExtension",
"module": "Lean.ScopedEnvExtension"
},
{
"name": "Lean.SimplePersistentEnvExtension",
"module": "Lean.EnvExtension"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "open",
"content": "notation \"[part|\" t \"]\" => open PartialCorrectness PartialCorrectness.DemonicChoice in t"
},
{
"name": "open",
"content": "notation \"[part|\" t \"]\" => open ExceptionAsSuccess in t"
},
{
"name": "open",
"content": "notation \"[totl|\" t \"]\" => open TotalCorrectness TotalCorrectness.DemonicChoice in t"
},
{
"name": "open",
"content": "notation \"[totl|\" t \"]\" => open ExceptionAsFailure in t"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f => fun post => ⨆ a, ⌜p a⌝ ⊓ wp (f a) post\n | _, .repeatCont init f cont => fun post => ⨆ (inv : ForInStep _ -> l),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "spec",
"content": "def spec (pre : l) (post : α -> l) : Cont l α :=\n fun p => pre ⊓ ⌜post ≤ p⌝"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} {α : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m α -> Cont l α\n | .pure ret => pure ret\n | .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | .pickCont _ p f => fun post => ⨆ a, ⌜p a⌝ ⊓ wp (f a) post"
},
{
"name": "LE.pure",
"content": "noncomputable def LE.pure {l : Type u} [inst: LE l] [OrderTop l] [OrderBot l] : Prop -> l := fun p =>\n if p then ⊤ else ⊥"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f =>\n fun post =>\n let p : Set τ := p;\n ⨅ a ∈ (p : Set τ), wp (f a) post\n | _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} {α : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m α -> Cont l α\n | .pure ret => pure ret\n | .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | .pickCont τ p f => fun post => let p : Set τ := p; ⨅ a ∈ (p : Set τ), wp (f a) post"
},
{
"name": "W",
"content": "structure W (t : Type v) [Preorder t] (α : Type u) where\n wp : Cont t α\n wp_montone : wp.monotone"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f => fun post => let p : Set τ := p; ⌜∃ h, p h⌝ ⊓ ⨅ a ∈ (p : Set τ), wp (f a) post\n | _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l) (measure : β -> Nat),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) (fun | .yield b' => inv (.yield b') ⊓ ⌜ measure b' < measure b ⌝ | .done b' => inv (.done b'))⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ _ p _ f => fun post => ⨆ a, ⌜p a⌝ ⊓ wp (f a) post\n | _, .repeatCont init f cont => fun post => ⨆ (inv : ForInStep _ -> l) (measure : _ -> Nat),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) (fun | .yield b' => inv (.yield b') ⊓ ⌜ measure b' < measure b ⌝ | .done b' => inv (.done b'))⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "DivM",
"content": "inductive DivM (α : Type u) where\n | res (x : α)\n | div"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
},
{
"name": "NonDetT.bind",
"content": "def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=\n match x with\n | pure ret => f ret\n | vis x f' => vis x fun y => bind (f' y) f\n | pickCont τ p f' => pickCont τ p fun t => bind (f' t) f\n | repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f"
},
{
"name": "WPGen.bind",
"content": "def WPGen.bind {x : m α} {f : α -> m β} (wpg : WPGen x) (wpgf : ∀ a, WPGen (f a)) :\n WPGen (x >>= f) where\n get := fun post => wpg.get (fun a => (wpgf a).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "_root_.Lean.SimpleScopedEnvExtension.get",
"content": "private def _root_.Lean.SimpleScopedEnvExtension.get [Inhabited σ] (ext : SimpleScopedEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "_root_.Lean.SimplePersistentEnvExtension.get",
"content": "private def _root_.Lean.SimplePersistentEnvExtension.get [Inhabited σ] (ext : SimplePersistentEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "WPGen",
"content": "structure WPGen (x : m α) where\n get : Cont l α\n \n prop : ∀ post, get post <= wp x post"
},
{
"name": "_root_.Lean.EnvExtension.get",
"content": "private def _root_.Lean.EnvExtension.get [Inhabited σ] (ext : EnvExtension σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "CCPOBotLawful",
"content": "class CCPOBotLawful (m : Type u -> Type v) [∀ α, Lean.Order.CCPO (m α)] [CCPOBot m] where\n prop {α} : CCPOBot.compBot (m := m) (α := α) = Lean.Order.bot"
}
] | [
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "TotalCorrectness.DivM.wp_eq",
"content": "lemma TotalCorrectness.DivM.wp_eq (α : Type) (x : DivM α) (post : α -> Prop) :\n wp x post =\n match x with"
},
{
"name": "PartialCorrectness.DivM.wp_eq",
"content": "lemma PartialCorrectness.DivM.wp_eq (α : Type) (x : DivM α) (post : α -> Prop) :\n wp x post =\n match x with"
},
{
"name": "NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
},
{
"name": "NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α β : Type u} (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "NonDetT.wp_mono",
"content": "lemma NonDetT.wp_mono [LawfulMonad m] {α : Type u} {l : Type u} [CompleteLattice l] [MAlgOrdered m l] (x : NonDetT m α) (f g : α -> l) :\n (∀ a, f a <= g a) ->\n NonDetT.wp x f <= NonDetT.wp x g"
},
{
"name": "spec_mono",
"content": "lemma spec_mono {α : Type u} {l : Type u} [CompleteLattice l] (pre : l) (post : α -> l) (f g : α -> l) :\n (∀ a, f a <= g a) ->\n spec pre post f <= spec pre post g"
},
{
"name": "spec_mono",
"content": "omit [MAlgOrdered m l] in\nlemma spec_mono {α : Type u} {l : Type u} [CompleteLattice l] (pre : l) (post : α -> l) (f g : α -> l) :\n (∀ a, f a <= g a) ->\n spec pre post f <= spec pre post g"
},
{
"name": "NonDetT.wp_mono",
"content": "lemma NonDetT.wp_mono {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α : Type u} (x : NonDetT m α) (f g : α -> l) :\n (∀ a, f a <= g a) ->\n NonDetT.wp x f <= NonDetT.wp x g"
}
] | [] | [
{
"name": "DivM.total_decompose",
"content": "@[local simp]\nlemma DivM.total_decompose (α : Type) (x : DivM α) (post₁ post₂ : α -> Prop) :\n ([totl| wp x post₁] ∧ [part| wp x post₂]) = [totl| wp x (post₁ ⊓ post₂)]"
},
{
"name": "wp_mono_part",
"content": "@[local simp]\nlemma wp_mono_part (x : NonDetT DivM α) (post₁ post₂ : α -> Prop) :\n (post₁ ≤ post₂) → ([totl|wp x post₁]) ≤ ([part| wp x post₂])"
}
] | import Loom.MonadAlgebras.NonDetT.Extract
notation "[totl|" t "]" => open TotalCorrectness TotalCorrectness.DemonicChoice in t
notation "[part|" t "]" => open PartialCorrectness PartialCorrectness.DemonicChoice in t | lemma VelvetM.total_decompose {α : Type} (x : VelvetM α) (post₁ post₂ : α -> Prop):
[totl| wp x post₁] ⊓ [part| wp x post₂] = [totl| wp x (post₁ ⊓ post₂)] := | := by
unhygienic induction x <;> try simp [loomLogicSimp]
{ simp [DivM.total_decompose]
simp [[totl|DivM.wp_eq]]
split
{ simp }
rename_i arg
have ind := f_ih arg post₁ post₂
simp at ind
rw [ind]
trivial }
{ constructor <;> rintro hyp
{ constructor; aesop
intro i hi
have hl := hyp.left.right i hi
have hr := hyp.right i hi
have ind := f_ih i post₁ post₂
simp [hl, hr] at ind
exact ind }
constructor; constructor; aesop
all_goals
intro i hi
have conj := hyp.right i hi
have ind := f_ih i post₁ post₂
simp [loomLogicSimp] at ind
rw [←ind] at conj
simp [conj] }
constructor
{ intro conj
rcases conj with ⟨h, inv_spec, hspec⟩
rcases h with ⟨inv, x1, hinv⟩
rcases x1 with ⟨x, hx⟩
exists inv ⊓ inv_spec
constructor
{ exists x
intro b hb
simp [←[totl| NonDetT.wp_eq_wp]]
simp [loomLogicSimp] at hb
have hxb := hx b hb.left
simp [←[totl| NonDetT.wp_eq_wp]] at hxb
simp [spec, LE.pure, loomLogicSimp, ←[part| NonDetT.wp_eq_wp]] at hspec
have hspecb := hspec.left b hb.right
have ind := f_ih b
(fun x_1 ↦
match x_1 with
| ForInStep.yield b' => inv (ForInStep.yield b') ∧ x b' < x b
| ForInStep.done b' => inv (ForInStep.done b'))
inv_spec
simp [loomLogicSimp] at ind
have indr := ind.mp (And.intro hxb hspecb)
have v1 := [totl| NonDetT.wp_mono
(f b)
(fun x_1 ↦
(match x_1 with
| ForInStep.yield b' => inv (ForInStep.yield b') ∧ x b' < x b
| ForInStep.done b' => inv (ForInStep.done b')) ∧
inv_spec x_1)
(fun x_1 ↦
match x_1 with
| ForInStep.yield b' => (inv (ForInStep.yield b') ∧ inv_spec (ForInStep.yield b')) ∧ x b' < x b
| ForInStep.done b' => inv (ForInStep.done b') ∧ inv_spec (ForInStep.done b'))
]
simp [loomLogicSimp, ←[totl| NonDetT.wp_eq_wp]] at v1
exact v1
(fun x => by
match x with
| .yield b' => intro hb hspec; simp [hb, hspec]
| .done b' => intro hb hspec; simp [hb, hspec] )
indr }
simp [spec, LE.pure, loomLogicSimp, ←[totl| NonDetT.wp_eq_wp]] at hinv
simp [spec, LE.pure, loomLogicSimp, ←[part| NonDetT.wp_eq_wp]] at hspec
simp [spec, LE.pure, loomLogicSimp, ←[totl| NonDetT.wp_eq_wp]]
simp [hinv, hspec]
intro x inv_x inv_spec
have h₁ := hinv.right x inv_x
have h₂ := hspec.right.right x inv_spec
have cont_ind := cont_ih x post₁ post₂
simp [loomLogicSimp] at cont_ind
exact cont_ind.mp (And.intro h₁ h₂) }
intro hyp
rcases hyp with ⟨inv, x_ex, h_inv⟩
rcases x_ex with ⟨x, hx⟩
simp [spec]
simp [spec, LE.pure] at h_inv
constructor <;> exists inv <;> constructor
{ exists x }
{ simp [h_inv, LE.pure]
exact le_trans h_inv.right (by
simp [← [totl|NonDetT.wp_eq_wp]]
simp [loomLogicSimp]
intro x and_wp
have cont_ind := cont_ih x post₁ post₂
simp [loomLogicSimp, and_wp] at cont_ind
simp [cont_ind] ) }
{ intro b hb
have hbx := hx b hb
simp [←[totl| NonDetT.wp_eq_wp]] at hbx
have hb_triv: True ≤ ([totl| wp (f b) fun x_1 ↦
match x_1 with
| ForInStep.yield b' => inv (ForInStep.yield b') ∧ x b' < x b
| ForInStep.done b' => inv (ForInStep.done b')]) := by
simp [loomLogicSimp]
exact hbx
have tr_intro: True ≤ ([part| NonDetT.wp (f b) inv]) := le_trans hb_triv (by
simp [loomLogicSimp]
intro wp_x
simp [←[part| NonDetT.wp_eq_wp]]
apply wp_mono_part (f b) (fun x_1 ↦
match x_1 with
| ForInStep.yield b' => inv (ForInStep.yield b') ∧ x b' < x b
| ForInStep.done b' => inv (ForInStep.done b')) (fun x => inv x)
{ simp [loomLogicSimp]
intro x1
match x1 with
| ForInStep.yield b' => simp; intros; simp [*]
| ForInStep.done b' => simp }
exact wp_x)
simp at tr_intro
simp [tr_intro] }
simp [LE.pure, h_inv]
exact le_trans h_inv.right (by
simp [←[totl| NonDetT.wp_eq_wp], ←[part| NonDetT.wp_eq_wp]]
simp [loomLogicSimp]) | 4 | 56 | false | Framework |
377 | VSpV_correct_pure | theorem VSpV_correct_pure (out: Array Int) (arr: Array Int)
(spv: SpV Int)
(h_b: ∀ i < spv.size, spv.ind[i]! < arr.size):
out.size = 1 → out[0]! = sumUpTo spv arr spv.size →
out[0]! = ∑ i ∈ Finset.range (arr.size), spv[i] * arr[i]! | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "Nat.lt_iff_le_and_ne",
"module": "Init.Data.Nat.Basic"
},
{
"name": "add_left_cancel_iff",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "sumUpTo",
"content": "def sumUpTo\n (spv : SpV Int)\n (v : Array Int) (bound : ℕ) : Int := ∑ i ∈ Finset.range bound, ((spv.val)[i]! * v[(spv.ind)[i]!]!)"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def sumUpTo
(spv : SpV Int)
(v : Array Int) (bound : ℕ) : Int := ∑ i ∈ Finset.range bound, ((spv.val)[i]! * v[(spv.ind)[i]!]!) | theorem VSpV_correct_pure (out: Array Int) (arr: Array Int)
(spv: SpV Int)
(h_b: ∀ i < spv.size, spv.ind[i]! < arr.size):
out.size = 1 → out[0]! = sumUpTo spv arr spv.size →
out[0]! = ∑ i ∈ Finset.range (arr.size), spv[i] * arr[i]! := | := by
intro sz sum_eq
rw [sum_eq, sumUpTo]
have ind_lemma: ∀ k, k ≤ arr.size →
∑ i ∈ Finset.range (spv.size), (if spv.ind[i]! < k then spv.val[i]! * arr[spv.ind[i]!]! else 0) =
∑ i ∈ Finset.range k, spv[i] * arr[i]! := by
intro k
induction k with
| zero =>
simp
| succ m hm =>
intro lt_m
simp [Finset.sum_range_succ]
rw [←hm (by omega)]
have splitted_sum:
(∑ i ∈ Finset.range (spv.ind.size), if spv.ind[i]! < m then spv.val[i]! * arr[spv.ind[i]!]! else 0) +
(∑ i ∈ Finset.range (spv.ind.size), if spv.ind[i]! = m then spv.val[i]! * arr[spv.ind[i]!]! else 0) =
(∑ i ∈ Finset.range (spv.ind.size), if spv.ind[i]! < m + 1 then spv.val[i]! * arr[spv.ind[i]!]! else 0) := by
rw [←Finset.sum_add_distrib]
rw [Finset.sum_congr (by rfl)]
intro x hx
by_cases h_eq_m : spv.ind[x]! = m <;> simp [h_eq_m]
have miff : spv.ind[x]! < m ↔ spv.ind[x]! < m + 1 := by
constructor <;> rintro h_lt <;> omega
simp [miff]
rw [←spv.size_eq.1, ←splitted_sum, add_left_cancel_iff.mpr]
by_cases exists_i: ∃ i < spv.size, spv.ind[i]! = m
{ rcases exists_i with ⟨ind, h_ind⟩
rw [← h_ind.right]
have lemma_res := getValSpV_eq spv ind h_ind.left
simp at lemma_res
simp [lemma_res]
have almost_zero : ∀ i ∈ Finset.range (spv.ind.size), i ≠ ind →
((if spv.ind[i]! = spv.ind[ind]! then spv.val[i]! * arr[spv.ind[i]!]! else 0) = 0) := by
intro i i_inb i_not_ind
by_cases vind_eq : spv.ind[i]! = spv.ind[ind]!
{ simp at i_inb
have i_sz: i < spv.size := by
rw [spv.size_eq.1] at i_inb
exact i_inb
rcases lt_or_gt_of_ne i_not_ind with i_lt | inb_lt
{ simp [getElem, Nat.lt_iff_le_and_ne.mp (spv.inc i ind i_sz h_ind.left i_lt)] }
have lt := Nat.lt_iff_le_and_ne.mp (spv.inc ind i h_ind.left i_sz inb_lt)
simp [getElem] at vind_eq
simp [vind_eq] at lt }
simp [vind_eq]
have ind_inb: ind ∉ Finset.range (spv.size) →
((if spv.ind[ind]! = spv.ind[ind]! then spv.val[ind]! * arr[spv.ind[ind]!]! else 0) = 0) := by
intro ind_not_inb
simp at ind_not_inb
omega
rw [←spv.size_eq.1] at ind_inb
simp [Finset.sum_eq_single ind almost_zero ind_inb] }
simp at exists_i
have h_getVal := getValSpV_empty spv m exists_i
simp at h_getVal
simp [h_getVal]
apply Finset.sum_eq_zero
rintro x hx
by_cases h_eq: spv.ind[x]! = m <;> simp [h_eq]
simp [←h_eq] at h_getVal
simp at hx
rw [spv.size_eq.1] at hx
simp [getValSpV_eq spv x hx] at h_getVal
simp [h_getVal]
have fin_lemma := ind_lemma (arr.size) (by rfl)
rw [←fin_lemma]
exact Finset.sum_congr (by rfl) fun i h_i => by aesop | 2 | 19 | false | Framework |
378 | DemonicChoice.ExtractNonDet.extract_refines_wp_weak | omit [MAlgDet m l] in
lemma ExtractNonDet.extract_refines_wp_weak [∀ α, CCPO (m α)] [MAlgPartial m] [CCPOBotLawful m] (s : NonDetT m α) (inst : ExtractNonDet WeakFindable s) :
wp s post <= wp s.extractWeak post | loom | Loom/MonadAlgebras/NonDetT'/Extract.lean | [
"import Loom.MonadAlgebras.WP.Gen",
"import Loom.MonadAlgebras.WP.Liberal",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Mathlib.Data.W.Basic",
"import Loom.MonadAlgebras.NonDetT'.Basic",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.Defs",
"import Mathlib.Order.Lattice",
"import Mathlib.Data.FinEnum",
"import Mathlib.Order.Basic"
] | [
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "inline",
"module": "Init.Core"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Encodable",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Encodable.decode",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Lean.Order.CCPO",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.bot",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "Lean.Order.CCPO.csup",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.chain",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Nonempty",
"module": "Init.Prelude"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadEnv",
"module": "Lean.Environment"
},
{
"name": "Lean.SimpleScopedEnvExtension",
"module": "Lean.ScopedEnvExtension"
},
{
"name": "Lean.SimplePersistentEnvExtension",
"module": "Lean.EnvExtension"
},
{
"name": "LE",
"module": "Init.Prelude"
},
{
"name": "OrderBot",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "OrderTop",
"module": "Mathlib.Order.BoundedOrder.Basic"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "MonadNonDet",
"content": "class MonadNonDet (m : Type u → Type v) where\n pick : (τ : Type u) → [Inhabited τ] → m τ\n \n pickSuchThat : (τ : Type u) → (p : τ → Prop) → [Findable p] → m τ\n assume : (as : Prop) → [Decidable as] → m PUnit.{u+1}\n \n rep {α : Type u} : α → (α → m (ForInStep α)) → m α"
},
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "CCPOBot",
"content": "class CCPOBot (m : Type u -> Type v) where\n compBot {α} : m α"
},
{
"name": "CCPOBotLawful",
"content": "class CCPOBotLawful (m : Type u -> Type v) [∀ α, Lean.Order.CCPO (m α)] [CCPOBot m] where\n prop {α} : CCPOBot.compBot (m := m) (α := α) = Lean.Order.bot"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "MAlgPartial",
"content": "class MAlgPartial (m : Type u -> Type v) [Monad m] [∀ α, Lean.Order.CCPO (m α)]\n [CompleteLattice l] [MAlgOrdered m l] where\n csup_lift {α : Type u} (xc : Set (m α)) (post : α -> l) :\n Lean.Order.chain xc ->\n ⨅ x ∈ xc, MAlg.lift x post <= MAlg.lift (Lean.Order.CCPO.csup xc) post"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "MAlgDet",
"content": "class MAlgDet (l : outParam (Type v)) [Monad m] [CompleteLattice l] [MAlgOrdered m l] where\n \n demonic {α ι : Type v} (c : m α) (p : ι -> α -> l) [Nonempty ι] :\n ⨅ i, MAlg.lift c (p i) ≤ MAlg.lift c (fun x => ⨅ i, p i x)\n \n angelic {α ι : Type v} (c : m α) (p : ι -> α -> l) [Nonempty ι] :\n ⨆ i, MAlg.lift c (p i) ≥ MAlg.lift c (fun x => ⨆ i, p i x)"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} {α : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m α -> Cont l α\n | .pure ret => pure ret\n | .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | .pickCont τ p f => fun post => let p : Set τ := p; ⨅ a ∈ (p : Set τ), wp (f a) post"
},
{
"name": "NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
},
{
"name": "NonDetT.bind",
"content": "def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=\n match x with\n | pure ret => f ret\n | vis x f' => vis x fun y => bind (f' y) f\n | pickCont τ p f' => pickCont τ p fun t => bind (f' t) f\n | repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f"
},
{
"name": "WPGen.bind",
"content": "def WPGen.bind {x : m α} {f : α -> m β} (wpg : WPGen x) (wpgf : ∀ a, WPGen (f a)) :\n WPGen (x >>= f) where\n get := fun post => wpg.get (fun a => (wpgf a).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "_root_.Lean.SimpleScopedEnvExtension.get",
"content": "private def _root_.Lean.SimpleScopedEnvExtension.get [Inhabited σ] (ext : SimpleScopedEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "_root_.Lean.SimplePersistentEnvExtension.get",
"content": "private def _root_.Lean.SimplePersistentEnvExtension.get [Inhabited σ] (ext : SimplePersistentEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "WPGen",
"content": "structure WPGen (x : m α) where\n get : Cont l α\n \n prop : ∀ post, get post <= wp x post"
},
{
"name": "_root_.Lean.EnvExtension.get",
"content": "private def _root_.Lean.EnvExtension.get [Inhabited σ] (ext : EnvExtension σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "LE.pure",
"content": "noncomputable def LE.pure {l : Type u} [inst: LE l] [OrderTop l] [OrderBot l] : Prop -> l := fun p =>\n if p then ⊤ else ⊥"
}
] | [
{
"name": "Set.mem_empty_iff_false",
"module": "Mathlib.Data.Set.Basic"
},
{
"name": "eq_top_iff",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "le_iInf₂",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "le_trans'",
"module": "Mathlib.Order.Basic"
},
{
"name": "ge_iff_le",
"module": "Init.Core"
},
{
"name": "iInf_const",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "iInf_le_of_le",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "inf_comm",
"module": "Mathlib.Order.Lattice"
},
{
"name": "le_top",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "monadLift_self",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "top_himp",
"module": "Mathlib.Order.Heyting.Basic"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
},
{
"name": "NonDetT.wp_vis",
"content": "@[simp]\nlemma NonDetT.wp_vis {β : Type u} (x : m β) (f : β → NonDetT m α) post :\n _root_.wp (NonDetT.vis x f) post = _root_.wp x fun a => _root_.wp (f a) post"
},
{
"name": "NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
},
{
"name": "NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α β : Type u} (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "NonDetT.wp_pickCont",
"content": "@[simp]\nlemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) post :\n _root_.wp (NonDetT.pickCont τ p f) post = ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post"
},
{
"name": "NonDetT.wp_pickCont",
"content": "@[simp]\nlemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) post :\n _root_.wp (NonDetT.pickCont τ p f) post = ⨆ a, ⌜p a⌝ ⊓ _root_.wp (f a) post"
},
{
"name": "wp_bind",
"content": "lemma wp_bind {β} (x : m α) (f : α -> m β) (post : β -> l) :\n wp (x >>= f) post = wp x (fun x => wp (f x) post)"
},
{
"name": "trueE",
"content": "@[simp]\nlemma trueE (l : Type v) [inst: LE l] [OrderTop l] [OrderBot l] : ⌜True⌝ = (⊤ : l)"
}
] | [
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
},
{
"name": "find",
"content": "def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=\n findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode"
},
{
"name": "WeakFindable",
"content": "class WeakFindable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_some_p : find () = some x -> p x"
},
{
"name": "WeakFindable",
"content": "instance WeakFindable.of_Findable {α : Type u} (p : α -> Prop) [Findable p] : WeakFindable p where\n find := Findable.find p\n find_some_p := Findable.find_some_p"
},
{
"name": "ExtractNonDet",
"content": "inductive ExtractNonDet (findable : {τ : Type u} -> (τ -> Prop) -> Type u) {m} : {α : Type u} -> NonDetT m α -> Type _ where\n | pure {α} : ∀ (x : α), ExtractNonDet findable (NonDetT.pure x)\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) :\n (∀ y, ExtractNonDet findable (f y)) → ExtractNonDet findable (.vis x f)\n | pickSuchThat {α} (τ : Type u) (p : τ -> Prop) (f : τ → NonDetT m α)\n {_ : findable p}\n : (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont τ p f)\n | assume {α} (p : PUnit -> Prop) (f : PUnit → NonDetT m α) {_ : Decidable (p .unit)} :\n (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont PUnit p f)"
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pure' : ExtractNonDet findable (Pure.pure (f := NonDetT m) x) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.liftM (x : m α) :\n ExtractNonDet findable (liftM (n := NonDetT m) x) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.assume' {p : Prop} [Decidable p] : ExtractNonDet findable (MonadNonDet.assume (m := NonDetT m) p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pickSuchThat' {τ : Type u} (p : τ -> Prop) [Findable p] :\n ExtractNonDet Findable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pickSuchThat_weak {τ : Type u} (p : τ -> Prop) [WeakFindable p] :\n ExtractNonDet WeakFindable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.if {p : Prop} {dec : Decidable p} {x y : NonDetT m α}\n (_ : ExtractNonDet findable x) (_ : ExtractNonDet findable y) :\n ExtractNonDet findable (if p then x else y) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}\n (_ : ∀ a b, ExtractNonDet findable (f a b)) :\n ExtractNonDet findable (forIn xs init f) :="
},
{
"name": "NonDetT.extractGen",
"content": "@[simp, inline]\ndef NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}\n (findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)\n : (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/\n ) -> m α\n | .pure x, _ => Pure.pure x\n | .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))\n | .pickCont _ p f, .pickSuchThat _ _ _ _ =>\n match findOf p ‹_› () with\n | none => CCPOBot.compBot\n | some x => extractGen findOf (f x)\n | .pickCont _ p f, .assume _ _ _ =>\n if p .unit then\n extractGen findOf (f .unit)\n else CCPOBot.compBot"
},
{
"name": "NonDetT.extractWeak",
"content": "def NonDetT.extractWeak {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet WeakFindable s := by admit /- proof elided -/\n) : m α :=\n NonDetT.extractGen WeakFindable.find s"
}
] | [
{
"name": "DemonicChoice.wp_csup",
"content": "omit [CCPOBot m] [MAlgDet m l] [LawfulMonad m] in\nlemma wp_csup (xc : Set (m α)) (post : α -> l) [∀ α, CCPO (m α)] [MAlgPartial m]:\n Lean.Order.chain xc ->\n ⨅ c ∈ xc, wp c post ≤ wp (Lean.Order.CCPO.csup xc) post"
},
{
"name": "DemonicChoice.wp_bot",
"content": "omit [CCPOBot m] [MAlgDet m l] [LawfulMonad m] in\nlemma wp_bot [∀ α, CCPO (m α)] [MAlgPartial m]:\n wp (bot : m α) = fun _ => (⊤ : l)"
}
] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Mathlib.Data.W.Basic
import Mathlib.Data.FinEnum
import Loom.MonadAlgebras.WP.Gen
import Loom.MonadAlgebras.WP.Liberal
import Loom.MonadAlgebras.NonDetT'.Basic
open Lean.Order
def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=
let rec aux i :=
if p i then
some i
else
aux (i + 1)
partial_fixpoint
aux 0
def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=
findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode
class WeakFindable {α : Type u} (p : α -> Prop) where
find : Unit -> Option α
find_some_p : find () = some x -> p x
instance WeakFindable.of_Findable {α : Type u} (p : α -> Prop) [Findable p] : WeakFindable p where
find := Findable.find p
find_some_p := Findable.find_some_p
inductive ExtractNonDet (findable : {τ : Type u} -> (τ -> Prop) -> Type u) {m} : {α : Type u} -> NonDetT m α -> Type _ where
| pure {α} : ∀ (x : α), ExtractNonDet findable (NonDetT.pure x)
| vis {α} {β} (x : m β) (f : β → NonDetT m α) :
(∀ y, ExtractNonDet findable (f y)) → ExtractNonDet findable (.vis x f)
| pickSuchThat {α} (τ : Type u) (p : τ -> Prop) (f : τ → NonDetT m α)
{_ : findable p}
: (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont τ p f)
| assume {α} (p : PUnit -> Prop) (f : PUnit → NonDetT m α) {_ : Decidable (p .unit)} :
(∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont PUnit p f)
instance ExtractNonDet.pure' : ExtractNonDet findable (Pure.pure (f := NonDetT m) x) :=
instance ExtractNonDet.liftM (x : m α) :
ExtractNonDet findable (liftM (n := NonDetT m) x) :=
instance ExtractNonDet.assume' {p : Prop} [Decidable p] : ExtractNonDet findable (MonadNonDet.assume (m := NonDetT m) p) :=
instance ExtractNonDet.pickSuchThat' {τ : Type u} (p : τ -> Prop) [Findable p] :
ExtractNonDet Findable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :=
instance ExtractNonDet.pickSuchThat_weak {τ : Type u} (p : τ -> Prop) [WeakFindable p] :
ExtractNonDet WeakFindable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :=
instance ExtractNonDet.if {p : Prop} {dec : Decidable p} {x y : NonDetT m α}
(_ : ExtractNonDet findable x) (_ : ExtractNonDet findable y) :
ExtractNonDet findable (if p then x else y) :=
instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}
(_ : ∀ a b, ExtractNonDet findable (f a b)) :
ExtractNonDet findable (forIn xs init f) :=
variable [Monad m] [CCPOBot m] [CompleteBooleanAlgebra l] [MAlgOrdered m l] [MAlgDet m l] [LawfulMonad m]
@[simp, inline]
def NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}
(findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)
: (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/
) -> m α
| .pure x, _ => Pure.pure x
| .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))
| .pickCont _ p f, .pickSuchThat _ _ _ _ =>
match findOf p ‹_› () with
| none => CCPOBot.compBot
| some x => extractGen findOf (f x)
| .pickCont _ p f, .assume _ _ _ =>
if p .unit then
extractGen findOf (f .unit)
else CCPOBot.compBot
def NonDetT.extractWeak {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet WeakFindable s := by admit /- proof elided -/
) : m α :=
NonDetT.extractGen WeakFindable.find s
namespace DemonicChoice | omit [MAlgDet m l] in
lemma ExtractNonDet.extract_refines_wp_weak [∀ α, CCPO (m α)] [MAlgPartial m] [CCPOBotLawful m] (s : NonDetT m α) (inst : ExtractNonDet WeakFindable s) :
wp s post <= wp s.extractWeak post := | := by
unhygienic induction inst
{ simp [wp_pure, NonDetT.extractWeak] }
{ simp only [NonDetT.wp_vis, NonDetT.extractWeak, NonDetT.extractGen, monadLift_self, wp_bind]
apply wp_cons; aesop (add norm inf_comm) }
{ simp only [NonDetT.wp_pickCont, NonDetT.extractWeak, NonDetT.extractGen]; split
simp only [CCPOBotLawful.prop, wp_bot, le_top]
rename_i y h
refine iInf_le_of_le y ?_
have := WeakFindable.find_some_p (p := p) (by assumption)
simp only [this, trueE, top_himp, ge_iff_le]; apply a_ih }
simp only [NonDetT.wp_pickCont, NonDetT.extractWeak, NonDetT.extractGen]
have : ∀ a : PUnit.{u_1 + 1}, a = .unit := by simp
simp [this, iInf_const]; split_ifs <;> simp [*, CCPOBotLawful.prop, wp_bot]
apply a_ih | 5 | 82 | true | Framework |
379 | spv_dot_pure | theorem spv_dot_pure (spv1 spv2: SpV Int) (n: ℕ)
(sz1: ∀ i < spv1.size, spv1.ind[i]! < n) (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):
spv_dot spv1 spv2 0 0 = ∑ i ∈ Finset.range n, spv1[i] * spv2[i] | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Array.replicate",
"module": "Init.Data.Array.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" ",
"content": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" term \")\"\n (require_caluse )*\n (ensures_caluse)* \"do\" doSeq\n Termination.suffix : command\n\nsyntax \"ensures\" termBeforeReqEnsDo : ensures_caluse\n\nsyntax \"while_some\" term \":|\" termBeforeDo \"do\" doSeq : doElem\n\nsyntax \"while_some\" term \":|\" term\n (invariantClause)+\n (doneWith)?\n \"do\" doSeq : doElem\n\nsyntax \"let\" term \":|\" term : doElem\n\nsyntax \"done_with\" termBeforeDo : doneWith\n\nsyntax \"invariant\" termBeforeDo linebreak : invariantClause\n\nsyntax \"while\" term\n (invariantClause)*\n (doneWith)?\n (decreasingTerm)?\n \"do\" doSeq : doElem\n\nsyntax \"(mut\" ident \":\" term \")\" : leafny_binder"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| let $x:term :| $t) => `(doElem| let $x:term <- pickSuchThat _ (fun $x => type_with_name_prefix `choice $t))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t do $seq:doSeq) => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- withRef (<- getRef) `(invariants [])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done ¬$t:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match measure with\n | some measure_some =>\n let decr <- withRef measure_some `(decreasing type_with_name_prefix `decreasing $measure_some)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | none => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while_some $x:ident :| $t do $seq:doSeq) =>\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n while ∃ $x:ident, $t do\n let $x :| $t\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| while_some $x:ident :| $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]? do\n $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n let decr <- withRef (<- getRef) `(decreasing none)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if ∃ $x:ident, $t then\n let $x :| $t\n $[$seq:doElem]*\n else break)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| for $x:ident in $t\n $[invariant $inv:term\n ]*\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n for $x:ident in $t do\n $invs:term\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"for expects a sequence of do-elements\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(tactic|loom_solver) =>\n `(tactic|(\n try simp at *\n try aesop))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let balance := mkIdent `balance_name\n let balanceType <- `(term| Bal)\n let inv : Array Term <- inv.mapM fun (inv : Term) => withRef inv ``(fun ($(balance):ident : $balanceType)=> with_name_prefix `inv $inv)\n let invd_some <- match inv_done with\n | some invd_some => withRef invd_some ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done $invd_some)\n | none => ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done ¬$t:term)\n match measure with\n | some measure_some =>\n let measure_some ← withRef measure_some ``(type_with_name_prefix `decreasing ($measure_some:term))\n do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget ($measure_some:term)\n if $t then\n $seq:doSeq\n else break)\n | none => do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget none\n if $t then\n $seq:doSeq\n else break)"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(doElem|balance_set $t) => do\n let balId := mkIdent `balance\n `(doElem|do\n $balId:ident := $t\n set $balId:ident\n $balId:ident ← get)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem|$id:ident[$idx:term] := $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (fun _ => $val))\n | `(doElem|$id:ident[$idx:term] += $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (· + $val))"
}
] | [
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "em",
"module": "Mathlib.Logic.Basic"
},
{
"name": "if_pos",
"module": "Init.Core"
},
{
"name": "le_iff_eq_or_lt",
"module": "Mathlib.Order.Basic"
},
{
"name": "le_of_lt",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_of_lt_of_le",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "Finset.sum_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "lt_iff_le_not_ge",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "spv_dot",
"content": "def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=\n if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then\n 0\n else\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n (spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n spv_dot spv1 spv2 (pnt1 + 1) pnt2\n else\n spv_dot spv1 spv2 pnt1 (pnt2 + 1)\n termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)\n\n\nmethod SpVSpV\n (mut out: Array Int)\n (spv1: SpV Int)\n (spv2: SpV Int) return (u: Unit)\n ensures out.size = 1\n ensures out[0]! = spv_dot spv1 spv2 0 0\n do\n out := Array.replicate 1 0\n let mut pnt1 := 0\n let mut pnt2 := 0\n while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size\n invariant out.size = 1\n invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size\n invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0\n done_with pnt1 = spv1.size ∨ pnt2 = spv2.size\n do\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!\n pnt1 := pnt1 + 1\n pnt2 := pnt2 + 1\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n pnt1 := pnt1 + 1\n else\n pnt2 := pnt2 + 1\n return\n\n\nmethod SpMSpV\n (mut out: Array Int)\n (spm: Array (SpV Int))\n (spv: SpV Int) return (u: Unit)\n ensures out.size = spm.size\n ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0\n do\n out := Array.replicate spm.size 0\n let mut spmInd := Array.replicate spm.size 0\n let mut spvInd := Array.replicate spm.size 0\n while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size\n invariant spvInd.size = spm.size\n invariant spmInd.size = spm.size\n invariant out.size = spm.size\n invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size\n invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size\n invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0\n done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size\n do\n let ind_m := spmInd[i]!\n let ind_v := spvInd[i]!\n if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then\n out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!\n spmInd[i] += 1\n spvInd[i] += 1\n else\n if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then\n spmInd[i] += 1\n else\n spvInd[i] += 1\n return"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
},
{
"name": "spv_dot_pure_gen",
"content": "theorem spv_dot_pure_gen (spv1: SpV Int) (spv2: SpV Int) (n pnt1 pnt2: ℕ)\n (sz1: ∀ i < spv1.size, spv1.ind[i]! < n)\n (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):\n spv_dot spv1 spv2 pnt1 pnt2 =\n ∑ i ∈ Finset.range n,\n if max\n (if spv1.size ≤ pnt1 then n else spv1.ind[pnt1]!)\n (if spv2.size ≤ pnt2 then n else spv2.ind[pnt2]!) ≤ i then\n spv1[i] * spv2[i]\n else\n 0"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=
if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then
0
else
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
(spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
spv_dot spv1 spv2 (pnt1 + 1) pnt2
else
spv_dot spv1 spv2 pnt1 (pnt2 + 1)
termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)
method SpVSpV
(mut out: Array Int)
(spv1: SpV Int)
(spv2: SpV Int) return (u: Unit)
ensures out.size = 1
ensures out[0]! = spv_dot spv1 spv2 0 0
do
out := Array.replicate 1 0
let mut pnt1 := 0
let mut pnt2 := 0
while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size
invariant out.size = 1
invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size
invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0
done_with pnt1 = spv1.size ∨ pnt2 = spv2.size
do
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!
pnt1 := pnt1 + 1
pnt2 := pnt2 + 1
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
pnt1 := pnt1 + 1
else
pnt2 := pnt2 + 1
return
method SpMSpV
(mut out: Array Int)
(spm: Array (SpV Int))
(spv: SpV Int) return (u: Unit)
ensures out.size = spm.size
ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0
do
out := Array.replicate spm.size 0
let mut spmInd := Array.replicate spm.size 0
let mut spvInd := Array.replicate spm.size 0
while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size
invariant spvInd.size = spm.size
invariant spmInd.size = spm.size
invariant out.size = spm.size
invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size
invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size
invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0
done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size
do
let ind_m := spmInd[i]!
let ind_v := spvInd[i]!
if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then
out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!
spmInd[i] += 1
spvInd[i] += 1
else
if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then
spmInd[i] += 1
else
spvInd[i] += 1
return | theorem spv_dot_pure (spv1 spv2: SpV Int) (n: ℕ)
(sz1: ∀ i < spv1.size, spv1.ind[i]! < n) (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):
spv_dot spv1 spv2 0 0 = ∑ i ∈ Finset.range n, spv1[i] * spv2[i] := | := by
simp [spv_dot_pure_gen spv1 spv2 n 0 0 sz1 sz2]
apply Finset.sum_congr
{ rfl }
intro x hx
simp at hx
by_cases em1: spv1.size = 0 <;> simp [em1]
{ simp [lt_iff_le_not_ge.mp hx]
simp [getValSpV_empty spv1 x (by intro i hi; omega)] }
by_cases em2: spv2.size = 0 <;> simp [em2]
{ intros
simp [getValSpV_empty spv2 x (by intro i hi; omega)] }
intro zer_ineq
have zer_lemma (spv: SpV Int) (i: ℕ) (hsz: spv.size ≠ 0): i < spv.ind[0]! → spv[i] = 0 := by
intro lt
have all_none: ∀ j < spv.size, spv.ind[j]! ≠ i := by
intro i1 hi1
by_cases i10 : i1 = 0
{ simp [←i10] at lt
omega }
have contra := spv.inc 0 i1 (by omega) (by omega) (by omega)
simp at lt
omega
simp [getValSpV_empty spv i all_none]
by_cases sm1: spv1.ind[0]! ≤ x
{ simp [sm1] at zer_ineq
simp [zer_lemma spv2 x em2 zer_ineq] }
simp at sm1
simp [zer_lemma spv1 x em1 sm1] | 3 | 28 | false | Framework |
380 | array_extract_split_i_j_k | lemma array_extract_split_i_j_k (arr : Array α) (i j k: Nat) :
i < j -> j < k -> k ≤ arr.size →
arr.extract i k = (arr.extract i j) ++ (arr.extract j k) | loom | CaseStudies/Velvet/VelvetExamples/EncodeDecodeStr.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Loom.MonadAlgebras.WP.Tactic",
"import CaseStudies.TestingUtil",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Char",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Array.map",
"module": "Init.Data.Array.Basic"
},
{
"name": "Array.replicate",
"module": "Init.Data.Array.Basic"
},
{
"name": "Lean.Syntax",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Lean.Name",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.matchExpr",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.optIdent",
"module": "Lean.Parser.Term.Basic"
},
{
"name": "args",
"module": "Auto.Parser.TPTP"
},
{
"name": "cond",
"module": "Init.Prelude"
},
{
"name": "ite",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadQuotation",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadRef",
"module": "Init.Prelude"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "Lean.withRef",
"module": "Init.Prelude"
},
{
"name": "kind",
"module": "Auto.Parser.TPTP"
},
{
"name": "Lean.MacroM",
"module": "Init.Prelude"
},
{
"name": "ReaderT",
"module": "Init.Prelude"
},
{
"name": "Bind",
"module": "Init.Prelude"
},
{
"name": "Bind.bind",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.debugAssert",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.doAssert",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doDbgTrace",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doDebugAssert",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.ident",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Syntax.mkApp",
"module": "Init.Meta.Defs"
},
{
"name": "Lean.mkIdentFrom",
"module": "Init.Meta.Defs"
},
{
"name": "Lean.Parser.Term.let_delayed",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.mkIdentFromRef",
"module": "Init.Meta.Defs"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "Lean.quoteNameMk",
"module": "Init.Meta.Defs"
},
{
"name": "DoResultPR",
"module": "Init.Core"
},
{
"name": "DoResultPRBC",
"module": "Init.Core"
},
{
"name": "DoResultSBC",
"module": "Init.Core"
},
{
"name": "ForInStep",
"module": "Init.Core"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "DoResultBC",
"module": "Init.Core"
},
{
"name": "ForInStep.yield",
"module": "Init.Core"
},
{
"name": "Lean.Name.cmp",
"module": "Lean.Data.Name"
},
{
"name": "Std.TreeMap",
"module": "Std.Data.TreeMap.Basic"
},
{
"name": "Lean.Elab.Term.TermElabM",
"module": "Lean.Elab.Term.TermElabM"
},
{
"name": "Lean.Parser.Term.doLetArrow",
"module": "Lean.Parser.Do"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.doHave",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doLet",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doLetRec",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doReassign",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doReassignArrow",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.throwErrorAt",
"module": "Lean.Exception"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.doSeqBracketed",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doSeqIndent",
"module": "Lean.Parser.Do"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "Id.run",
"module": "Init.Control.Id"
},
{
"name": "modify",
"module": "Init.Prelude"
},
{
"name": "Lean.Elab.liftMacroM",
"module": "Lean.Elab.Util"
},
{
"name": "Unit.unit",
"module": "Init.Prelude"
},
{
"name": "term",
"module": "Auto.Parser.TPTP"
},
{
"name": "type",
"module": "Auto.Lib.Rebind"
},
{
"name": "Lean.Parser.Term.unreachable",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.throwError",
"module": "Lean.Exception"
},
{
"name": "Lean.Elab.Term.Quotation.getPatternVars",
"module": "Lean.Elab.Quotation.Util"
},
{
"name": "Lean.Elab.Term.getPatternVars",
"module": "Lean.Elab.PatternVar"
},
{
"name": "PUnit.unit",
"module": "Init.Prelude"
},
{
"name": "Stream",
"module": "Init.Data.Stream"
},
{
"name": "Stream.next?",
"module": "Init.Data.Stream"
},
{
"name": "Lean.mkNullNode",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.optType",
"module": "Lean.Parser.Term.Basic"
},
{
"name": "Lean.Parser.Term.doCatch",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doCatchMatch",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.matchAlts",
"module": "Lean.Parser.Term"
},
{
"name": "MonadExcept",
"module": "Init.Prelude"
},
{
"name": "MonadExcept.tryCatch",
"module": "Init.Prelude"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "tryCatchThe",
"module": "Init.Prelude"
},
{
"name": "tryFinally",
"module": "Init.Control.Except"
},
{
"name": "Lean.Parser.Term.doLetElse",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.mkNode",
"module": "Init.Prelude"
},
{
"name": "Lean.HygieneInfo.mkIdent",
"module": "Init.Meta.Defs"
},
{
"name": "Lean.Parser.Term.letId",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.hygieneInfoKind",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.letIdDecl",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.letPatDecl",
"module": "Lean.Parser.Term"
},
{
"name": "sequence",
"module": "Mathlib.Control.Traversable.Basic"
},
{
"name": "Lean.Elab.Term.Quotation.getPatternsVars",
"module": "Lean.Elab.Quotation.Util"
},
{
"name": "Lean.Elab.Term.getPatternsVars",
"module": "Lean.Elab.PatternVar"
},
{
"name": "Lean.Elab.Term.expandMatchAlt",
"module": "Lean.Elab.BindersUtil"
},
{
"name": "Lean.Parser.Term.letEqnsDecl",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.letDecl",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.doIdDecl",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doPatDecl",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.SyntaxNodeKind",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.termFor",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.termReturn",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.termTry",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.termUnless",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.liftMethod",
"module": "Lean.Parser.Do"
},
{
"name": "termDepIfThenElse",
"module": "Init.Notation"
},
{
"name": "termIfThenElse",
"module": "Init.Notation"
},
{
"name": "Lean.Parser.Term.letrec",
"module": "Lean.Parser.Term"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "Lean.Parser.Term.num",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Syntax.node",
"module": "Init.Prelude"
},
{
"name": "Lean.choiceKind",
"module": "Init.Prelude"
},
{
"name": "error",
"module": "Auto.Parser.TPTP"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "node",
"module": "Test.SmtTranslation.Inductive"
},
{
"name": "Lean.MonadQuotation.addMacroScope",
"module": "Init.Prelude"
},
{
"name": "Lean.Parser.Term.doBreak",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doContinue",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doExpr",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doFor",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doIf",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doMatch",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doMatchExpr",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doNested",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doReturn",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doTry",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.Parser.Term.doUnless",
"module": "Lean.Parser.Do"
},
{
"name": "Lean.withIncRecDepth",
"module": "Lean.Exception"
},
{
"name": "Lean.Elab.Term.expandOptType",
"module": "Lean.Elab.BindersUtil"
},
{
"name": "Lean.Parser.Term.letRecDecls",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Macro.throwErrorAt",
"module": "Init.Prelude"
},
{
"name": "Lean.Meta.instantiateMVarsIfMVarApp",
"module": "Lean.Meta.Basic"
},
{
"name": "Lean.Parser.Term.matchAlt",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.matchExprAlt",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.matchExprAlts",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.matchExprElseAlt",
"module": "Lean.Parser.Term"
},
{
"name": "Lean.Parser.Term.matchExprPat",
"module": "Lean.Parser.Term"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Encodable",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Encodable.decode",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "inline",
"module": "Init.Core"
},
{
"name": "Lean.Order.CCPO",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.MonoBind",
"module": "Init.Internal.Order.Basic"
},
{
"name": "List.cons",
"module": "Init.Prelude"
},
{
"name": "List.nil",
"module": "Init.Prelude"
},
{
"name": "List.take",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "syntax \"let\" term \":|\" term : doElem",
"content": "syntax \"let\" term \":|\" term : doElem\n\nsyntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" term \")\"\n (require_caluse )*\n (ensures_caluse)* \"do\" doSeq\n Termination.suffix : command"
},
{
"name": "macro \"extract_tactic\" : tactic =>",
"content": "macro \"extract_tactic\" : tactic =>\n `(tactic| repeat' (intros; extract_step <;> try dsimp))\n\nsyntax \"loom_solve\" : loom_solve_tactic\n\nsyntax \"ensures\" termBeforeReqEnsDo : ensures_caluse\n\nsyntax \"require\" termBeforeReqEnsDo : require_caluse\n\nsyntax \"prove_correct\" : prove_correct_command\n\nsyntax \"prove_correct\" ident Termination.suffix \"by\" tacticSeq : command\n\nsyntax \"done_with\" termBeforeDo : doneWith\n\nsyntax \"invariant\" termBeforeDo linebreak : invariantClause\n\nsyntax \"while\" term\n (invariantClause)*\n (doneWith)?\n (decreasingTerm)?\n \"do\" doSeq : doElem"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem|$id:ident[$idx:term] := $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (fun _ => $val))\n | `(doElem|$id:ident[$idx:term] += $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (· + $val))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| let $x:term :| $t) => `(doElem| let $x:term <- pickSuchThat _ (fun $x => type_with_name_prefix `choice $t))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t do $seq:doSeq) => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- withRef (<- getRef) `(invariants [])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done ¬$t:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match measure with\n | some measure_some =>\n let decr <- withRef measure_some `(decreasing type_with_name_prefix `decreasing $measure_some)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | none => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while_some $x:ident :| $t do $seq:doSeq) =>\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n while ∃ $x:ident, $t do\n let $x :| $t\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| while_some $x:ident :| $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]? do\n $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n let decr <- withRef (<- getRef) `(decreasing none)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if ∃ $x:ident, $t then\n let $x :| $t\n $[$seq:doElem]*\n else break)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| for $x:ident in $t\n $[invariant $inv:term\n ]*\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n for $x:ident in $t do\n $invs:term\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"for expects a sequence of do-elements\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(tactic|loom_solver) =>\n `(tactic|(\n try simp at *\n try aesop))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let balance := mkIdent `balance_name\n let balanceType <- `(term| Bal)\n let inv : Array Term <- inv.mapM fun (inv : Term) => withRef inv ``(fun ($(balance):ident : $balanceType)=> with_name_prefix `inv $inv)\n let invd_some <- match inv_done with\n | some invd_some => withRef invd_some ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done $invd_some)\n | none => ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done ¬$t:term)\n match measure with\n | some measure_some =>\n let measure_some ← withRef measure_some ``(type_with_name_prefix `decreasing ($measure_some:term))\n do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget ($measure_some:term)\n if $t then\n $seq:doSeq\n else break)\n | none => do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget none\n if $t then\n $seq:doSeq\n else break)"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(doElem|balance_set $t) => do\n let balId := mkIdent `balance\n `(doElem|do\n $balId:ident := $t\n set $balId:ident\n $balId:ident ← get)"
},
{
"name": "VelvetM.extract",
"content": "def VelvetM.extract {α : Type} (x : VelvetM α)\n [∀ α, Lean.Order.CCPO (DivM α)] [Lean.Order.MonoBind DivM] [Inhabited α] : α :=\n x.run.run"
},
{
"name": "run",
"content": "def run (code : Code) (m : Syntax) (returnType : Syntax) (uvars : Array Var := #[]) (kind := Kind.regular) : MacroM Syntax :=\n toTerm code { m, returnType, kind, uvars }"
},
{
"name": "Kind",
"content": "inductive Kind where\n | regular\n | forIn\n | forInWithReturn\n | nestedBC\n | nestedPR\n | nestedSBC\n | nestedPRBC"
},
{
"name": "Var",
"content": "abbrev Var := Syntax "
},
{
"name": "Code",
"content": "inductive Code where\n | decl (xs : Array Var) (doElem : Syntax) (k : Code)\n | reassign (xs : Array Var) (doElem : Syntax) (k : Code)\n \n | joinpoint (name : Name) (params : Array (Var × Bool)) (body : Code) (k : Code)\n | seq (action : Syntax) (k : Code)\n | action (action : Syntax)\n | break (ref : Syntax)\n | continue (ref : Syntax)\n | return (ref : Syntax) (val : Syntax)\n \n | ite (ref : Syntax) (h? : Option Var) (optIdent : Syntax) (cond : Syntax) (thenBranch : Code) (elseBranch : Code)\n | match (ref : Syntax) (gen : Syntax) (discrs : Syntax) (optMotive : Syntax) (alts : Array (Alt Code))\n | matchExpr (ref : Syntax) («meta» : Bool) (discr : Syntax) (alts : Array (AltExpr Code)) (elseBranch : Code)\n | jmp (ref : Syntax) (jpName : Name) (args : Array Syntax)\n deriving Inhabited"
},
{
"name": "AltExpr",
"content": "structure AltExpr (σ : Type) where\n ref : Syntax\n var? : Option Var\n funName : Syntax\n pvars : Array Syntax\n rhs : σ\n deriving Inhabited"
},
{
"name": "DoIfView",
"content": "structure DoIfView where\n ref : Syntax\n optIdent : Syntax\n cond : Syntax\n thenBranch : Syntax\n elseBranch : Syntax"
},
{
"name": "Alt",
"content": "structure Alt (σ : Type) where\n ref : Syntax\n vars : Array Var\n patterns : Syntax\n rhs : σ\n deriving Inhabited"
},
{
"name": "JPDecl",
"content": "structure JPDecl where\n name : Name\n params : Array (Var × Bool)\n body : Code"
},
{
"name": "toTerm",
"content": "partial def toTerm (c : Code) : M Syntax := do\n let term ← go c\n if let some ref := c.getRef? then\n annotate ref term\n else\n return term\nwhere\n go (c : Code) : M Syntax := do\n match c with\n | .return ref val => withRef ref <| returnToTerm val\n | .continue ref => withRef ref continueToTerm\n | .break ref => withRef ref breakToTerm\n | .action e => actionTerminalToTerm e\n | .joinpoint j ps b k => mkJoinPoint j ps (← toTerm b) (← toTerm k)\n | .jmp ref j args => return mkJmp ref j args\n | .decl _ stx k => declToTerm stx (← toTerm k)\n | .reassign _ stx k => reassignToTerm stx (← toTerm k)\n | .seq stx k => seqToTerm stx (← toTerm k)\n | .ite ref _ o c t e => withRef ref <| do mkIte o c (← toTerm t) (← toTerm e)\n | .match ref genParam discrs optMotive alts =>\n let mut termAlts := #[]\n for alt in alts do\n let rhs ← toTerm alt.rhs\n let termAlt := mkNode ``Parser.Term.matchAlt #[mkAtomFrom alt.ref \"|\", mkNullNode #[alt.patterns], mkAtomFrom alt.ref \"=>\", rhs]\n termAlts := termAlts.push termAlt\n let termMatchAlts := mkNode ``Parser.Term.matchAlts #[mkNullNode termAlts]\n return mkNode ``Parser.Term.«match» #[mkAtomFrom ref \"match\", genParam, optMotive, discrs, mkAtomFrom ref \"with\", termMatchAlts]\n | .matchExpr ref «meta» d alts elseBranch => withFreshMacroScope do\n let d' ← `(discr)\n let mut termAlts := #[]\n for alt in alts do\n let rhs ← `(($(← toTerm alt.rhs) : $((← read).m) _))\n let optVar := if let some var := alt.var? then mkNullNode #[var, mkAtomFrom var \"@\"] else mkNullNode #[]\n let pat := mkNode ``Parser.Term.matchExprPat #[optVar, alt.funName, mkNullNode alt.pvars]\n let termAlt := mkNode ``Parser.Term.matchExprAlt #[mkAtomFrom alt.ref \"|\", pat, mkAtomFrom alt.ref \"=>\", rhs]\n termAlts := termAlts.push termAlt\n let elseBranch := mkNode ``Parser.Term.matchExprElseAlt #[mkAtomFrom ref \"|\", mkHole ref, mkAtomFrom ref \"=>\", (← toTerm elseBranch)]\n let termMatchExprAlts := mkNode ``Parser.Term.matchExprAlts #[mkNullNode termAlts, elseBranch]\n let body := mkNode ``Parser.Term.matchExpr #[mkAtomFrom ref \"match_expr\", d', mkAtomFrom ref \"with\", termMatchExprAlts]\n if «meta» then\n `(Bind.bind (instantiateMVarsIfMVarApp $d) fun discr => $body)\n else\n `(let discr := $d; $body)"
},
{
"name": "annotate",
"content": "def annotate [Monad m] [MonadRef m] [MonadQuotation m] (ref : Syntax) (term : Syntax) : m Syntax :=\n withRef term <| `(with_annotate_term $ref $term)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "seqToTerm",
"content": "def seqToTerm (action : Syntax) (k : Syntax) : M Syntax := withRef action <| withFreshMacroScope do\n if action.getKind == ``Parser.Term.doDbgTrace then\n let msg := action[1]\n `(dbg_trace $msg; $k)\n else if action.getKind == ``Parser.Term.doAssert then\n let cond := action[1]\n `(assert! $cond; $k)\n else if action.getKind == ``Parser.Term.doDebugAssert then\n let cond := action[1]\n `(debugAssert| debug_assert! $cond; $k)\n else\n let action ← withRef action ``(($action : $((←read).m) PUnit))\n ``(Bind.bind $action (fun (_ : PUnit) => $k))"
},
{
"name": "M",
"content": "abbrev M := ReaderT Context MacroM"
},
{
"name": "Context",
"content": "structure Context where\n \n m : Syntax\n \n returnType : Syntax\n uvars : Array Var\n kind : Kind"
},
{
"name": "ToForInTermResult",
"content": "structure ToForInTermResult where\n uvars : Array Var\n term : Syntax"
},
{
"name": "Code.getRef?",
"content": "def Code.getRef? : Code → Option Syntax\n | .decl _ doElem _ => doElem\n | .reassign _ doElem _ => doElem\n | .joinpoint .. => none\n | .seq a _ => a\n | .action a => a\n | .break ref => ref\n | .continue ref => ref\n | .return ref _ => ref\n | .ite ref .. => ref\n | .match ref .. => ref\n | .matchExpr ref .. => ref\n | .jmp ref .. => ref"
},
{
"name": "mkIte",
"content": "def mkIte (optIdent : Syntax) (cond : Syntax) (thenBranch : Syntax) (elseBranch : Syntax) : MacroM Syntax := do\n if optIdent.isNone then\n ``(if $cond then $thenBranch else $elseBranch)\n else\n let h := optIdent[0]\n ``(if $h:ident : $cond then $thenBranch else $elseBranch)"
},
{
"name": "mkJmp",
"content": "def mkJmp (ref : Syntax) (j : Name) (args : Array Syntax) : Syntax :=\n Syntax.mkApp (mkIdentFrom ref j) args"
},
{
"name": "mkJoinPoint",
"content": "def mkJoinPoint (j : Name) (ps : Array (Syntax × Bool)) (body : Syntax) (k : Syntax) : M Syntax := withRef body <| withFreshMacroScope do\n let pTypes ← ps.mapM fun ⟨id, useTypeOf⟩ => do if useTypeOf then `(type_of% $id) else `(_)\n let ps := ps.map (·.1)\n \n `(let_delayed $(← mkIdentFromRef j):ident $[($ps : $pTypes)]* : $((← read).m) _ := $body; $k)"
},
{
"name": "returnToTerm",
"content": "def returnToTerm (val : Syntax) : M Syntax := do\n let ctx ← read\n let u ← mkUVarTuple\n match ctx.kind with\n | .regular => if ctx.uvars.isEmpty then ``(Pure.pure $val) else ``(Pure.pure (MProdWithNames.mk $val $u))\n | .forIn => ``(Pure.pure (ForInStep.done $u))\n | .forInWithReturn => ``(Pure.pure (ForInStep.done (MProdWithNames.mk (some $val) $u)))\n | .nestedBC => unreachable!\n | .nestedPR => ``(Pure.pure (DoResultPR.«return» $val $u))\n | .nestedSBC => ``(Pure.pure (DoResultSBC.«pureReturn» $val $u))\n | .nestedPRBC => ``(Pure.pure (DoResultPRBC.«return» $val $u))"
},
{
"name": "mkUVarTuple",
"content": "def mkUVarTuple : M Syntax := do\n let ctx ← read\n mkTuple ctx.uvars"
},
{
"name": "mkTuple",
"content": "private def mkTuple (elems : Array Syntax) : MacroM Syntax := do\n if elems.size = 0 then\n mkUnit\n else if h : elems.size = 1 then\n ``(WithName.mk' $(elems[0]) $(Lean.quoteNameMk elems[0].getId))\n else\n let init <- ``(WithName.mk' $(elems.back!) $(Lean.quoteNameMk elems.back!.getId))\n elems.extract 0 (elems.size - 1) |>.foldrM (init := init) fun elem tuple => do\n let name := Lean.quoteNameMk elem.getId\n ``(MProdWithNames.mk' $elem $tuple $name)"
},
{
"name": "MProdWithNames.mk'",
"content": "abbrev MProdWithNames.mk' {α β : Type u} (a : α) (b : β)\n (αName : Lean.Name := default) : MProdWithNames α β αName :=\n @MProdWithNames.mk _ _ αName a b"
},
{
"name": "mkUnit",
"content": "private def mkUnit : MacroM Syntax :=\n ``((⟨⟩ : PUnit))"
},
{
"name": "WithName.mk'",
"content": "abbrev WithName.mk' {α : Sort u} (a : α) (name : Lean.Name := default) : WithName α name :=\n a"
},
{
"name": "continueToTerm",
"content": "def continueToTerm : M Syntax := do\n let ctx ← read\n let u ← mkUVarTuple\n match ctx.kind with\n | .regular => unreachable!\n | .forIn => ``(Pure.pure (ForInStep.yield $u))\n | .forInWithReturn => ``(Pure.pure (ForInStep.yield (MProdWithNames.mk none $u)))\n | .nestedBC => ``(Pure.pure (DoResultBC.«continue» $u))\n | .nestedPR => unreachable!\n | .nestedSBC => ``(Pure.pure (DoResultSBC.«continue» $u))\n | .nestedPRBC => ``(Pure.pure (DoResultPRBC.«continue» $u))"
},
{
"name": "declToTerm",
"content": "def declToTerm (decl : Syntax) (k : Syntax) : M Syntax := withRef decl <| withFreshMacroScope do\n let kind := decl.getKind\n if kind == ``Parser.Term.doLet then\n let letDecl := decl[2]\n `(let $letDecl:letDecl; $k)\n else if kind == ``Parser.Term.doLetRec then\n let letRecToken := decl[0]\n let letRecDecls := decl[1]\n return mkNode ``Parser.Term.letrec #[letRecToken, letRecDecls, mkNullNode, k]\n else if kind == ``Parser.Term.doLetArrow then\n let arg := decl[2]\n if arg.getKind == ``Parser.Term.doIdDecl then\n let id := arg[0]\n let type := expandOptType id arg[1]\n let doElem := arg[3]\n \n match isDoExpr? doElem with\n | some action =>\n let action ← withRef action `(($action : $((← read).m) $type))\n ``(Bind.bind $action (fun ($id:ident : $type) => $k))\n | none => Macro.throwErrorAt decl \"unexpected kind of `do` declaration\"\n else\n Macro.throwErrorAt decl \"unexpected kind of `do` declaration\"\n else if kind == ``Parser.Term.doHave then\n \n let args := decl.getArgs\n let args := args ++ #[mkNullNode , k]\n return mkNode `Lean.Parser.Term.«have» args\n else\n Macro.throwErrorAt decl \"unexpected kind of `do` declaration\"\n\n partial def doLetArrowToCode (doLetArrow : Syntax) (doElems : List Syntax) : M CodeBlock := do\n let decl := doLetArrow[2]\n if decl.getKind == ``Parser.Term.doIdDecl then\n let y := decl[0]\n checkNotShadowingMutable #[y]\n let doElem := decl[3]\n let k ← withNewMutableVars #[y] (isMutableLet doLetArrow) (doSeqToCode doElems)\n match isDoExpr? doElem with\n | some _ => return mkVarDeclCore #[y] doLetArrow k\n | none =>\n checkLetArrowRHS doElem\n let c ← doSeqToCode [doElem]\n match doElems with\n | [] => pure c\n | kRef::_ => concat c kRef y k\n else if decl.getKind == ``Parser.Term.doPatDecl then\n let pattern := decl[0]\n let doElem := decl[2]\n let optElse := decl[3]\n if optElse.isNone then withFreshMacroScope do\n let auxDo ← if isMutableLet doLetArrow then\n `(do let%$doLetArrow __discr ← $doElem; let%$doLetArrow mut $pattern:term := __discr)\n else\n `(do let%$doLetArrow __discr ← $doElem; let%$doLetArrow $pattern:term := __discr)\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems\n else\n let contSeq ← if isMutableLet doLetArrow then\n let vars ← (← getPatternVarsEx pattern).mapM fun var => `(doElem| let mut $var := $var)\n pure (vars ++ doElems.toArray)\n else\n pure doElems.toArray\n let contSeq := mkDoSeq contSeq\n let elseSeq := optElse[1]\n let auxDo ← `(do let%$doLetArrow __discr ← $doElem; match%$doLetArrow __discr with | $pattern:term => $contSeq | _ => $elseSeq)\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo)\n else\n throwError \"unexpected kind of `do` declaration\""
},
{
"name": "checkLetArrowRHS",
"content": "def checkLetArrowRHS (doElem : Syntax) : M Unit := do\n let kind := doElem.getKind\n if kind == ``Parser.Term.doLetArrow ||\n kind == ``Parser.Term.doLet ||\n kind == ``Parser.Term.doLetRec ||\n kind == ``Parser.Term.doHave ||\n kind == ``Parser.Term.doReassign ||\n kind == ``Parser.Term.doReassignArrow then\n throwErrorAt doElem \"invalid kind of value `{kind}` in an assignment\""
},
{
"name": "M",
"content": "abbrev M := ReaderT Context TermElabM"
},
{
"name": "VarSet",
"content": "abbrev VarSet := Std.TreeMap Name Syntax Name.cmp"
},
{
"name": "getDoSeq",
"content": "private def getDoSeq (doStx : Syntax) : Syntax :=\n doStx[1]\n\n partial def doSeqToCode : List Syntax → M CodeBlock\n | [] => do liftMacroM mkPureUnitAction\n | doElem::doElems => withIncRecDepth <| withRef doElem do\n checkSystem \"`do`-expander\"\n match (← liftMacroM <| expandMacro? doElem) with\n | some doElem => doSeqToCode (doElem::doElems)\n | none =>\n match (← liftMacroM <| expandDoIf? doElem) with\n | some doElem => doSeqToCode (doElem::doElems)\n | none =>\n match (← liftMacroM <| expandDoLetExpr? doElem doElems) with\n | some doElem => doSeqToCode [doElem]\n | none =>\n let (liftedDoElems, doElem) ← expandLiftMethod doElem\n if !liftedDoElems.isEmpty then\n doSeqToCode (liftedDoElems ++ [doElem] ++ doElems)\n else\n let ref := doElem\n let k := doElem.getKind\n if k == ``Parser.Term.doLet then\n let vars ← getDoLetVars doElem\n checkNotShadowingMutable vars\n mkVarDeclCore vars doElem <$> withNewMutableVars vars (isMutableLet doElem) (doSeqToCode doElems)\n else if k == ``Parser.Term.doHave then\n let vars ← getDoHaveVars doElem\n checkNotShadowingMutable vars\n mkVarDeclCore vars doElem <$> (doSeqToCode doElems)\n else if k == ``Parser.Term.doLetRec then\n let vars ← getDoLetRecVars doElem\n checkNotShadowingMutable vars\n mkVarDeclCore vars doElem <$> (doSeqToCode doElems)\n else if k == ``Parser.Term.doReassign then\n let vars ← getDoReassignVars doElem\n checkReassignable vars\n let k ← doSeqToCode doElems\n mkReassignCore vars doElem k\n else if k == ``Parser.Term.doLetArrow then\n doLetArrowToCode doElem doElems\n else if k == ``Parser.Term.doLetElse then\n doLetElseToCode doElem doElems\n else if k == ``Parser.Term.doReassignArrow then\n doReassignArrowToCode doElem doElems\n else if k == ``Parser.Term.doIf then\n doIfToCode doElem doElems\n else if k == ``Parser.Term.doUnless then\n doUnlessToCode doElem doElems\n else if k == ``Parser.Term.doFor then withFreshMacroScope do\n doForToCode doElem doElems\n else if k == ``Parser.Term.doMatch then\n doMatchToCode doElem doElems\n else if k == ``Parser.Term.doMatchExpr then\n doMatchExprToCode doElem doElems\n else if k == ``Parser.Term.doTry then\n doTryToCode doElem doElems\n else if k == ``Parser.Term.doBreak then\n ensureInsideFor\n ensureEOS doElems\n return mkBreak ref\n else if k == ``Parser.Term.doContinue then\n ensureInsideFor\n ensureEOS doElems\n return mkContinue ref\n else if k == ``Parser.Term.doReturn then\n doReturnToCode doElem doElems\n else if k == ``Parser.Term.doDbgTrace then\n return mkSeq doElem (← doSeqToCode doElems)\n else if k == ``Parser.Term.doAssert then\n return mkSeq doElem (← doSeqToCode doElems)\n else if k == ``Parser.Term.doDebugAssert then\n return mkSeq doElem (← doSeqToCode doElems)\n else if k == ``Parser.Term.doNested then\n let nestedDoSeq := doElem[1]\n doSeqToCode (getDoSeqElems nestedDoSeq ++ doElems)\n else if k == ``Parser.Term.doExpr then\n let term := doElem[0]\n if doElems.isEmpty then\n return mkTerminalAction term\n else\n return mkSeq term (← doSeqToCode doElems)\n else\n throwError \"unexpected do-element of kind {doElem.getKind}:\\n{doElem}\""
},
{
"name": "getDoSeqElems",
"content": "private def getDoSeqElems (doSeq : Syntax) : List Syntax :=\n if doSeq.getKind == ``Parser.Term.doSeqBracketed then\n doSeq[1].getArgs.toList.map fun arg => arg[0]\n else if doSeq.getKind == ``Parser.Term.doSeqIndent then\n doSeq[0].getArgs.toList.map fun arg => arg[0]\n else\n []\n\n partial def doIfToCode (doIf : Syntax) (doElems : List Syntax) : M CodeBlock := do\n let view := mkDoIfView doIf\n let thenBranch ← doSeqToCode (getDoSeqElems view.thenBranch)\n let elseBranch ← doSeqToCode (getDoSeqElems view.elseBranch)\n let ite ← mkIte view.ref view.optIdent view.cond thenBranch elseBranch\n concatWith ite doElems"
},
{
"name": "CodeBlock",
"content": "structure CodeBlock where\n code : Code\n uvars : VarSet := {} "
},
{
"name": "mkDoIfView",
"content": "private def mkDoIfView (doIf : Syntax) : DoIfView := {\n ref := doIf\n optIdent := doIf[1][0]\n cond := doIf[1][1]\n thenBranch := doIf[3]\n elseBranch := doIf[5][1]\n}\n\n partial def concatWith (c : CodeBlock) (doElems : List Syntax) : M CodeBlock :=\n match doElems with\n | [] => pure c\n | nextDoElem :: _ => do\n let k ← doSeqToCode doElems\n let ref := nextDoElem\n concat c ref none k"
},
{
"name": "concat",
"content": "def concat (terminal : CodeBlock) (kRef : Syntax) (y? : Option Var) (k : CodeBlock) : TermElabM CodeBlock := do\n unless hasTerminalAction terminal.code do\n throwErrorAt kRef \"`do` element is unreachable\"\n let (terminal, k) ← homogenize terminal k\n let xs := varSetToArray k.uvars\n let y ← match y? with | some y => pure y | none => `(y)\n let ps := xs.map fun x => (x, true)\n let ps := ps.push (y, false)\n let jpDecl ← mkFreshJP ps k.code\n let jp := jpDecl.name\n let terminal ← liftMacroM <| convertTerminalActionIntoJmp terminal.code jp xs\n return { code := attachJP jpDecl terminal, uvars := k.uvars }"
},
{
"name": "homogenize",
"content": "def homogenize (c₁ c₂ : CodeBlock) : TermElabM (CodeBlock × CodeBlock) := do\n let ws := union c₁.uvars c₂.uvars\n let c₁ ← extendUpdatedVars c₁ ws\n let c₂ ← extendUpdatedVars c₂ ws\n pure (c₁, c₂)"
},
{
"name": "extendUpdatedVars",
"content": "partial def extendUpdatedVars (c : CodeBlock) (ws : VarSet) : TermElabM CodeBlock := do\n if ws.any fun x _ => !c.uvars.contains x then\n \n pure { code := (← extendUpdatedVarsAux c.code ws), uvars := ws }\n else\n pure { c with uvars := ws }"
},
{
"name": "extendUpdatedVarsAux",
"content": "partial def extendUpdatedVarsAux (c : Code) (ws : VarSet) : TermElabM Code :=\n let rec update (c : Code) : TermElabM Code := do\n match c with\n | .joinpoint j ps b k => return .joinpoint j ps (← update b) (← update k)\n | .seq e k => return .seq e (← update k)\n | .match ref g ds t alts =>\n if alts.any fun alt => alt.vars.any fun x => ws.contains x.getId then\n \n pullExitPoints c\n else\n return .match ref g ds t (← alts.mapM fun alt => do pure { alt with rhs := (← update alt.rhs) })\n | .matchExpr ref «meta» d alts e =>\n if alts.any fun alt => alt.vars.any fun x => ws.contains x.getId then\n \n pullExitPoints c\n else\n let alts ← alts.mapM fun alt => do pure { alt with rhs := (← update alt.rhs) }\n let e ← update e\n return .matchExpr ref «meta» d alts e\n | .ite ref none o c t e => return .ite ref none o c (← update t) (← update e)\n | .ite ref (some h) o cond t e =>\n if ws.contains h.getId then\n \n pullExitPoints c\n else\n return Code.ite ref (some h) o cond (← update t) (← update e)\n | .reassign xs stx k => return .reassign xs stx (← update k)\n | .decl xs stx k => do\n if xs.any fun x => ws.contains x.getId then\n \n pullExitPoints c\n else\n return .decl xs stx (← update k)\n | c => return c\n update c"
},
{
"name": "AltExpr.vars",
"content": "def AltExpr.vars (alt : AltExpr σ) : Array Var := Id.run do\n let mut vars := #[]\n if let some var := alt.var? then\n vars := vars.push var\n for pvar in alt.pvars do\n match pvar with\n | `(_) => pure ()\n | _ => vars := vars.push pvar\n return vars"
},
{
"name": "pullExitPoints",
"content": "def pullExitPoints (c : Code) : TermElabM Code := do\n if hasExitPoint c then\n let (c, jpDecls) ← (pullExitPointsAux {} c).run #[]\n return attachJPs jpDecls c\n else\n return c"
},
{
"name": "hasExitPoint",
"content": "def hasExitPoint (c : Code) : Bool :=\n hasExitPointPred c fun _ => true"
},
{
"name": "hasExitPointPred",
"content": "partial def hasExitPointPred (c : Code) (p : Code → Bool) : Bool :=\n let rec loop : Code → Bool\n | .decl _ _ k => loop k\n | .reassign _ _ k => loop k\n | .joinpoint _ _ b k => loop b || loop k\n | .seq _ k => loop k\n | .ite _ _ _ _ t e => loop t || loop e\n | .match _ _ _ _ alts => alts.any (loop ·.rhs)\n | .matchExpr _ _ _ alts e => alts.any (loop ·.rhs) || loop e\n | .jmp .. => false\n | c => p c\n loop c"
},
{
"name": "pullExitPointsAux",
"content": "partial def pullExitPointsAux (rs : VarSet) (c : Code) : StateRefT (Array JPDecl) TermElabM Code := do\n match c with\n | .decl xs stx k => return .decl xs stx (← pullExitPointsAux (eraseVars rs xs) k)\n | .reassign xs stx k => return .reassign xs stx (← pullExitPointsAux (insertVars rs xs) k)\n | .joinpoint j ps b k => return .joinpoint j ps (← pullExitPointsAux rs b) (← pullExitPointsAux rs k)\n | .seq e k => return .seq e (← pullExitPointsAux rs k)\n | .ite ref x? o c t e => return .ite ref x? o c (← pullExitPointsAux (eraseOptVar rs x?) t) (← pullExitPointsAux (eraseOptVar rs x?) e)\n | .jmp .. => return c\n | .break ref => mkSimpleJmp ref rs (.break ref)\n | .continue ref => mkSimpleJmp ref rs (.continue ref)\n | .return ref val => mkJmp ref rs val (fun y => return .return ref y)\n | .action e =>\n \n mkAuxDeclFor e fun y =>\n let ref := e\n mkJmp ref rs y (fun yFresh => return .action (← ``(Pure.pure $yFresh)))\n | .match ref g ds t alts =>\n let alts ← alts.mapM fun alt => do pure { alt with rhs := (← pullExitPointsAux (eraseVars rs alt.vars) alt.rhs) }\n return .match ref g ds t alts\n | .matchExpr ref «meta» d alts e =>\n let alts ← alts.mapM fun alt => do pure { alt with rhs := (← pullExitPointsAux (eraseVars rs alt.vars) alt.rhs) }\n let e ← pullExitPointsAux rs e\n return .matchExpr ref «meta» d alts e"
},
{
"name": "mkJmp",
"content": "def mkJmp (ref : Syntax) (rs : VarSet) (val : Syntax) (mkJPBody : Syntax → MacroM Code) : StateRefT (Array JPDecl) TermElabM Code := do\n let xs := varSetToArray rs\n let args := xs.push val\n let yFresh ← withRef ref `(y)\n let ps := xs.map fun x => (x, true)\n let ps := ps.push (yFresh, false)\n let jpBody ← liftMacroM <| mkJPBody yFresh\n let jp ← addFreshJP ps jpBody\n return Code.jmp ref jp args"
},
{
"name": "varSetToArray",
"content": "private def varSetToArray (s : VarSet) : Array Var :=\n s.foldl (fun xs _ x => xs.push x) #[]"
},
{
"name": "addFreshJP",
"content": "def addFreshJP (ps : Array (Var × Bool)) (body : Code) : StateRefT (Array JPDecl) TermElabM Name := do\n let jp ← mkFreshJP ps body\n modify fun (jps : Array JPDecl) => jps.push jp\n pure jp.name"
},
{
"name": "mkFreshJP",
"content": "def mkFreshJP (ps : Array (Var × Bool)) (body : Code) : TermElabM JPDecl := do\n let ps ← if ps.isEmpty then\n let y ← `(y)\n pure #[(y.raw, false)]\n else\n pure ps\n \n \n \n let name ← mkFreshUserName `__do_jp\n pure { name := name, params := ps, body := body }"
},
{
"name": "mkSimpleJmp",
"content": "def mkSimpleJmp (ref : Syntax) (rs : VarSet) (c : Code) : StateRefT (Array JPDecl) TermElabM Code := do\n let xs := varSetToArray rs\n let jp ← addFreshJP (xs.map fun x => (x, true)) c\n if xs.isEmpty then\n let unit ← ``(Unit.unit)\n return Code.jmp ref jp #[unit]\n else\n return Code.jmp ref jp xs"
},
{
"name": "eraseOptVar",
"content": "def eraseOptVar (rs : VarSet) (x? : Option Var) : VarSet :=\n match x? with\n | none => rs\n | some x => rs.insert x.getId x"
},
{
"name": "mkAuxDeclFor",
"content": "def mkAuxDeclFor {m} [Monad m] [MonadQuotation m] (e : Syntax) (mkCont : Syntax → m Code) : m Code := withRef e <| withFreshMacroScope do\n let y ← `(y)\n let doElem ← `(doElem| let y ← $e:term)\n \n let y ← `(ensure_expected_type% \"type mismatch, result value\" $y)\n let k ← mkCont y\n return .decl #[y] doElem k"
},
{
"name": "eraseVars",
"content": "def eraseVars (rs : VarSet) (xs : Array Var) : VarSet :=\n xs.foldl (·.erase ·.getId) rs"
},
{
"name": "insertVars",
"content": "def insertVars (rs : VarSet) (xs : Array Var) : VarSet :=\n xs.foldl (fun rs x => rs.insert x.getId x) rs"
},
{
"name": "attachJPs",
"content": "def attachJPs (jpDecls : Array JPDecl) (k : Code) : Code :=\n jpDecls.foldr attachJP k"
},
{
"name": "attachJP",
"content": "def attachJP (jpDecl : JPDecl) (k : Code) : Code :=\n Code.joinpoint jpDecl.name jpDecl.params jpDecl.body k"
},
{
"name": "union",
"content": "private def union (s₁ s₂ : VarSet) : VarSet :=\n s₁.foldl (·.insert ·) s₂"
},
{
"name": "convertTerminalActionIntoJmp",
"content": "partial def convertTerminalActionIntoJmp (code : Code) (jp : Name) (xs : Array Var) : MacroM Code :=\n let rec loop : Code → MacroM Code\n | .decl xs stx k => return .decl xs stx (← loop k)\n | .reassign xs stx k => return .reassign xs stx (← loop k)\n | .joinpoint n ps b k => return .joinpoint n ps (← loop b) (← loop k)\n | .seq e k => return .seq e (← loop k)\n | .ite ref x? h c t e => return .ite ref x? h c (← loop t) (← loop e)\n | .action e => mkAuxDeclFor e fun y =>\n let ref := e\n \n let jmpArgs := xs.push y\n return Code.jmp ref jp jmpArgs\n | .match ref g ds t alts =>\n return .match ref g ds t (← alts.mapM fun alt => do pure { alt with rhs := (← loop alt.rhs) })\n | .matchExpr ref «meta» d alts e => do\n let alts ← alts.mapM fun alt => do pure { alt with rhs := (← loop alt.rhs) }\n let e ← loop e\n return .matchExpr ref «meta» d alts e\n | c => return c\n loop code"
},
{
"name": "hasTerminalAction",
"content": "def hasTerminalAction (c : Code) : Bool :=\n hasExitPointPred c fun\n | .action _ => true\n | _ => false"
},
{
"name": "mkIte",
"content": "def mkIte (ref : Syntax) (optIdent : Syntax) (cond : Syntax) (thenBranch : CodeBlock) (elseBranch : CodeBlock) : TermElabM CodeBlock := do\n let x? := optIdent.getOptional?\n let (thenBranch, elseBranch) ← homogenize thenBranch elseBranch\n return {\n code := .ite ref x? optIdent cond thenBranch.code elseBranch.code,\n uvars := thenBranch.uvars,\n }"
},
{
"name": "ensureInsideFor",
"content": "def ensureInsideFor : M Unit :=\n unless (← read).insideFor do\n throwError \"invalid `do` element, it must be inside `for`\"\n\n partial def doForToCode (doFor : Syntax) (doElems : List Syntax) : M CodeBlock := do\n let doForDecls := doFor[1].getSepArgs\n if h : doForDecls.size > 1 then\n \n \n let doForDecl := doForDecls[1]!\n unless doForDecl[0].isNone do\n throwErrorAt doForDecl[0] \"the proof annotation here has not been implemented yet\"\n let y := doForDecl[1]\n let ys := doForDecl[3]\n let doForDecls := doForDecls.eraseIdx 1\n let body := doFor[3]\n withFreshMacroScope do\n \n let toStreamApp ← withRef ys `(@toStream _ _ _ $ys)\n let auxDo ←\n `(do let mut s := $toStreamApp:term\n for $doForDecls:doForDecl,* do\n match @Stream.next? _ _ _ s with\n | none => break\n | some ($y, s') =>\n s := s'\n do $body)\n doSeqToCode (getDoSeqElems (getDoSeq auxDo) ++ doElems)\n else withRef doFor do\n let h? := if doForDecls[0]![0].isNone then none else some doForDecls[0]![0][0]\n let x := doForDecls[0]![1]\n withRef x <| checkNotShadowingMutable (← getPatternVarsEx x)\n let xs := doForDecls[0]![3]\n let forElems := getDoSeqElems doFor[3]\n let forInBodyCodeBlock ← withFor (doSeqToCode forElems)\n let ⟨uvars, forInBody⟩ ← mkForInBody x forInBodyCodeBlock\n let ctx ← read\n \n \n \n let uvars := uvars.map fun v => ctx.mutableVars.getD v.getId v\n let uvarsTuple ← liftMacroM do mkTuple uvars\n let uvarsTuplePat ← liftMacroM do mkTuplePat uvars\n\n if hasReturn forInBodyCodeBlock.code then\n let forInBody ← liftMacroM <| destructTuple uvars (← `(r)) forInBody\n let optType ← `(Option $((← read).returnType))\n let forInTerm ← if let some h := h? then\n annotate doFor\n (← `(for_in'% $(xs) (MProdWithNames.mk (none : $optType) $uvarsTuple) fun $x $h (r : MProdWithNames $optType _) => let r := r.2; $forInBody))\n else\n annotate doFor\n (← `(for_in% $(xs) (MProdWithNames.mk (none : $optType) $uvarsTuple) fun $x (r : MProdWithNames $optType _) => let r := r.2; $forInBody))\n let auxDo ← `(do let r ← $forInTerm:term;\n $uvarsTuplePat:term := r.2;\n match r.1 with\n | none => Pure.pure (ensure_expected_type% \"type mismatch, `for`\" PUnit.unit)\n | some a => return ensure_expected_type% \"type mismatch, `for`\" a)\n doSeqToCode (getDoSeqElems (getDoSeq auxDo) ++ doElems)\n else\n let forInBody ← liftMacroM <| destructTuple uvars (← `(r)) forInBody\n let forInTerm ← if let some h := h? then\n annotate doFor (← `(for_in'% $(xs) $uvarsTuple fun $x $h r => $forInBody))\n else\n annotate doFor (← `(for_in% $(xs) $uvarsTuple fun $x r => $forInBody))\n if doElems.isEmpty then\n let auxDo ← `(do let r ← $forInTerm:term;\n $uvarsTuplePat:term := r;\n Pure.pure (ensure_expected_type% \"type mismatch, `for`\" PUnit.unit))\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo)\n else\n let auxDo ← `(do let r ← $forInTerm:term; $uvarsTuplePat:term := r)\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems"
},
{
"name": "destructTuple",
"content": "private def destructTuple (uvars : Array Var) (x : Syntax) (body : Syntax) : MacroM Syntax := do\n if uvars.size = 0 then\n return body\n else if h : uvars.size = 1 then\n `(let $(uvars[0]):ident := WithName.erase $x; $body)\n else\n destruct uvars.toList x body\nwhere\n destruct (as : List Var) (x : Syntax) (body : Syntax) : MacroM Syntax := do\n match as with\n | [a, b] => `(let $a:ident := $x.1; let $b:ident := WithName.erase $x.2; $body)\n | a :: as => withFreshMacroScope do\n let rest ← destruct as (← `(x)) body\n `(let $a:ident := $x.1; let x := $x.2; $rest)\n | _ => unreachable!"
},
{
"name": "WithName.erase",
"content": "abbrev WithName.erase {α : Type u} {name} (a : WithName α name) : α := a"
},
{
"name": "withFor",
"content": "def withFor {α} (x : M α) : M α :=\n withReader (fun ctx => { ctx with insideFor := true }) x"
},
{
"name": "checkNotShadowingMutable",
"content": "def checkNotShadowingMutable (xs : Array Var) : M Unit := do\n let throwInvalidShadowing (x : Name) : M Unit :=\n throwError \"mutable variable `{x.simpMacroScopes}` cannot be shadowed\"\n let ctx ← read\n for x in xs do\n if ctx.mutableVars.contains x.getId then\n withRef x <| throwInvalidShadowing x.getId"
},
{
"name": "hasReturn",
"content": "def hasReturn (c : Code) : Bool :=\n hasExitPointPred c fun\n | .return .. => true\n | _ => false"
},
{
"name": "getPatternVarsEx",
"content": "def getPatternVarsEx (pattern : Syntax) : TermElabM (Array Var) :=\n getPatternVars pattern <|>\n Quotation.getPatternVars pattern"
},
{
"name": "mkTuplePat",
"content": "private def mkTuplePat (elems : Array Syntax) : MacroM Syntax := do\n if elems.size = 0 then\n mkUnit\n else if h : elems.size = 1 then\n return elems[0]\n else\n elems.extract 0 (elems.size - 1) |>.foldrM (init := elems.back!) fun elem tuple => do\n ``(MProdWithNames.mk $elem $tuple)"
},
{
"name": "mkForInBody",
"content": "def mkForInBody (_ : Syntax) (forInBody : CodeBlock) : M ToForInTermResult := do\n let ctx ← read\n let uvars := forInBody.uvars\n let uvars := varSetToArray uvars\n let term ← liftMacroM <| ToTerm.run forInBody.code ctx.m ctx.returnType uvars (if hasReturn forInBody.code then ToTerm.Kind.forInWithReturn else ToTerm.Kind.forIn)\n return ⟨uvars, term⟩"
},
{
"name": "mkBreak",
"content": "def mkBreak (ref : Syntax) : CodeBlock :=\n { code := .break ref }\n\n partial def doUnlessToCode (doUnless : Syntax) (doElems : List Syntax) : M CodeBlock := withRef doUnless do\n let cond := doUnless[1]\n let doSeq := doUnless[3]\n let body ← doSeqToCode (getDoSeqElems doSeq)\n let unlessCode ← liftMacroM <| mkUnless cond body\n concatWith unlessCode doElems"
},
{
"name": "mkUnless",
"content": "def mkUnless (cond : Syntax) (c : CodeBlock) : MacroM CodeBlock := do\n let thenBranch ← mkPureUnitAction\n return { c with code := .ite (← getRef) none mkNullNode cond thenBranch.code c.code }"
},
{
"name": "mkPureUnitAction",
"content": "def mkPureUnitAction : MacroM CodeBlock := do\n return mkTerminalAction (← mkPureUnit)"
},
{
"name": "mkPureUnit",
"content": "private def mkPureUnit : MacroM Syntax :=\n ``(pure PUnit.unit)"
},
{
"name": "mkTerminalAction",
"content": "def mkTerminalAction (action : Syntax) : CodeBlock :=\n { code := .action action }\n\n partial def doTryToCode (doTry : Syntax) (doElems: List Syntax) : M CodeBlock := do\n let tryCode ← doSeqToCode (getDoSeqElems doTry[1])\n let optFinally := doTry[3]\n let catches ← doTry[2].getArgs.mapM fun catchStx : Syntax => do\n if catchStx.getKind == ``Parser.Term.doCatch then\n let x := catchStx[1]\n if x.isIdent then\n withRef x <| checkNotShadowingMutable #[x]\n let optType := catchStx[2]\n let c ← doSeqToCode (getDoSeqElems catchStx[4])\n return { x := x, optType := optType, codeBlock := c : Catch }\n else if catchStx.getKind == ``Parser.Term.doCatchMatch then\n let matchAlts := catchStx[1]\n let x ← `(ex)\n let auxDo ← `(do match ex with $matchAlts)\n let c ← doSeqToCode (getDoSeqElems (getDoSeq auxDo))\n return { x := x, codeBlock := c, optType := mkNullNode : Catch }\n else\n throwError \"unexpected kind of `catch`\"\n let finallyCode? ← if optFinally.isNone then pure none else some <$> doSeqToCode (getDoSeqElems optFinally[0][1])\n if catches.isEmpty && finallyCode?.isNone then\n throwError \"invalid `try`, it must have a `catch` or `finally`\"\n let ctx ← read\n let ws := getTryCatchUpdatedVars tryCode catches finallyCode?\n let uvars := varSetToArray ws\n let a := tryCatchPred tryCode catches finallyCode? hasTerminalAction\n let r := tryCatchPred tryCode catches finallyCode? hasReturn\n let bc := tryCatchPred tryCode catches finallyCode? hasBreakContinue\n let toTerm (codeBlock : CodeBlock) : M Syntax := do\n let codeBlock ← liftM $ extendUpdatedVars codeBlock ws\n liftMacroM <| ToTerm.mkNestedTerm codeBlock.code ctx.m ctx.returnType uvars a r bc\n let term ← toTerm tryCode\n let term ← catches.foldlM (init := term) fun term «catch» => do\n let catchTerm ← toTerm «catch».codeBlock\n if catch.optType.isNone then\n annotate doTry (← ``(MonadExcept.tryCatch $term (fun $(«catch».x):ident => $catchTerm)))\n else\n let type := «catch».optType[1]\n annotate doTry (← ``(tryCatchThe $type $term (fun $(«catch».x):ident => $catchTerm)))\n let term ← match finallyCode? with\n | none => pure term\n | some finallyCode => withRef optFinally do\n unless finallyCode.uvars.isEmpty do\n throwError \"`finally` currently does not support reassignments\"\n if hasBreakContinueReturn finallyCode.code then\n throwError \"`finally` currently does `return`, `break`, nor `continue`\"\n let finallyTerm ← liftMacroM <| ToTerm.run finallyCode.code ctx.m ctx.returnType {} ToTerm.Kind.regular\n annotate doTry (← ``(tryFinally $term $finallyTerm))\n let doElemsNew ← liftMacroM <| ToTerm.matchNestedTermResult term uvars a r bc\n doSeqToCode (doElemsNew ++ doElems)"
},
{
"name": "tryCatchPred",
"content": "def tryCatchPred (tryCode : CodeBlock) (catches : Array Catch) (finallyCode? : Option CodeBlock) (p : Code → Bool) : Bool :=\n p tryCode.code ||\n catches.any (fun «catch» => p «catch».codeBlock.code) ||\n match finallyCode? with\n | none => false\n | some finallyCode => p finallyCode.code"
},
{
"name": "Catch",
"content": "structure Catch where\n x : Syntax\n optType : Syntax\n codeBlock : CodeBlock"
},
{
"name": "mkNestedTerm",
"content": "def mkNestedTerm (code : Code) (m : Syntax) (returnType : Syntax) (uvars : Array Var) (a r bc : Bool) : MacroM Syntax := do\n ToTerm.run code m returnType uvars (mkNestedKind a r bc)"
},
{
"name": "mkNestedKind",
"content": "def mkNestedKind (a r bc : Bool) : Kind :=\n match a, r, bc with\n | true, false, false => .regular\n | false, true, false => .regular\n | false, false, true => .nestedBC\n | true, true, false => .nestedPR\n | true, false, true => .nestedSBC\n | false, true, true => .nestedSBC\n | true, true, true => .nestedPRBC\n | false, false, false => unreachable!"
},
{
"name": "getTryCatchUpdatedVars",
"content": "def getTryCatchUpdatedVars (tryCode : CodeBlock) (catches : Array Catch) (finallyCode? : Option CodeBlock) : VarSet :=\n let ws := tryCode.uvars\n let ws := catches.foldl (init := ws) fun ws alt => union alt.codeBlock.uvars ws\n let ws := match finallyCode? with\n | none => ws\n | some c => union c.uvars ws\n ws"
},
{
"name": "hasBreakContinueReturn",
"content": "def hasBreakContinueReturn (c : Code) : Bool :=\n hasExitPointPred c fun\n | .break _ => true\n | .continue _ => true\n | .return _ _ => true\n | _ => false"
},
{
"name": "matchNestedTermResult",
"content": "def matchNestedTermResult (term : Syntax) (uvars : Array Var) (a r bc : Bool) : MacroM (List Syntax) := do\n let toDoElems (auxDo : Syntax) : List Syntax := getDoSeqElems (getDoSeq auxDo)\n let u ← mkTuplePat uvars\n match a, r, bc with\n | true, false, false =>\n if uvars.isEmpty then\n return toDoElems (← `(do $term:term))\n else\n return toDoElems (← `(do let r ← $term:term; $u:term := r.2; pure r.1))\n | false, true, false =>\n if uvars.isEmpty then\n return toDoElems (← `(do let r ← $term:term; return r))\n else\n return toDoElems (← `(do let r ← $term:term; $u:term := r.2; return r.1))\n | false, false, true => toDoElems <$>\n `(do let r ← $term:term;\n match r with\n | .break u => $u:term := u; break\n | .continue u => $u:term := u; continue)\n | true, true, false => toDoElems <$>\n `(do let r ← $term:term;\n match r with\n | .pure a u => $u:term := u; pure a\n | .return b u => $u:term := u; return b)\n | true, false, true => toDoElems <$>\n `(do let r ← $term:term;\n match r with\n | .pureReturn a u => $u:term := u; pure a\n | .break u => $u:term := u; break\n | .continue u => $u:term := u; continue)\n | false, true, true => toDoElems <$>\n `(do let r ← $term:term;\n match r with\n | .pureReturn a u => $u:term := u; return a\n | .break u => $u:term := u; break\n | .continue u => $u:term := u; continue)\n | true, true, true => toDoElems <$>\n `(do let r ← $term:term;\n match r with\n | .pure a u => $u:term := u; pure a\n | .return a u => $u:term := u; return a\n | .break u => $u:term := u; break\n | .continue u => $u:term := u; continue)\n | false, false, false => unreachable!"
},
{
"name": "hasBreakContinue",
"content": "def hasBreakContinue (c : Code) : Bool :=\n hasExitPointPred c fun\n | .break _ => true\n | .continue _ => true\n | _ => false"
},
{
"name": "mkContinue",
"content": "def mkContinue (ref : Syntax) : CodeBlock :=\n { code := .continue ref }\n\n partial def doLetElseToCode (doLetElse : Syntax) (doElems : List Syntax) : M CodeBlock := do\n \n let pattern := doLetElse[2]\n let val := doLetElse[4]\n let elseSeq := doLetElse[6]\n let contSeq ← if isMutableLet doLetElse then\n let vars ← (← getPatternVarsEx pattern).mapM fun var => `(doElem| let mut $var := $var)\n pure (vars ++ doElems.toArray)\n else\n pure doElems.toArray\n let contSeq := mkDoSeq contSeq\n let auxDo ← `(do match $val:term with | $pattern:term => $contSeq | _ => $elseSeq)\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo)"
},
{
"name": "isMutableLet",
"content": "def isMutableLet (doElem : Syntax) : Bool :=\n let kind := doElem.getKind\n (kind == ``doLetArrow || kind == ``doLet || kind == ``doLetElse)\n &&\n !doElem[1].isNone"
},
{
"name": "mkDoSeq",
"content": "def mkDoSeq (doElems : Array Syntax) : Syntax :=\n mkNode `Lean.Parser.Term.doSeqIndent #[mkNullNode <| doElems.map fun doElem => mkNullNode #[doElem, mkNullNode]]"
},
{
"name": "mkSeq",
"content": "def mkSeq (action : Syntax) (c : CodeBlock) : CodeBlock :=\n { c with code := .seq action c.code }"
},
{
"name": "withNewMutableVars",
"content": "def withNewMutableVars {α} (newVars : Array Var) (mutable : Bool) (x : M α) : M α :=\n withReader (fun ctx => if mutable then { ctx with mutableVars := insertVars ctx.mutableVars newVars } else ctx) x"
},
{
"name": "mkReassignCore",
"content": "def mkReassignCore (xs : Array Var) (stx : Syntax) (c : CodeBlock) : TermElabM CodeBlock := do\n let us := c.uvars\n let ws := insertVars us xs\n \n \n let code ← if xs.any fun x => !us.contains x.getId then extendUpdatedVarsAux c.code ws else pure c.code\n pure { code := .reassign xs stx code, uvars := ws }"
},
{
"name": "getDoReassignVars",
"content": "def getDoReassignVars (doReassign : Syntax) : TermElabM (Array Var) := do\n let arg := doReassign[0]\n if arg.getKind == ``Parser.Term.letIdDecl then\n return getLetIdDeclVars arg\n else if arg.getKind == ``Parser.Term.letPatDecl then\n getLetPatDeclVars arg\n else\n throwError \"unexpected kind of reassignment\""
},
{
"name": "getLetIdDeclVars",
"content": "def getLetIdDeclVars (letIdDecl : Syntax) : Array Var :=\n assert! letIdDecl.isOfKind ``Parser.Term.letIdDecl\n \n \n getLetIdVars letIdDecl[0]"
},
{
"name": "getLetIdVars",
"content": "def getLetIdVars (letId : Syntax) : Array Var :=\n assert! letId.isOfKind ``Parser.Term.letId\n \n if letId[0].isIdent then\n #[letId[0]]\n else if letId[0].isOfKind hygieneInfoKind then\n #[HygieneInfo.mkIdent letId[0] `this (canonical := true)]\n else\n #[]"
},
{
"name": "getLetPatDeclVars",
"content": "def getLetPatDeclVars (letPatDecl : Syntax) : TermElabM (Array Var) := do\n \n let pattern := letPatDecl[0]\n getPatternVarsEx pattern"
},
{
"name": "ensureEOS",
"content": "def ensureEOS (doElems : List Syntax) : M Unit :=\n unless doElems.isEmpty do\n throwError \"must be last element in a `do` sequence\""
},
{
"name": "mkVarDeclCore",
"content": "def mkVarDeclCore (xs : Array Var) (stx : Syntax) (c : CodeBlock) : CodeBlock := {\n code := Code.decl xs stx c.code,\n uvars := eraseVars c.uvars xs\n}\n\n partial def doMatchToCode (doMatch : Syntax) (doElems: List Syntax) : M CodeBlock := do\n let ref := doMatch\n let genParam := doMatch[1]\n let optMotive := doMatch[2]\n let discrs := doMatch[3]\n let matchAlts := doMatch[5][0].getArgs \n let matchAlts ← matchAlts.foldlM (init := #[]) fun result matchAlt => return result ++ (← liftMacroM <| expandMatchAlt matchAlt)\n let alts ← matchAlts.mapM fun matchAlt => do\n let patterns := matchAlt[1][0]\n let vars ← getPatternsVarsEx patterns.getSepArgs\n withRef patterns <| checkNotShadowingMutable vars\n let rhs := matchAlt[3]\n let rhs ← doSeqToCode (getDoSeqElems rhs)\n pure { ref := matchAlt, vars := vars, patterns := patterns, rhs := rhs : Alt CodeBlock }\n let matchCode ← mkMatch ref genParam discrs optMotive alts\n concatWith matchCode doElems"
},
{
"name": "mkMatch",
"content": "def mkMatch (ref : Syntax) (genParam : Syntax) (discrs : Syntax) (optMotive : Syntax) (alts : Array (Alt CodeBlock)) : TermElabM CodeBlock := do\n \n let ws := alts.foldl (union · ·.rhs.uvars) {}\n let alts ← alts.mapM fun alt => do\n let rhs ← extendUpdatedVars alt.rhs ws\n return { ref := alt.ref, vars := alt.vars, patterns := alt.patterns, rhs := rhs.code : Alt Code }\n return { code := .match ref genParam discrs optMotive alts, uvars := ws }"
},
{
"name": "getPatternsVarsEx",
"content": "def getPatternsVarsEx (patterns : Array Syntax) : TermElabM (Array Var) :=\n getPatternsVars patterns <|>\n Quotation.getPatternsVars patterns"
},
{
"name": "doReturnToCode",
"content": "def doReturnToCode (doReturn : Syntax) (doElems: List Syntax) : M CodeBlock := withRef doReturn do\n ensureEOS doElems\n let argOpt := doReturn[1]\n let arg ← if argOpt.isNone then liftMacroM mkUnit else pure argOpt[0]\n return mkReturn (← getRef) arg"
},
{
"name": "mkReturn",
"content": "def mkReturn (ref : Syntax) (val : Syntax) : CodeBlock :=\n { code := .return ref val }"
},
{
"name": "getDoHaveVars",
"content": "def getDoHaveVars (doHave : Syntax) : TermElabM (Array Var) :=\n \n getLetDeclVars doHave[1]"
},
{
"name": "getLetDeclVars",
"content": "def getLetDeclVars (letDecl : Syntax) : TermElabM (Array Var) := do\n \n let arg := letDecl[0]\n if arg.getKind == ``Parser.Term.letIdDecl then\n return getLetIdDeclVars arg\n else if arg.getKind == ``Parser.Term.letPatDecl then\n getLetPatDeclVars arg\n else if arg.getKind == ``Parser.Term.letEqnsDecl then\n return getLetEqnsDeclVars arg\n else\n throwError \"unexpected kind of let declaration\""
},
{
"name": "getLetEqnsDeclVars",
"content": "def getLetEqnsDeclVars (letEqnsDecl : Syntax) : Array Var :=\n assert! letEqnsDecl.isOfKind ``Parser.Term.letEqnsDecl\n \n \n getLetIdVars letEqnsDecl[0]"
},
{
"name": "getDoLetRecVars",
"content": "def getDoLetRecVars (doLetRec : Syntax) : TermElabM (Array Var) := do\n \n let letRecDecls := doLetRec[1][0].getSepArgs\n let letDecls := letRecDecls.map fun p => p[2]\n let mut allVars := #[]\n for letDecl in letDecls do\n let vars ← getLetDeclVars letDecl\n allVars := allVars ++ vars\n return allVars\n\n partial def doReassignArrowToCode (doReassignArrow : Syntax) (doElems : List Syntax) : M CodeBlock := do\n let decl := doReassignArrow[0]\n if decl.getKind == ``Parser.Term.doIdDecl then\n let doElem := decl[3]\n let y := decl[0]\n let auxDo ← `(do let r ← $doElem; $y:ident := r)\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems\n else if decl.getKind == ``Parser.Term.doPatDecl then\n let pattern := decl[0]\n let doElem := decl[2]\n let optElse := decl[3]\n if optElse.isNone then withFreshMacroScope do\n let auxDo ← `(do let __discr ← $doElem; $pattern:term := __discr)\n doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems\n else\n throwError \"reassignment with `|` (i.e., \\\"else clause\\\") is not currently supported\"\n else\n throwError \"unexpected kind of `do` reassignment\""
},
{
"name": "expandLiftMethod",
"content": "def expandLiftMethod (doElem : Syntax) : M (List Syntax × Syntax) := do\n if !hasLiftMethod doElem then\n return ([], doElem)\n else\n let baseId ← withFreshMacroScope (MonadQuotation.addMacroScope `__do_lift)\n let (doElem, doElemsNew) ← (expandLiftMethodAux baseId false false doElem).run []\n return (doElemsNew, doElem)"
},
{
"name": "hasLiftMethod",
"content": "private partial def hasLiftMethod : Syntax → Bool\n | Syntax.node _ k args =>\n if liftMethodDelimiter k then false\n \n \n else if k == ``Parser.Term.liftMethod then true\n \n else if k == ``termDepIfThenElse || k == ``termIfThenElse then args.size >= 2 && hasLiftMethod args[1]!\n else args.any hasLiftMethod\n | _ => false"
},
{
"name": "liftMethodDelimiter",
"content": "private def liftMethodDelimiter (k : SyntaxNodeKind) : Bool :=\n k == ``Parser.Term.do ||\n k == ``Parser.Term.doSeqIndent ||\n k == ``Parser.Term.doSeqBracketed ||\n k == ``Parser.Term.termReturn ||\n k == ``Parser.Term.termUnless ||\n k == ``Parser.Term.termTry ||\n k == ``Parser.Term.termFor"
},
{
"name": "expandLiftMethodAux",
"content": "private partial def expandLiftMethodAux (inQuot : Bool) (inBinder : Bool) : Syntax → StateT (List Syntax) M Syntax\n | stx@(Syntax.node i k args) =>\n if k == choiceKind then do\n \n let alts ← stx.getArgs.mapM (expandLiftMethodAux inQuot inBinder · |>.run [])\n let (_, lifts) := alts[0]!\n unless alts.all (·.2 == lifts) do\n throwErrorAt stx \"cannot lift `(<- ...)` over inconsistent syntax variants, consider lifting out the binding manually\"\n modify (· ++ lifts)\n return .node i k (alts.map (·.1))\n else if liftMethodDelimiter k then\n return stx\n \n else if h : args.size >= 2 ∧ (k == ``termDepIfThenElse || k == ``termIfThenElse) then do\n let inAntiquot := stx.isAntiquot && !stx.isEscapedAntiquot\n let arg1 ← expandLiftMethodAux (inQuot && !inAntiquot || stx.isQuot) inBinder args[1]\n let args := args.set! 1 arg1\n return Syntax.node i k args\n else if k == ``Parser.Term.liftMethod && !inQuot then withFreshMacroScope do\n if inBinder then\n throwErrorAt stx \"cannot lift `(<- ...)` over a binder, this error usually happens when you are trying to lift a method nested in a `fun`, `let`, or `match`-alternative, and it can often be fixed by adding a missing `do`\"\n let term := args[1]!\n let term ← expandLiftMethodAux inQuot inBinder term\n \n let id ← mkIdentFromRef (.num baseId (← get).length)\n let auxDoElem : Syntax ← `(doElem| let $id:ident ← $term:term)\n modify fun s => s ++ [auxDoElem]\n return id\n else do\n let inAntiquot := stx.isAntiquot && !stx.isEscapedAntiquot\n let inBinder := inBinder || (!inQuot && liftMethodForbiddenBinder stx)\n let args ← args.mapM (expandLiftMethodAux (inQuot && !inAntiquot || stx.isQuot) inBinder)\n return Syntax.node i k args\n | stx => return stx"
},
{
"name": "run",
"content": "def run (doStx : Syntax) (m : Syntax) (returnType : Syntax) : TermElabM CodeBlock :=\n (doSeqToCode <| getDoSeqElems <| getDoSeq doStx).run { ref := doStx, m, returnType }"
},
{
"name": "liftMethodForbiddenBinder",
"content": "private def liftMethodForbiddenBinder (stx : Syntax) : Bool :=\n let k := stx.getKind\n \n if k == ``Parser.Term.fun || k == ``Parser.Term.matchAlts ||\n k == ``Parser.Term.doLetRec || k == ``Parser.Term.letrec then\n \n true\n \n else if k == ``Parser.Term.let then\n letDeclHasBinders stx[1]\n else if k == ``Parser.Term.doLet then\n letDeclHasBinders stx[2]\n else if k == ``Parser.Term.doLetArrow then\n letDeclArgHasBinders stx[2]\n else\n false"
},
{
"name": "letDeclHasBinders",
"content": "private def letDeclHasBinders (letDecl : Syntax) : Bool :=\n letDeclArgHasBinders letDecl[0]"
},
{
"name": "letDeclArgHasBinders",
"content": "private def letDeclArgHasBinders (letDeclArg : Syntax) : Bool :=\n let k := letDeclArg.getKind\n if k == ``Parser.Term.letPatDecl then\n false\n else if k == ``Parser.Term.letEqnsDecl then\n true\n else if k == ``Parser.Term.letIdDecl then\n \n let binders := letDeclArg[1]\n binders.getNumArgs > 0\n else\n false"
},
{
"name": "checkReassignable",
"content": "def checkReassignable (xs : Array Var) : M Unit := do\n let throwInvalidReassignment (x : Name) : M Unit :=\n throwError \"`{x.simpMacroScopes}` cannot be mutated, only variables declared using `let mut` can be mutated. If you did not intend to mutate but define `{x.simpMacroScopes}`, consider using `let {x.simpMacroScopes}` instead\"\n let ctx ← read\n for x in xs do\n unless ctx.mutableVars.contains x.getId do\n throwInvalidReassignment x.getId\n\n partial def doMatchExprToCode (doMatchExpr : Syntax) (doElems: List Syntax) : M CodeBlock := do\n let ref := doMatchExpr\n let «meta» := doMatchExpr[1].isNone\n let discr := doMatchExpr[2]\n let alts := doMatchExpr[4][0].getArgs \n let alts ← alts.mapM fun alt => do\n let pat := alt[1]\n let var? := if pat[0].isNone then none else some pat[0][0]\n let funName := pat[1]\n let pvars := pat[2].getArgs\n let rhs := alt[3]\n let rhs ← doSeqToCode (getDoSeqElems rhs)\n pure { ref, var?, funName, pvars, rhs }\n let elseBranch ← doSeqToCode (getDoSeqElems doMatchExpr[4][1][3])\n let matchCode ← mkMatchExpr ref «meta» discr alts elseBranch\n concatWith matchCode doElems"
},
{
"name": "mkMatchExpr",
"content": "def mkMatchExpr (ref : Syntax) («meta» : Bool) (discr : Syntax) (alts : Array (AltExpr CodeBlock)) (elseBranch : CodeBlock) : TermElabM CodeBlock := do\n \n let ws := alts.foldl (union · ·.rhs.uvars) {}\n let ws := union ws elseBranch.uvars\n let alts ← alts.mapM fun alt => do\n let rhs ← extendUpdatedVars alt.rhs ws\n return { alt with rhs := rhs.code : AltExpr Code }\n let elseBranch ← extendUpdatedVars elseBranch ws\n return { code := .matchExpr ref «meta» discr alts elseBranch.code, uvars := ws }"
},
{
"name": "getDoLetVars",
"content": "def getDoLetVars (doLet : Syntax) : TermElabM (Array Var) :=\n \n getLetDeclVars doLet[2]"
},
{
"name": "isDoExpr?",
"content": "def isDoExpr? (doElem : Syntax) : Option Syntax :=\n if doElem.getKind == ``Parser.Term.doExpr then\n some doElem[0]\n else\n none"
},
{
"name": "reassignToTerm",
"content": "def reassignToTerm (reassign : Syntax) (k : Syntax) : MacroM Syntax := withRef reassign <| withFreshMacroScope do\n match reassign with\n | `(doElem| $x:ident := $rhs) => `(let $x:ident := ensure_type_of% $x $(quote \"invalid reassignment, value\") $rhs; $k)\n | `(doElem| $e:term := $rhs) => `(let $e:term := ensure_type_of% $e $(quote \"invalid reassignment, value\") $rhs; $k)\n | _ =>\n \n Macro.throwErrorAt reassign \"unexpected kind of `do` reassignment\""
},
{
"name": "actionTerminalToTerm",
"content": "def actionTerminalToTerm (action : Syntax) : M Syntax := withRef action <| withFreshMacroScope do\n let ctx ← read\n let u ← mkUVarTuple\n match ctx.kind with\n | .regular => if ctx.uvars.isEmpty then pure action else ``(Bind.bind $action fun y => Pure.pure (MProdWithNames.mk y $u))\n | .forIn => ``(Bind.bind $action fun (_ : PUnit) => Pure.pure (ForInStep.yield $u))\n | .forInWithReturn => ``(Bind.bind $action fun (_ : PUnit) => Pure.pure (ForInStep.yield (MProdWithNames.mk none $u)))\n | .nestedBC => unreachable!\n | .nestedPR => ``(Bind.bind $action fun y => (Pure.pure (DoResultPR.«pure» y $u)))\n | .nestedSBC => ``(Bind.bind $action fun y => (Pure.pure (DoResultSBC.«pureReturn» y $u)))\n | .nestedPRBC => ``(Bind.bind $action fun y => (Pure.pure (DoResultPRBC.«pure» y $u)))"
},
{
"name": "breakToTerm",
"content": "def breakToTerm : M Syntax := do\n let ctx ← read\n let u ← mkUVarTuple\n match ctx.kind with\n | .regular => unreachable!\n | .forIn => ``(Pure.pure (ForInStep.done $u))\n | .forInWithReturn => ``(Pure.pure (ForInStep.done (MProdWithNames.mk none $u)))\n | .nestedBC => ``(Pure.pure (DoResultBC.«break» $u))\n | .nestedPR => unreachable!\n | .nestedSBC => ``(Pure.pure (DoResultSBC.«break» $u))\n | .nestedPRBC => ``(Pure.pure (DoResultPRBC.«break» $u))"
},
{
"name": "DivM",
"content": "inductive DivM (α : Type u) where\n | res (x : α)\n | div"
},
{
"name": "NonDetT.run",
"content": "def NonDetT.run {α : Type u} : NonDetT m α -> m α\n | .pure x => Pure.pure x\n | .vis x f => liftM x >>= (fun x => (f x).run)\n | @NonDetT.pickCont _ _ _ p _ f =>\n match Findable.find (p := p) () with\n | none => CCPOBot.compBot\n | some x => (f x).run\n | .repeatCont init f cont =>\n forIn Lean.Loop.mk init (fun _ x => (f x).run) >>= (fun x => (cont x).run)"
},
{
"name": "ExtractNonDet.ForIn_list",
"content": "instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}\n (_ : ∀ a b, ExtractNonDet findable (f a b)) :\n ExtractNonDet findable (forIn xs init f) :="
},
{
"name": "MonadNonDet",
"content": "class MonadNonDet (m : Type u → Type v) where\n pick : (τ : Type u) → [Inhabited τ] → m τ\n \n pickSuchThat : (τ : Type u) → (p : τ → Prop) → [Findable p] → m τ\n assume : (as : Prop) → [Decidable as] → m PUnit.{u+1}\n \n rep {α : Type u} : α → (α → m (ForInStep α)) → m α"
},
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "Findable",
"content": "class Findable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_none : (find ()).isNone -> ∀ x, ¬ p x\n find_some_p : find () = some x -> p x"
},
{
"name": "find",
"content": "def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=\n findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode"
},
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
},
{
"name": "NonDetT.extract",
"content": "@[inline]\ndef NonDetT.extract {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet Findable s := by admit /- proof elided -/\n) : m α :=\n NonDetT.extractGen Findable.find s"
},
{
"name": "NonDetT.extractGen",
"content": "@[simp, inline]\ndef NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}\n (findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)\n : (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/\n ) -> m α\n | .pure x, _ => Pure.pure x\n | .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))\n | .pickCont _ p f, .pickSuchThat _ _ _ _ =>\n match findOf p ‹_› () with\n | none => CCPOBot.compBot\n | some x => extractGen findOf (f x)\n | .pickCont _ p f, .assume _ _ _ =>\n if p .unit then\n extractGen findOf (f .unit)\n else CCPOBot.compBot"
},
{
"name": "CCPOBot",
"content": "class CCPOBot (m : Type u -> Type v) where\n compBot {α} : m α"
},
{
"name": "DivM.run",
"content": "def DivM.run {α : Type u} [Inhabited α] : DivM α -> α\n | DivM.res x => x\n | DivM.div => default"
}
] | [
{
"name": "Array.append_right_inj",
"module": "Init.Data.Array.Lemmas"
},
{
"name": "Array.push_eq_append",
"module": "Init.Data.Array.Lemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Encoding",
"content": "structure Encoding where\n cnt: Nat\n c: Char\n deriving Inhabited"
},
{
"name": "get_cnt_sum",
"content": "def get_cnt_sum (l: List Encoding) :=\n match l with\n | List.nil => 0\n | List.cons x xs => x.cnt + get_cnt_sum xs"
},
{
"name": "is_valid_run_sequence",
"content": "@[reducible]\ndef is_valid_run_sequence (encoded_str: Array Encoding) :=\n forall i, ( h: i < encoded_str.size ) -> (encoded_str[i]'h).cnt > 0\n\nmethod decodeStr' (encoded_str: Array Encoding)\n return (res: Array Char)\n require is_valid_run_sequence encoded_str\n ensures (res.size = get_cnt_sum encoded_str.toList)\n do\n let mut decoded := Array.replicate 0 'x'\n let mut i := 0\n while i < encoded_str.size\n invariant 0 <= i ∧ i <= encoded_str.size\n invariant decoded.size = get_cnt_sum (encoded_str.extract 0 i).toList\n done_with i = encoded_str.size\n do\n let elem := encoded_str[i]!\n let elem_decoded := Array.replicate elem.cnt elem.c\n decoded := decoded ++ elem_decoded\n i := i + 1\n return decoded\n\nprove_correct decodeStr' by\n loom_solve\n · simp[*] at *\n have : decoded.size = get_cnt_sum (List.take i encoded_str.toList) := by admit /- proof elided -/"
},
{
"name": "decodeStrLean",
"content": "@[grind]\ndef decodeStrLean (encoded_str: Array Encoding) : Array Char :=\n let mp := Array.map (fun e => Array.replicate e.cnt e.c) encoded_str\n mp.flatten"
}
] | [
{
"name": "decodeStrLean_append",
"content": "lemma decodeStrLean_append : forall arr1 arr2,\n decodeStrLean (arr1 ++ arr2) = ( decodeStrLean arr1 ) ++ ( decodeStrLean arr2 )"
},
{
"name": "array_extract_split",
"content": "lemma array_extract_split (arr : Array α) (i j : Nat) :\n i < j → j ≤ arr.size →\n arr.extract 0 j = (arr.extract 0 i) ++ (arr.extract i j)"
}
] | import Auto
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
import CaseStudies.TestingUtil
open PartialCorrectness DemonicChoice
section RunLengthEncoding
structure Encoding where
cnt: Nat
c: Char
deriving Inhabited
def get_cnt_sum (l: List Encoding) :=
match l with
| List.nil => 0
| List.cons x xs => x.cnt + get_cnt_sum xs
@[reducible]
def is_valid_run_sequence (encoded_str: Array Encoding) :=
forall i, ( h: i < encoded_str.size ) -> (encoded_str[i]'h).cnt > 0
method decodeStr' (encoded_str: Array Encoding)
return (res: Array Char)
require is_valid_run_sequence encoded_str
ensures (res.size = get_cnt_sum encoded_str.toList)
do
let mut decoded := Array.replicate 0 'x'
let mut i := 0
while i < encoded_str.size
invariant 0 <= i ∧ i <= encoded_str.size
invariant decoded.size = get_cnt_sum (encoded_str.extract 0 i).toList
done_with i = encoded_str.size
do
let elem := encoded_str[i]!
let elem_decoded := Array.replicate elem.cnt elem.c
decoded := decoded ++ elem_decoded
i := i + 1
return decoded
prove_correct decodeStr' by
loom_solve
· simp[*] at *
have : decoded.size = get_cnt_sum (List.take i encoded_str.toList) := by admit /- proof elided -/
@[grind]
def decodeStrLean (encoded_str: Array Encoding) : Array Char :=
let mp := Array.map (fun e => Array.replicate e.cnt e.c) encoded_str
mp.flatten | lemma array_extract_split_i_j_k (arr : Array α) (i j k: Nat) :
i < j -> j < k -> k ≤ arr.size →
arr.extract i k = (arr.extract i j) ++ (arr.extract j k) := | := by
-- 1. Introduce hypotheses into the context
intro h_lt h_le
simp[*]
grind
prove_correct encodeStr by
loom_solve
· rw [array_extract_split str i j (by assumption) (by assumption)]
rw [Array.push_eq_append]
rw [decodeStrLean_append]
have : decodeStrLean encoding = str.extract 0 i := by trivial
rw [this]
refine (Array.append_right_inj (str.extract 0 i)).mpr ?_
repeat (unfold decodeStrLean ; simp_all)
apply Array.ext
grind
intros l hl hl2
have inv : ∀ (k : ℕ), i ≤ k → k < j → str[k]! = str[i] := by trivial
have inv' := inv (i+l)
grind | 17 | 292 | false | Framework |
381 | TotalCorrectness.repeat_inv | lemma repeat_inv (f : Unit -> β -> m (ForInStep β))
(inv : ForInStep β -> l) (measure : β -> Nat)
init :
(∀ b, triple (inv (.yield b)) (f () b) (fun | .yield b' => inv (.yield b') ⊓ ⌜ measure b' < measure b ⌝ | .done b' => inv (.done b'))) ->
triple (inv (.yield init)) (Loop.forIn.loop f init) (fun b => inv (.done b)) | loom | Loom/MonadAlgebras/WP/Basic.lean | [
"import Loom.MonadAlgebras.Instances.Gen",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.Instances.ReaderT",
"import Loom.MonadAlgebras.Instances.ExceptT",
"import Loom.MonadAlgebras.Instances.StateT",
"import Loom.MonadAlgebras.Instances.Basic"
] | [
{
"name": "ForInStep",
"module": "Init.Core"
},
{
"name": "Lean.Order.CCPO",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.MonoBind",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "inline",
"module": "Init.Core"
},
{
"name": "ForInStep.yield",
"module": "Init.Core"
},
{
"name": "Lean.Loop",
"module": "Init.While"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "Preorder",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "Cont.monotone",
"content": "@[simp]\ndef Cont.monotone {t : Type v} {α : Type u} [Preorder t] (wp : Cont t α) :=\n ∀ (f f' : α -> t), (∀ a, f a ≤ f' a) → wp f ≤ wp f'"
},
{
"name": "Cont",
"content": "abbrev Cont (t : Type v) (α : Type u) := (α -> t) -> t"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "Cont.monotone_lift",
"content": "lemma Cont.monotone_lift {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteLattice l] [MAlgOrdered m l] :\n ∀ {α : Type u} (x : m α), MAlg.lift x |>.monotone"
},
{
"name": "triple_bind",
"content": "lemma triple_bind {β} (pre : l) (x : m α) (cut : α -> l)\n (f : α -> m β) (post : β -> l) :\n triple pre x cut ->\n (∀ y, triple (cut y) (f y) post) ->\n triple pre (x >>= f) post"
},
{
"name": "triple_pure",
"content": "lemma triple_pure (pre : l) (x : α) (post : α -> l) :\n triple pre (pure (f := m) x) post <-> pre ≤ (post x)"
}
] | [
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "Loop.forIn.loop",
"content": "@[specialize, inline]\ndef Loop.forIn.loop {m : Type u -> Type v} [Monad m] [∀ α, CCPO (m α)] [MonoBind m] (f : Unit → β → m (ForInStep β)) (b : β) : m β := do\n match ← f () b with\n | ForInStep.done b => pure b\n | ForInStep.yield b => loop f b\n partial_fixpoint"
},
{
"name": "Loop.forIn",
"content": "@[inline]\ndef Loop.forIn {β : Type u} [Monad m] [∀ α, CCPO (m α)] [MonoBind m]\n (_ : Lean.Loop) (init : β) (f : Unit → β → m (ForInStep β)) : m β :=\n Loop.forIn.loop f init"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "wp_bind",
"content": "lemma wp_bind {β} (x : m α) (f : α -> m β) (post : β -> l) :\n wp (x >>= f) post = wp x (fun x => wp (f x) post)"
},
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
}
] | import Loom.MonadAlgebras.Defs
import Loom.MonadAlgebras.Instances.Basic
import Loom.MonadAlgebras.Instances.ExceptT
import Loom.MonadAlgebras.Instances.StateT
import Loom.MonadAlgebras.Instances.ReaderT
import Loom.MonadAlgebras.Instances.Gen
variable {m : Type u -> Type v} [Monad m] [LawfulMonad m] {α : Type u} {l : Type u}
section
variable [CompleteLattice l]
section
variable [mprop : MAlgOrdered m l]
def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post
def triple (pre : l) (c : m α) (post : α -> l) : Prop :=
pre ≤ wp c post
end
variable [MAlgOrdered m l]
end
section
variable [CompleteLattice l] [MAlgOrdered m l]
noncomputable
end
section Determinism
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end Determinism
section Loops
open Lean.Order
@[specialize, inline]
def Loop.forIn.loop {m : Type u -> Type v} [Monad m] [∀ α, CCPO (m α)] [MonoBind m] (f : Unit → β → m (ForInStep β)) (b : β) : m β := do
match ← f () b with
| ForInStep.done b => pure b
| ForInStep.yield b => loop f b
partial_fixpoint
@[inline]
def Loop.forIn {β : Type u} [Monad m] [∀ α, CCPO (m α)] [MonoBind m]
(_ : Lean.Loop) (init : β) (f : Unit → β → m (ForInStep β)) : m β :=
Loop.forIn.loop f init
variable [inst: _root_.CompleteLattice l] [MAlgOrdered m l]
namespace PartialCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m] [MAlgPartial m]
end PartialCorrectness
namespace TotalCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m] | lemma repeat_inv (f : Unit -> β -> m (ForInStep β))
(inv : ForInStep β -> l) (measure : β -> Nat)
init :
(∀ b, triple (inv (.yield b)) (f () b) (fun | .yield b' => inv (.yield b') ⊓ ⌜ measure b' < measure b ⌝ | .done b' => inv (.done b'))) ->
triple (inv (.yield init)) (Loop.forIn.loop f init) (fun b => inv (.done b)) := | := by
intro hstep
have induc (C : β → Prop) (a : β) (h : ∀ x, (∀ y, measure y < measure x → C y) → C x): C a := by
have lem: ∀ n: Nat, ∀ x, measure x ≤ n → C x := by
intro n
induction n with
| zero =>
intro x hx
exact h x (fun y => by omega)
| succ m ih =>
intro x hx
by_cases neq: measure x ≤ m
{ exact ih x neq }
have eq: measure x = m + 1 := by omega
exact h x (fun y hy => ih y (by omega))
exact lem (measure a) a (by simp)
apply induc
(fun ini => triple (inv (.yield ini)) (Loop.forIn.loop f ( ini)) (fun b => inv (.done b))) init
intro b ih; unfold Loop.forIn.loop; simp [triple, wp_bind]; apply le_trans
apply hstep; apply wp_cons; rintro (_|_)
{ simp [wp_pure] }
rename_i a
match ForInStep.yield a with
| .yield b' =>
simp; intro m_lt
have ihb := ih b' m_lt
simp [triple] at ihb
exact ihb
| .done b' =>
simp
rw [wp_pure b' (fun s: β => inv (ForInStep.done s))] | 4 | 31 | true | Framework |
382 | SpMSpV_correct_triple | theorem SpMSpV_correct_triple
(out: Array Int)
(spm: Array (SpV Int))
(spv: SpV Int)
(n: ℕ):
triple
(∀ i < spm.size, (∀ j < spm[i]!.size, spm[i]!.ind[j]! < n) ∧ (∀ j < spv.size, spv.ind[j]! < n))
(SpMSpV out spm spv)
fun ⟨_, outNew⟩ =>
outNew.size = spm.size ∧ ∀ i < spm.size, outNew[i]! = ∑ idx ∈ Finset.range n, spm[i]![idx]! * spv[idx]! | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Array.replicate",
"module": "Init.Data.Array.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Lean.Name",
"module": "Init.Prelude"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" ",
"content": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" term \")\"\n (require_caluse )*\n (ensures_caluse)* \"do\" doSeq\n Termination.suffix : command\n\nsyntax \"ensures\" termBeforeReqEnsDo : ensures_caluse\n\nsyntax \"while_some\" term \":|\" termBeforeDo \"do\" doSeq : doElem\n\nsyntax \"while_some\" term \":|\" term\n (invariantClause)+\n (doneWith)?\n \"do\" doSeq : doElem\n\nsyntax \"let\" term \":|\" term : doElem\n\nsyntax \"done_with\" termBeforeDo : doneWith\n\nsyntax \"invariant\" termBeforeDo linebreak : invariantClause\n\nsyntax \"while\" term\n (invariantClause)*\n (doneWith)?\n (decreasingTerm)?\n \"do\" doSeq : doElem\n\nsyntax \"(mut\" ident \":\" term \")\" : leafny_binder"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| let $x:term :| $t) => `(doElem| let $x:term <- pickSuchThat _ (fun $x => type_with_name_prefix `choice $t))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t do $seq:doSeq) => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- withRef (<- getRef) `(invariants [])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done ¬$t:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match measure with\n | some measure_some =>\n let decr <- withRef measure_some `(decreasing type_with_name_prefix `decreasing $measure_some)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | none => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while_some $x:ident :| $t do $seq:doSeq) =>\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n while ∃ $x:ident, $t do\n let $x :| $t\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| while_some $x:ident :| $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]? do\n $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n let decr <- withRef (<- getRef) `(decreasing none)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if ∃ $x:ident, $t then\n let $x :| $t\n $[$seq:doElem]*\n else break)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| for $x:ident in $t\n $[invariant $inv:term\n ]*\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n for $x:ident in $t do\n $invs:term\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"for expects a sequence of do-elements\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(tactic|loom_solver) =>\n `(tactic|(\n try simp at *\n try aesop))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let balance := mkIdent `balance_name\n let balanceType <- `(term| Bal)\n let inv : Array Term <- inv.mapM fun (inv : Term) => withRef inv ``(fun ($(balance):ident : $balanceType)=> with_name_prefix `inv $inv)\n let invd_some <- match inv_done with\n | some invd_some => withRef invd_some ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done $invd_some)\n | none => ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done ¬$t:term)\n match measure with\n | some measure_some =>\n let measure_some ← withRef measure_some ``(type_with_name_prefix `decreasing ($measure_some:term))\n do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget ($measure_some:term)\n if $t then\n $seq:doSeq\n else break)\n | none => do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget none\n if $t then\n $seq:doSeq\n else break)"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(doElem|balance_set $t) => do\n let balId := mkIdent `balance\n `(doElem|do\n $balId:ident := $t\n set $balId:ident\n $balId:ident ← get)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem|$id:ident[$idx:term] := $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (fun _ => $val))\n | `(doElem|$id:ident[$idx:term] += $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (· + $val))"
},
{
"name": "WithName",
"content": "abbrev WithName (α : Sort u) (name : Lean.Name := default) := α"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "em",
"module": "Mathlib.Logic.Basic"
},
{
"name": "if_pos",
"module": "Init.Core"
},
{
"name": "le_iff_eq_or_lt",
"module": "Mathlib.Order.Basic"
},
{
"name": "le_of_lt",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_of_lt_of_le",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "Finset.sum_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "lt_iff_le_not_ge",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "spv_dot",
"content": "def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=\n if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then\n 0\n else\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n (spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n spv_dot spv1 spv2 (pnt1 + 1) pnt2\n else\n spv_dot spv1 spv2 pnt1 (pnt2 + 1)\n termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)\n\n\nmethod SpVSpV\n (mut out: Array Int)\n (spv1: SpV Int)\n (spv2: SpV Int) return (u: Unit)\n ensures out.size = 1\n ensures out[0]! = spv_dot spv1 spv2 0 0\n do\n out := Array.replicate 1 0\n let mut pnt1 := 0\n let mut pnt2 := 0\n while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size\n invariant out.size = 1\n invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size\n invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0\n done_with pnt1 = spv1.size ∨ pnt2 = spv2.size\n do\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!\n pnt1 := pnt1 + 1\n pnt2 := pnt2 + 1\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n pnt1 := pnt1 + 1\n else\n pnt2 := pnt2 + 1\n return\n\n\nmethod SpMSpV\n (mut out: Array Int)\n (spm: Array (SpV Int))\n (spv: SpV Int) return (u: Unit)\n ensures out.size = spm.size\n ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0\n do\n out := Array.replicate spm.size 0\n let mut spmInd := Array.replicate spm.size 0\n let mut spvInd := Array.replicate spm.size 0\n while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size\n invariant spvInd.size = spm.size\n invariant spmInd.size = spm.size\n invariant out.size = spm.size\n invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size\n invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size\n invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0\n done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size\n do\n let ind_m := spmInd[i]!\n let ind_v := spvInd[i]!\n if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then\n out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!\n spmInd[i] += 1\n spvInd[i] += 1\n else\n if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then\n spmInd[i] += 1\n else\n spvInd[i] += 1\n return"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
},
{
"name": "spv_dot_pure_gen",
"content": "theorem spv_dot_pure_gen (spv1: SpV Int) (spv2: SpV Int) (n pnt1 pnt2: ℕ)\n (sz1: ∀ i < spv1.size, spv1.ind[i]! < n)\n (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):\n spv_dot spv1 spv2 pnt1 pnt2 =\n ∑ i ∈ Finset.range n,\n if max\n (if spv1.size ≤ pnt1 then n else spv1.ind[pnt1]!)\n (if spv2.size ≤ pnt2 then n else spv2.ind[pnt2]!) ≤ i then\n spv1[i] * spv2[i]\n else\n 0"
},
{
"name": "spv_dot_pure",
"content": "theorem spv_dot_pure (spv1 spv2: SpV Int) (n: ℕ)\n (sz1: ∀ i < spv1.size, spv1.ind[i]! < n) (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):\n spv_dot spv1 spv2 0 0 = ∑ i ∈ Finset.range n, spv1[i] * spv2[i]"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=
if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then
0
else
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
(spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
spv_dot spv1 spv2 (pnt1 + 1) pnt2
else
spv_dot spv1 spv2 pnt1 (pnt2 + 1)
termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)
method SpVSpV
(mut out: Array Int)
(spv1: SpV Int)
(spv2: SpV Int) return (u: Unit)
ensures out.size = 1
ensures out[0]! = spv_dot spv1 spv2 0 0
do
out := Array.replicate 1 0
let mut pnt1 := 0
let mut pnt2 := 0
while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size
invariant out.size = 1
invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size
invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0
done_with pnt1 = spv1.size ∨ pnt2 = spv2.size
do
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!
pnt1 := pnt1 + 1
pnt2 := pnt2 + 1
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
pnt1 := pnt1 + 1
else
pnt2 := pnt2 + 1
return
method SpMSpV
(mut out: Array Int)
(spm: Array (SpV Int))
(spv: SpV Int) return (u: Unit)
ensures out.size = spm.size
ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0
do
out := Array.replicate spm.size 0
let mut spmInd := Array.replicate spm.size 0
let mut spvInd := Array.replicate spm.size 0
while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size
invariant spvInd.size = spm.size
invariant spmInd.size = spm.size
invariant out.size = spm.size
invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size
invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size
invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0
done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size
do
let ind_m := spmInd[i]!
let ind_v := spvInd[i]!
if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then
out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!
spmInd[i] += 1
spvInd[i] += 1
else
if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then
spmInd[i] += 1
else
spvInd[i] += 1
return | theorem SpMSpV_correct_triple
(out: Array Int)
(spm: Array (SpV Int))
(spv: SpV Int)
(n: ℕ):
triple
(∀ i < spm.size, (∀ j < spm[i]!.size, spm[i]!.ind[j]! < n) ∧ (∀ j < spv.size, spv.ind[j]! < n))
(SpMSpV out spm spv)
fun ⟨_, outNew⟩ =>
outNew.size = spm.size ∧ ∀ i < spm.size, outNew[i]! = ∑ idx ∈ Finset.range n, spm[i]![idx]! * spv[idx]! := | := by
simp [triple]
intro inb
apply wp_cons (SpMSpV out spm spv)
fun ⟨_, outNew⟩ =>
(∀ i < spm.size, outNew[i]! = spv_dot spm[i]! spv 0 0) ∧ outNew.size = spm.size
{ rintro outNew; simp
intro sum_eq sz_eq
simp [sz_eq]
intro i ib
simp [←spv_dot_pure spm[i]! spv n (inb i ib).left (inb i ib).right]
exact sum_eq i ib }
simp
have triple_true := SpMSpV_correct out spm spv
simp [triple] at triple_true
simp [WithName] at triple_true
exact triple_true | 4 | 37 | false | Framework |
383 | PartialCorrectness.repeat_inv | lemma repeat_inv (f : Unit -> β -> m (ForInStep β))
(inv : ForInStep β -> l)
init :
(∀ b, triple (inv (.yield b)) (f () b) (inv)) ->
triple (inv (.yield init)) (Loop.forIn.loop f init) (fun b => inv (.done b)) | loom | Loom/MonadAlgebras/WP/Basic.lean | [
"import Loom.MonadAlgebras.Instances.Gen",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.Instances.ReaderT",
"import Loom.MonadAlgebras.Instances.ExceptT",
"import Loom.MonadAlgebras.Instances.StateT",
"import Loom.MonadAlgebras.Instances.Basic"
] | [
{
"name": "ForInStep",
"module": "Init.Core"
},
{
"name": "Lean.Order.CCPO",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.MonoBind",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "inline",
"module": "Init.Core"
},
{
"name": "ForInStep.yield",
"module": "Init.Core"
},
{
"name": "Lean.Loop",
"module": "Init.While"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Lean.Order.admissible",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.admissible_pi_apply",
"module": "Init.Internal.Order.Basic"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "Lean.Order.CCPO.csup",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Lean.Order.chain",
"module": "Init.Internal.Order.Basic"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "Preorder",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "MAlgPartial",
"content": "class MAlgPartial (m : Type u -> Type v) [Monad m] [∀ α, Lean.Order.CCPO (m α)]\n [CompleteLattice l] [MAlgOrdered m l] where\n csup_lift {α : Type u} (xc : Set (m α)) (post : α -> l) :\n Lean.Order.chain xc ->\n ⨅ x ∈ xc, MAlg.lift x post <= MAlg.lift (Lean.Order.CCPO.csup xc) post"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "Cont.monotone",
"content": "@[simp]\ndef Cont.monotone {t : Type v} {α : Type u} [Preorder t] (wp : Cont t α) :=\n ∀ (f f' : α -> t), (∀ a, f a ≤ f' a) → wp f ≤ wp f'"
},
{
"name": "Cont",
"content": "abbrev Cont (t : Type v) (α : Type u) := (α -> t) -> t"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "le_trans'",
"module": "Mathlib.Order.Basic"
}
] | [
{
"name": "Cont.monotone_lift",
"content": "lemma Cont.monotone_lift {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteLattice l] [MAlgOrdered m l] :\n ∀ {α : Type u} (x : m α), MAlg.lift x |>.monotone"
}
] | [
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "Loop.forIn.loop",
"content": "@[specialize, inline]\ndef Loop.forIn.loop {m : Type u -> Type v} [Monad m] [∀ α, CCPO (m α)] [MonoBind m] (f : Unit → β → m (ForInStep β)) (b : β) : m β := do\n match ← f () b with\n | ForInStep.done b => pure b\n | ForInStep.yield b => loop f b\n partial_fixpoint"
},
{
"name": "Loop.forIn",
"content": "@[inline]\ndef Loop.forIn {β : Type u} [Monad m] [∀ α, CCPO (m α)] [MonoBind m]\n (_ : Lean.Loop) (init : β) (f : Unit → β → m (ForInStep β)) : m β :=\n Loop.forIn.loop f init"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "wp_bind",
"content": "lemma wp_bind {β} (x : m α) (f : α -> m β) (post : β -> l) :\n wp (x >>= f) post = wp x (fun x => wp (f x) post)"
},
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
},
{
"name": "PartialCorrectness.wp_csup",
"content": "omit [MonoBind m] [LawfulMonad m] in\nlemma wp_csup (xc : Set (m α)) (post : α -> l) :\n Lean.Order.chain xc ->\n ⨅ c ∈ xc, wp c post ≤ wp (Lean.Order.CCPO.csup xc) post"
}
] | import Loom.MonadAlgebras.Defs
import Loom.MonadAlgebras.Instances.Basic
import Loom.MonadAlgebras.Instances.ExceptT
import Loom.MonadAlgebras.Instances.StateT
import Loom.MonadAlgebras.Instances.ReaderT
import Loom.MonadAlgebras.Instances.Gen
variable {m : Type u -> Type v} [Monad m] [LawfulMonad m] {α : Type u} {l : Type u}
section
variable [CompleteLattice l]
section
variable [mprop : MAlgOrdered m l]
def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post
def triple (pre : l) (c : m α) (post : α -> l) : Prop :=
pre ≤ wp c post
end
variable [MAlgOrdered m l]
end
section
variable [CompleteLattice l] [MAlgOrdered m l]
noncomputable
end
section Determinism
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end Determinism
section Loops
open Lean.Order
@[specialize, inline]
def Loop.forIn.loop {m : Type u -> Type v} [Monad m] [∀ α, CCPO (m α)] [MonoBind m] (f : Unit → β → m (ForInStep β)) (b : β) : m β := do
match ← f () b with
| ForInStep.done b => pure b
| ForInStep.yield b => loop f b
partial_fixpoint
@[inline]
def Loop.forIn {β : Type u} [Monad m] [∀ α, CCPO (m α)] [MonoBind m]
(_ : Lean.Loop) (init : β) (f : Unit → β → m (ForInStep β)) : m β :=
Loop.forIn.loop f init
variable [inst: _root_.CompleteLattice l] [MAlgOrdered m l]
namespace PartialCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m] [MAlgPartial m] | lemma repeat_inv (f : Unit -> β -> m (ForInStep β))
(inv : ForInStep β -> l)
init :
(∀ b, triple (inv (.yield b)) (f () b) (inv)) ->
triple (inv (.yield init)) (Loop.forIn.loop f init) (fun b => inv (.done b)) := | := by
intro hstep
revert init
apply Loop.forIn.loop.fixpoint_induct (f := f) (motive :=
fun loop => ∀ init, triple (inv (.yield init)) (loop init) (fun b =>inv (.done b)))
{ apply Lean.Order.admissible_pi_apply
(P := fun init loop => triple (inv (.yield init)) (loop) (fun b =>inv (.done b)))
simp [admissible, triple]; intro init loops cl h
apply le_trans'; apply wp_csup; solve_by_elim
simp; solve_by_elim }
intro loop ih init; simp [triple, wp_bind]; apply le_trans; apply hstep
apply wp_cons; rintro (_|_); simp [wp_pure]
apply ih | 4 | 38 | false | Framework |
384 | SpVSpV_correct_triple | theorem SpVSpV_correct_triple (out: Array Int) (spv1 spv2: SpV Int) (n: ℕ):
triple
((∀ i < spv1.size, spv1.ind[i]! < n) ∧ (∀ i < spv2.size, spv2.ind[i]! < n))
(SpVSpV out spv1 spv2)
fun ⟨_, outNew⟩ =>
outNew[0]! = ∑ i ∈ Finset.range n, spv1[i]! * spv2[i]! | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Array.replicate",
"module": "Init.Data.Array.Basic"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Lean.Name",
"module": "Init.Prelude"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" ",
"content": "syntax \"method\" ident leafny_binder* \"return\" \"(\" ident \":\" term \")\"\n (require_caluse )*\n (ensures_caluse)* \"do\" doSeq\n Termination.suffix : command\n\nsyntax \"ensures\" termBeforeReqEnsDo : ensures_caluse\n\nsyntax \"while_some\" term \":|\" termBeforeDo \"do\" doSeq : doElem\n\nsyntax \"while_some\" term \":|\" term\n (invariantClause)+\n (doneWith)?\n \"do\" doSeq : doElem\n\nsyntax \"let\" term \":|\" term : doElem\n\nsyntax \"done_with\" termBeforeDo : doneWith\n\nsyntax \"invariant\" termBeforeDo linebreak : invariantClause\n\nsyntax \"while\" term\n (invariantClause)*\n (doneWith)?\n (decreasingTerm)?\n \"do\" doSeq : doElem\n\nsyntax \"(mut\" ident \":\" term \")\" : leafny_binder"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| let $x:term :| $t) => `(doElem| let $x:term <- pickSuchThat _ (fun $x => type_with_name_prefix `choice $t))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t do $seq:doSeq) => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- withRef (<- getRef) `(invariants [])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done ¬$t:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match measure with\n | some measure_some =>\n let decr <- withRef measure_some `(decreasing type_with_name_prefix `decreasing $measure_some)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | none => do\n let decr <- withRef (<- getRef) `(decreasing none)\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if $t then\n $seq:doSeq\n else break)\n | `(doElem| while_some $x:ident :| $t do $seq:doSeq) =>\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n while ∃ $x:ident, $t do\n let $x :| $t\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| while_some $x:ident :| $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]? do\n $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n let invd_some ← match inv_done with\n | some invd_some => withRef invd_some ``($invd_some)\n | none => ``(¬$t:term)\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n let decr <- withRef (<- getRef) `(decreasing none)\n `(doElem|\n for _ in Lean.Loop.mk do\n $invs:term\n onDoneGadget (with_name_prefix `done $invd_some:term)\n $decr:term\n if ∃ $x:ident, $t then\n let $x :| $t\n $[$seq:doElem]*\n else break)\n | _ => Lean.Macro.throwError \"while_some expects a sequence of do-elements\"\n | `(doElem| for $x:ident in $t\n $[invariant $inv:term\n ]*\n do $seq:doSeq) => do\n let invs <- `(invariants [ $[(with_name_prefix `invariant $inv:term)],* ])\n match seq with\n | `(doSeq| $[$seq:doElem]*)\n | `(doSeq| $[$seq:doElem;]*)\n | `(doSeq| { $[$seq:doElem]* }) =>\n `(doElem|\n for $x:ident in $t do\n $invs:term\n $[$seq:doElem]*)\n | _ => Lean.Macro.throwError \"for expects a sequence of do-elements\""
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(tactic|loom_solver) =>\n `(tactic|(\n try simp at *\n try aesop))"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem| while $t\n $[invariant $inv:term\n ]*\n $[done_with $inv_done]?\n $[decreasing $measure]?\n do $seq:doSeq) => do\n let balance := mkIdent `balance_name\n let balanceType <- `(term| Bal)\n let inv : Array Term <- inv.mapM fun (inv : Term) => withRef inv ``(fun ($(balance):ident : $balanceType)=> with_name_prefix `inv $inv)\n let invd_some <- match inv_done with\n | some invd_some => withRef invd_some ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done $invd_some)\n | none => ``(fun ($(balance):ident : $balanceType) => with_name_prefix `done ¬$t:term)\n match measure with\n | some measure_some =>\n let measure_some ← withRef measure_some ``(type_with_name_prefix `decreasing ($measure_some:term))\n do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget ($measure_some:term)\n if $t then\n $seq:doSeq\n else break)\n | none => do\n `(doElem|\n for _ in Lean.Loop.mk do\n invariantGadget [ $[$inv:term],* ]\n onDoneGadget ($invd_some:term)\n decreasingGadget none\n if $t then\n $seq:doSeq\n else break)"
},
{
"name": "macro_rules",
"content": "macro_rules\n| `(doElem|balance_set $t) => do\n let balId := mkIdent `balance\n `(doElem|do\n $balId:ident := $t\n set $balId:ident\n $balId:ident ← get)"
},
{
"name": "macro_rules",
"content": "macro_rules\n | `(doElem|$id:ident[$idx:term] := $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (fun _ => $val))\n | `(doElem|$id:ident[$idx:term] += $val:term) =>\n `(doElem| $id:term := ($id:term).modify $idx (· + $val))"
},
{
"name": "WithName",
"content": "abbrev WithName (α : Sort u) (name : Lean.Name := default) := α"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "em",
"module": "Mathlib.Logic.Basic"
},
{
"name": "if_pos",
"module": "Init.Core"
},
{
"name": "le_iff_eq_or_lt",
"module": "Mathlib.Order.Basic"
},
{
"name": "le_of_lt",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "le_trans",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_of_lt_of_le",
"module": "Mathlib.Order.Defs.PartialOrder"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
},
{
"name": "Finset.sum_congr",
"module": "Mathlib.Algebra.BigOperators.Group.Finset.Basic"
},
{
"name": "lt_iff_le_not_ge",
"module": "Mathlib.Order.Defs.PartialOrder"
}
] | [
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "spv_dot",
"content": "def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=\n if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then\n 0\n else\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n (spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n spv_dot spv1 spv2 (pnt1 + 1) pnt2\n else\n spv_dot spv1 spv2 pnt1 (pnt2 + 1)\n termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)\n\n\nmethod SpVSpV\n (mut out: Array Int)\n (spv1: SpV Int)\n (spv2: SpV Int) return (u: Unit)\n ensures out.size = 1\n ensures out[0]! = spv_dot spv1 spv2 0 0\n do\n out := Array.replicate 1 0\n let mut pnt1 := 0\n let mut pnt2 := 0\n while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size\n invariant out.size = 1\n invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size\n invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0\n done_with pnt1 = spv1.size ∨ pnt2 = spv2.size\n do\n if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then\n out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!\n pnt1 := pnt1 + 1\n pnt2 := pnt2 + 1\n else\n if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then\n pnt1 := pnt1 + 1\n else\n pnt2 := pnt2 + 1\n return\n\n\nmethod SpMSpV\n (mut out: Array Int)\n (spm: Array (SpV Int))\n (spv: SpV Int) return (u: Unit)\n ensures out.size = spm.size\n ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0\n do\n out := Array.replicate spm.size 0\n let mut spmInd := Array.replicate spm.size 0\n let mut spvInd := Array.replicate spm.size 0\n while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size\n invariant spvInd.size = spm.size\n invariant spmInd.size = spm.size\n invariant out.size = spm.size\n invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size\n invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size\n invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0\n done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size\n do\n let ind_m := spmInd[i]!\n let ind_v := spvInd[i]!\n if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then\n out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!\n spmInd[i] += 1\n spvInd[i] += 1\n else\n if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then\n spmInd[i] += 1\n else\n spvInd[i] += 1\n return"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
},
{
"name": "spv_dot_pure_gen",
"content": "theorem spv_dot_pure_gen (spv1: SpV Int) (spv2: SpV Int) (n pnt1 pnt2: ℕ)\n (sz1: ∀ i < spv1.size, spv1.ind[i]! < n)\n (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):\n spv_dot spv1 spv2 pnt1 pnt2 =\n ∑ i ∈ Finset.range n,\n if max\n (if spv1.size ≤ pnt1 then n else spv1.ind[pnt1]!)\n (if spv2.size ≤ pnt2 then n else spv2.ind[pnt2]!) ≤ i then\n spv1[i] * spv2[i]\n else\n 0"
},
{
"name": "spv_dot_pure",
"content": "theorem spv_dot_pure (spv1 spv2: SpV Int) (n: ℕ)\n (sz1: ∀ i < spv1.size, spv1.ind[i]! < n) (sz2: ∀ i < spv2.size, spv2.ind[i]! < n):\n spv_dot spv1 spv2 0 0 = ∑ i ∈ Finset.range n, spv1[i] * spv2[i]"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def spv_dot (spv1 spv2: SpV Int) (pnt1 pnt2: ℕ): Int :=
if (spv1.size) ≤ pnt1 ∨ (spv2.size) ≤ pnt2 then
0
else
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
(spv1.val)[pnt1]! * (spv2.val)[pnt2]! + spv_dot spv1 spv2 (pnt1 + 1) (pnt2 + 1)
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
spv_dot spv1 spv2 (pnt1 + 1) pnt2
else
spv_dot spv1 spv2 pnt1 (pnt2 + 1)
termination_by ((spv1.size) + (spv2.size) - pnt1 - pnt2)
method SpVSpV
(mut out: Array Int)
(spv1: SpV Int)
(spv2: SpV Int) return (u: Unit)
ensures out.size = 1
ensures out[0]! = spv_dot spv1 spv2 0 0
do
out := Array.replicate 1 0
let mut pnt1 := 0
let mut pnt2 := 0
while pnt1 ≠ spv1.size ∧ pnt2 ≠ spv2.size
invariant out.size = 1
invariant pnt1 ≤ spv1.size ∧ pnt2 ≤ spv2.size
invariant out[0]! + spv_dot spv1 spv2 pnt1 pnt2 = spv_dot spv1 spv2 0 0
done_with pnt1 = spv1.size ∨ pnt2 = spv2.size
do
if (spv1.ind)[pnt1]! = (spv2.ind)[pnt2]! then
out[0] += (spv1.val)[pnt1]! * (spv2.val)[pnt2]!
pnt1 := pnt1 + 1
pnt2 := pnt2 + 1
else
if (spv1.ind)[pnt1]! < (spv2.ind)[pnt2]! then
pnt1 := pnt1 + 1
else
pnt2 := pnt2 + 1
return
method SpMSpV
(mut out: Array Int)
(spm: Array (SpV Int))
(spv: SpV Int) return (u: Unit)
ensures out.size = spm.size
ensures ∀ i < spm.size, out[i]! = spv_dot spm[i]! spv 0 0
do
out := Array.replicate spm.size 0
let mut spmInd := Array.replicate spm.size 0
let mut spvInd := Array.replicate spm.size 0
while_some i :| i < spm.size ∧ spmInd[i]! < spm[i]!.size ∧ spvInd[i]! < spv.size
invariant spvInd.size = spm.size
invariant spmInd.size = spm.size
invariant out.size = spm.size
invariant ∀ i < spmInd.size, spmInd[i]! <= spm[i]!.size
invariant ∀ i < spvInd.size, spvInd[i]! <= spv.size
invariant ∀ i < spm.size, out[i]! + spv_dot spm[i]! spv spmInd[i]! spvInd[i]! = spv_dot spm[i]! spv 0 0
done_with ∀ i < spm.size, spmInd[i]! = spm[i]!.size ∨ spvInd[i]! = spv.size
do
let ind_m := spmInd[i]!
let ind_v := spvInd[i]!
if spm[i]!.ind[ind_m]! = spv.ind[ind_v]! then
out[i] += spm[i]!.val[ind_m]! * spv.val[ind_v]!
spmInd[i] += 1
spvInd[i] += 1
else
if spm[i]!.ind[ind_m]! < spv.ind[ind_v]! then
spmInd[i] += 1
else
spvInd[i] += 1
return | theorem SpVSpV_correct_triple (out: Array Int) (spv1 spv2: SpV Int) (n: ℕ):
triple
((∀ i < spv1.size, spv1.ind[i]! < n) ∧ (∀ i < spv2.size, spv2.ind[i]! < n))
(SpVSpV out spv1 spv2)
fun ⟨_, outNew⟩ =>
outNew[0]! = ∑ i ∈ Finset.range n, spv1[i]! * spv2[i]! := | := by
simp [triple]
intro b1 b2
apply wp_cons (SpVSpV out spv1 spv2)
fun ⟨_, outNew⟩ =>
outNew[0]! = spv_dot spv1 spv2 0 0 ∧ outNew.size = 1
{ rintro outNew; simp
intro sum_eq sz_eq
simp [sum_eq]
exact spv_dot_pure spv1 spv2 n b1 b2 }
simp
have triple_true := SpVSpV_correct out spv1 spv2
simp [triple] at triple_true
simp [WithName] at triple_true
exact triple_true | 4 | 37 | false | Framework |
385 | spmv_correct_triple | theorem spmv_correct_triple (out: Array Int) (arr: Array Int) (spm: Array (SpV Int)):
triple
(∀ i < spm.size, ∀ j < spm[i]!.size, spm[i]!.ind[j]! < arr.size)
(spmv out arr spv spm)
fun ⟨_, outNew⟩ =>
(∀ j < outNew.size, outNew[j]! = ∑ i ∈ Finset.range (arr.size), spm[j]![i] * arr[i]!) | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Array.replicate",
"module": "Init.Data.Array.Basic"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "Nat.lt_iff_le_and_ne",
"module": "Init.Data.Nat.Basic"
},
{
"name": "add_left_cancel_iff",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
}
] | [
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "sumUpTo",
"content": "def sumUpTo\n (spv : SpV Int)\n (v : Array Int) (bound : ℕ) : Int := ∑ i ∈ Finset.range bound, ((spv.val)[i]! * v[(spv.ind)[i]!]!)"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
},
{
"name": "VSpV_correct_pure",
"content": "theorem VSpV_correct_pure (out: Array Int) (arr: Array Int)\n (spv: SpV Int)\n (h_b: ∀ i < spv.size, spv.ind[i]! < arr.size):\n out.size = 1 → out[0]! = sumUpTo spv arr spv.size →\n out[0]! = ∑ i ∈ Finset.range (arr.size), spv[i] * arr[i]!"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def sumUpTo
(spv : SpV Int)
(v : Array Int) (bound : ℕ) : Int := ∑ i ∈ Finset.range bound, ((spv.val)[i]! * v[(spv.ind)[i]!]!) | theorem spmv_correct_triple (out: Array Int) (arr: Array Int) (spm: Array (SpV Int)):
triple
(∀ i < spm.size, ∀ j < spm[i]!.size, spm[i]!.ind[j]! < arr.size)
(spmv out arr spv spm)
fun ⟨_, outNew⟩ =>
(∀ j < outNew.size, outNew[j]! = ∑ i ∈ Finset.range (arr.size), spm[j]![i] * arr[i]!) := | := by
simp [triple]
intro h_b
apply wp_cons
(spmv out arr spv spm)
fun ⟨_, outNew⟩ =>
((∀ i < spm.size, outNew[i]! = sumUpTo spm[i]! arr spm[i]!.size) ∧ spm.size = outNew.size)
{ simp; rintro outNew;
intro sum_eq sz_eq j h_j
have single_elem : (Array.replicate 1 outNew[j]!)[0]! = outNew[j]! := by
simp
-- simp [getElem!] at replicate_get
-- simp [getElem, replicate_get]
have single_th := VSpV_correct_pure
(Array.replicate 1 outNew[j]!)
arr
spm[j]!
(h_b j (by rw [←sz_eq] at h_j; exact h_j))
(by simp)
(by simp; exact sum_eq j (by rw [←sz_eq] at h_j; exact h_j))
simp at single_th
simp [←single_th] }
simp
have triple_true := spmv_correct out arr spv spm
simp [triple] at triple_true
exact triple_true | 3 | 27 | false | Framework |
386 | VSpV_correct_triple | theorem VSpV_correct_triple (out: Array Int) (arr: Array Int) (spv: SpV Int):
triple
(∀ i < spv.size, spv.ind[i]! < arr.size)
(VSpV out arr spv)
fun ⟨_, outNew⟩ =>
outNew[0]! = ∑ i ∈ Finset.range (arr.size), spv[i] * arr[i]! | loom | CaseStudies/Velvet/VelvetExamples/SpMSpV_Example.lean | [
"import Auto",
"import CaseStudies.Velvet.Std",
"import Mathlib.Algebra.BigOperators.Intervals",
"import Loom.MonadAlgebras.WP.DoNames'",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Algebra.Ring.Int.Defs",
"import Lean",
"import Loom.MonadAlgebras.NonDetT.Extract"
] | [
{
"name": "Array",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Int",
"module": "Init.Data.Int.Basic"
},
{
"name": "Finset",
"module": "Mathlib.Data.Finset.Defs"
},
{
"name": "Finset.range",
"module": "Mathlib.Data.Finset.Range"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "List.find?",
"module": "Init.Data.List.Basic"
},
{
"name": "List.zip",
"module": "Init.Data.List.Basic"
}
] | [
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "List.find?_eq_some_iff_getElem",
"module": "Init.Data.List.Nat.Find"
},
{
"name": "List.find?_eq_none",
"module": "Init.Data.List.Find"
},
{
"name": "List.mem_iff_get",
"module": "Init.Data.List.Lemmas"
},
{
"name": "List.of_mem_zip",
"module": "Init.Data.List.Zip"
},
{
"name": "Nat.lt_iff_le_and_ne",
"module": "Init.Data.Nat.Basic"
},
{
"name": "add_left_cancel_iff",
"module": "Mathlib.Algebra.Group.Defs"
},
{
"name": "lt_or_gt_of_ne",
"module": "Mathlib.Order.Defs.LinearOrder"
}
] | [
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
}
] | [
{
"name": "SpV",
"content": "structure SpV (valTyp : Type) where\n ind: Array Nat\n val: Array valTyp\n size: ℕ\n size_eq: ind.size = size ∧ val.size = size\n inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!"
},
{
"name": "sumUpTo",
"content": "def sumUpTo\n (spv : SpV Int)\n (v : Array Int) (bound : ℕ) : Int := ∑ i ∈ Finset.range bound, ((spv.val)[i]! * v[(spv.ind)[i]!]!)"
}
] | [
{
"name": "getValSpV_eq",
"content": "theorem getValSpV_eq (spv: SpV Int) (j: ℕ) (h_ind: j < spv.size): spv[spv.ind[j]!] = (spv.val)[j]!"
},
{
"name": "getValSpV_empty",
"content": "theorem getValSpV_empty (spv: SpV Int) (j: ℕ) (h_empty: ∀ i < spv.size, spv.ind[i]! ≠ j): spv[j] = 0"
},
{
"name": "VSpV_correct_pure",
"content": "theorem VSpV_correct_pure (out: Array Int) (arr: Array Int)\n (spv: SpV Int)\n (h_b: ∀ i < spv.size, spv.ind[i]! < arr.size):\n out.size = 1 → out[0]! = sumUpTo spv arr spv.size →\n out[0]! = ∑ i ∈ Finset.range (arr.size), spv[i] * arr[i]!"
}
] | import Auto
import Lean
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Ring.Int.Defs
import Loom.MonadAlgebras.NonDetT.Extract
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.DoNames'
import CaseStudies.Velvet.Std
section SpMV
structure SpV (valTyp : Type) where
ind: Array Nat
val: Array valTyp
size: ℕ
size_eq: ind.size = size ∧ val.size = size
inc: ∀ (i j: Nat), i < size → j < size → i < j → ind[i]! < ind[j]!
def sumUpTo
(spv : SpV Int)
(v : Array Int) (bound : ℕ) : Int := ∑ i ∈ Finset.range bound, ((spv.val)[i]! * v[(spv.ind)[i]!]!) | theorem VSpV_correct_triple (out: Array Int) (arr: Array Int) (spv: SpV Int):
triple
(∀ i < spv.size, spv.ind[i]! < arr.size)
(VSpV out arr spv)
fun ⟨_, outNew⟩ =>
outNew[0]! = ∑ i ∈ Finset.range (arr.size), spv[i] * arr[i]! := | := by
simp [triple]
intro h_b
apply wp_cons (VSpV out arr spv)
fun ⟨u, outNew⟩ =>
(outNew[0]! = sumUpTo spv arr spv.size ∧ outNew.size = 1)
{ rintro ⟨u, outNew⟩; simp
intro sum_eq sz
exact VSpV_correct_pure outNew arr spv h_b sz sum_eq }
simp
have triple_true := VSpV_correct out arr spv
simp [triple] at triple_true
apply triple_true | 3 | 26 | false | Framework |
387 | DemonicChoice.ExtractNonDet.extract_refines | lemma ExtractNonDet.extract_refines (pre : l) (s : NonDetT m α) (inst : ExtractNonDet Findable s) :
triple pre s post ->
pre <= s.prop ⊤ ->
triple pre s.extract post | loom | Loom/MonadAlgebras/NonDetT'/Extract.lean | [
"import Loom.MonadAlgebras.WP.Gen",
"import Loom.MonadAlgebras.WP.Liberal",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Mathlib.Data.W.Basic",
"import Loom.MonadAlgebras.NonDetT'.Basic",
"import Loom.MonadAlgebras.WP.Basic",
"import Mathlib.Order.Lattice",
"import Mathlib.Data.FinEnum",
"import Mathlib.Order.Basic",
"import Loom/MonadAlgebras/NonDetT/Findable.lean"
] | [
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Encodable",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Encodable.decode",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "BooleanAlgebra",
"module": "Mathlib.Order.BooleanAlgebra.Defs"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "Pure",
"module": "Init.Prelude"
},
{
"name": "Decidable",
"module": "Init.Prelude"
},
{
"name": "PUnit",
"module": "Init.Prelude"
},
{
"name": "inline",
"module": "Init.Core"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadEnv",
"module": "Lean.Environment"
},
{
"name": "Lean.SimpleScopedEnvExtension",
"module": "Lean.ScopedEnvExtension"
},
{
"name": "Lean.SimplePersistentEnvExtension",
"module": "Lean.EnvExtension"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "MonadNonDet",
"content": "class MonadNonDet (m : Type u → Type v) where\n pick : (τ : Type u) → [Inhabited τ] → m τ\n \n pickSuchThat : (τ : Type u) → (p : τ → Prop) → [Findable p] → m τ\n assume : (as : Prop) → [Decidable as] → m PUnit.{u+1}\n \n rep {α : Type u} : α → (α → m (ForInStep α)) → m α"
},
{
"name": "wlp",
"content": "def wlp (c : m α) (post : α -> l) : l := iwp c post ⊔ wp c post"
},
{
"name": "iwp",
"content": "abbrev iwp (c : m α) : Cont l α := Cont.inv (wp c)"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "Cont.inv",
"content": "def Cont.inv {t : Type v} {α : Type u} [BooleanAlgebra t] (wp : Cont t α) : Cont t α :=\n fun f => (wp fun x => (f x)ᶜ)ᶜ"
},
{
"name": "Cont",
"content": "abbrev Cont (t : Type v) (α : Type u) := (α -> t) -> t"
},
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "CCPOBot",
"content": "class CCPOBot (m : Type u -> Type v) where\n compBot {α} : m α"
},
{
"name": "WPGen",
"content": "structure WPGen (x : m α) where\n get : Cont l α\n \n prop : ∀ post, get post <= wp x post"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "CCPOBotLawful",
"content": "class CCPOBotLawful (m : Type u -> Type v) [∀ α, Lean.Order.CCPO (m α)] [CCPOBot m] where\n prop {α} : CCPOBot.compBot (m := m) (α := α) = Lean.Order.bot"
},
{
"name": "NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} {α : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m α -> Cont l α\n | .pure ret => pure ret\n | .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | .pickCont τ p f => fun post => let p : Set τ := p; ⨅ a ∈ (p : Set τ), wp (f a) post"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "NonDetT.bind",
"content": "def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=\n match x with\n | pure ret => f ret\n | vis x f' => vis x fun y => bind (f' y) f\n | pickCont τ p f' => pickCont τ p fun t => bind (f' t) f\n | repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f"
},
{
"name": "WPGen.bind",
"content": "def WPGen.bind {x : m α} {f : α -> m β} (wpg : WPGen x) (wpgf : ∀ a, WPGen (f a)) :\n WPGen (x >>= f) where\n get := fun post => wpg.get (fun a => (wpgf a).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "_root_.Lean.SimpleScopedEnvExtension.get",
"content": "private def _root_.Lean.SimpleScopedEnvExtension.get [Inhabited σ] (ext : SimpleScopedEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "_root_.Lean.SimplePersistentEnvExtension.get",
"content": "private def _root_.Lean.SimplePersistentEnvExtension.get [Inhabited σ] (ext : SimplePersistentEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "_root_.Lean.EnvExtension.get",
"content": "private def _root_.Lean.EnvExtension.get [Inhabited σ] (ext : EnvExtension σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "NonDetT.pickSuchThat",
"content": "def NonDetT.pickSuchThat (τ : Type u) (p : τ → Prop) [Findable p] : NonDetT m τ :=\n NonDetT.pickCont τ p pure"
},
{
"name": "{l",
"content": "instance {l σ : Type u} : MonadLift (Cont l) (Cont (σ -> l)) where\n monadLift x := fun f s => x (f · s)"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "iInf_const",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "iInf_inf_eq",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "iInf_le_of_le",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "iSup_const",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "inf_assoc",
"module": "Mathlib.Order.Lattice"
},
{
"name": "inf_comm",
"module": "Mathlib.Order.Lattice"
},
{
"name": "inf_le_of_left_le",
"module": "Mathlib.Order.Lattice"
},
{
"name": "le_trans'",
"module": "Mathlib.Order.Basic"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "wp_bind",
"content": "lemma wp_bind {β} (x : m α) (f : α -> m β) (post : β -> l) :\n wp (x >>= f) post = wp x (fun x => wp (f x) post)"
},
{
"name": "wlp_join_wp",
"content": "lemma wlp_join_wp (c : m α) (post post' : α -> l) :\n wlp c post ⊓ wp c post' = wp c (fun x => post x ⊓ post' x)"
},
{
"name": "wlp_himp",
"content": "lemma wlp_himp (c : m α) (post post' : α -> l) :\n wp c (fun x => post' x ⇨ post x) = wlp c post' ⇨ wp c post"
},
{
"name": "wp_wlp",
"content": "omit [LawfulMonad m] in\nlemma wp_wlp (c : m α) (post : α -> l) :\n wp c post <= wlp c post"
},
{
"name": "NonDetT.wp_vis",
"content": "@[simp]\nlemma NonDetT.wp_vis {β : Type u} (x : m β) (f : β → NonDetT m α) post :\n _root_.wp (NonDetT.vis x f) post = _root_.wp x fun a => _root_.wp (f a) post"
},
{
"name": "NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
},
{
"name": "NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α β : Type u} (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "wp_cons",
"content": "lemma wp_cons (x : m α) (post post' : α -> l) :\n (∀ y, post y ≤ post' y) ->\n wp x post ≤ wp x post'"
},
{
"name": "NonDetT.wp_pickCont",
"content": "@[simp]\nlemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) post :\n _root_.wp (NonDetT.pickCont τ p f) post = ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post"
},
{
"name": "NonDetT.wp_pickCont",
"content": "@[simp]\nlemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) post :\n _root_.wp (NonDetT.pickCont τ p f) post = ⨆ a, ⌜p a⌝ ⊓ _root_.wp (f a) post"
},
{
"name": "meet_himp",
"content": "lemma meet_himp (x x' y z : l) :\n x = x' ->\n (x ⇨ y) ⊓ (x' ⇨ z) = x ⇨ (y ⊓ z)"
}
] | [
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
},
{
"name": "find",
"content": "def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=\n findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode"
},
{
"name": "WeakFindable",
"content": "class WeakFindable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_some_p : find () = some x -> p x"
},
{
"name": "Findable",
"content": "class Findable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_none : (find ()).isNone -> ∀ x, ¬ p x\n find_some_p : find () = some x -> p x"
},
{
"name": "WeakFindable",
"content": "instance WeakFindable.of_Findable {α : Type u} (p : α -> Prop) [Findable p] : WeakFindable p where\n find := Findable.find p\n find_some_p := Findable.find_some_p"
},
{
"name": "_inst_α",
"content": "instance {p : α -> Prop} [Encodable α] [DecidablePred p] : Findable p where\n find := fun _ => find p\n find_none := find_none p\n find_some_p := find_some_p p _"
},
{
"name": "_inst_α",
"content": "@[instance high]\ninstance {p : α -> Prop} [FinEnum α] [DecidablePred p] : Findable p where\n find := fun _ => FinEnum.toList α |>.find? p\n find_none := by admit /- proof elided -/"
},
{
"name": "ExtractNonDet",
"content": "inductive ExtractNonDet (findable : {τ : Type u} -> (τ -> Prop) -> Type u) {m} : {α : Type u} -> NonDetT m α -> Type _ where\n | pure {α} : ∀ (x : α), ExtractNonDet findable (NonDetT.pure x)\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) :\n (∀ y, ExtractNonDet findable (f y)) → ExtractNonDet findable (.vis x f)\n | pickSuchThat {α} (τ : Type u) (p : τ -> Prop) (f : τ → NonDetT m α)\n {_ : findable p}\n : (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont τ p f)\n | assume {α} (p : PUnit -> Prop) (f : PUnit → NonDetT m α) {_ : Decidable (p .unit)} :\n (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont PUnit p f)"
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pure' : ExtractNonDet findable (Pure.pure (f := NonDetT m) x) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.liftM (x : m α) :\n ExtractNonDet findable (liftM (n := NonDetT m) x) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.assume' {p : Prop} [Decidable p] : ExtractNonDet findable (MonadNonDet.assume (m := NonDetT m) p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pickSuchThat' {τ : Type u} (p : τ -> Prop) [Findable p] :\n ExtractNonDet Findable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.pickSuchThat_weak {τ : Type u} (p : τ -> Prop) [WeakFindable p] :\n ExtractNonDet WeakFindable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.if {p : Prop} {dec : Decidable p} {x y : NonDetT m α}\n (_ : ExtractNonDet findable x) (_ : ExtractNonDet findable y) :\n ExtractNonDet findable (if p then x else y) :="
},
{
"name": "ExtractNonDet",
"content": "instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}\n (_ : ∀ a b, ExtractNonDet findable (f a b)) :\n ExtractNonDet findable (forIn xs init f) :="
},
{
"name": "NonDetT.extractGen",
"content": "@[simp, inline]\ndef NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}\n (findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)\n : (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/\n ) -> m α\n | .pure x, _ => Pure.pure x\n | .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))\n | .pickCont _ p f, .pickSuchThat _ _ _ _ =>\n match findOf p ‹_› () with\n | none => CCPOBot.compBot\n | some x => extractGen findOf (f x)\n | .pickCont _ p f, .assume _ _ _ =>\n if p .unit then\n extractGen findOf (f .unit)\n else CCPOBot.compBot"
},
{
"name": "NonDetT.extract",
"content": "@[inline]\ndef NonDetT.extract {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet Findable s := by admit /- proof elided -/\n) : m α :=\n NonDetT.extractGen Findable.find s"
},
{
"name": "NonDetT.prop",
"content": "abbrev NonDetT.prop {α : Type u} : (s : NonDetT m α) -> Cont l α\n | .pure x => Pure.pure x\n | .vis x f => fun post => wlp x fun y => NonDetT.prop (f y) post\n | .pickCont _ p f => fun post =>\n (⨅ t, ⌜p t⌝ ⇨ NonDetT.prop (f t) post) ⊓ (⨆ t, ⌜p t⌝)"
},
{
"name": "Extractable",
"content": "structure Extractable (x : NonDetT m α) where\n cond : Cont l α\n prop : ∀ post, cond post <= x.prop post"
},
{
"name": "ExtractNonDet.prop",
"content": "def ExtractNonDet.prop {α : Type u} (s : NonDetT m α) : ExtractNonDet WeakFindable s -> l\n | .pure x => ⊤\n | .vis x f ex => wlp x fun y => (ex y).prop\n | .pickSuchThat _ p f ex => ⨅ t ∈ WeakFindable.find p (), (ex t).prop\n | .assume p f ex =>\n if p .unit then\n (ex .unit).prop\n else ⊤"
}
] | [
{
"name": "DemonicChoice.ExtractNonDet.extract_refines_wp",
"content": "lemma ExtractNonDet.extract_refines_wp (s : NonDetT m α) (inst : ExtractNonDet Findable s) :\n wp s post ⊓ s.prop ⊤ <= wp s.extract post"
}
] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Mathlib.Data.W.Basic
import Mathlib.Data.FinEnum
import Loom.MonadAlgebras.WP.Gen
import Loom.MonadAlgebras.WP.Liberal
import Loom.MonadAlgebras.NonDetT'.Basic
open Lean.Order
def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=
let rec aux i :=
if p i then
some i
else
aux (i + 1)
partial_fixpoint
aux 0
def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=
findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode
class WeakFindable {α : Type u} (p : α -> Prop) where
find : Unit -> Option α
find_some_p : find () = some x -> p x
class Findable {α : Type u} (p : α -> Prop) where
find : Unit -> Option α
find_none : (find ()).isNone -> ∀ x, ¬ p x
find_some_p : find () = some x -> p x
instance WeakFindable.of_Findable {α : Type u} (p : α -> Prop) [Findable p] : WeakFindable p where
find := Findable.find p
find_some_p := Findable.find_some_p
instance {p : α -> Prop} [Encodable α] [DecidablePred p] : Findable p where
find := fun _ => find p
find_none := find_none p
find_some_p := find_some_p p _
@[instance high]
instance {p : α -> Prop} [FinEnum α] [DecidablePred p] : Findable p where
find := fun _ => FinEnum.toList α |>.find? p
find_none := by admit /- proof elided -/
inductive ExtractNonDet (findable : {τ : Type u} -> (τ -> Prop) -> Type u) {m} : {α : Type u} -> NonDetT m α -> Type _ where
| pure {α} : ∀ (x : α), ExtractNonDet findable (NonDetT.pure x)
| vis {α} {β} (x : m β) (f : β → NonDetT m α) :
(∀ y, ExtractNonDet findable (f y)) → ExtractNonDet findable (.vis x f)
| pickSuchThat {α} (τ : Type u) (p : τ -> Prop) (f : τ → NonDetT m α)
{_ : findable p}
: (∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont τ p f)
| assume {α} (p : PUnit -> Prop) (f : PUnit → NonDetT m α) {_ : Decidable (p .unit)} :
(∀ x, ExtractNonDet findable (f x)) → ExtractNonDet findable (.pickCont PUnit p f)
instance ExtractNonDet.pure' : ExtractNonDet findable (Pure.pure (f := NonDetT m) x) :=
instance ExtractNonDet.liftM (x : m α) :
ExtractNonDet findable (liftM (n := NonDetT m) x) :=
instance ExtractNonDet.assume' {p : Prop} [Decidable p] : ExtractNonDet findable (MonadNonDet.assume (m := NonDetT m) p) :=
instance ExtractNonDet.pickSuchThat' {τ : Type u} (p : τ -> Prop) [Findable p] :
ExtractNonDet Findable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :=
instance ExtractNonDet.pickSuchThat_weak {τ : Type u} (p : τ -> Prop) [WeakFindable p] :
ExtractNonDet WeakFindable (MonadNonDet.pickSuchThat (m := NonDetT m) τ p) :=
instance ExtractNonDet.if {p : Prop} {dec : Decidable p} {x y : NonDetT m α}
(_ : ExtractNonDet findable x) (_ : ExtractNonDet findable y) :
ExtractNonDet findable (if p then x else y) :=
instance ExtractNonDet.ForIn_list {xs : List α} {init : β} {f : α → β → NonDetT m (ForInStep β)}
(_ : ∀ a b, ExtractNonDet findable (f a b)) :
ExtractNonDet findable (forIn xs init f) :=
variable [Monad m] [CCPOBot m] [CompleteBooleanAlgebra l] [MAlgOrdered m l] [MAlgDet m l] [LawfulMonad m]
@[simp, inline]
def NonDetT.extractGen {findable : {τ : Type u} -> (τ -> Prop) -> Type u} {α : Type u}
(findOf : ∀ {τ : Type u} (p : τ -> Prop), findable p -> Unit -> Option τ)
: (s : NonDetT m α) -> (ex : ExtractNonDet findable s := by admit /- proof elided -/
) -> m α
| .pure x, _ => Pure.pure x
| .vis x f, .vis _ _ _ => liftM x >>= (fun x => extractGen findOf (f x))
| .pickCont _ p f, .pickSuchThat _ _ _ _ =>
match findOf p ‹_› () with
| none => CCPOBot.compBot
| some x => extractGen findOf (f x)
| .pickCont _ p f, .assume _ _ _ =>
if p .unit then
extractGen findOf (f .unit)
else CCPOBot.compBot
@[inline]
def NonDetT.extract {α : Type u} (s : NonDetT m α) (ex : ExtractNonDet Findable s := by admit /- proof elided -/
) : m α :=
NonDetT.extractGen Findable.find s
abbrev NonDetT.prop {α : Type u} : (s : NonDetT m α) -> Cont l α
| .pure x => Pure.pure x
| .vis x f => fun post => wlp x fun y => NonDetT.prop (f y) post
| .pickCont _ p f => fun post =>
(⨅ t, ⌜p t⌝ ⇨ NonDetT.prop (f t) post) ⊓ (⨆ t, ⌜p t⌝)
structure Extractable (x : NonDetT m α) where
cond : Cont l α
prop : ∀ post, cond post <= x.prop post
def ExtractNonDet.prop {α : Type u} (s : NonDetT m α) : ExtractNonDet WeakFindable s -> l
| .pure x => ⊤
| .vis x f ex => wlp x fun y => (ex y).prop
| .pickSuchThat _ p f ex => ⨅ t ∈ WeakFindable.find p (), (ex t).prop
| .assume p f ex =>
if p .unit then
(ex .unit).prop
else ⊤
namespace DemonicChoice | lemma ExtractNonDet.extract_refines (pre : l) (s : NonDetT m α) (inst : ExtractNonDet Findable s) :
triple pre s post ->
pre <= s.prop ⊤ ->
triple pre s.extract post := | := by
intro tr imp; apply le_trans'; apply ExtractNonDet.extract_refines_wp
simp; aesop | 5 | 80 | false | Framework |
388 | StateT.wp_lift | lemma StateT.wp_lift (c : m α) (post : α -> σ -> l) :
wp (liftM (n := StateT σ m) c) post = fun s => wp (m := m) c (post · s) | loom | Loom/MonadAlgebras/WP/Basic.lean | [
"import Loom.MonadAlgebras.Instances.Gen",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.Instances.ReaderT",
"import Loom.MonadAlgebras.Instances.ExceptT",
"import Loom.MonadAlgebras.Instances.StateT",
"import Loom.MonadAlgebras.Instances.Basic"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "MonadLift",
"module": "Init.Prelude"
},
{
"name": "MonadLift.monadLift",
"module": "Init.Prelude"
},
{
"name": "StateT.lift",
"module": "Init.Control.State"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
}
] | [
{
"name": "StateT.ext",
"module": "Init.Control.Lawful.Instances"
},
{
"name": "map_eq_pure_bind",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "MAlg.lift_StateT",
"content": "lemma MAlg.lift_StateT [Monad m] [LawfulMonad m] [CompleteLattice l] [inst: MAlgOrdered m l] (x : StateT σ m α) :\n MAlg.lift x post = fun s => MAlg.lift (x s) (fun xs => post xs.1 xs.2)"
}
] | [
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "wp_bind",
"content": "lemma wp_bind {β} (x : m α) (f : α -> m β) (post : β -> l) :\n wp (x >>= f) post = wp x (fun x => wp (f x) post)"
}
] | import Loom.MonadAlgebras.Defs
import Loom.MonadAlgebras.Instances.Basic
import Loom.MonadAlgebras.Instances.ExceptT
import Loom.MonadAlgebras.Instances.StateT
import Loom.MonadAlgebras.Instances.ReaderT
import Loom.MonadAlgebras.Instances.Gen
variable {m : Type u -> Type v} [Monad m] [LawfulMonad m] {α : Type u} {l : Type u}
section
variable [CompleteLattice l]
section
variable [mprop : MAlgOrdered m l]
def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post
end
variable [MAlgOrdered m l]
end
section
variable [CompleteLattice l] [MAlgOrdered m l]
noncomputable
end
section Determinism
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end Determinism
section Loops
open Lean.Order
variable [inst: _root_.CompleteLattice l] [MAlgOrdered m l]
namespace PartialCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m] [MAlgPartial m]
end PartialCorrectness
namespace TotalCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m]
variable [MAlgTotal m]
end TotalCorrectness
end Loops
section Lift
variable [inst: CompleteLattice l] [MAlgOrdered m l]
open ExceptionAsSuccess in
open ExceptionAsFailure in
open TotalCorrectness in | lemma StateT.wp_lift (c : m α) (post : α -> σ -> l) :
wp (liftM (n := StateT σ m) c) post = fun s => wp (m := m) c (post · s) := | := by
simp [wp, liftM, monadLift, MAlg.lift_StateT, MonadLift.monadLift, StateT.lift];
have liftE : ∀ α, MAlg.lift (m := m) (α := α) = wp := by intros; ext; simp [wp, liftM, monadLift]
ext s; rw [map_eq_pure_bind, liftE, liftE, wp_bind]; simp [wp_pure] | 2 | 21 | false | Framework |
389 | Gen.wp_rand | lemma Gen.wp_rand {α : Type} (c : Gen α) :
triple ⊤ c (fun _ => ⊤) | loom | Loom/MonadAlgebras/WP/Basic.lean | [
"import Loom.MonadAlgebras.Instances.Gen",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.Instances.ReaderT",
"import Loom.MonadAlgebras.Instances.ExceptT",
"import Loom.MonadAlgebras.Instances.StateT",
"import Loom.MonadAlgebras.Instances.Basic"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Plausible.Gen",
"module": "Plausible.Gen"
},
{
"name": "StdGen",
"module": "Init.Data.Random"
},
{
"name": "ULift",
"module": "Init.Prelude"
},
{
"name": "Id",
"module": "Init.Control.Id"
},
{
"name": "ReaderT",
"module": "Init.Prelude"
},
{
"name": "StateT",
"module": "Init.Control.State"
},
{
"name": "inferInstanceAs",
"module": "Init.Prelude"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "MAlgGenInst",
"content": "instance MAlgGenInst : MAlgOrdered Gen (ULift Nat -> ULift StdGen -> Prop) :=\n inferInstanceAs\n (MAlgOrdered\n (ReaderT (ULift Nat)\n (StateT (ULift StdGen) Id))\n (ULift Nat ->\n ULift StdGen -> Prop))"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "triple",
"content": "notation \"{\" P \"}\" c \"{\" v \",\" Q \"}\" => triple P c (fun v => Q)"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "MAlg.lift_StateT",
"content": "lemma MAlg.lift_StateT [Monad m] [LawfulMonad m] [CompleteLattice l] [inst: MAlgOrdered m l] (x : StateT σ m α) :\n MAlg.lift x post = fun s => MAlg.lift (x s) (fun xs => post xs.1 xs.2)"
},
{
"name": "MAlg.lift_ReaderT",
"content": "lemma MAlg.lift_ReaderT [Monad m] [LawfulMonad m] [CompleteLattice l] [inst: MAlgOrdered m l] (x : ReaderT σ m α) :\n MAlg.lift x post = fun s => MAlg.lift (x s) (fun xs => post xs s)"
}
] | [
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
}
] | [
{
"name": "StateT.wp_eq",
"content": "lemma StateT.wp_eq (c : StateT σ m α) (post : α -> σ -> l) :\n wp c post = fun s => wp (m := m) (c s) (fun xs => post xs.1 xs.2)"
},
{
"name": "ReaderT.wp_eq",
"content": "lemma ReaderT.wp_eq (c : ReaderT σ m α) (post : α -> σ -> l) :\n wp c post = fun s => wp (m := m) (c s) (post · s)"
}
] | import Loom.MonadAlgebras.Defs
import Loom.MonadAlgebras.Instances.Basic
import Loom.MonadAlgebras.Instances.ExceptT
import Loom.MonadAlgebras.Instances.StateT
import Loom.MonadAlgebras.Instances.ReaderT
import Loom.MonadAlgebras.Instances.Gen
variable {m : Type u -> Type v} [Monad m] [LawfulMonad m] {α : Type u} {l : Type u}
section
variable [CompleteLattice l]
section
variable [mprop : MAlgOrdered m l]
def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post
def triple (pre : l) (c : m α) (post : α -> l) : Prop :=
pre ≤ wp c post
end
variable [MAlgOrdered m l]
end
section
variable [CompleteLattice l] [MAlgOrdered m l]
noncomputable
end
section Determinism
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end Determinism
section Loops
open Lean.Order
variable [inst: _root_.CompleteLattice l] [MAlgOrdered m l]
namespace PartialCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m] [MAlgPartial m]
end PartialCorrectness
namespace TotalCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m]
variable [MAlgTotal m]
end TotalCorrectness
end Loops
section Lift
variable [inst: CompleteLattice l] [MAlgOrdered m l]
open ExceptionAsSuccess in
open ExceptionAsFailure in
open TotalCorrectness in
end Lift
section ExceptT
variable [inst: CompleteLattice l] [MAlgOrdered m l] [IsHandler (ε := ε) hd]
end ExceptT
section StateT
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end StateT
section ReaderT
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end ReaderT
section Gen
open Plausible | lemma Gen.wp_rand {α : Type} (c : Gen α) :
triple ⊤ c (fun _ => ⊤) := | := by
simp [triple, MAlgGenInst, ReaderT.wp_eq, StateT.wp_eq]
simp [wp, liftM, monadLift, MAlg.lift, MAlgOrdered.μ]; rfl | 3 | 26 | false | Framework |
390 | MAlgLift.wp_throw | lemma MAlgLift.wp_throw
[Monad n] [CompleteLattice k] [MAlgOrdered n k] [MonadLiftT m n]
[MonadLiftT (ExceptT ε m) n]
[inst: MAlgLiftT (ExceptT ε m) l n k] :
wp (liftM (n := n) (throw (m := ExceptT ε m) e)) post = ⌜hd e⌝ | loom | Loom/MonadAlgebras/WP/Basic.lean | [
"import Loom.MonadAlgebras.Instances.Gen",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.Instances.ReaderT",
"import Loom.MonadAlgebras.Instances.ExceptT",
"import Loom.MonadAlgebras.Instances.StateT",
"import Loom.MonadAlgebras.Instances.Basic"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "MonadLiftT",
"module": "Init.Prelude"
},
{
"name": "LE",
"module": "Init.Prelude"
},
{
"name": "OrderBot",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "OrderTop",
"module": "Mathlib.Order.BoundedOrder.Basic"
},
{
"name": "ExceptT",
"module": "Init.Control.Except"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
},
{
"name": "ExceptT.mk",
"module": "Init.Control.Except"
},
{
"name": "MonadExceptOf",
"module": "Init.Prelude"
},
{
"name": "MonadExceptOf.throw",
"module": "Init.Prelude"
},
{
"name": "throwThe",
"module": "Init.Prelude"
},
{
"name": "error",
"module": "Auto.Parser.TPTP"
},
{
"name": "Except",
"module": "Init.Prelude"
},
{
"name": "Except.error",
"module": "Init.Prelude"
},
{
"name": "Except.bind",
"module": "Init.Control.Except"
},
{
"name": "ExceptT.bind",
"module": "Init.Control.Except"
},
{
"name": "ExceptT.bindCont",
"module": "Init.Control.Except"
},
{
"name": "ExceptT.instMonad",
"module": "Init.Control.Except"
},
{
"name": "Function.comp",
"module": "Init.Prelude"
},
{
"name": "Pi.hasLe",
"module": "Mathlib.Order.Basic"
},
{
"name": "le",
"module": "Test.SmtTranslation.Names"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "MAlgLiftT",
"content": "class MAlgLiftT\n (m : (Type u -> Type v)) (l : (Type u)) [Monad m] [CompleteLattice l] [MAlgOrdered m l]\n (n : (Type u -> Type w)) (k : outParam (Type u)) [Monad n] [CompleteLattice k] [MAlgOrdered n k]\n [MonadLiftT m n]\n where\n [cl : LogicLiftT l k]\n μ_lift (x : m α) : MAlg.lift (liftM (n := n) x) f = liftM (n := Cont k) (MAlg.lift x) f"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "LogicLiftT",
"content": "class LogicLiftT (l : (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLiftT (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "LogicLift",
"content": "class LogicLift (l : outParam (Type u)) ( k : Type u) [CompleteLattice l] [CompleteLattice k] where\n [lift : MonadLift (Cont l) (Cont k)]\n lift_top {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊤) = ⊤\n lift_bot {α : Type u} :\n monadLift (m := Cont l) (n := Cont k) (fun (_ : α -> l) => ⊥) = ⊥"
},
{
"name": "LE.pure",
"content": "noncomputable def LE.pure {l : Type u} [inst: LE l] [OrderTop l] [OrderBot l] : Prop -> l := fun p =>\n if p then ⊤ else ⊥"
},
{
"name": "IsHandler",
"content": "class IsHandler {ε : Type*} (handler : outParam (ε -> Prop)) where"
},
{
"name": "Except.getD",
"content": "abbrev Except.getD {ε α} (default : ε -> α) : Except ε α -> α\n | Except.ok p => p\n | Except.error e => default e"
},
{
"name": "MAlgExcept",
"content": "def MAlgExcept (ε : Type u) (df : ε -> Prop) (l : Type u) (m : Type u -> Type v)\n [CompleteLattice l]\n [Monad m] [LawfulMonad m] [inst: MAlgOrdered m l] : MAlgOrdered (ExceptT ε m) l where\n μ := fun e => inst.μ $ Except.getD (⌜df ·⌝) <$> e\n μ_ord_pure := by admit /- proof elided -/"
},
{
"name": "Except.bind'",
"content": "abbrev Except.bind' {m : Type u -> Type v} {ε α β} [Monad m] : Except ε α -> (α -> ExceptT ε m β) -> ExceptT ε m β :=\n fun x f => bind (m := ExceptT ε m) (pure (f := m) x) f"
},
{
"name": "OfHd",
"content": "instance OfHd {hd : ε -> Prop} [hdInst : IsHandler hd]\n [CompleteLattice l] [inst: MAlgOrdered m l] : MAlgOrdered (ExceptT ε m) l := MAlgExcept ε hd l m"
}
] | [
{
"name": "ExceptT.ext",
"module": "Init.Control.Lawful.Instances"
}
] | [
{
"name": "MAlg.lift_ExceptT",
"content": "lemma MAlg.lift_ExceptT ε (hd : ε -> Prop) [IsHandler hd] [CompleteLattice l] [inst: MAlgOrdered m l]\n (c : ExceptT ε m α) post :\n MAlg.lift c post = MAlg.lift (m := m) c (fun | .ok x => post x | .error e => ⌜hd e⌝)"
}
] | [
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
}
] | [
{
"name": "wp_pure",
"content": "lemma wp_pure (x : α) (post : α -> l) : wp (m := m) (pure x) post = post x"
},
{
"name": "wp_except_handler_eq",
"content": "lemma wp_except_handler_eq ε (hd : ε -> Prop) [IsHandler hd] (c : ExceptT ε m α) post :\n wp c post = wp (m := m) c (fun | .ok x => post x | .error e => ⌜hd e⌝)"
},
{
"name": "MAlgLift.wp_lift",
"content": "omit [LawfulMonad m] in\nlemma MAlgLift.wp_lift [Monad n] [CompleteLattice k] [MAlgOrdered n k] [MonadLiftT m n]\n -- [MonadLiftT (Cont l) (Cont k)]\n [mAlgLift : MAlgLiftT m l n k] (c : m α):\n wp (liftM (n := n) c) = fun (post : α -> k) => mAlgLift.cl.lift.monadLift (wp c) post"
},
{
"name": "ExceptT.wp_throw",
"content": "lemma ExceptT.wp_throw (e : ε) :\n wp (α := α) (throw (m := ExceptT ε m) e) = fun _ => ⌜hd e⌝"
}
] | import Loom.MonadAlgebras.Defs
import Loom.MonadAlgebras.Instances.Basic
import Loom.MonadAlgebras.Instances.ExceptT
import Loom.MonadAlgebras.Instances.StateT
import Loom.MonadAlgebras.Instances.ReaderT
import Loom.MonadAlgebras.Instances.Gen
variable {m : Type u -> Type v} [Monad m] [LawfulMonad m] {α : Type u} {l : Type u}
section
variable [CompleteLattice l]
section
variable [mprop : MAlgOrdered m l]
def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post
end
variable [MAlgOrdered m l]
end
section
variable [CompleteLattice l] [MAlgOrdered m l]
noncomputable
end
section Determinism
variable [inst: CompleteLattice l] [MAlgOrdered m l]
end Determinism
section Loops
open Lean.Order
variable [inst: _root_.CompleteLattice l] [MAlgOrdered m l]
namespace PartialCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m] [MAlgPartial m]
end PartialCorrectness
namespace TotalCorrectness
variable [∀ α, CCPO (m α)] [MonoBind m]
variable [MAlgTotal m]
end TotalCorrectness
end Loops
section Lift
variable [inst: CompleteLattice l] [MAlgOrdered m l]
open ExceptionAsSuccess in
open ExceptionAsFailure in
open TotalCorrectness in
end Lift
section ExceptT
variable [inst: CompleteLattice l] [MAlgOrdered m l] [IsHandler (ε := ε) hd] | lemma MAlgLift.wp_throw
[Monad n] [CompleteLattice k] [MAlgOrdered n k] [MonadLiftT m n]
[MonadLiftT (ExceptT ε m) n]
[inst: MAlgLiftT (ExceptT ε m) l n k] :
wp (liftM (n := n) (throw (m := ExceptT ε m) e)) post = ⌜hd e⌝ := | := by
rw [MAlgLift.wp_lift, ExceptT.wp_throw]
simp only [LE.pure]; split <;> simp [inst.cl.lift_top, inst.cl.lift_bot] | 6 | 45 | false | Framework |
391 | p_findNat_some | lemma p_findNat_some (p : Nat -> Prop) [DecidablePred p] (i : Nat) :
p i -> ∃ j, p j ∧ j <= i ∧ findNat p = some j | loom | Loom/MonadAlgebras/NonDetT/Findable.lean | [
"import Mathlib.Order.Lattice",
"import Mathlib.Data.FinEnum",
"import Mathlib.Order.Basic",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Mathlib.Data.W.Basic"
] | [
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Nat.decreasingInduction",
"module": "Mathlib.Data.Nat.Init"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Option.isSome_iff_exists",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Option.not_isSome_iff_eq_none",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Option.isNone_iff_eq_none",
"module": "Init.Data.Option.Instances"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "AccFrom",
"content": "inductive AccFrom (p : Nat -> Prop) : Nat -> Prop\n | now : p i -> AccFrom p i\n | later : ¬ p i -> AccFrom p (i + 1) -> AccFrom p i"
},
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
}
] | [
{
"name": "AccFrom_findNat",
"content": "lemma AccFrom_findNat (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n AccFrom p i -> (findNat.aux p i).isSome"
},
{
"name": "AccFrom_of_p",
"content": "lemma AccFrom_of_p (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n p i -> ∀ j ≤ i, AccFrom p j"
},
{
"name": "exists_findNat",
"content": "lemma exists_findNat (p : Nat -> Prop) [DecidablePred p] :\n (∃ x, p x) ↔ (findNat p).isSome"
},
{
"name": "findNat_none",
"content": "lemma findNat_none (p : Nat -> Prop) [DecidablePred p] :\n (findNat p).isNone -> ∀ i, ¬ p i"
},
{
"name": "findNat_aux_some_le",
"content": "lemma findNat_aux_some_le (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n findNat.aux p i = some j -> ∀ k, i <= k -> k < j -> ¬ p k"
},
{
"name": "findNat_some_p",
"content": "lemma findNat_some_p (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n findNat p = some i -> p i"
}
] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Mathlib.Data.W.Basic
import Mathlib.Data.FinEnum
inductive AccFrom (p : Nat -> Prop) : Nat -> Prop
| now : p i -> AccFrom p i
| later : ¬ p i -> AccFrom p (i + 1) -> AccFrom p i
def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=
let rec aux i :=
if p i then
some i
else
aux (i + 1)
partial_fixpoint
aux 0 | lemma p_findNat_some (p : Nat -> Prop) [DecidablePred p] (i : Nat) :
p i -> ∃ j, p j ∧ j <= i ∧ findNat p = some j := | := by
intro pi;
have : (findNat p).isSome := by
false_or_by_contra; rename_i h
simp at h
rw [←Option.isNone_iff_eq_none] at h
have h := findNat_none _ h
aesop
revert this; simp [Option.isSome_iff_exists]
intro x h
have := findNat_aux_some_le p 0 h
exists x; repeat' constructor
{ solve_by_elim [findNat_some_p] }
{ have h := fun h₁ h₂ => this _ h₁ h₂ pi
simp at h; exact h }
solve_by_elim | 4 | 15 | false | Framework |
392 | p_findNat_some | lemma p_findNat_some (p : Nat -> Prop) [DecidablePred p] (i : Nat) :
p i -> ∃ j, p j ∧ j <= i ∧ findNat p = some j | loom | Loom/MonadAlgebras/NonDetT'/Extract.lean | [
"import Loom.MonadAlgebras.WP.Gen",
"import Loom.MonadAlgebras.WP.Liberal",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Mathlib.Data.W.Basic",
"import Loom.MonadAlgebras.NonDetT'.Basic",
"import Mathlib.Order.Lattice",
"import Mathlib.Data.FinEnum",
"import Mathlib.Order.Basic"
] | [
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat.decreasingInduction",
"module": "Mathlib.Data.Nat.Init"
}
] | [
{
"name": "...",
"content": "..."
}
] | [
{
"name": "Option.isSome_iff_exists",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "forall_exists_index",
"module": "Init.PropLemmas"
},
{
"name": "Option.not_isSome_iff_eq_none",
"module": "Init.Data.Option.Lemmas"
},
{
"name": "Bool.not_eq_true",
"module": "Init.SimpLemmas"
},
{
"name": "Option.isSome_eq_false_iff",
"module": "Init.Data.Option.Lemmas"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "AccFrom",
"content": "inductive AccFrom (p : Nat -> Prop) : Nat -> Prop\n | now : p i -> AccFrom p i\n | later : ¬ p i -> AccFrom p (i + 1) -> AccFrom p i"
},
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
}
] | [
{
"name": "AccFrom_findNat",
"content": "lemma AccFrom_findNat (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n AccFrom p i -> (findNat.aux p i).isSome"
},
{
"name": "AccFrom_of_p",
"content": "lemma AccFrom_of_p (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n p i -> ∀ j ≤ i, AccFrom p j"
},
{
"name": "exists_findNat",
"content": "lemma exists_findNat (p : Nat -> Prop) [DecidablePred p] :\n (∃ x, p x) ↔ (findNat p).isSome"
},
{
"name": "findNat_none",
"content": "lemma findNat_none (p : Nat -> Prop) [DecidablePred p] :\n (findNat p).isNone -> ∀ i, ¬ p i"
},
{
"name": "findNat_aux_some_le",
"content": "lemma findNat_aux_some_le (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n findNat.aux p i = some j -> ∀ k, i <= k -> k < j -> ¬ p k"
},
{
"name": "findNat_some_p",
"content": "lemma findNat_some_p (p : Nat -> Prop) [DecidablePred p] (i : Nat) :\n findNat p = some i -> p i"
}
] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Mathlib.Data.W.Basic
import Mathlib.Data.FinEnum
import Loom.MonadAlgebras.WP.Gen
import Loom.MonadAlgebras.WP.Liberal
import Loom.MonadAlgebras.NonDetT'.Basic
open Lean.Order
inductive AccFrom (p : Nat -> Prop) : Nat -> Prop
| now : p i -> AccFrom p i
| later : ¬ p i -> AccFrom p (i + 1) -> AccFrom p i
def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=
let rec aux i :=
if p i then
some i
else
aux (i + 1)
partial_fixpoint
aux 0 | lemma p_findNat_some (p : Nat -> Prop) [DecidablePred p] (i : Nat) :
p i -> ∃ j, p j ∧ j <= i ∧ findNat p = some j := | := by
intro pi;
have : (findNat p).isSome := by
false_or_by_contra; rename_i h
simp only [Bool.not_eq_true, Option.isSome_eq_false_iff] at h
have h := findNat_none _ h
aesop
revert this; simp [Option.isSome_iff_exists]
intro x h
have := findNat_aux_some_le p 0 h
exists x; repeat' constructor
{ solve_by_elim [findNat_some_p] }
{ have h := fun h₁ h₂ => this _ h₁ h₂ pi
simp at h; exact h }
solve_by_elim | 4 | 18 | true | Framework |
393 | PartialCorrectness.DemonicChoice.NonDetT.wp_pickCont | @[simp]
lemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) [Findable p] post :
_root_.wp (NonDetT.pickCont τ p f) post = ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post | loom | Loom/MonadAlgebras/NonDetT/Basic.lean | [
"import Loom.MonadAlgebras.WP.Gen",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.NonDetT.Findable",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Order.Lattice",
"import Mathlib.Order.Basic"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "ForInStep",
"module": "Init.Core"
},
{
"name": "ForInStep.yield",
"module": "Init.Core"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Encodable",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Encodable.decode",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Membership",
"module": "Init.Prelude"
},
{
"name": "Membership.mem",
"module": "Init.Prelude"
},
{
"name": "Set.Mem",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadEnv",
"module": "Lean.Environment"
},
{
"name": "Lean.SimpleScopedEnvExtension",
"module": "Lean.ScopedEnvExtension"
},
{
"name": "Lean.SimplePersistentEnvExtension",
"module": "Lean.EnvExtension"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "WPGen.assert",
"content": "def WPGen.assert {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteBooleanAlgebra l] [MAlgOrdered m l] (h : l) : WPGen (assertGadget (m := m) h) where\n get := fun post => h ⊓ (h ⇨ post .unit)\n prop := by admit /- proof elided -/"
},
{
"name": "WPGen.if",
"content": "def WPGen.if {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteBooleanAlgebra l] [MAlgOrdered m l]\n {hd : Decidable h} {x y : m α}\n (wpgx : h → WPGen x) (wpgy : ¬h → WPGen y)\n : WPGen (if h then x else y) where\n get := fun post =>\n (⨅ hc : WithName h (Lean.Name.anonymous.mkStr \"if_pos\"), (wpgx hc).get post) ⊓\n (⨅ hc : WithName (¬h) (Lean.Name.anonymous.mkStr \"if_neg\"), (wpgy hc).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "WPGen.let",
"content": "def WPGen.let {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteBooleanAlgebra l] [MAlgOrdered m l]\n (y : β) {x : β -> m α} (wpgx : ∀ y, WPGen (x y)) : WPGen (let z := y; x z) where\n get := fun post => ⨅ z, ⌜z = y⌝ ⇨ (wpgx z).get post\n prop := by admit /- proof elided -/\nmacro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "LE.pure",
"content": "noncomputable def LE.pure {l : Type u} [inst: LE l] [OrderTop l] [OrderBot l] : Prop -> l := fun p =>\n if p then ⊤ else ⊥"
},
{
"name": "spec",
"content": "def spec (pre : l) (post : α -> l) : Cont l α :=\n fun p => pre ⊓ ⌜post ≤ p⌝"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "Findable",
"content": "class Findable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_none : (find ()).isNone -> ∀ x, ¬ p x\n find_some_p : find () = some x -> p x"
},
{
"name": "find",
"content": "def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=\n findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode"
},
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "wp",
"content": "def wp (c : m α) (post : α -> l) : l := liftM (n := Cont l) c post"
},
{
"name": "triple",
"content": "def triple (pre : l) (c : m α) (post : α -> l) : Prop :=\n pre ≤ wp c post"
},
{
"name": "spec",
"content": "def spec (pre : l) (post : α -> l) : Cont l α :=\n fun p => pre ⊓ ⌜post ≤ p⌝"
},
{
"name": "Loop.forIn.loop",
"content": "@[specialize, inline]\ndef Loop.forIn.loop {m : Type u -> Type v} [Monad m] [∀ α, CCPO (m α)] [MonoBind m] (f : Unit → β → m (ForInStep β)) (b : β) : m β := do\n match ← f () b with\n | ForInStep.done b => pure b\n | ForInStep.yield b => loop f b\n partial_fixpoint"
},
{
"name": "WPGen.bind",
"content": "def WPGen.bind {x : m α} {f : α -> m β} (wpg : WPGen x) (wpgf : ∀ a, WPGen (f a)) :\n WPGen (x >>= f) where\n get := fun post => wpg.get (fun a => (wpgf a).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "_root_.Lean.SimpleScopedEnvExtension.get",
"content": "private def _root_.Lean.SimpleScopedEnvExtension.get [Inhabited σ] (ext : SimpleScopedEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "_root_.Lean.SimplePersistentEnvExtension.get",
"content": "private def _root_.Lean.SimplePersistentEnvExtension.get [Inhabited σ] (ext : SimplePersistentEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "WPGen",
"content": "structure WPGen (x : m α) where\n get : Cont l α\n \n prop : ∀ post, get post <= wp x post"
},
{
"name": "_root_.Lean.EnvExtension.get",
"content": "private def _root_.Lean.EnvExtension.get [Inhabited σ] (ext : EnvExtension σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "CCPOBotLawful",
"content": "class CCPOBotLawful (m : Type u -> Type v) [∀ α, Lean.Order.CCPO (m α)] [CCPOBot m] where\n prop {α} : CCPOBot.compBot (m := m) (α := α) = Lean.Order.bot"
}
] | [
{
"name": "iSup_le_iff",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "le_himp_iff",
"module": "Mathlib.Order.Heyting.Basic"
},
{
"name": "map_eq_pure_bind",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "emp_sum",
"content": "@[aesop safe]\nlemma emp_sum (x: Bal) (h: 0 ≤ x) : ∃ h: List Nat, h.sum ≤ x"
},
{
"name": "WPGen.intro",
"content": "omit [LawfulMonad m] in\nlemma WPGen.intro (x : m α) (wpg : WPGen x) :\n pre <= wpg.get post ->\n -- pre <= wpg.sideCond ->\n triple pre x post"
},
{
"name": "triple_forIn_deacreasing",
"content": "theorem triple_forIn_deacreasing {β} {measure : β -> ℕ}\n {init : β} {f : β → m (ForInStep β)}\n (inv : β → l)\n (hstep : ∀ b,\n measure b <= measure init ->\n triple\n (inv b)\n (f b)\n (fun | .yield b' => inv b' ⊓ ⌜measure b' < measure b⌝ | .done b' => ⌜ measure b' = 0 ⌝ ⊓ inv b')) :\n triple (inv init) (forIn [0:measure init] init (fun _ => f)) (fun b => inv b ⊓ ⌜measure b = 0⌝)"
},
{
"name": "trueE",
"content": "@[simp]\nlemma trueE (l : Type v) [inst: LE l] [OrderTop l] [OrderBot l] : ⌜True⌝ = (⊤ : l)"
},
{
"name": "falseE",
"content": "@[simp]\nlemma falseE (l : Type v) [inst: LE l] [OrderTop l] [OrderBot l] : ⌜False⌝ = (⊥ : l)"
},
{
"name": "LE.pure_imp",
"content": "lemma LE.pure_imp {l : Type u} [inst: LE l] [OrderTop l] [OrderBot l]\n (p₁ p₂ : Prop) : (p₁ -> p₂) -> ⌜p₁⌝ <= (⌜p₂⌝ : l)"
},
{
"name": "LE.pure_intro",
"content": "@[simp]\nlemma LE.pure_intro {l : Type u} [inst: LE l] [OrderTop l] [OrderBot l]\n (p : Prop) (h : l) : (⌜p⌝ <= h) = (p -> ⊤ <= h)"
},
{
"name": "pure_intro_l",
"content": "@[simp]\nlemma pure_intro_l {l : Type u} [CompleteLattice l] (x y : l) :\n (x ⊓ ⌜ p ⌝ <= y) = (p -> x <= y)"
},
{
"name": "pure_intro_r",
"content": "@[simp]\nlemma pure_intro_r {l : Type u} [CompleteLattice l] (x y : l) :\n (⌜ p ⌝ ⊓ x <= y) = (p -> x <= y)"
},
{
"name": "MAlgOrdered.bind",
"content": "lemma MAlgOrdered.bind {α : Type u} {m} {l : Type u} [Monad m] [CompleteLattice l] [MAlgOrdered m l] :\n ∀ (x : m α) (f g : α -> m l), μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "Cont.monotone_lift",
"content": "lemma Cont.monotone_lift {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteLattice l] [MAlgOrdered m l] :\n ∀ {α : Type u} (x : m α), MAlg.lift x |>.monotone"
},
{
"name": "MAlg.μ_eq",
"content": "@[simp]\nlemma MAlg.μ_eq {m l} [Monad m] [CompleteLattice l] [MAlgOrdered m l] : MAlg.μ (m := m) = MAlgOrdered.μ (m := m)"
},
{
"name": "MAlg.monadLift_bind",
"content": "lemma MAlg.monadLift_bind {α β} {l : Type u} {m : Type u -> Type v} [Monad m] [LawfulMonad m] [CompleteLattice l] [MAlgOrdered m l]\n (x : m α) (f g : α -> Cont l β) :\n f <= g ->\n (lift x >>= f) ≤ (lift x >>= g)"
},
{
"name": "lift_cont_eq",
"content": "@[simp]\nlemma lift_cont_eq {l σ : Type u} [CompleteLattice l] [CompleteLattice σ] (c : Cont l α) :\n liftM (m := Cont l) (n := Cont (σ -> l)) c = fun post s => c (post · s)"
},
{
"name": "leE",
"content": "@[loomLogicSimp]\nlemma leE (l : Type u) [PartialOrder l] (a b : α -> l) : a ≤ b ↔ ∀ x, a x ≤ b x"
},
{
"name": "lePropE",
"content": "@[loomLogicSimp]\nlemma lePropE (a b : Prop) : (a ≤ b) = (a → b)"
},
{
"name": "pureE",
"content": "@[loomLogicSimp]\nlemma pureE (l : Type u) [CompleteLattice l] (a : Prop) : (⌜a⌝ : α -> l) = fun _ => ⌜a⌝"
},
{
"name": "purePropE",
"content": "@[loomLogicSimp]\nlemma purePropE : (⌜a⌝ : Prop) = a"
},
{
"name": "infPropE",
"content": "@[loomLogicSimp]\nlemma infPropE (a b : Prop) : (a ⊓ b) = (a ∧ b)"
},
{
"name": "infE",
"content": "@[loomLogicSimp]\nlemma infE (l : Type u) [CompleteLattice l] (a b : α -> l) : (a ⊓ b) = fun x => a x ⊓ b x"
},
{
"name": "supE",
"content": "@[loomLogicSimp]\nlemma supE (l : Type u) [CompleteLattice l] (a b : α -> l) : (a ⊔ b) = fun x => a x ⊔ b x"
},
{
"name": "supPropE",
"content": "@[loomLogicSimp]\nlemma supPropE (a b : Prop) : (a ⊔ b) = (a ∨ b)"
},
{
"name": "iInfE",
"content": "@[loomLogicSimp]\nlemma iInfE (l : Type u) [CompleteLattice l] (a : ι -> α -> Prop) : (⨅ i, a i) = fun x => ⨅ i, a i x"
},
{
"name": "iSupE",
"content": "@[loomLogicSimp]\nlemma iSupE (l : Type u) [CompleteLattice l] (a : ι -> α -> Prop) : (⨆ i, a i) = fun x => ⨆ i, a i x"
},
{
"name": "himpE",
"content": "@[loomLogicSimp]\nlemma himpE (l : Type u) [CompleteBooleanAlgebra l] (a b : α -> l) :\n (a ⇨ b) = fun x => a x ⇨ b x"
},
{
"name": "himpPureE",
"content": "@[loomLogicSimp]\nlemma himpPureE (a b : Prop) :\n (a ⇨ b) = (a -> b)"
},
{
"name": "topE",
"content": "@[loomLogicSimp]\nlemma topE (l : Type u) [CompleteLattice l] : (⊤ : α -> l) = fun _ => ⊤"
},
{
"name": "topPureE",
"content": "@[loomLogicSimp]\nlemma topPureE : (⊤ : Prop) = True"
},
{
"name": "List.sum_lt",
"content": "@[aesop safe]\ntheorem List.sum_lt (x: Bal) : x < y -> x < ([Int.toNat y]).sum"
},
{
"name": "balance_lt",
"content": "@[aesop safe]\ntheorem balance_lt (x: Bal) : x < x + 1"
},
{
"name": "Except.bind'_bind",
"content": "lemma Except.bind'_bind {m : Type u -> Type v} {ε α β} [Monad m] [LawfulMonad m] (i : m (Except ε α)) (f : α -> ExceptT ε m β) :\n (i >>= fun a => Except.bind' a f) = bind (m := ExceptT ε m) i f"
},
{
"name": "MAlg.lift_ExceptT",
"content": "lemma MAlg.lift_ExceptT ε (hd : ε -> Prop) [IsHandler hd] [CompleteLattice l] [inst: MAlgOrdered m l]\n (c : ExceptT ε m α) post :\n MAlg.lift c post = MAlg.lift (m := m) c (fun | .ok x => post x | .error e => ⌜hd e⌝)"
},
{
"name": "lift_map",
"content": "lemma lift_map {α : Type u} {β : Type u} (f : α -> β) (x : m α)\n [Monad m] [Monad n] [LawfulMonad m] [LawfulMonad n] [MonadLiftT m n] [LawfulMonadLiftT m n] :\n liftM (f <$> x) = f <$> liftM (n := n) x"
},
{
"name": "tail_length",
"content": "@[aesop unsafe]\ntheorem tail_length : ∀ q : List Nat, q.nonEmpty → q.tail.length < q.length"
},
{
"name": "tail_sum",
"content": "@[aesop norm]\ntheorem tail_sum (q: List Nat) (hnemp: q.nonEmpty): q.sum = q.tail.sum + q.head!"
},
{
"name": "non_zero_length",
"content": "@[aesop unsafe]\ntheorem non_zero_length (q: List Nat) (hnemp: q.nonEmpty): 0 < q.length"
},
{
"name": "sum_zero",
"content": "@[aesop norm]\ntheorem sum_zero : ∀ q : List Nat, ¬q.nonEmpty → q.sum = 0"
},
{
"name": "meet_himp",
"content": "lemma meet_himp (x x' y z : l) :\n x = x' ->\n (x ⇨ y) ⊓ (x' ⇨ z) = x ⇨ (y ⊓ z)"
},
{
"name": "NonDetT.wp_mono",
"content": "lemma NonDetT.wp_mono {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α : Type u} (x : NonDetT m α) (f g : α -> l) :\n (∀ a, f a <= g a) ->\n NonDetT.wp x f <= NonDetT.wp x g"
},
{
"name": "W_ext",
"content": "@[ext]\nlemma W_ext (t : Type v) (α : Type u) [Preorder t] (w w' : W t α) :\n w.wp = w'.wp → w = w'"
}
] | [
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "NonDetT.bind",
"content": "def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=\n match x with\n | pure ret => f ret\n | vis x f' => vis x fun y => bind (f' y) f\n | pickCont τ p f' => pickCont τ p fun t => bind (f' t) f\n | repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f"
},
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f =>\n fun post =>\n let p : Set τ := p;\n ⨅ a ∈ (p : Set τ), wp (f a) post\n | _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
}
] | [
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α β : Type u} (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
}
] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Loom.MonadAlgebras.WP.Basic
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.Gen
import Loom.MonadAlgebras.NonDetT.Findable
section NonDeterministicTransformer
inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where
| pure {α} (ret : α) : NonDetT m α
| vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α
| pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α
| repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α
variable {m : Type u -> Type v} {α β : Type u} [Monad m]
def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=
match x with
| pure ret => f ret
| vis x f' => vis x fun y => bind (f' y) f
| pickCont τ p f' => pickCont τ p fun t => bind (f' t) f
| repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f
variable [CompleteBooleanAlgebra l] [MAlgOrdered m l]
namespace PartialCorrectness
namespace DemonicChoice
/- WP for NonDetT -/
noncomputable
def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α
| _, .pure ret => pure ret
| _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post
| _, @NonDetT.pickCont _ _ τ p _ f =>
fun post =>
let p : Set τ := p;
⨅ a ∈ (p : Set τ), wp (f a) post
| _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l),
⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓
spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)
def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id
variable [LawfulMonad m]
/- Ordered Monad Algebra instance for NonDetT -/
noncomputable
scoped | @[simp]
lemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) [Findable p] post :
_root_.wp (NonDetT.pickCont τ p f) post = ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post := | := by
simp [NonDetT.wp_eq_wp, NonDetT.wp]; congr; ext x
simp [Membership.mem, Set.Mem]
by_cases h: p x <;> simp [h] | 5 | 48 | false | Framework |
394 | TotalCorrectness.DemonicChoice.NonDetT.wp_pickCont | @[simp]
lemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) [Findable p] post :
_root_.wp (NonDetT.pickCont τ p f) post = ⌜∃ h, p h⌝ ⊓ ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post | loom | Loom/MonadAlgebras/NonDetT/Basic.lean | [
"import Loom.MonadAlgebras.WP.Gen",
"import Mathlib.Order.CompleteBooleanAlgebra",
"import Mathlib.Logic.Function.Basic",
"import Loom.MonadAlgebras.WP.Basic",
"import Loom.MonadAlgebras.NonDetT.Findable",
"import Loom.MonadAlgebras.Defs",
"import Loom.MonadAlgebras.WP.Tactic",
"import Mathlib.Order.Lattice",
"import Mathlib.Order.Basic"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "CompleteLattice",
"module": "Mathlib.Order.CompleteLattice.Defs"
},
{
"name": "Monad",
"module": "Init.Prelude"
},
{
"name": "outParam",
"module": "Init.Prelude"
},
{
"name": "f",
"module": "Test.SmtTranslation.Trigger"
},
{
"name": "ForInStep",
"module": "Init.Core"
},
{
"name": "ForInStep.yield",
"module": "Init.Core"
},
{
"name": "Set",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "measure",
"module": "Init.WF"
},
{
"name": "DecidablePred",
"module": "Init.Prelude"
},
{
"name": "Option",
"module": "Init.Prelude"
},
{
"name": "Encodable",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Encodable.decode",
"module": "Mathlib.Logic.Encodable.Basic"
},
{
"name": "Unit",
"module": "Init.Prelude"
},
{
"name": "Membership",
"module": "Init.Prelude"
},
{
"name": "Membership.mem",
"module": "Init.Prelude"
},
{
"name": "Set.Mem",
"module": "Mathlib.Data.Set.Defs"
},
{
"name": "id",
"module": "Init.Prelude"
},
{
"name": "liftM",
"module": "Init.Prelude"
},
{
"name": "Inhabited",
"module": "Init.Prelude"
},
{
"name": "Lean.MonadEnv",
"module": "Lean.Environment"
},
{
"name": "Lean.SimpleScopedEnvExtension",
"module": "Lean.ScopedEnvExtension"
},
{
"name": "Lean.SimplePersistentEnvExtension",
"module": "Lean.EnvExtension"
},
{
"name": "LawfulMonad",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)",
"content": "macro \"⌜\" p:term \"⌝\" : term => `(LE.pure $p)"
},
{
"name": "spec",
"content": "def spec (pre : l) (post : α -> l) : Cont l α :=\n fun p => pre ⊓ ⌜post ≤ p⌝"
},
{
"name": "MAlgOrdered",
"content": "class MAlgOrdered (l : outParam (Type v)) [Monad m] [CompleteLattice l] where\n μ : m l -> l\n μ_ord_pure : ∀ l, μ (pure l) = l\n μ_ord_bind {α : Type v} :\n ∀ (f g : α -> m l), μ ∘ f ≤ μ ∘ g ->\n ∀ x : m α, μ (x >>= f) ≤ μ (x >>= g)"
},
{
"name": "Findable",
"content": "class Findable {α : Type u} (p : α -> Prop) where\n find : Unit -> Option α\n find_none : (find ()).isNone -> ∀ x, ¬ p x\n find_some_p : find () = some x -> p x"
},
{
"name": "find",
"content": "def find [Encodable α] (p : α -> Prop) [DecidablePred p] : Option α :=\n findNat (fun x => (Encodable.decode x).any (p ·)) |>.bind Encodable.decode"
},
{
"name": "findNat",
"content": "def findNat (p : Nat -> Prop) [DecidablePred p] : Option Nat :=\n let rec aux i :=\n if p i then\n some i\n else\n aux (i + 1)\n partial_fixpoint\n aux 0"
},
{
"name": "MAlg.lift",
"content": "abbrev MAlg.lift {m : Type u -> Type v} {l : Type u} [Monad m] [MAlg m l] :\n {α : Type u} -> m α -> Cont l α := fun x f => μ $ f <$> x"
},
{
"name": "MAlg",
"content": "class MAlg [Monad m] (l : outParam (Type v)) where\n μ : m l -> l\n pure : ∀ l, μ (pure l) = l\n bind : ∀ {α : Type v} (x : m α) (f g : α -> m l),\n μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
},
{
"name": "WPGen.bind",
"content": "def WPGen.bind {x : m α} {f : α -> m β} (wpg : WPGen x) (wpgf : ∀ a, WPGen (f a)) :\n WPGen (x >>= f) where\n get := fun post => wpg.get (fun a => (wpgf a).get post)\n prop := by admit /- proof elided -/"
},
{
"name": "_root_.Lean.SimpleScopedEnvExtension.get",
"content": "private def _root_.Lean.SimpleScopedEnvExtension.get [Inhabited σ] (ext : SimpleScopedEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "Context",
"content": "structure Context where\n ref : Syntax\n \n m : Syntax\n \n returnType : Syntax\n mutableVars : VarSet := {}\n insideFor : Bool := false"
},
{
"name": "_root_.Lean.SimplePersistentEnvExtension.get",
"content": "private def _root_.Lean.SimplePersistentEnvExtension.get [Inhabited σ] (ext : SimplePersistentEnvExtension α σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "WPGen",
"content": "structure WPGen (x : m α) where\n get : Cont l α\n \n prop : ∀ post, get post <= wp x post"
},
{
"name": "_root_.Lean.EnvExtension.get",
"content": "private def _root_.Lean.EnvExtension.get [Inhabited σ] (ext : EnvExtension σ)\n [Monad m] [MonadEnv m] : m σ := do\n return ext.getState (<- getEnv)"
},
{
"name": "CCPOBotLawful",
"content": "class CCPOBotLawful (m : Type u -> Type v) [∀ α, Lean.Order.CCPO (m α)] [CCPOBot m] where\n prop {α} : CCPOBot.compBot (m := m) (α := α) = Lean.Order.bot"
}
] | [
{
"name": "iSup_le_iff",
"module": "Mathlib.Order.CompleteLattice.Basic"
},
{
"name": "le_himp_iff",
"module": "Mathlib.Order.Heyting.Basic"
},
{
"name": "map_eq_pure_bind",
"module": "Init.Control.Lawful.Basic"
}
] | [
{
"name": "MAlgOrdered.bind",
"content": "lemma MAlgOrdered.bind {α : Type u} {m} {l : Type u} [Monad m] [CompleteLattice l] [MAlgOrdered m l] :\n ∀ (x : m α) (f g : α -> m l), μ ∘ f = μ ∘ g ->\n μ (x >>= f) = μ (x >>= g)"
}
] | [
{
"name": "NonDetT",
"content": "inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where\n | pure {α} (ret : α) : NonDetT m α\n | vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α\n | pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α\n | repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α"
},
{
"name": "NonDetT.bind",
"content": "def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=\n match x with\n | pure ret => f ret\n | vis x f' => vis x fun y => bind (f' y) f\n | pickCont τ p f' => pickCont τ p fun t => bind (f' t) f\n | repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f"
},
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f =>\n fun post =>\n let p : Set τ := p;\n ⨅ a ∈ (p : Set τ), wp (f a) post\n | _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
},
{
"name": "PartialCorrectness.AngelicChoice.NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f => fun post => ⨆ a, ⌜p a⌝ ⊓ wp (f a) post\n | _, .repeatCont init f cont => fun post => ⨆ (inv : ForInStep _ -> l),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "PartialCorrectness.AngelicChoice.NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
},
{
"name": "TotalCorrectness.DemonicChoice.NonDetT.wp",
"content": "def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α\n | _, .pure ret => pure ret\n | _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post\n | _, @NonDetT.pickCont _ _ τ p _ f => fun post => let p : Set τ := p; ⌜∃ h, p h⌝ ⊓ ⨅ a ∈ (p : Set τ), wp (f a) post\n | _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l) (measure : β -> Nat),\n ⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) (fun | .yield b' => inv (.yield b') ⊓ ⌜ measure b' < measure b ⌝ | .done b' => inv (.done b'))⌝ ⊓\n spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)"
},
{
"name": "TotalCorrectness.DemonicChoice.NonDetT.μ",
"content": "def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id"
}
] | [
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind {l : Type u} [CompleteLattice l] [MAlgOrdered m l] [LawfulMonad m] {α β : Type u} (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "PartialCorrectness.DemonicChoice.NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
},
{
"name": "PartialCorrectness.AngelicChoice.NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind [LawfulMonad m] {α β : Type u} {l : Type u} [CompleteLattice l] [MAlgOrdered m l] (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "PartialCorrectness.AngelicChoice.NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
},
{
"name": "TotalCorrectness.DemonicChoice.NonDetT.wp_bind",
"content": "lemma NonDetT.wp_bind [LawfulMonad m] {α β : Type u} {l : Type u} [CompleteLattice l] [MAlgOrdered m l] (x : NonDetT m α) (f : α -> NonDetT m β)\n (post : β -> l):\n NonDetT.wp (x.bind f) post = NonDetT.wp x (fun x => NonDetT.wp (f x) post)"
},
{
"name": "TotalCorrectness.DemonicChoice.NonDetT.wp_eq_wp",
"content": "lemma NonDetT.wp_eq_wp {α : Type u} (x : NonDetT m α) (post : α -> l) :\n _root_.wp x post = NonDetT.wp x post"
}
] | import Mathlib.Logic.Function.Basic
import Mathlib.Order.CompleteBooleanAlgebra
import Mathlib.Order.Lattice
import Mathlib.Order.Basic
import Loom.MonadAlgebras.WP.Basic
import Loom.MonadAlgebras.WP.Tactic
import Loom.MonadAlgebras.WP.Gen
import Loom.MonadAlgebras.NonDetT.Findable
section NonDeterministicTransformer
inductive NonDetT (m : Type u -> Type v) : (α : Type u) -> Type _ where
| pure {α} (ret : α) : NonDetT m α
| vis {α} {β} (x : m β) (f : β → NonDetT m α) : NonDetT m α
| pickCont {α} (τ : Type u) (p : τ -> Prop) [Findable p] (f : τ → NonDetT m α) : NonDetT m α
| repeatCont {α} {β} (init : β) (f : β -> NonDetT m (ForInStep β)) (cont : β -> NonDetT m α) : NonDetT m α
variable {m : Type u -> Type v} {α β : Type u} [Monad m]
def NonDetT.bind (x : NonDetT m α) (f : α → NonDetT m β) : NonDetT m β :=
match x with
| pure ret => f ret
| vis x f' => vis x fun y => bind (f' y) f
| pickCont τ p f' => pickCont τ p fun t => bind (f' t) f
| repeatCont init f' cont => repeatCont init f' fun t => bind (cont t) f
variable [CompleteBooleanAlgebra l] [MAlgOrdered m l]
namespace PartialCorrectness
namespace DemonicChoice
/- WP for NonDetT -/
noncomputable
def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α
| _, .pure ret => pure ret
| _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post
| _, @NonDetT.pickCont _ _ τ p _ f =>
fun post =>
let p : Set τ := p;
⨅ a ∈ (p : Set τ), wp (f a) post
| _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l),
⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓
spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)
def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id
variable [LawfulMonad m]
/- Ordered Monad Algebra instance for NonDetT -/
noncomputable
scoped
end DemonicChoice
namespace AngelicChoice
/- WP for NonDetT -/
noncomputable
def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α
| _, .pure ret => pure ret
| _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post
| _, @NonDetT.pickCont _ _ τ p _ f => fun post => ⨆ a, ⌜p a⌝ ⊓ wp (f a) post
| _, .repeatCont init f cont => fun post => ⨆ (inv : ForInStep _ -> l),
⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) inv⌝ ⊓
spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)
def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id
variable [LawfulMonad m]
/- Ordered Monad Algebra instance for NonDetT -/
noncomputable
scoped
end AngelicChoice
end PartialCorrectness
namespace TotalCorrectness
namespace DemonicChoice
/- WP for NonDetT -/
noncomputable
def NonDetT.wp {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : {α : Type u} -> NonDetT m α -> Cont l α
| _, .pure ret => pure ret
| _, .vis x f => fun post => _root_.wp x fun a => wp (f a) post
| _, @NonDetT.pickCont _ _ τ p _ f => fun post => let p : Set τ := p; ⌜∃ h, p h⌝ ⊓ ⨅ a ∈ (p : Set τ), wp (f a) post
| _, @NonDetT.repeatCont _ _ β init f cont => fun post => ⨆ (inv : ForInStep β -> l) (measure : β -> Nat),
⌜ ∀ b, (inv (ForInStep.yield b)) <= wp (f b) (fun | .yield b' => inv (.yield b') ⊓ ⌜ measure b' < measure b ⌝ | .done b' => inv (.done b'))⌝ ⊓
spec (inv (.yield init)) (fun b => inv (.done b)) (fun b => wp (cont b) post)
def NonDetT.μ {l : Type u} [CompleteLattice l] [MAlgOrdered m l] : NonDetT m l -> l := fun x => NonDetT.wp x id
variable [LawfulMonad m]
/- Ordered Monad Algebra instance for NonDetT -/
noncomputable
scoped | @[simp]
lemma NonDetT.wp_pickCont {τ : Type u} p (f : τ → NonDetT m α) [Findable p] post :
_root_.wp (NonDetT.pickCont τ p f) post = ⌜∃ h, p h⌝ ⊓ ⨅ a, ⌜p a⌝ ⇨ _root_.wp (f a) post := | := by
simp [NonDetT.wp_eq_wp, NonDetT.wp]; congr; ext x
simp [Membership.mem, Set.Mem]
by_cases h: p x <;> simp [h] | 5 | 50 | false | Framework |
395 | Tm.sub_den_eq | theorem Tm.sub_den_eq (e : Γ ⊢ τ) : ∀ {Δ}, (σ : Sb Γ Δ) → ⟦e.sub σ⟧ = (⟦e⟧) ∘' (⟦σ⟧) | pcf-lean | PCF/Denotation.lean | [
"import PCF.Utility",
"import «PCF».Flat",
"import PCF.Domain",
"import «PCF».Context"
] | [
{
"name": "Cont",
"module": "Mathlib.Control.Monad.Cont"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "And",
"module": "Init.Prelude"
},
{
"name": "Prod",
"module": "Init.Prelude"
},
{
"name": "Prod.fst",
"module": "Init.Prelude"
},
{
"name": "Prod.snd",
"module": "Init.Prelude"
},
{
"name": "Trans.trans",
"module": "Init.Prelude"
},
{
"name": "Bool",
"module": "Init.Prelude"
},
{
"name": "Nat.succ",
"module": "Init.Prelude"
},
{
"name": "Nat.zero",
"module": "Init.Prelude"
},
{
"name": "Con",
"module": "Mathlib.GroupTheory.Congruence.Defs"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "Eq",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:max \"⟦\" τ \" ty⟧\" => Ty.den τ",
"content": "notation:max \"⟦\" τ \" ty⟧\" => Ty.den τ"
},
{
"name": "notation:max \"⟦\" Γ \" cx⟧\" => Ev Γ",
"content": "notation:max \"⟦\" Γ \" cx⟧\" => Ev Γ"
},
{
"name": "notation:100 \"⟦\" t \"⟧\" => Tm.den t",
"content": "notation:100 \"⟦\" t \"⟧\" => Tm.den t"
},
{
"name": "notation:100 \"⟦\" r \"⟧\" => Ren.den r",
"content": "notation:100 \"⟦\" r \"⟧\" => Ren.den r"
},
{
"name": "notation:100 \"⟦\" σ \"⟧\" => Sb.den σ",
"content": "notation:100 \"⟦\" σ \"⟧\" => Sb.den σ"
},
{
"name": "notation:100 \"⟦\" C \" con⟧\" => Con.den C",
"content": "notation:100 \"⟦\" C \" con⟧\" => Con.den C"
},
{
"name": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x",
"content": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x"
},
{
"name": "notation:max \"⨆\" => Domain.sup",
"content": "notation:max \"⨆\" => Domain.sup"
},
{
"name": "notation:max \"⋆\" => Order.refl",
"content": "notation:max \"⋆\" => Order.refl"
},
{
"name": "notation:max \"⊥\" => Domain.bot",
"content": "notation:max \"⊥\" => Domain.bot"
},
{
"name": "Mono",
"content": "structure Mono (α) (β) [Order α] [Order β] where\n act : α → β\n act' : is_monotone act"
},
{
"name": "Tm",
"content": "inductive Tm : Cx → Ty → Type\n | var : ∀ τ, Γ ∋ τ → Tm Γ τ\n | true : Tm Γ .bool\n | false : Tm Γ .bool\n | zero : Tm Γ .nat\n | succ : Tm Γ .nat → Tm Γ .nat\n | pred : Tm Γ .nat → Tm Γ .nat\n | zero? : Tm Γ .nat → Tm Γ .bool\n | cond : Tm Γ .bool → Tm Γ τ → Tm Γ τ → Tm Γ τ\n | fn : Tm (Γ ∷ τ) υ → Tm Γ (τ ⇒ υ)\n | app : Tm Γ (τ ⇒ υ) → Tm Γ τ → Tm Γ υ\n | fix : Tm Γ (τ ⇒ τ) → Tm Γ τ"
},
{
"name": "Cont.eval",
"content": "def Cont.eval {α : Type i} {β : Type j} [Order α] [Order β] [Domain α] [Domain β]\n : Cont (Cont α β × α) β := ⟨\n Mono.eval_cont,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Cont.fst",
"content": "def Cont.fst [Order α] [Order β] [Domain α] [Domain β] : Cont (α × β) α :=\n ⟨⟨Prod.fst, And.left⟩, Domain.sup_is_mono (fun _ ↦ ⋆)⟩"
},
{
"name": "Cont",
"content": "structure Cont (α) (β) [Order α] [Order β] [Domain α] [Domain β] where\n fn : Mono α β\n sub : ∀ {c : Chain α}, fn.act (⨆ c) ⊑ ⨆ (fn ∘ c)"
},
{
"name": "Domain",
"content": "class Domain (α) [Order α] where\n bot : α\n sup : (c : Chain α) → α\n is_bot {x} : bot ⊑ x\n is_bound (c) (n): c.act n ⊑ sup c\n is_least (c) {d} : ({n : _} → c.act n ⊑ d) → sup c ⊑ d"
},
{
"name": "Order",
"content": "class Order (α) where\n R : α → α → Prop\n refl {x} : R x x\n trans {x y z} : R x y → R y z → R x z\n anti {x y} : R x y → R y x → x = y"
},
{
"name": "Chain",
"content": "def Chain (α : Type i) [Order α] := Mono Nat α"
},
{
"name": "is_monotone",
"content": "def is_monotone [Order α] [Order β] (f : α → β) := ∀ {x y : α}, x ⊑ y → f x ⊑ f y"
},
{
"name": "Cont.snd",
"content": "def Cont.snd [Order α] [Order β] [Domain α] [Domain β] : Cont (α × β) β :=\n ⟨⟨Prod.snd, And.right⟩, Domain.sup_is_mono (fun _ ↦ ⋆)⟩"
},
{
"name": "Chain.apply",
"content": "def Chain.apply [Order α] [Order β] [Domain α] [Domain β] (c : Chain (Cont α β)) (a : α) : Chain β\n := Mono.apply c a"
},
{
"name": "Mono.apply",
"content": "def Mono.apply [Order α] [Order β] [Domain α] [Domain β] (c : Mono Nat (Cont α β)) (a : α) : Chain β where\n act := fun n ↦ (c n) a\n act' := fun a_b ↦ (c • a_b) _"
},
{
"name": "Mono.eval_cont",
"content": "def Mono.eval_cont {α : Type i} {β : Type j} [Order α] [Order β] [Domain α] [Domain β]\n : Mono (Cont α β × α) β :=\n ⟨fun x ↦ x.fst x.snd, fun {x y} p ↦ (x.fst • p.right) ⬝ (p.left y.snd)⟩"
},
{
"name": "Mono.from_cont",
"content": "def Mono.from_cont [Order α] [Order β] [Domain α] [Domain β] : Mono (Cont α β) (Mono α β) :=\n ⟨Cont.fn, fun p a ↦ p a⟩"
},
{
"name": "Mono.sup",
"content": "def Mono.sup [Order α] [Domain α] : Mono (Chain α) α :=\n ⟨⨆, Domain.sup_is_mono⟩"
},
{
"name": "Cont.comp'",
"content": "def Cont.comp' [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] (f : Cont β γ) (g : Cont α β)\n : Cont α γ\n := ⟨\n ⟨fun x ↦ f (g x), fun x_y ↦ f • g • x_y⟩,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Mono.eval",
"content": "def Mono.eval {α : Type i} {β : Type j} [Order α] [Order β] : Mono (Mono α β × α) β :=\n ⟨fun x ↦ x.fst x.snd, fun {x y} p ↦ (x.fst • p.right) ⬝ (p.left y.snd)⟩"
},
{
"name": "Chain.fst",
"content": "def Chain.fst [Order α] [Order β] (c : Chain (α × β)) : Chain α :=\n ⟨fun n ↦ (c n).fst, fun p ↦ by admit /- proof elided -/\n ⟩"
},
{
"name": "Chain.snd",
"content": "def Chain.snd [Order α] [Order β] (c : Chain (α × β)) : Chain β :=\n ⟨fun n ↦ (c n).snd, fun p ↦ by admit /- proof elided -/\n ⟩"
},
{
"name": "Mono.const",
"content": "def Mono.const [Order α] [Order β] (b : β) : Mono α β := ⟨fun _ ↦ b, fun _ ↦ ⋆⟩"
},
{
"name": "Mono.comp",
"content": "def Mono.comp {α : Type i} {β : Type j} {γ : Type k} [Order α] [Order β] [Order γ]\n : Mono (Mono β γ × Mono α β) (Mono α γ) := ⟨\n fun h ↦ ⟨fun x ↦ h.fst (h.snd x), fun x_y ↦ h.fst • (h.snd • x_y)⟩,\n fun {h₀ h₁} h a ↦ (h₀.fst • h.right a) ⬝ (h.left (h₁.snd a))\n ⟩"
},
{
"name": "Mono.pair",
"content": "def Mono.pair [Order α] [Order β] [Order γ]\n (f : Mono γ α) (g : Mono γ β) : Mono γ (α × β) :=\n ⟨fun c ↦ ⟨f c, g c⟩, fun p ↦ ⟨f • p, g • p⟩⟩"
},
{
"name": "Cont.const",
"content": "def Cont.const [Order α] [Order β] [Domain α] [Domain β] (b : β) : Cont α β := ⟨Mono.const b, fun {c} ↦ by admit /- proof elided -/\n ⟩"
},
{
"name": "Domain.sup_of_const",
"content": "def Domain.sup_of_const [Order α] [Domain α] (a : α) : ⨆ (Mono.const a) = a :=\n (by admit /- proof elided -/\n ) ⇄! (Domain.is_bound (Mono.const a) 0)"
},
{
"name": "Cont.flat",
"content": "def Cont.flat (f : α → β) : (Cont (Flat α) (Flat β)) := (Mono.flat f).promote_trivial"
},
{
"name": "Flat",
"content": "inductive Flat (α : Type) : Type where\n | none : Flat α\n | some : α → Flat α"
},
{
"name": "Mono.flat",
"content": "def Mono.flat (f : α → β) : (Mono (Flat α) (Flat β)) := ⟨\n lift_flat f,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "lift_flat",
"content": "def lift_flat (f : α → β) : Flat α → Flat β\n| .none => .none\n| .some x => .some (f x)"
},
{
"name": "Cont.cond",
"content": "def Cont.cond [Order α] [Domain α] : Cont (Flat Bool) (Cont (α × α) α) := ⟨\n cond',\n by admit /- proof elided -/\n⟩"
},
{
"name": "cond'",
"content": "def cond' [Order α] [Domain α] : Mono (Flat Bool) (Cont (α × α) α) := ⟨\n fun b ↦ (\n match b with\n | .none => Cont.const ⊥\n | .some true => Cont.fst\n | .some false => Cont.snd\n ),\n by admit /- proof elided -/\n⟩"
},
{
"name": "Cont.pred",
"content": "def Cont.pred : Cont (Flat Nat) (Flat Nat) := Mono.pred.promote_trivial"
},
{
"name": "Mono.pred",
"content": "def Mono.pred : Mono (Flat Nat) (Flat Nat) := ⟨\n Nat.partial_pred,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Nat.partial_pred",
"content": "def Nat.partial_pred : Flat Nat → Flat Nat :=\n fun n ↦ match n with\n | .some (.succ n) => .some n\n | _ => .none"
},
{
"name": "Cont.curry",
"content": "def Cont.curry {α : Type i} {β : Type j}\n [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ]\n (f : Cont (α × β) γ) : Cont α (Cont β γ) := ⟨\n ⟨\n fun a ↦ ⟨\n ⟨\n fun b ↦ f (a, b),\n fun b' ↦ f • ⟨⋆, b'⟩\n ⟩,\n by admit /- proof elided -/\n ⟩,\n fun a' b ↦ f • ⟨a', ⋆⟩\n ⟩,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Cont.pair",
"content": "def Cont.pair [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ]\n (f : Cont γ α) (g : Cont γ β) : Cont γ (α × β) := ⟨\n ⟨fun c ↦ ⟨f c, g c⟩, fun p ↦ ⟨f • p, g • p⟩⟩,\n ⟨f.sub ⬝ Domain.sup_is_mono (fun _ ↦ ⋆), g.sub ⬝ Domain.sup_is_mono (fun _ ↦ ⋆)⟩\n ⟩"
},
{
"name": "Cont.uncurry",
"content": "def Cont.uncurry {α : Type i} {β : Type j}\n [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ]\n (f : Cont α (Cont β γ)) : Cont (α × β) γ := ⟨\n Mono.uncurry_cont f,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Mono.uncurry_cont",
"content": "def Mono.uncurry_cont {α : Type i} {β : Type j}\n [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ]\n (f : Cont α (Cont β γ)) : Mono (α × β) γ := ⟨\n fun ⟨a, b⟩ ↦ (f a) b,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Cont.fix'",
"content": "def Cont.fix' [Order α] [Domain α] : Cont (Cont α α) α := ⟨\n fix_mono,\n by\n intro f\n apply fix_is_least_prefixed\n calc ⨆ f (⨆ (fix_mono ∘ f))\n _ = ⨆ (f.apply (⨆ (fix_mono ∘ f))) := rfl\n _ ⊑ ⨆ (Mono.sup ∘ Mono.comp ∘ Mono.pair (Mono.from_cont ∘ f) (Mono.const (fix_mono ∘ f))) :="
},
{
"name": "fix_is_prefixed",
"content": "def fix_is_prefixed [Order α] [Domain α] (f : Cont α α) : is_prefixed f (⨆ f.iterations) :="
},
{
"name": "sup_succ",
"content": "def sup_succ [Order α] [Domain α] {c : Chain α} : ⨆ (c ∘ Mono.succ) ⊑ ⨆ c :="
},
{
"name": "Mono.succ",
"content": "def Mono.succ : Mono Nat Nat := ⟨Nat.succ, Nat.succ_le_succ⟩"
},
{
"name": "Cont.iterations",
"content": "def Cont.iterations [Order α] [Domain α] (f : Cont α α) : Chain α := ⟨\n fun n ↦ Cont.iter n f ⊥,\n increasing_implies_monotone (fun n ↦ iter n f ⊥) (by admit /- proof elided -/\n )\n ⟩"
},
{
"name": "Cont.iter",
"content": "def Cont.iter [Order α] [Domain α] : Nat → Cont α α → Cont α α\n| 0 => fun _ ↦ Cont.id\n| .succ n => fun f ↦ f ∘ iter n f"
},
{
"name": "Cont.id",
"content": "def Cont.id [Order α] [Domain α] : Cont α α := ⟨Mono.id, ⋆⟩"
},
{
"name": "Mono.id",
"content": "def Mono.id [Order α] : Mono α α\n := ⟨Function.id, Function.id⟩"
},
{
"name": "Function.id",
"content": "@[inline] def Function.id {α : Sort u} (a : α) : α := a"
},
{
"name": "increasing_implies_monotone",
"content": "def increasing_implies_monotone [Order α] (f : Nat → α) : (∀ n, f n ⊑ f n.succ) → is_monotone f :="
},
{
"name": "is_prefixed",
"content": "def is_prefixed [Order α] [Domain α] (f : Cont α α) (a : α) := f a ⊑ a"
},
{
"name": "Cont.fix",
"content": "def Cont.fix [Order α] [Domain α] (f : Cont α α) := ⨆ f.iterations"
},
{
"name": "fix_is_least_prefixed",
"content": "def fix_is_least_prefixed [Order α] [Domain α] (f : Cont α α) (a : α) (h : is_prefixed f a)\n : f.fix ⊑ a :="
},
{
"name": "Cont.fix_mono",
"content": "def Cont.fix_mono [Order α] [Domain α] : Mono (Cont α α) α := ⟨\n Cont.fix,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Nat.zero?",
"content": "def Nat.zero? : Nat → Bool\n| .zero => true\n| _ => false"
},
{
"name": "Cont.swap",
"content": "def Cont.swap [Order α] [Domain α] [Order β] [Domain β] : Cont (α × β) (β × α) := ⟨\n Mono.swap,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Mono.swap",
"content": "def Mono.swap [Order α] [Order β] : Mono (α × β) (β × α) := ⟨\n fun p ↦ ⟨p.snd, p.fst⟩,\n fun ⟨a', b'⟩ ↦ ⟨b', a'⟩\n ⟩"
},
{
"name": "Cont.assoc_swap_assoc",
"content": "def Cont.assoc_swap_assoc {α : Type i} {β : Type j}\n [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] : Cont ((α × β) × γ) ((α × γ) × β) := ⟨\n Mono.assoc_swap_assoc,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Mono.assoc_swap_assoc",
"content": "def Mono.assoc_swap_assoc {α : Type i} {β : Type j}\n [Order α] [Order β] [Order γ] : Mono ((α × β) × γ) ((α × γ) × β) := ⟨\n fun p ↦ ⟨⟨p.fst.fst, p.snd⟩, p.fst.snd⟩,\n fun ⟨⟨a', b'⟩, c'⟩ ↦ ⟨⟨a', c'⟩, b'⟩\n ⟩"
},
{
"name": "Ty",
"content": "inductive Ty\n | bool\n | nat\n | pow : Ty → Ty → Ty"
},
{
"name": "DomainType",
"content": "structure DomainType : Type (i + 1) :=\n carrier : Type i\n order : Order carrier\n domain : Domain carrier"
},
{
"name": "Cx",
"content": "inductive Cx\n | nil\n | cons : Cx -> Ty -> Cx"
},
{
"name": "Ren.weak",
"content": "def Ren.weak {τ : Ty} : Ren Γ (Γ ∷ τ) := Var.s"
},
{
"name": "Var",
"content": "inductive Var : Cx → Ty → Type\n | z : ∀ {Γ : Cx}, Var (Γ ∷ τ) τ\n | s : ∀ {Γ : Cx} {υ : Ty} τ, Var Γ τ → Var (Γ ∷ υ) τ"
},
{
"name": "Sb",
"content": "def Sb Γ Δ := ∀ τ, Γ ∋ τ → Δ ⊢ τ"
},
{
"name": "infixr:100 \" ⇒ \" => Ty.pow",
"content": "infixr:100 \" ⇒ \" => Ty.pow"
},
{
"name": "infixl:70 \" ∷ \" => Cx.cons",
"content": "infixl:70 \" ∷ \" => Cx.cons"
},
{
"name": "infix:70 \" ∋ \" => Var",
"content": "infix:70 \" ∋ \" => Var"
},
{
"name": "infix:70 \" ⊢ \" => Tm",
"content": "infix:70 \" ⊢ \" => Tm"
},
{
"name": "infix:100 \" ⊑ \" => Order.R",
"content": "infix:100 \" ⊑ \" => Order.R"
},
{
"name": "notation:max \"⋆\" => Order.refl",
"content": "notation:max \"⋆\" => Order.refl"
},
{
"name": "infix:100 \" ⇄! \" => Order.anti",
"content": "infix:100 \" ⇄! \" => Order.anti"
},
{
"name": "infixl:100 \" • \" => Mono.act'",
"content": "infixl:100 \" • \" => Mono.act'"
},
{
"name": "notation:max \"⊥\" => Domain.bot",
"content": "notation:max \"⊥\" => Domain.bot"
},
{
"name": "notation:max \"⨆\" => Domain.sup",
"content": "notation:max \"⨆\" => Domain.sup"
},
{
"name": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x",
"content": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x"
},
{
"name": "infix:100 \" ∘ \" => Cont.comp'",
"content": "infix:100 \" ∘ \" => Cont.comp'"
},
{
"name": "infixr:100 \" ∘' \" => Cont.comp'",
"content": "infixr:100 \" ∘' \" => Cont.comp'"
}
] | [
{
"name": "congrArg",
"module": "Init.Prelude"
}
] | [
{
"name": "Cont.ext",
"content": "@[ext] theorem Cont.ext [Order α] [Order β] [Domain α] [Domain β]\n {f g : Cont α β} (p : f.fn.act = g.fn.act) : f = g"
},
{
"name": "congrArg2",
"content": "theorem congrArg2\n {α₀ : Sort u₀} {α₁ : Sort u₁} {β : Sort v} {a₀ a₀' : α₀} {a₁ a₁' : α₁}\n (f : α₀ → α₁ → β) (h₀ : Eq a₀ a₀') (h₁ : Eq a₁ a₁') : Eq (f a₀ a₁) (f a₀' a₁')"
},
{
"name": "Cont.pair_after",
"content": "theorem Cont.pair_after [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] [Order δ] [Domain δ]\n (f : Cont γ α) (g : Cont γ β) (h : Cont δ γ) : (f ∘' h).pair (g ∘' h) = (f.pair g) ∘' h"
}
] | [
{
"name": "Ty.den",
"content": "noncomputable def Ty.den : Ty → DomainType\n | .bool => ⟨Flat Bool, _, inferInstance⟩\n | .nat => ⟨Flat Nat, _, inferInstance⟩\n | .pow T₀ T₁ => by admit /- proof elided -/"
},
{
"name": "Ev",
"content": "def Ev (Γ : Cx) : Type := ∀ τ, Var Γ τ → ↑⟦τ ty⟧"
},
{
"name": "Ev.push",
"content": "def Ev.push {Γ : Cx} (ρ : ⟦Γ cx⟧) {τ : Ty} (d : ↑⟦τ ty⟧) : ⟦Γ ∷ τ cx⟧ :=\n fun {τ} x ↦ match x with\n | .z => d\n | .s τ x => ρ τ x"
},
{
"name": "Ev.from",
"content": "def Ev.from {Γ : Cx} {τ : Ty} : Cont (⟦Γ cx⟧ × ⟦τ ty⟧) (⟦Γ ∷ τ cx⟧) := ⟨\n ⟨\n fun ⟨ρ, d⟩ υ x ↦ ρ.push d υ x,\n by admit /- proof elided -/\n ⟩,\n by admit /- proof elided -/\n⟩"
},
{
"name": "Tm.den",
"content": "noncomputable def Tm.den : (Γ ⊢ τ) → Cont (⟦Γ cx⟧) (⟦τ ty⟧)\n | .var τ x => ⟨⟨fun ρ ↦ ρ τ x, fun ρ₀_ρ₁ ↦ ρ₀_ρ₁ τ x⟩, ⋆⟩\n | .true => Cont.const (.some .true)\n | .false => Cont.const (.some .false)\n | .zero => Cont.const (.some 0)\n | .succ e => Cont.flat (Nat.succ) ∘ e.den\n | .pred e => Cont.pred ∘ e.den\n | .zero? e => Cont.flat (Nat.zero?) ∘ e.den\n | .cond s t f => Cont.uncurry (Cont.cond) ∘ Cont.pair s.den (Cont.pair t.den f.den)\n | .fn e => Cont.curry (e.den ∘ Ev.from)\n | .app f e => Cont.eval ∘ (Cont.pair f.den e.den)\n | .fix f => Cont.fix' ∘ f.den"
},
{
"name": "Ren.den",
"content": "noncomputable def Ren.den (r : Ren Γ Δ) : Cont (⟦Δ cx⟧) (⟦Γ cx⟧) :=\n ⟨⟨fun ρ _ x ↦ (⟦(x.ren r).tm⟧) ρ, fun ρ' _ x ↦ (⟦(x.ren r).tm⟧) • ρ'⟩, fun _ x ↦ (⟦(x.ren r).tm⟧).sub⟩"
},
{
"name": "Sb.den",
"content": "noncomputable def Sb.den (σ : Sb Γ Δ) : Cont (⟦Δ cx⟧) (⟦Γ cx⟧) :=\n ⟨⟨fun ρ _ x ↦ (⟦x.sub σ⟧) ρ, fun ρ' _ x ↦ (⟦x.sub σ⟧) • ρ'⟩, fun _ x ↦ (⟦x.sub σ⟧).sub⟩"
},
{
"name": "Con.den",
"content": "noncomputable def Con.den : Con Δ υ Γ τ → Cont (⟦Γ cx⟧ × Cont (⟦Δ cx⟧) (⟦υ ty⟧)) ⟦τ ty⟧\n | id => Cont.uncurry Cont.id ∘' Cont.swap\n | comp C₀ C₁ => Cont.uncurry (Cont.curry (C₁.den ∘' Cont.swap)\n ∘' Cont.curry (C₀.den ∘' Cont.swap)) ∘' Cont.swap\n | sub C σ => Cont.uncurry ((Cont.curry C.den) ∘' (⟦σ⟧))\n | succ C => Cont.flat (Nat.succ) ∘' C.den\n | pred C => Cont.pred ∘' C.den\n | zero? C => Cont.flat (Nat.zero?) ∘' C.den\n | fn C => Cont.curry ((Cont.uncurry (Cont.curry C.den ∘' Ev.from)) ∘' Cont.assoc_swap_assoc)\n | cond_s C t f => Cont.uncurry (Cont.cond)\n ∘' Cont.pair C.den (Cont.pair ((⟦t⟧) ∘' Cont.fst) ((⟦f⟧) ∘' Cont.fst))\n | cond_t s C f => Cont.uncurry (Cont.cond)\n ∘' Cont.pair ((⟦s⟧) ∘' Cont.fst) (Cont.pair C.den ((⟦f⟧) ∘' Cont.fst))\n | cond_f s t C => Cont.uncurry (Cont.cond)\n ∘' Cont.pair ((⟦s⟧) ∘' Cont.fst) (Cont.pair ((⟦t⟧) ∘' Cont.fst) C.den)\n | app_f C a => Cont.eval ∘' (Cont.pair C.den ((⟦a⟧) ∘' Cont.fst))\n | app_a f C => Cont.eval ∘' (Cont.pair ((⟦f⟧) ∘' Cont.fst) C.den)\n | fix C => Cont.fix' ∘' C.den"
}
] | [
{
"name": "Ren.weak_den_eq",
"content": "theorem Ren.weak_den_eq : (⟦Ren.weak⟧) (Ev.from (ρ, d)) = ρ"
}
] | import «PCF».Flat
import «PCF».Context
noncomputable def Ty.den : Ty → DomainType
| .bool => ⟨Flat Bool, _, inferInstance⟩
| .nat => ⟨Flat Nat, _, inferInstance⟩
| .pow T₀ T₁ => by admit /- proof elided -/
notation:max "⟦" τ " ty⟧" => Ty.den τ
def Ev (Γ : Cx) : Type := ∀ τ, Var Γ τ → ↑⟦τ ty⟧
notation:max "⟦" Γ " cx⟧" => Ev Γ
def Ev.push {Γ : Cx} (ρ : ⟦Γ cx⟧) {τ : Ty} (d : ↑⟦τ ty⟧) : ⟦Γ ∷ τ cx⟧ :=
fun {τ} x ↦ match x with
| .z => d
| .s τ x => ρ τ x
def Ev.from {Γ : Cx} {τ : Ty} : Cont (⟦Γ cx⟧ × ⟦τ ty⟧) (⟦Γ ∷ τ cx⟧) := ⟨
⟨
fun ⟨ρ, d⟩ υ x ↦ ρ.push d υ x,
by admit /- proof elided -/
⟩,
by admit /- proof elided -/
⟩
noncomputable def Tm.den : (Γ ⊢ τ) → Cont (⟦Γ cx⟧) (⟦τ ty⟧)
| .var τ x => ⟨⟨fun ρ ↦ ρ τ x, fun ρ₀_ρ₁ ↦ ρ₀_ρ₁ τ x⟩, ⋆⟩
| .true => Cont.const (.some .true)
| .false => Cont.const (.some .false)
| .zero => Cont.const (.some 0)
| .succ e => Cont.flat (Nat.succ) ∘ e.den
| .pred e => Cont.pred ∘ e.den
| .zero? e => Cont.flat (Nat.zero?) ∘ e.den
| .cond s t f => Cont.uncurry (Cont.cond) ∘ Cont.pair s.den (Cont.pair t.den f.den)
| .fn e => Cont.curry (e.den ∘ Ev.from)
| .app f e => Cont.eval ∘ (Cont.pair f.den e.den)
| .fix f => Cont.fix' ∘ f.den
notation:100 "⟦" t "⟧" => Tm.den t
noncomputable def Ren.den (r : Ren Γ Δ) : Cont (⟦Δ cx⟧) (⟦Γ cx⟧) :=
⟨⟨fun ρ _ x ↦ (⟦(x.ren r).tm⟧) ρ, fun ρ' _ x ↦ (⟦(x.ren r).tm⟧) • ρ'⟩, fun _ x ↦ (⟦(x.ren r).tm⟧).sub⟩
notation:100 "⟦" r "⟧" => Ren.den r
noncomputable def Sb.den (σ : Sb Γ Δ) : Cont (⟦Δ cx⟧) (⟦Γ cx⟧) :=
⟨⟨fun ρ _ x ↦ (⟦x.sub σ⟧) ρ, fun ρ' _ x ↦ (⟦x.sub σ⟧) • ρ'⟩, fun _ x ↦ (⟦x.sub σ⟧).sub⟩
notation:100 "⟦" σ "⟧" => Sb.den σ
noncomputable def Con.den : Con Δ υ Γ τ → Cont (⟦Γ cx⟧ × Cont (⟦Δ cx⟧) (⟦υ ty⟧)) ⟦τ ty⟧
| id => Cont.uncurry Cont.id ∘' Cont.swap
| comp C₀ C₁ => Cont.uncurry (Cont.curry (C₁.den ∘' Cont.swap)
∘' Cont.curry (C₀.den ∘' Cont.swap)) ∘' Cont.swap
| sub C σ => Cont.uncurry ((Cont.curry C.den) ∘' (⟦σ⟧))
| succ C => Cont.flat (Nat.succ) ∘' C.den
| pred C => Cont.pred ∘' C.den
| zero? C => Cont.flat (Nat.zero?) ∘' C.den
| fn C => Cont.curry ((Cont.uncurry (Cont.curry C.den ∘' Ev.from)) ∘' Cont.assoc_swap_assoc)
| cond_s C t f => Cont.uncurry (Cont.cond)
∘' Cont.pair C.den (Cont.pair ((⟦t⟧) ∘' Cont.fst) ((⟦f⟧) ∘' Cont.fst))
| cond_t s C f => Cont.uncurry (Cont.cond)
∘' Cont.pair ((⟦s⟧) ∘' Cont.fst) (Cont.pair C.den ((⟦f⟧) ∘' Cont.fst))
| cond_f s t C => Cont.uncurry (Cont.cond)
∘' Cont.pair ((⟦s⟧) ∘' Cont.fst) (Cont.pair ((⟦t⟧) ∘' Cont.fst) C.den)
| app_f C a => Cont.eval ∘' (Cont.pair C.den ((⟦a⟧) ∘' Cont.fst))
| app_a f C => Cont.eval ∘' (Cont.pair ((⟦f⟧) ∘' Cont.fst) C.den)
| fix C => Cont.fix' ∘' C.den
notation:100 "⟦" C " con⟧" => Con.den C | theorem Tm.sub_den_eq (e : Γ ⊢ τ) : ∀ {Δ}, (σ : Sb Γ Δ) → ⟦e.sub σ⟧ = (⟦e⟧) ∘' (⟦σ⟧) := | := by
induction e with
| fn e Φ =>
intro _ σ
calc ⟦e.fn.sub σ⟧
_ = Cont.curry ((⟦e.sub (σ.keep _)⟧) ∘ Ev.from) := rfl
_ = Cont.curry (((⟦e⟧) ∘' ⟦σ.keep _⟧) ∘ Ev.from) := by rw [Φ (σ.keep _)]
_ = (⟦e.fn⟧) ∘' ⟦σ⟧ := by {
apply Cont.ext ∘ funext
intro ρ
apply Cont.ext ∘ funext
intro d
have p : (⟦σ.keep _⟧) (Ev.from (ρ, d)) = Ev.from ((⟦σ⟧) ρ, d) := by {
funext τ x
cases x with
| z => rfl
| s τ x =>
calc (⟦σ.keep _⟧) (Ev.from (ρ, d)) τ x.succ
_ = (⟦(x.sub σ).ren Ren.weak⟧) (Ev.from (ρ, d)) := rfl
_ = ((⟦x.sub σ⟧) ∘' ⟦Ren.weak⟧) (Ev.from (ρ, d)) := by rw [(x.sub σ).ren_den_eq]
_ = (⟦x.sub σ⟧) ((⟦Ren.weak⟧) (Ev.from (ρ, d))) := rfl
_ = (⟦x.sub σ⟧) (ρ) := by rw [Ren.weak_den_eq]
_ = Ev.from ((⟦σ⟧) ρ, d) τ x.s := rfl
}
calc ((((⟦e⟧) ∘' ⟦σ.keep _⟧) ∘' Ev.from).curry ρ) d
_ = (⟦e⟧) ((⟦σ.keep _⟧) (Ev.from (ρ, d))) := rfl
_ = (⟦e⟧) (Ev.from ((⟦σ⟧) ρ, d)) := by rw [p]
_ = ((⟦e.fn⟧) ((⟦σ⟧) ρ)) d := rfl
}
| var | true | false | zero => intros; rfl
| succ _ Φ | pred _ Φ | zero? _ Φ | fix _ Φ => intro _ σ; exact congrArg _ (Φ σ)
| app _ _ Φf Φa =>
intro _ σ; exact congrArg2 (fun f a ↦ Cont.eval ∘' Cont.pair f a) (Φf σ) (Φa σ)
| cond s t f Φs Φt Φf =>
intro _ σ
calc ⟦(s.cond t f).sub σ⟧
_ = _ ∘' Cont.pair (⟦s.sub σ⟧) (Cont.pair (⟦t.sub σ⟧) (⟦f.sub σ⟧)) := rfl
_ = _ ∘' Cont.pair ((⟦s⟧) ∘' ⟦σ⟧) (Cont.pair ((⟦t⟧) ∘' ⟦σ⟧) ((⟦f⟧) ∘' ⟦σ⟧)) := by rw [Φs, Φt, Φf]
_ = _ ∘' Cont.pair (⟦s⟧) ((Cont.pair (⟦t⟧) (⟦f⟧))) ∘' ⟦σ⟧
:= by rw [Cont.pair_after (⟦t⟧) (⟦f⟧) (⟦σ⟧), Cont.pair_after (⟦s⟧) _ (⟦σ⟧)]
_ = (⟦s.cond t f⟧) ∘' ⟦σ⟧ := rfl | 12 | 91 | false | Semantics |
396 | Flat.sup_some | theorem Flat.sup_some {c : Chain _} {a : α} : (∃ k, c.act k = .some a) ↔ (flat_sup c = .some a) | pcf-lean | PCF/Flat.lean | [
"import «PCF».Domain"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Eq",
"module": "Init.Prelude"
}
] | [
{
"name": "Chain",
"content": "def Chain (α : Type i) [Order α] := Mono Nat α"
},
{
"name": "Order",
"content": "class Order (α) where\n R : α → α → Prop\n refl {x} : R x x\n trans {x y z} : R x y → R y z → R x z\n anti {x y} : R x y → R y x → x = y"
},
{
"name": "Mono",
"content": "structure Mono (α) (β) [Order α] [Order β] where\n act : α → β\n act' : is_monotone act"
},
{
"name": "is_monotone",
"content": "def is_monotone [Order α] [Order β] (f : α → β) := ∀ {x y : α}, x ⊑ y → f x ⊑ f y"
},
{
"name": "infix:100 \" ⊑ \" => Order.R",
"content": "infix:100 \" ⊑ \" => Order.R"
},
{
"name": "infix:100 \" ⇄! \" => Order.anti",
"content": "infix:100 \" ⇄! \" => Order.anti"
},
{
"name": "infixl:100 \" • \" => Mono.act'",
"content": "infixl:100 \" • \" => Mono.act'"
},
{
"name": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x",
"content": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x"
}
] | [
{
"name": "Classical.em",
"module": "Init.Classical"
},
{
"name": "Nat.gt_of_not_le",
"module": "Init.Data.Nat.Basic"
},
{
"name": "Nat.le_of_lt",
"module": "Init.Data.Nat.Basic"
},
{
"name": "dif_neg",
"module": "Init.Core"
},
{
"name": "dif_pos",
"module": "Init.Core"
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Flat",
"content": "inductive Flat (α : Type) : Type where\n | none : Flat α\n | some : α → Flat α"
},
{
"name": "flat_sup",
"content": "noncomputable def flat_sup (c : Chain (Flat α)) : Flat α :=\n if p : ∃ a n, c.act n = .some a then .some p.choose else .none"
}
] | [
{
"name": "Flat.chain_some",
"content": "theorem Flat.chain_some {c : Chain (Flat _)} {a b : α}\n (p : ∃ k, c.act k = .some a) (q : ∃ k, c.act k = .some b) : a = b"
}
] | import «PCF».Domain
inductive Flat (α : Type) : Type where
| none : Flat α
| some : α → Flat α
open Classical
noncomputable def flat_sup (c : Chain (Flat α)) : Flat α :=
if p : ∃ a n, c.act n = .some a then .some p.choose else .none | theorem Flat.sup_some {c : Chain _} {a : α} : (∃ k, c.act k = .some a) ↔ (flat_sup c = .some a) := | := by
constructor
case mp =>
intro h;
have p : ∃ a n, c.act n = .some a := ⟨a, h⟩
rw [Flat.chain_some h p.choose_spec]
exact dif_pos p
case mpr =>
intro h;
if p : ∃ a n, c.act n = .some a
then
have q : flat_sup c = .some _ := dif_pos p
rw [← h, q]
exact p.choose_spec
else
have q : flat_sup c = .none := dif_neg p
rw [q] at h
exact Flat.noConfusion h | 4 | 14 | true | Semantics |
397 | Ren.ren_comp_eq | theorem Ren.ren_comp_eq {t : Γ₀ ⊢ τ}
: ∀ {Γ₁ Γ₂} {σ₀₁ : Ren Γ₀ Γ₁} {σ₁₂ : Ren Γ₁ Γ₂}, t.ren (σ₀₁ ⬝ σ₁₂) = (t.ren σ₀₁).ren σ₁₂ | pcf-lean | PCF/Substitution.lean | [
"import PCF.Utility",
"import «PCF».Syntax"
] | [
{
"name": "Vector",
"module": "Init.Data.Vector.Basic"
},
{
"name": "DecidableEq",
"module": "Init.Prelude"
},
{
"name": "List",
"module": "Init.Prelude"
},
{
"name": "Repr",
"module": "Init.Data.Repr"
},
{
"name": "String",
"module": "Init.Prelude"
},
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Trans.trans",
"module": "Init.Prelude"
},
{
"name": "Eq",
"module": "Init.Prelude"
}
] | [
{
"name": "Var",
"content": "inductive Var : Cx → Ty → Type\n | z : ∀ {Γ : Cx}, Var (Γ ∷ τ) τ\n | s : ∀ {Γ : Cx} {υ : Ty} τ, Var Γ τ → Var (Γ ∷ υ) τ"
},
{
"name": "Cx",
"content": "inductive Cx\n | nil\n | cons : Cx -> Ty -> Cx"
},
{
"name": "Ty",
"content": "inductive Ty\n | bool\n | nat\n | pow : Ty → Ty → Ty"
},
{
"name": "Tm",
"content": "inductive Tm : Cx → Ty → Type\n | var : ∀ τ, Γ ∋ τ → Tm Γ τ\n | true : Tm Γ .bool\n | false : Tm Γ .bool\n | zero : Tm Γ .nat\n | succ : Tm Γ .nat → Tm Γ .nat\n | pred : Tm Γ .nat → Tm Γ .nat\n | zero? : Tm Γ .nat → Tm Γ .bool\n | cond : Tm Γ .bool → Tm Γ τ → Tm Γ τ → Tm Γ τ\n | fn : Tm (Γ ∷ τ) υ → Tm Γ (τ ⇒ υ)\n | app : Tm Γ (τ ⇒ υ) → Tm Γ τ → Tm Γ υ\n | fix : Tm Γ (τ ⇒ τ) → Tm Γ τ"
},
{
"name": "infixl:70 \" ∷ \" => Cx.cons",
"content": "infixl:70 \" ∷ \" => Cx.cons"
},
{
"name": "infix:70 \" ∋ \" => Var",
"content": "infix:70 \" ∋ \" => Var"
},
{
"name": "infix:70 \" ⊢ \" => Tm",
"content": "infix:70 \" ⊢ \" => Tm"
}
] | [
{
"name": "congrArg",
"module": "Init.Prelude"
}
] | [
{
"name": "congrArg3",
"content": "theorem congrArg3\n {α₀ : Sort u₀} {α₁ : Sort u₁} {α₂ : Sort u₂} {β : Sort v} {a₀ a₀' : α₀} {a₁ a₁' : α₁} {a₂ a₂' : α₂}\n (f : α₀ → α₁ → α₂ → β) (h₀ : Eq a₀ a₀') (h₁ : Eq a₁ a₁') (h₂ : Eq a₂ a₂') : Eq (f a₀ a₁ a₂) (f a₀' a₁' a₂')"
},
{
"name": "congrArg2",
"content": "theorem congrArg2\n {α₀ : Sort u₀} {α₁ : Sort u₁} {β : Sort v} {a₀ a₀' : α₀} {a₁ a₁' : α₁}\n (f : α₀ → α₁ → β) (h₀ : Eq a₀ a₀') (h₁ : Eq a₁ a₁') : Eq (f a₀ a₁) (f a₀' a₁')"
}
] | [
{
"name": "Ren",
"content": "def Ren Γ Δ := ∀ τ, Γ ∋ τ → Δ ∋ τ"
},
{
"name": "Var.ren",
"content": "def Var.ren (v : Γ ∋ τ) (r : Ren Γ Δ) := r τ v"
},
{
"name": "Ren.keep",
"content": "def Ren.keep (r : Ren Γ Δ) (τ : Ty) : Ren (Γ ∷ τ) (Δ ∷ τ) :=\n fun υ v => match v with\n | .z => .z\n | .s _ x => (x.ren r).succ"
},
{
"name": "Tm.ren",
"content": "def Tm.ren (t : Γ ⊢ τ) (r : Ren Γ Δ) : Δ ⊢ τ :=\n match t with\n | .var τ x => (x.ren r).tm\n | .true => .true\n | .false => .false\n | .zero => .zero\n | .succ e => (e.ren r).succ\n | .pred e => (e.ren r).pred\n | .zero? e => (e.ren r).zero?\n | .cond s t f => (s.ren r).cond (t.ren r) (f.ren r)\n | .fn e => (e.ren (r ∷ᵣ _)).fn\n | .app f a => (f.ren r).app (a.ren r)\n | .fix f => (f.ren r).fix"
}
] | [
{
"name": "Ren.keep_comp",
"content": "theorem Ren.keep_comp {r₀₁ : Ren Γ₀ Γ₁} {r₁₂ : Ren Γ₁ Γ₂}\n : (r₀₁ ⬝ r₁₂) ∷ᵣ τ = (r₀₁ ∷ᵣ τ) ⬝ (r₁₂ ∷ᵣ τ)"
}
] | import «PCF».Syntax
def Ren Γ Δ := ∀ τ, Γ ∋ τ → Δ ∋ τ
def Var.ren (v : Γ ∋ τ) (r : Ren Γ Δ) := r τ v
def Ren.keep (r : Ren Γ Δ) (τ : Ty) : Ren (Γ ∷ τ) (Δ ∷ τ) :=
fun υ v => match v with
| .z => .z
| .s _ x => (x.ren r).succ
infixl:70 " ∷ᵣ " => Ren.keep
infixl:70 " ++ᵣ " => Ren.keeps
def Tm.ren (t : Γ ⊢ τ) (r : Ren Γ Δ) : Δ ⊢ τ :=
match t with
| .var τ x => (x.ren r).tm
| .true => .true
| .false => .false
| .zero => .zero
| .succ e => (e.ren r).succ
| .pred e => (e.ren r).pred
| .zero? e => (e.ren r).zero?
| .cond s t f => (s.ren r).cond (t.ren r) (f.ren r)
| .fn e => (e.ren (r ∷ᵣ _)).fn
| .app f a => (f.ren r).app (a.ren r)
| .fix f => (f.ren r).fix | theorem Ren.ren_comp_eq {t : Γ₀ ⊢ τ}
: ∀ {Γ₁ Γ₂} {σ₀₁ : Ren Γ₀ Γ₁} {σ₁₂ : Ren Γ₁ Γ₂}, t.ren (σ₀₁ ⬝ σ₁₂) = (t.ren σ₀₁).ren σ₁₂ := | := by
induction t with
| @fn _ τ υ e Φ =>
intro _ _ r₀₁ r₁₂
calc (e.ren ((r₀₁ ⬝ r₁₂) ∷ᵣ τ)).fn
_ = (e.ren ((r₀₁ ∷ᵣ τ) ⬝ (r₁₂ ∷ᵣ τ))).fn := by rw [Ren.keep_comp]
_ = ((e.ren (r₀₁ ∷ᵣ τ)).ren (r₁₂ ∷ᵣ τ)).fn := by rw [Φ]
| var | true | false | zero => intros; rfl
| succ _ Φ | pred _ Φ | zero? _ Φ | fix _ Φ => exact congrArg _ Φ
| app _ _ Φf Φa => exact congrArg2 _ Φf Φa
| cond _ _ _ Φs Φt Φf => exact congrArg3 _ Φs Φt Φf | 3 | 20 | false | Semantics |
398 | Flat.under_eq | theorem Flat.under_eq {x : Flat α} : x ⊑ .some a → x ⊑ .some b → a ≠ b → x = .none | pcf-lean | PCF/Flat.lean | [
"import «PCF».Domain"
] | [
{
"name": "Trans.trans",
"module": "Init.Prelude"
}
] | [
{
"name": "Order",
"content": "class Order (α) where\n R : α → α → Prop\n refl {x} : R x x\n trans {x y z} : R x y → R y z → R x z\n anti {x y} : R x y → R y x → x = y"
},
{
"name": "infix:100 \" ⊑ \" => Order.R",
"content": "infix:100 \" ⊑ \" => Order.R"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [] | [] | import «PCF».Domain
open Classical
inductive Flat (α : Type) : Type where
| none : Flat α
| some : α → Flat α
instance (a : Flat α) : Decidable (∃ k, a = .some k) :=
match a with
| .none => isFalse (fun p ↦ p.elim (fun _ y ↦ by injection y))
| .some a => isTrue (.intro a rfl)
instance [DecidableEq α] : DecidableEq (Flat α) := fun a b ↦
match a with
| .none => match b with
| .none => isTrue rfl
| .some _ => isFalse Flat.noConfusion
| .some a => match b with
| .none => isFalse Flat.noConfusion
| .some b => if p : a = b then isTrue (by rw [p]) else isFalse (fun q ↦ p (by injection q))
instance [DecidableEq α] : Order (Flat α) where
R := fun x y ↦ (x ≠ .none) → x = y
refl := fun _ ↦ rfl
trans {x y z} p q :=
if h : x = .none
then fun a ↦ (a h).elim
else fun a ↦ by rw [p h]; rw [p h] at h; rw [q h]
anti {x y} p q :=
if i : x = .none
then if j : y = .none then by rw [i, j] else by rw [q j]
else by rw [p i]
noncomputable def flat_sup (c : Chain (Flat α)) : Flat α :=
if p : ∃ a n, c.act n = .some a then .some p.choose else .none
noncomputable instance : Domain (Flat α) where
bot := .none
sup := flat_sup
is_bot := by admit /- proof elided -/
is_bound := by admit /- proof elided -/
is_least := by admit /- proof elided -/ | theorem Flat.under_eq {x : Flat α} : x ⊑ .some a → x ⊑ .some b → a ≠ b → x = .none := | := by
intro under_a under_b a_neq_b
by_cases x = none
case pos => assumption
case neg h => exfalso; exact a_neq_b (by injection (under_a h).symm ⬝ (under_b h)) | 1 | 2 | false | Semantics |
399 | Cont.pair_after | theorem Cont.pair_after [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] [Order δ] [Domain δ]
(f : Cont γ α) (g : Cont γ β) (h : Cont δ γ) : (f ∘' h).pair (g ∘' h) = (f.pair g) ∘' h | pcf-lean | PCF/Domain.lean | [
"import PCF/Denotation.lean",
"import «PCF».Order",
"import PCF/Flat.lean",
"import PCF.Order"
] | [
{
"name": "Nat",
"module": "Init.Prelude"
},
{
"name": "Trans.trans",
"module": "Init.Prelude"
}
] | [
{
"name": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x",
"content": "notation:101 f \" • \" x:100 => Mono.act' (Cont.fn f) x"
},
{
"name": "notation:max \"⨆\" => Domain.sup",
"content": "notation:max \"⨆\" => Domain.sup"
},
{
"name": "Order",
"content": "class Order (α) where\n R : α → α → Prop\n refl {x} : R x x\n trans {x y z} : R x y → R y z → R x z\n anti {x y} : R x y → R y x → x = y"
},
{
"name": "Chain",
"content": "def Chain (α : Type i) [Order α] := Mono Nat α"
},
{
"name": "Mono",
"content": "structure Mono (α) (β) [Order α] [Order β] where\n act : α → β\n act' : is_monotone act"
},
{
"name": "is_monotone",
"content": "def is_monotone [Order α] [Order β] (f : α → β) := ∀ {x y : α}, x ⊑ y → f x ⊑ f y"
},
{
"name": "(Γ",
"content": "noncomputable instance (Γ : Cx) : Domain (⟦Γ cx⟧) where\n bot := fun _ _ ↦ ⊥\n sup := fun c _ x ↦ ⨆ ⟨fun n ↦ c.act n _ x, fun i_j ↦ c.act' i_j _ x⟩\n is_bot := fun _ _ ↦ Domain.is_bot\n is_bound := fun c {n} {_} x ↦ Domain.is_bound ⟨fun n ↦ c.act n _ x, fun i_j ↦ c.act' i_j _ x⟩ n\n is_least := fun c _ p {_} x ↦ Domain.is_least ⟨fun n ↦ c.act n _ x, fun i_j ↦ c.act' i_j _ x⟩\n (fun {_} ↦ p _ x)"
},
{
"name": "[Order",
"content": "instance [Order α] [Order β] [Domain α] [Domain β] : Domain (Cont α β) where\n bot := ⟨⟨fun _ ↦ ⊥, fun _ ↦ Domain.is_bot⟩, Domain.is_bot⟩\n sup := fun c ↦ ⟨Mono.sup_cont c, by admit /- proof elided -/\n ⟩\n is_bot := fun _ ↦ Domain.is_bot\n is_bound := by admit /- proof elided -/"
},
{
"name": "flat_sup",
"content": "noncomputable def flat_sup (c : Chain (Flat α)) : Flat α :=\n if p : ∃ a n, c.act n = .some a then .some p.choose else .none"
},
{
"name": "Flat",
"content": "inductive Flat (α : Type) : Type where\n | none : Flat α\n | some : α → Flat α"
},
{
"name": "infix:100 \" ⊑ \" => Order.R",
"content": "infix:100 \" ⊑ \" => Order.R"
},
{
"name": "notation:max \"⋆\" => Order.refl",
"content": "notation:max \"⋆\" => Order.refl"
},
{
"name": "infix:100 \" ⇄! \" => Order.anti",
"content": "infix:100 \" ⇄! \" => Order.anti"
},
{
"name": "infixl:100 \" • \" => Mono.act'",
"content": "infixl:100 \" • \" => Mono.act'"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "Mono.ext",
"content": "@[ext] theorem Mono.ext [Order α] [Order β] {f g : Mono α β} (p : f.act = g.act) : f = g"
}
] | [
{
"name": "Domain",
"content": "class Domain (α) [Order α] where\n bot : α\n sup : (c : Chain α) → α\n is_bot {x} : bot ⊑ x\n is_bound (c) (n): c.act n ⊑ sup c\n is_least (c) {d} : ({n : _} → c.act n ⊑ d) → sup c ⊑ d"
},
{
"name": "DomainType",
"content": "structure DomainType : Type (i + 1) :=\n carrier : Type i\n order : Order carrier\n domain : Domain carrier"
},
{
"name": "_inst_DomainType",
"content": "instance (τ : DomainType) : Order (τ) := τ.order"
},
{
"name": "_inst_DomainType",
"content": "instance (τ : DomainType) : Domain (τ) := τ.domain"
},
{
"name": "Cont",
"content": "structure Cont (α) (β) [Order α] [Order β] [Domain α] [Domain β] where\n fn : Mono α β\n sub : ∀ {c : Chain α}, fn.act (⨆ c) ⊑ ⨆ (fn ∘ c)"
},
{
"name": "Cont.comp'",
"content": "def Cont.comp' [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] (f : Cont β γ) (g : Cont α β)\n : Cont α γ\n := ⟨\n ⟨fun x ↦ f (g x), fun x_y ↦ f • g • x_y⟩,\n by admit /- proof elided -/\n ⟩"
},
{
"name": "Cont.pair",
"content": "def Cont.pair [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ]\n (f : Cont γ α) (g : Cont γ β) : Cont γ (α × β) := ⟨\n ⟨fun c ↦ ⟨f c, g c⟩, fun p ↦ ⟨f • p, g • p⟩⟩,\n ⟨f.sub ⬝ Domain.sup_is_mono (fun _ ↦ ⋆), g.sub ⬝ Domain.sup_is_mono (fun _ ↦ ⋆)⟩\n ⟩"
}
] | [
{
"name": "Cont.ext",
"content": "@[ext] theorem Cont.ext [Order α] [Order β] [Domain α] [Domain β]\n {f g : Cont α β} (p : f.fn.act = g.fn.act) : f = g"
}
] | import «PCF».Order
class Domain (α) [Order α] where
bot : α
sup : (c : Chain α) → α
is_bot {x} : bot ⊑ x
is_bound (c) (n): c.act n ⊑ sup c
is_least (c) {d} : ({n : _} → c.act n ⊑ d) → sup c ⊑ d
notation:max "⊥" => Domain.bot
notation:max "⨆" => Domain.sup
structure DomainType : Type (i + 1) :=
carrier : Type i
order : Order carrier
domain : Domain carrier
instance (τ : DomainType) : Order (τ) := τ.order
instance (τ : DomainType) : Domain (τ) := τ.domain
structure Cont (α) (β) [Order α] [Order β] [Domain α] [Domain β] where
fn : Mono α β
sub : ∀ {c : Chain α}, fn.act (⨆ c) ⊑ ⨆ (fn ∘ c)
notation:101 f " • " x:100 => Mono.act' (Cont.fn f) x
def Cont.comp' [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] (f : Cont β γ) (g : Cont α β)
: Cont α γ
:= ⟨
⟨fun x ↦ f (g x), fun x_y ↦ f • g • x_y⟩,
by admit /- proof elided -/
⟩
infix:100 " ∘ " => Cont.comp'
infixr:100 " ∘' " => Cont.comp'
def Cont.pair [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ]
(f : Cont γ α) (g : Cont γ β) : Cont γ (α × β) := ⟨
⟨fun c ↦ ⟨f c, g c⟩, fun p ↦ ⟨f • p, g • p⟩⟩,
⟨f.sub ⬝ Domain.sup_is_mono (fun _ ↦ ⋆), g.sub ⬝ Domain.sup_is_mono (fun _ ↦ ⋆)⟩
⟩ | theorem Cont.pair_after [Order α] [Domain α] [Order β] [Domain β] [Order γ] [Domain γ] [Order δ] [Domain δ]
(f : Cont γ α) (g : Cont γ β) (h : Cont δ γ) : (f ∘' h).pair (g ∘' h) = (f.pair g) ∘' h := | := by
apply Cont.ext ∘ funext
intro x
rfl | 3 | 12 | false | Semantics |
400 | Flat.leq_none | theorem Flat.leq_none {a : Flat α} : a ⊑ .none → a = .none | pcf-lean | PCF/Flat.lean | [
"import «PCF».Domain"
] | [
{
"name": "Trans.trans",
"module": "Init.Prelude"
}
] | [
{
"name": "Order",
"content": "class Order (α) where\n R : α → α → Prop\n refl {x} : R x x\n trans {x y z} : R x y → R y z → R x z\n anti {x y} : R x y → R y x → x = y"
},
{
"name": "infix:100 \" ⊑ \" => Order.R",
"content": "infix:100 \" ⊑ \" => Order.R"
}
] | [
{
"name": "...",
"module": ""
}
] | [
{
"name": "List.getElem_append_left{α",
"content": "theorem List.getElem_append_left{α : Type u_1} {l₁ l₂ : List α} {i : Nat} (hn : i < l₁.length) :\\n(l₁ ++ l₂)[i] = l₁[i]"
}
] | [
{
"name": "Flat",
"content": "inductive Flat (α : Type) : Type where\n | none : Flat α\n | some : α → Flat α"
}
] | [
{
"name": "Flat.invert",
"content": "theorem Flat.invert {x : Flat α} (p : x ≠ .none) : ∃ k, x = .some k"
}
] | import «PCF».Domain
open Classical | theorem Flat.leq_none {a : Flat α} : a ⊑ .none → a = .none := | := by
intro a_bf_n
by_cases a = none
case pos => assumption
case neg h =>
have ⟨n, a_eq_sn⟩ := Flat.invert h
exact a_bf_n (by intro a_eq_n; injection a_eq_n.symm ⬝ a_eq_sn) | 1 | 3 | false | Semantics |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.