| import Mathlib.Data.Fintype.Sum |
| import Mathlib.Logic.Embedding.Basic |
|
|
| namespace OAI |
|
|
| namespace BinPackingGap.NatExpressionCompiler |
|
|
| universe u |
|
|
| inductive Expr (α : Type u) : Type u |
| | constant (value : Nat) |
| | input (index : α) |
| | add (left right : Expr α) |
| | mul (left right : Expr α) |
| | monus (left right : Expr α) |
|
|
| variable {α : Type u} |
|
|
| def eval (values : α → Nat) : Expr α → Nat |
| | .constant value => value |
| | .input index => values index |
| | .add left right => eval values left + eval values right |
| | .mul left right => eval values left * eval values right |
| | .monus left right => eval values left - eval values right |
|
|
| @[simp] theorem eval_constant (values : α → Nat) (value : Nat) : |
| eval values (.constant value) = value := rfl |
|
|
| @[simp] theorem eval_input (values : α → Nat) (index : α) : |
| eval values (.input index) = values index := rfl |
|
|
| @[simp] theorem eval_add (values : α → Nat) (left right : Expr α) : |
| eval values (.add left right) = eval values left + eval values right := rfl |
|
|
| @[simp] theorem eval_mul (values : α → Nat) (left right : Expr α) : |
| eval values (.mul left right) = eval values left * eval values right := rfl |
|
|
| @[simp] theorem eval_monus (values : α → Nat) (left right : Expr α) : |
| eval values (.monus left right) = eval values left - eval values right := rfl |
|
|
| def Node : Expr α → Type |
| | .constant _ => Unit |
| | .input _ => Unit |
| | .add left right => Unit ⊕ (Node left ⊕ Node right) |
| | .mul left right => Unit ⊕ (Node left ⊕ Node right) |
| | .monus left right => Unit ⊕ (Node left ⊕ Node right) |
|
|
| instance nodeFintype : (expression : Expr α) → Fintype (Node expression) |
| | .constant _ => inferInstanceAs (Fintype Unit) |
| | .input _ => inferInstanceAs (Fintype Unit) |
| | .add left right => |
| letI : Fintype (Node left) := nodeFintype left |
| letI : Fintype (Node right) := nodeFintype right |
| inferInstanceAs (Fintype (Unit ⊕ (Node left ⊕ Node right))) |
| | .mul left right => |
| letI : Fintype (Node left) := nodeFintype left |
| letI : Fintype (Node right) := nodeFintype right |
| inferInstanceAs (Fintype (Unit ⊕ (Node left ⊕ Node right))) |
| | .monus left right => |
| letI : Fintype (Node left) := nodeFintype left |
| letI : Fintype (Node right) := nodeFintype right |
| inferInstanceAs (Fintype (Unit ⊕ (Node left ⊕ Node right))) |
|
|
| instance nodeDecidableEq : (expression : Expr α) → DecidableEq (Node expression) |
| | .constant _ => inferInstanceAs (DecidableEq Unit) |
| | .input _ => inferInstanceAs (DecidableEq Unit) |
| | .add left right => |
| letI : DecidableEq (Node left) := nodeDecidableEq left |
| letI : DecidableEq (Node right) := nodeDecidableEq right |
| inferInstanceAs (DecidableEq (Unit ⊕ (Node left ⊕ Node right))) |
| | .mul left right => |
| letI : DecidableEq (Node left) := nodeDecidableEq left |
| letI : DecidableEq (Node right) := nodeDecidableEq right |
| inferInstanceAs (DecidableEq (Unit ⊕ (Node left ⊕ Node right))) |
| | .monus left right => |
| letI : DecidableEq (Node left) := nodeDecidableEq left |
| letI : DecidableEq (Node right) := nodeDecidableEq right |
| inferInstanceAs (DecidableEq (Unit ⊕ (Node left ⊕ Node right))) |
|
|
| def rootBranch (left right : Expr α) : Unit ⊕ (Node left ⊕ Node right) := |
| .inl () |
|
|
| def root : (expression : Expr α) → Node expression |
| | .constant _ => () |
| | .input _ => () |
| | .add left right => rootBranch left right |
| | .mul left right => rootBranch left right |
| | .monus left right => rootBranch left right |
|
|
| @[simp] theorem rootBranch_eq (left right : Expr α) : |
| rootBranch left right = Sum.inl () := rfl |
|
|
| @[simp] theorem root_constant (value : Nat) : |
| root (.constant (α := α) value) = () := rfl |
|
|
| @[simp] theorem root_input (index : α) : root (.input index) = () := rfl |
|
|
| @[simp] theorem root_add (left right : Expr α) : |
| root (.add left right) = rootBranch left right := rfl |
|
|
| @[simp] theorem root_mul (left right : Expr α) : |
| root (.mul left right) = rootBranch left right := rfl |
|
|
| @[simp] theorem root_monus (left right : Expr α) : |
| root (.monus left right) = rootBranch left right := rfl |
|
|
| def leftNode (left right : Expr α) : Node left ↪ Unit ⊕ (Node left ⊕ Node right) where |
| toFun node := .inr (.inl node) |
| inj' := by |
| intro a b h |
| exact Sum.inl.inj (Sum.inr.inj h) |
|
|
| def rightNode (left right : Expr α) : Node right ↪ Unit ⊕ (Node left ⊕ Node right) where |
| toFun node := .inr (.inr node) |
| inj' := by |
| intro a b h |
| exact Sum.inr.inj (Sum.inr.inj h) |
|
|
| @[simp] theorem leftNode_apply (left right : Expr α) (node : Node left) : |
| leftNode left right node = Sum.inr (Sum.inl node) := rfl |
|
|
| @[simp] theorem rightNode_apply (left right : Expr α) (node : Node right) : |
| rightNode left right node = Sum.inr (Sum.inr node) := rfl |
|
|
| end BinPackingGap.NatExpressionCompiler |
|
|
| end OAI |
|
|
