import Mathlib.Data.Nat.Notation
import Mathlib.Data.Int.Notation
namespace MyNat

inductive Nat : Type where
  | zero : Nat
  | succ : Nat → Nat

end MyNat

inductive AExp : Type where
  | num : ℤ → AExp
  | var : String → AExp
  | add : AExp → AExp → AExp
  | sub : AExp → AExp → AExp
  | mul : AExp → AExp → AExp
  | div : AExp → AExp → AExp

namespace MyList

inductive List (α : Type) : Type where
  | nil  : List α
  | cons : α → List α → List α

end MyList

def appendPretty {α : Type} : List α → List α → List α
  | [],      ys => ys
  | x :: xs, ys => x :: appendPretty xs ys

def reverse {α : Type} : List α → List α
  | []      => []
  | x :: xs => appendPretty (reverse xs) [x]

def eval (env : String → ℤ) : AExp → ℤ
  | AExp.num i     => i
  | AExp.var x     => env x
  | AExp.add e₁ e₂ => eval env e₁ + eval env e₂
  | AExp.sub e₁ e₂ => eval env e₁ - eval env e₂
  | AExp.mul e₁ e₂ => eval env e₁ * eval env e₂
  | AExp.div e₁ e₂ => eval env e₁ / eval env e₂

/-!
Exercises for Lecture 3: Programs and Theorems.
Replace each `sorry` with a definition, a proof, or a
statement, as each exercise asks. The definitions above
come from the lecture.
-/
def pred : ℕ → ℕ := sorry

-- Expected: #eval pred 5 gives 4, #eval pred 0 gives 0.

def double : ℕ → ℕ := sorry

theorem double_five : double 5 = 10 := sorry

def someEnv : String → ℤ := sorry

theorem eval_sub :
    eval someEnv
      (AExp.sub (AExp.var "y") (AExp.var "x")) = 14 :=
  sorry

theorem eval_div_zero :
    eval someEnv
      (AExp.div (AExp.var "y") (AExp.num 0)) = 0 :=
  sorry

def sumList : List ℕ → ℕ := sorry

theorem sumList_example : sumList [1, 2, 3] = 6 := sorry

def length {α : Type} : List α → ℕ := sorry

theorem length_three : length [1, 2, 3] = 3 := sorry

def map {α β : Type} (f : α → β) : List α → List β :=
  sorry

-- State the two laws here as theorems proved by sorry:
-- map_ident : mapping (fun x => x) over xs gives xs.
-- map_comp  : map g (map f xs) equals mapping their
--             composition over xs.

def flatten {α : Type} : List (List α) → List α := sorry

-- State flatten_length here as a theorem proved by sorry:
-- length (flatten xss) equals sumList (map length xss).

def simplify : AExp → AExp
  | AExp.add (AExp.num 0) e₂ => simplify e₂
  | AExp.add e₁ (AExp.num 0) => simplify e₁
  | AExp.sub e₁ e₂           => sorry
  | AExp.mul e₁ e₂           => sorry
  | AExp.div e₁ e₂           => sorry
  | AExp.add e₁ e₂           =>
      AExp.add (simplify e₁) (simplify e₂)
  | e                        => e

-- State simplify_correct here as a theorem proved by
-- sorry: for every env and e, eval env (simplify e)
-- equals eval env e.

def size : AExp → ℕ := sorry

def depth : AExp → ℕ := sorry

theorem depth_le_size (e : AExp) :
    depth e ≤ size e := sorry

def mirror : AExp → AExp := sorry

-- State mirror_eval here as a theorem proved by sorry.