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₂

/-!
Exercícios da Aula 3: Programas e Teoremas.
Substitua cada `sorry` por uma definição, uma prova ou um
enunciado, conforme cada exercício pede. As definições
acima vêm da aula.
-/
def pred : ℕ → ℕ := sorry

-- Esperado: #eval pred 5 dá 4, #eval pred 0 dá 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

-- Enuncie as duas leis aqui como teoremas provados por
-- sorry:
-- map_ident : mapear (fun x => x) sobre xs dá xs.
-- map_comp  : map g (map f xs) é igual a mapear a
--             composição das duas sobre xs.

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

-- Enuncie flatten_length aqui como um teorema provado por
-- sorry: length (flatten xss) é igual a
-- 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

-- Enuncie simplify_correct aqui como um teorema provado
-- por sorry: para todo env e todo e, eval env
-- (simplify e) é igual a 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

-- Enuncie mirror_eval aqui como um teorema provado por
-- sorry.