Upload 2 files

EasyBenchmark.lean

@@ -0,0 +1,1045 @@
+import Mathlib
+
+
+def solveAdd (a b:Int): Int
+:= b-a
+
+theorem solveAdd_correct (a b: Int): a + (solveAdd a b) =b
+:= by simp[solveAdd]
+
+def solveAdd0(a:Int): Int
+:= -a
+
+theorem solveAdd0_correct(a: Int): a +(solveAdd0 a)=0
+:= by simp[solveAdd0]
+
+def solveSub(a b:Int): Int
+:= a-b
+
+theorem solveSub_correct(a b:Int): a - (solveSub a b)=b
+:= by simp[solveSub]
+
+def solve1x1(a b: Rat): Option Rat :=
+  if a = 0 then
+    if b=0 then
+      some 0
+    else
+      none
+  else
+    some (b/a)
+
+theorem solve1x1_correct(a b:Rat): (∃ x, a*x=b) -> a * (solve1x1 a b).get! =b
+:= by
+    intro hsol
+    simp[solve1x1]
+    split_ifs
+    next hb=>simp[hb]
+    next ha hb=> simp[ha] at hsol; rw[hsol] at hb; contradiction
+    next ha=>
+      simp
+      simp[Rat.div_def]
+      simp[Rat.mul_comm b]
+      simp[← Rat.mul_assoc]
+      have: a*a.inv=1 :=by{
+        have hainv: a⁻¹ = a.inv :=by {
+          exact rfl
+        }
+        rw[← hainv]
+        rw[Rat.mul_inv_cancel]
+        assumption
+      }
+      simp[this]
+
+theorem solve1x1_none(a b:Rat): (Not (∃ x, a*x=b)) -> solve1x1 a b=none
+:= by
+    intro h
+    simp[solve1x1]
+    split_ifs
+    next ha hb=> simp[ha] at h;rw[hb] at h; contradiction
+    next=>rfl
+    next ha=>
+      contrapose! h
+      use b/a
+      exact mul_div_cancel₀ b ha
+
+def solveMul(a: Rat): Rat
+:= if a=0 then 0 else 1/a
+
+theorem solveMul_correct(a:Rat): (∃ x, a*x=1)->a * (solveMul a)=1
+:= by
+    intro h
+    simp[solveMul]
+    split
+    next ha=>
+      simp[ha] at h
+    next ha=>
+      exact Rat.mul_inv_cancel a ha
+
+theorem solveMul_nosol (a:Rat): (Not (∃ x, a*x=1)) ->solveMul a =0
+:= by
+    intro h
+    simp[solveMul]
+    contrapose! h
+    use 1/a
+    exact mul_one_div_cancel h
+
+def solveDiv(a b:Rat) (ha: a≠ 0)(hb: b≠ 0): Rat
+:= a/b
+
+theorem solveDiv_correct(a b:Rat)(ha:a≠ 0)(hb: b≠ 0):
+a / (solveDiv a b ha hb)= b
+:= by
+    simp[solveDiv]
+    rw[← div_mul]
+    rw[div_self (by simp[ha])]
+    simp
+
+def isPrime(a: Nat): Bool
+:=
+  if a<=1 then false
+  else
+    let rec helper (cur: Nat):Bool:=
+      if cur>=a then true
+      else if a%cur=0 then false
+      else helper (cur+1)
+      termination_by a-cur
+      decreasing_by{
+        simp_wf
+        have hacur: a>cur:=by omega
+        exact Nat.sub_succ_lt_self a cur hacur
+      }
+    helper 2
+
+
+theorem isPrime_correct(a: Nat):
+  (isPrime a) <-> Nat.Prime a := by{
+    constructor
+    · {
+      unfold isPrime
+      split
+      simp
+      have: ∀ cur:Nat, cur>=2->(∀x:Nat, (x>=2 ∧  x< cur)-> a%x !=0) ->isPrime.helper a cur ->a.Prime:=by {
+        intro cur
+        intro hcur2
+        induction cur using isPrime.helper.induct
+        exact a
+        next ha1 c hcga =>
+          have hhelp: isPrime.helper a c =true:=by {
+            unfold isPrime.helper
+            simp[hcga]
+          }
+          simp[hhelp]
+          contrapose!
+          intro hnp
+
+          apply Nat.exists_dvd_of_not_prime2 at hnp
+          rcases hnp with ⟨ k, hnp'⟩
+          use k
+          simp[hnp']
+          omega
+          omega
+
+
+        next ha c hca hmod =>
+          have hhelp: isPrime.helper a c=false:=by{
+            unfold isPrime.helper
+            simp[hmod,hca]
+          }
+          simp[hhelp]
+
+        next ha c hca hmod ih =>
+          unfold isPrime.helper
+          split
+          simp
+          have: c>=a :=by assumption
+          contradiction
+          have: c+1>=2 :=by omega
+          simp[ this] at ih
+          simp
+          intro hx
+          apply ih
+          intro x
+          intro hx2
+          intro hxlt
+          cases hc1x: c-x
+
+          have: c=x :=by {
+            omega
+
+          }
+          rw[← this]
+          assumption
+          have: x<c :=by{
+            omega
+          }
+          apply hx
+          assumption
+          assumption
+        }
+
+
+      apply this
+      omega
+      intro x
+      omega
+
+    }
+    next=>
+      contrapose!
+      unfold isPrime
+      split
+      simp
+      have: a<=1 :=by assumption
+      have ha2: a ≠  2 :=by omega
+      have ha3: a≠ 3 :=by omega
+      intro hp
+      have h5p: 5<=a :=by {
+        exact Nat.Prime.five_le_of_ne_two_of_ne_three hp ha2 ha3 --Prime.five_le_of_ne_two_of_ne_three a hp ha2 ha3
+      }
+      omega
+      have: ∀cur: Nat, cur>=2 ->isPrime.helper a cur ≠ true ->¬ a.Prime :=by{
+        intro cur
+        intro hcur2
+        induction cur using isPrime.helper.induct
+        exact a
+        next ha1 x hxa=>
+          unfold isPrime.helper
+          simp[hxa]
+
+
+        next ha1 x hxa hmod =>
+          unfold isPrime.helper
+          simp[hxa,hmod]
+          have :x ∣ a :=by omega
+          have hxneqa: x≠ a :=by omega
+          have hxneq1: x≠ 1 :=by omega
+          exact Nat.not_prime_of_dvd_of_ne this hxneq1 hxneqa
+
+        next ha1 x hxa hmod ih=>
+          unfold isPrime.helper
+          simp[hxa,hmod]
+          simp at ih
+          apply ih
+          omega
+
+      }
+      apply this
+      omega
+
+}
+
+def modInv(a: Nat) (p:Nat)(hp:p.Prime): Option Nat
+:=
+  if a%p=0 then
+    none
+  else
+    let expn:Nat := p-2
+    some ( (a^expn) %p)
+
+theorem modInv_correct(a:Nat) (p:Nat)(hp:p.Prime):
+  (∃ x:Nat, (a*x)%p=1)->(a*(modInv a p hp).get!)%p=1 :=by{
+    intro hexist
+    have han0: a%p ≠ 0:=by{
+      contrapose! hexist
+      intro x
+      have: (a*x)%p =(a%p *x)%p:=by{
+        simp[Nat.mod_mul_mod]
+        --exact Eq.symm (Nat.mod_mul_mod a x ↑p)
+      }
+      rw[hexist] at this
+      simp[this]
+    }
+    unfold modInv
+    simp[han0]
+    --simp[Option.get!]
+    have hp2:p>=2 :=by{
+      exact Nat.Prime.two_le hp
+    }
+    have hm:a*a^(p-2)=a^(p-1) :=by{
+      calc
+        a*a^(p-2)= a^1 *a^(p-2):=by {simp}
+        _=a^(1+(p-2)) :=by{exact Eq.symm (Nat.pow_add a 1 (p - 2))}
+        _=a^(p-1) :=by{
+          have: 1+(p-2)=p-1:=by omega
+          exact congrArg (HPow.hPow a) this
+        }
+    }
+    simp[hm]
+
+      --Fermat's little theorem
+      --from Mathlib.FieldTheory.Finite
+    have hcop: IsCoprime (a:Int) p :=by{
+        refine Nat.isCoprime_iff_coprime.mpr ?_
+        have: ¬ p ∣ a :=by{omega}
+        refine Nat.coprime_iff_isRelPrime.mpr ?_
+        have hrp:= (Irreducible.isRelPrime_iff_not_dvd  hp).mpr  this
+        exact
+          IsRelPrime.symm hrp
+    }
+    have:= Int.ModEq.pow_card_sub_one_eq_one  hp hcop
+    have pz:((a:Int)^(p-1))%(p:Int)=1%(p:Int):=by{
+      exact this
+    }
+    --contrapose this
+    --intro hzmod
+    have h1mp: 1%(p:Int)=1 :=by{
+      refine Int.emod_eq_of_lt ?H1 ?H2
+      omega
+      omega
+    }
+    rw[h1mp] at pz
+
+    norm_cast at pz
+
+}
+
+theorem modInv_none(a:Nat) (p:Nat)(hp:p.Prime): (Not (∃ x, (a*x)%p=1))-> modInv a p hp=none
+:=by
+    intro h
+    simp[modInv]
+    contrapose! h
+    refine Nat.exists_mul_emod_eq_one_of_coprime ?hkn ?hk
+    refine Nat.coprime_iff_isRelPrime.mpr ?_
+    have: ¬ p ∣ a :=by{omega}
+    have hrp:= (Irreducible.isRelPrime_iff_not_dvd  hp).mpr this
+    exact IsRelPrime.symm hrp
+    exact Nat.Prime.one_lt hp
+
+def minFacT(a:Nat) (h: a>1)
+: {x:Nat//x>1∧ x ∣ a∧ Not (∃ y>1, y∣a ∧  y<x)}
+:=
+  let lst:= List.range (a+1)
+  let res:=lst.find? (fun x=> x>1 ∧  x∣ a)
+  have : res.isSome :=by{
+    refine (@List.find?_isSome _ lst fun x => decide (x > 1 ∧ x ∣ a)).mpr ?_
+    use a
+    constructor
+    exact List.self_mem_range_succ a
+    simp[h]
+  }
+  let r:=res.get this
+  ⟨r, by{
+        have hf:lst.find? (fun x=> x>1 ∧  x∣ a)=some r:=by{
+          exact Eq.symm (Option.some_get this)
+        }
+        have lem := @List.find?_range_eq_some (a+1) _ _|>.mp hf
+        simp at lem
+        constructor
+        simp[lem.left]
+        constructor
+        simp[lem.left]
+        have lr:=lem.right
+        rcases lr with ⟨ _,lr'⟩
+        intro hy
+        rcases hy with ⟨ y , hy'⟩
+        have:= lr' y hy'.2.2
+        rcases this <;> omega
+  }⟩
+
+def minFac(a:Nat) (h: a>1):Nat
+:= minFacT a h
+
+theorem minFac_isfac(a:Nat)(h: a>1): ( (minFac a h) ∣  a) ∧  (minFac a h>1)
+:=by
+    simp[minFac]
+    let r:=minFacT a h
+    simp[r.2]
+
+theorem minFac_ismin(a:Nat)(h:a>1): Not (∃ y>1,( y ∣ a) ∧  y<minFac a h)
+:=by
+    simp[minFac]
+    let r:=minFacT a h
+    have:=r.2.2.2
+    intro x h1 hdvd
+    simp at this
+    have:=this x h1 hdvd
+    simp[r,this]
+
+
+def midPoint (x1 y1 x2 y2: Rat):Rat × Rat
+:=((x1+x2)/2, (y1+y2)/2)
+
+def distSq( x1  y1 x2 y2: Rat):Rat:=
+  (x1-x2)^2 + (y1-y2)^2
+
+theorem midPoint_correct (x1 y1 x2 y2: Rat)
+: let (xmid,ymid) :=midPoint x1 y1 x2 y2
+distSq xmid ymid x1 y1=distSq xmid ymid x2 y2
+∧ 4*(distSq xmid ymid x1 y1)=distSq x1  y1 x2 y2
+:=by
+  simp[midPoint,distSq]
+  constructor <;> ring_nf
+
+
+def GCD (x y: Nat): Nat :=
+
+    if y = 0 then
+      x
+    else
+      GCD y (x % y)
+    termination_by y
+    decreasing_by {
+      simp_wf
+      apply Nat.mod_lt _
+      refine Nat.zero_lt_of_ne_zero ?_
+      assumption
+    }
+
+theorem gcd_is_div (x y: Nat):
+  (p: x > 0)→ ((GCD x y) ∣ x) ∧ ((GCD x y) ∣ y) := match y with
+  | 0 => by  {
+    simp[GCD]
+  }
+  | Nat.succ z =>by {
+    have hyp: z.succ>0 := by {
+      exact Nat.zero_lt_succ z
+    }
+    have ih := gcd_is_div z.succ (x % z.succ)
+    have ihh := ih hyp
+    have heq: GCD x z.succ = GCD z.succ (x%z.succ) :=by{
+      rw[GCD.eq_def]
+      tauto
+    }
+    intro hx
+    simp[heq, ihh]
+    rcases ihh.right with ⟨k, ihh' ⟩
+
+    have hq: x = (GCD z.succ (x%z.succ))*k +z.succ*(x/z.succ) :=by{
+      rw[← ihh']
+      exact Eq.symm (Nat.mod_add_div x z.succ)
+    }
+    rcases ihh.left with ⟨ m, ihhl'⟩
+    use  (x/z.succ) * m + k
+    rw[Nat.mul_add]
+    rw[Nat.mul_comm,  Nat.mul_assoc]
+    rw[Nat.mul_comm m]
+    rw[← ihhl']
+    rw[Nat.mul_comm]
+    rw[Nat.add_comm]
+    have hz: z+1 = z.succ :=by omega
+    rw[hz]
+    omega
+  }
+  termination_by y
+  decreasing_by {
+      simp_wf
+      apply Nat.mod_lt _
+      refine Nat.zero_lt_of_ne_zero ?_
+      tauto
+  }
+
+theorem gcd_is_greatest (x y: Nat):
+  (x>0) → Not (∃ z: Nat, z∣ x ∧ z∣ y ∧ z> GCD x y ) := match y with
+  | 0 => by {
+    have hgcd0: GCD x 0 = x :=by {
+      simp[GCD]
+    }
+    intro hx
+    intro hh
+    rcases hh with ⟨z0, hh' ⟩
+    have hzx: z0 ≤ x :=by{
+      have hzdx: z0∣ x:=by {tauto}
+      rcases hzdx with ⟨k, hzdx'⟩
+      have hk: k>0 :=by{
+        contrapose hx
+        have hk0: k=0 := by omega
+        have hx0: x=0:= by simp[hzdx', hk0]
+        omega
+      }
+      have hkg1: k>=1:=by{omega}
+      rw[hzdx']
+      have hz0: z0=z0*1:=by {omega}
+      nth_rewrite 1 [hz0]
+      exact Nat.mul_le_mul_left z0 hk
+    }
+    have: z0>GCD x 0:=by{tauto}
+    rw[hgcd0] at this
+    omega
+  }
+  | Nat.succ yy => by{
+    intro hx
+    intro hh
+    rcases hh with ⟨z0, hh' ⟩
+    have ih:=gcd_is_greatest yy.succ (x%yy.succ)
+    have hyg0: yy.succ>0 :=by{omega}
+    have ihh:= ih hyg0
+    have hgcd: GCD x yy.succ = GCD yy.succ (x%yy.succ) := by {
+      rw[GCD.eq_def]
+      tauto
+    }
+    contrapose! ihh
+    use z0
+    have hzg: z0> GCD yy.succ (x%yy.succ):= by {
+      omega
+    }
+    simp[hzg, hh']
+    have hzx: z0∣ x:=by tauto
+    rcases hzx with ⟨ k, hzx'⟩
+    have hzy: z0 ∣ yy.succ :=by tauto
+    rcases hzy with ⟨ m, hzy' ⟩
+    have hmod:  x%yy.succ + yy.succ * (x/yy.succ) =x :=by{
+      exact   Nat.mod_add_div x yy.succ
+    }
+    refine (Nat.dvd_mod_iff ?h.intro.intro.h).mpr ?h.intro.intro.a
+    tauto
+    tauto
+  }
+  termination_by y
+  decreasing_by {
+      simp_wf
+      apply Nat.mod_lt _
+      refine Nat.zero_lt_of_ne_zero ?_
+      tauto
+  }
+
+
+def solveProg(t:Nat):Nat
+:=
+  let rec loop (i:{i':Nat//¬ ∃ i'' < i',i''*(i''+1)>=t*2}) (acc:{a:Nat//a*2=i.val*(i.val+1)})
+  :{x:Nat//x*(x+1)>=t*2∧ ¬ ∃ y<x, y*(y+1)>=t*2}:=
+    have ih:=acc.2
+    have iih:=i.2
+    if h:acc>=t then
+      ⟨i, by constructor;omega;exact iih⟩
+    else
+      have hi: Not (i.val*(i.val+1)>=t*2):=by{
+        rw[← ih]
+        simp[h]
+      }
+      have: ¬∃ i'' < i.val + 1, i'' * (i'' + 1) ≥ t * 2:=by{
+        simp
+        intro x hx
+        by_cases x < i.val
+        next hlt=> simp at iih;  exact iih x hlt
+        next hlt=>
+          have : x=i:=by omega
+          rw[this]
+          simpa using hi
+      }
+      loop ⟨i.val+1,this⟩  ⟨acc.val+i.val+1, by ring_nf;rw[ih];ring⟩
+    termination_by t-acc
+    decreasing_by{
+      simp_wf
+      refine Nat.sub_lt_sub_left (by omega) (by omega)
+    }
+  loop ⟨ 0, by omega⟩  ⟨ 0, by simp⟩
+
+theorem solveProg_isgeq(t:Nat): (solveProg t)*((solveProg t)+1) >= t*2
+:=by
+    simp[solveProg]
+    have ih:=(solveProg.loop t ⟨ 0,by omega⟩  ⟨0, solveProg.proof_2⟩).2
+    omega
+
+theorem solveProg_ismin(t:Nat): Not (∃ y< (solveProg t), y*(y+1)>=t*2)
+:=by
+    simp[solveProg]
+    have ih:=(solveProg.loop t ⟨ 0,by omega⟩  ⟨0, solveProg.proof_2⟩).2
+    simp at ih
+    exact ih.right
+
+
+def solveGeom(a t:Nat)(h:a>1):Nat
+:=
+  let rec loop (h:a>1)(i:{i':Nat//¬ ∃i'' < i',a^(i''+1)-1>=t*(a-1)})(acc:{acc':Nat//a^(i.val+1)-1=acc'*(a-1)})
+  :{x:Nat//a^(x+1)-1>=t*(a-1)∧ ¬∃ y<x,a^(y+1)-1>=t*(a-1)}:=
+    have ih:=acc.2
+    have iih:=i.2
+    if hge:acc>=t then
+      ⟨i, by rw [ih];constructor;exact Nat.mul_le_mul_right (a - 1) hge; exact iih⟩
+    else
+      let newacc:=acc+a^(i.val+1)
+      have : a^(i.val+2)-1=newacc *(a-1):=by{
+        ring_nf
+        rw[← ih]
+        ring_nf
+        have : 0<  a * a ^ i.val :=by refine Nat.mul_pos (by omega) (by refine Nat.pow_pos (by omega))
+        rw[← Nat.add_sub_assoc (by omega) (a * a ^ i.val * (a - 1))]
+        ring_nf
+        have: a * a ^ i.val+a * a ^ i.val * (a - 1)  =a * a ^ i.val*a:=by{
+          have lem:=Nat.mul_one (a * a ^ i.val)
+          nth_rewrite 1 [← lem]
+          rw[← Nat.mul_add (a*a^i.val) 1]
+          have: 1+(a-1)=a:=by omega
+          rw[this]
+        }
+        rw[this]
+        ring_nf
+      }
+      have hopt:¬∃ i'' < i.val + 1, a ^ (i'' + 1) - 1 ≥ t * (a - 1):=by{
+        simp
+        intro x xh
+        by_cases x < i.val
+        next hlt=> simp at iih; exact iih x hlt
+        next hlt=>
+          have hxi: x=i :=by omega
+          simp at hge
+          rw[hxi,ih]
+          refine Nat.mul_lt_mul_of_pos_right hge (by simp[h])
+      }
+      loop h ⟨i.val+1, hopt⟩  ⟨newacc,this ⟩
+    termination_by t-acc
+    decreasing_by{
+      simp_wf
+      refine Nat.sub_lt_sub_left (by omega) ?_
+      have: a^(i.val+1)>0 :=by{
+        refine Nat.pow_pos (by omega)
+      }
+      omega
+    }
+  loop h ⟨0, by simp⟩  ⟨1, by ring_nf⟩
+
+theorem solveGeom_isgeq(a t:Nat)(h:a>1): a^((solveGeom a t h)+1)-1 >=t*(a-1)
+:=by
+    simp[solveGeom]
+    have:=(solveGeom.loop a t h h ⟨0, by simp⟩  ⟨1, by ring_nf⟩).2
+    simp[this]
+
+theorem solveGeom_ismin(a t:Nat)(h:a>1): Not (∃ y<solveGeom a t h, a^(y+1)-1>= t*(a-1))
+:=by
+    simp[solveGeom]
+    have:=(solveGeom.loop a t h h ⟨0, by simp⟩  ⟨1, by ring_nf⟩).2.2
+    simp at this
+    exact this
+
+
+def solveSquare(t:Nat): Nat
+:=
+  let rec loop (i:{i':Nat//¬ ∃ i'' < i', i''*i''>=t})
+  :{x:Nat//x*x>=t∧ ¬ ∃ y<x, y*y>=t} :=
+    have iih:=i.2
+    if hcomp: i*i>=t then
+      ⟨ i, by simp[hcomp];simp at iih;exact iih⟩
+    else
+      loop ⟨i+1,
+            by{
+                simp
+                intro x hx
+                by_cases x < i.val
+                next hlt=> simp at iih; exact iih x hlt
+                next hlt=>
+                  have hxi: x=i.val :=by omega
+                  rw[hxi]
+                  omega
+            }⟩
+    termination_by t-i*i
+    decreasing_by{
+      simp_wf
+      refine Nat.sub_lt_sub_left (by omega) (by ring_nf;omega)
+    }
+  loop ⟨0, by simp⟩
+
+theorem solveSquare_isgeq(t:Nat): (solveSquare t)*(solveSquare t)>=t
+:=by
+    simp[solveSquare]
+    have:=(solveSquare.loop t ⟨0, by simp⟩).2
+    simp[this]
+
+theorem solveSquare_ismin(t:Nat): Not (∃ y< (solveSquare t), y*y>=t)
+:=by
+    simp[solveSquare]
+    have:=(solveSquare.loop t ⟨0, by simp⟩).2.2
+    simp at this
+    exact this
+
+def f[Monad m] (op: Nat->Nat->(m Nat)) (n: Nat): (m Nat)
+:=
+  match n with
+  | 0 => pure 1
+  | 1 => pure 1
+  | n + 2 =>
+    do
+      let x ← f op (n + 1)
+      let y ← f op n
+      op x y
+
+
+theorem f_base (op : Nat → Nat → Id Nat) :
+    (f op 0 = pure 1) ∧  (f op 1 = pure 1)
+:= by constructor <;> rfl
+
+
+theorem f_recursive (op : Nat → Nat → Id Nat) (n : Nat) : f op (n+2) =do {op (←  f op (n+1)) (←  f op n) }
+:= by rfl
+
+def rev(xs: List Int): List Int
+:= match xs with
+  |[] => []
+  |h::t => (rev t) ++ [h]
+
+theorem reverse_correct(xs:List Int):
+  xs.length=(rev xs).length ∧
+  ∀ i<xs.length, xs[i]! =(rev xs)[xs.length-1-i]!
+  :=by{
+    induction xs
+    next=>simp[rev]
+    next h t ih=>
+    constructor
+    · {
+        simp[rev,ih]
+    }
+    · {
+        simp[rev]
+        intro i
+        have hlen: (rev t).length=t.length:=by{
+            simp [ih.left]
+        }
+        cases i with
+        |zero=>
+          simp
+          have :t.length<(rev t ++[h]).length :=by{
+            exact List.get_of_append_proof rfl hlen
+          }
+          have hind:(rev t ++ [h])[t.length]! =(rev t ++ [h])[t.length] :=by{
+            exact getElem!_pos (rev t ++ [h]) t.length this
+          }
+          simp[hind]
+          exact Eq.symm (List.getElem_concat_length (rev t) h t.length (id (Eq.symm hlen)) this)
+        |succ i'=>
+          simp
+          have:= ih.right i'
+          intro hi'
+          simp[hi'] at this
+
+          have hlind:t.length-1-i'=t.length - (i' + 1) :=by{
+            omega
+          }
+          have hh: (rev t)[t.length - 1 - i']! =(rev t ++ [h])[t.length - (i' + 1)]! :=by{
+            simp[hlind]
+            have hlt:t.length - (i' + 1)<(rev t).length :=by{
+              simp[hlen]
+              omega
+            }
+            have hl':(rev t)[t.length - (i' + 1)]! =(rev t)[t.length - (i' + 1)] :=by{
+              exact getElem!_pos (rev t) (t.length - (i' + 1)) hlt
+            }
+            have hrlen: (rev t ++ [h]).length>(rev t).length:=by {
+              exact
+                List.get_of_append_proof rfl rfl
+            }
+            have hrlt: t.length - (i' + 1)<(rev t ++ [h]).length :=by{
+              omega
+            }
+            have hr': (rev t ++ [h])[t.length - (i' + 1)]! =(rev t ++ [h])[t.length - (i' + 1)] :=by{
+              refine getElem!_pos (rev t ++[h]) (t.length - (i' + 1)) ?_
+
+            }
+            simp[hr',hl']
+            refine Eq.symm (List.getElem_append_left (as:= rev t) (bs:=[h]) ?_)
+            omega
+          }
+          omega
+
+
+    }
+
+  }
+
+
+def maxProp(xs:List Int)(x:Int):=
+  x∈ xs ∧∀ y∈ xs, x≥ y
+
+def findMaxA (xs: List Int): Option <| Subtype <| maxProp xs :=
+  match hm: xs.attach with
+  |[]=>none
+  |h::t=>
+
+    let rec helper (curr: {y//y∈ xs})(rest:List {y//y∈ xs})
+    :{y//y∈ xs ∧ ∀ y'∈ curr::rest, y'<=y}:=
+      match rest with
+      |[]=> ⟨curr, by simp[maxProp,curr.2]⟩
+      |rh::rt=>
+        let newmax:= if rh.val>curr.val then rh else curr
+        let r:=helper newmax rt
+        have ih:=r.2
+        have ihr:=ih.right
+        ⟨ r, by {
+                simp[ih]
+
+                have:=ihr newmax (by simp)
+                have hgeq: newmax.val>=curr.val∧ newmax.val >=rh.val:=by{
+                  simp[newmax]
+                  split <;> constructor<;> try simp
+                  next hsplit=> exact le_of_lt hsplit
+                  next hsplit=>simp at hsplit; exact hsplit
+                }
+                constructor
+                omega
+                constructor
+                omega
+                intro a b hab
+                have:=ihr ⟨ a,b⟩ (by simp[hab])
+                simp[this]
+        }⟩
+
+    let res:=helper h t
+    have ih:=res.2
+    have ihr:=ih.right
+    some ⟨ res, by {
+                  simp[maxProp,ih]
+                  intro y yh
+                  let yy:{x//x∈xs}:=⟨ y,yh⟩
+                  have hin:yy∈ h::t :=by{
+                    rw[← hm]
+                    exact List.mem_attach xs yy
+                  }
+                  have:= ihr yy hin
+                  simp[this]
+                  }⟩
+
+def findMax (xs : List Int) : Option Int
+:= match xs with
+|[]=>none
+|h::t=> findMaxA (h::t)
+
+
+theorem findMax_correct(x: Int) (xs : List Int):
+  ∃ max∈ (x::xs),
+    And (findMax (x::xs) = some max) (∀ y ∈ (x::xs) , y ≤ max)
+:=by
+    simp only[findMax,pure]
+    have hsome: findMaxA (x::xs)|>.isSome :=by exact rfl
+    match hm: findMaxA (x::xs) with
+    |none=>contradiction
+    |some y=>
+      use y
+      simp
+      have:=y.2
+      simp[maxProp] at this
+      exact this
+
+
+
+theorem findMax_base : findMax [] = none
+:=by
+    unfold findMax
+    simp only [findMaxA]
+
+abbrev minSol(xs:List Int):=
+  {x:Int//x∈xs ∧ ∀ y∈ xs, y>=x}
+
+def findMinTyped (xs : List Int)
+: {r:Option  (minSol xs) // r=none ↔ xs=[]}
+:=match hm:xs with
+|[]=> ⟨ none, by simp⟩
+|h::t=>
+  let rest:=findMinTyped t
+  match hr: rest with
+  |⟨ none, hn⟩  =>
+    let sol:minSol (h::t) :=⟨ h, by simp[hm]; simp at hn; simp[hn] ⟩
+    ⟨ some sol, by simp ⟩
+  |⟨some r,_⟩  =>
+    let newmin:{y:Int//y∈ h::t∧ y≤ h ∧ y≤ r}:=if hcomp:h<r then ⟨h,by simp;omega⟩  else ⟨r,by simp[r.2];omega⟩
+    have ih:=r.2
+    let sol:minSol (h::t):=
+      ⟨ newmin,
+      by constructor;exact newmin.2.left;simp[newmin.2];intro a ha;have:=ih.right a ha; omega
+      ⟩
+    ⟨ some sol, by simp⟩
+
+def findMin (xs:List Int):Option Int
+:=match xs with
+|[]=>none
+|h::t=>findMinTyped (h::t) |>.val
+
+theorem findMin_correct(x: Int) (xs : List Int):
+  ∃ min∈ (x::xs),
+    And (findMin (x::xs) = some min) (∀ y ∈ (x::xs) , y >= min)
+:=by
+    simp only [findMin,pure]
+    --have hsome: findMinTyped (x::xs)|>.val.isSome :=by sorry
+    match hm: findMinTyped (x::xs) with
+    |⟨ none, hn⟩ =>simp at hn
+    |⟨ some y,_⟩ =>
+      use y
+      simp
+      have :=y.2
+      constructor;simpa using this.left;simpa using this.right
+
+theorem findMin_base : findMin [] = none
+:=by exact rfl
+
+def isIn (x:Int) (xs: List Int):Bool
+  := match xs with
+  |[] => false
+  |h::t => x==h || isIn x t
+
+def isIn_correct (x:Int)(xs:List Int):
+  isIn x xs = true ↔ x∈ xs := by{
+    induction xs with
+    |nil=> simp[isIn]
+    |cons h t ih=> simp[isIn,ih]
+  }
+
+
+def countEq (x:Int)(xs:List Int):Nat
+:= match xs with
+  |[]=>0
+  |h::t =>
+    let c:= if h=x then 1 else 0
+    (countEq x t) + c
+
+def countEq_correct (x:Int)(xs:List Int):
+  List.count x xs = countEq x xs
+:=by{
+    induction xs with
+    |nil =>rfl
+    |cons h t ih=>
+      simp[countEq]
+      have lem:=List.count_cons x h t
+      rw[← ih]
+      rw[lem]
+      simp
+  }
+
+def findIfT(xs:List Int)(p:Int->Bool)
+:{oi:Option Int//
+if (∃ x∈ xs, p x) then ∃ y∈ xs, oi=some y ∧ p y
+else oi=none}
+:=match xs with
+  |[]=>⟨ none, by exact rfl⟩
+  |h::t=>
+    if hp: (p h=true) then
+      ⟨ some h, by simp[hp]⟩
+    else
+      let rest:=findIfT t p
+      ⟨ rest, by simp[hp,rest.2]⟩
+
+def findIf(xs:List Int)(p:Int->Bool):Option Int
+:=findIfT xs p
+
+theorem findIf_some(xs:List Int)(p:Int->Bool):
+  (∃ x∈ xs, p x) -> ∃ y∈ xs, findIf xs p=some y ∧ p y
+:=by
+    simp only [findIf]
+    have:=(findIfT xs p).2
+    intro h
+    simp[h] at this
+    exact this
+
+
+theorem findIf_none(xs:List Int)(p:Int->Bool):
+  (¬ ∃ y∈ xs, p y =true)-> findIf xs p=none
+:=by
+    simp only [findIf]
+    have:=(findIfT xs p).2
+    intro h
+    simp[h] at this
+    exact this
+
+def filterIf(xs:List Int)(p:Int->Bool):List Int
+:=
+  match xs with
+  |[] => []
+  |h::t =>
+    if p h then
+       h::(filterIf t p)
+    else
+      filterIf t p
+
+
+theorem filterIf_correct(xs:List Int)(p:Int->Bool):
+  filterIf xs p = List.filter p xs
+:=by
+    induction xs with
+    |nil=> simp[filterIf]
+    |cons h t ih=>
+      simp[List.filter_cons]
+      simp[filterIf]
+      rw[ih]
+
+def mapInt(xs:List Int)(f:Int->Int):List Int
+:=match xs with
+  |[]=>[]
+  |h::t=> (f h) :: (mapInt t f)
+
+theorem mapInt_correct(xs:List Int)(f:Int->Int)
+: (mapInt xs f).length=xs.length
+∧  ∀ i:Fin xs.length, (mapInt xs f)[i]! = f xs[i]
+:=by
+    induction xs with
+    |nil=>simp[mapInt]
+    |cons h t ih=>
+      have hsize:(mapInt (h :: t) f).length = (h :: t).length :=by{
+        simp[mapInt,ih]
+      }
+      constructor
+      · exact hsize
+      · {
+        intro i
+        have hil:i<(mapInt (h :: t) f).length :=by{
+          simp[hsize]
+        }
+        have: (mapInt (h :: t) f)[i]! =(mapInt (h :: t) f)[i] :=by{
+          exact getElem!_pos (mapInt (h :: t) f) i hil
+        }
+        rw[this]
+        rcases i with ⟨i',hi⟩
+        cases i'
+        next=>
+          simp[mapInt]
+
+        next n=>
+          simp[mapInt]
+          have:=ih.right ⟨ n,by simp at hi;exact hi⟩
+          simp at this
+          rw[← this]
+          symm
+          exact getElem!_pos (mapInt t f) n (by simp at hi; omega)
+
+      }
+
+def isPrefix (p xs:List α):=
+  List.take p.length xs = p
+
+/- longest common prefix for a pair of lists-/
+def lcpPair(xs ys:List Int )
+:{zs:List Int//isPrefix zs xs∧ isPrefix zs ys
+   ∧ (∀zz, isPrefix zz xs∧ isPrefix zz ys->zz.length<=zs.length)}
+:=match xs,ys with
+  |[],_=>⟨ [],by simp[isPrefix]⟩
+  |_,[]=>⟨ [],by simp[isPrefix]⟩
+  |xh::xt, yh::yt=>
+    if heq: xh=yh then
+      let rest:=lcpPair xt yt
+      ⟨ xh:: rest,
+        by{
+          have:=rest.2
+          constructor
+          ·  simpa[isPrefix,rest,heq] using this.1
+          · {
+            constructor
+            · simpa[isPrefix,rest,heq] using this.2.1
+            ·{
+              intros zz hxy
+              cases zz
+              next=>
+                have: ([]:List Int).length=0:=by exact rfl
+                rw[this]
+                omega
+              next h t=>
+                simp[isPrefix] at hxy
+                have ih:=this.2.2
+                have ht:isPrefix t xt∧ isPrefix t yt:=by {
+                  simp[isPrefix,hxy]
+                }
+                have ihh:=ih _ ht
+                simp[ihh]
+            }
+          }
+
+        }
+      ⟩
+    else
+      ⟨ [],
+        by {
+          simp[isPrefix]
+          intros zz hx hy
+          cases zz
+          next=>rfl
+          next h t=>
+            simp at hx
+            simp at hy
+            have : xh=yh :=by simp[hx,hy]
+            contradiction
+        }
+      ⟩

easy.jsonl

@@ -0,0 +1,24 @@
+{"description": "write a function that, given integers a and b, returns an integer x such that a + x = b", "function_signature": "def solveAdd (a b:Int): Int", "test_cases": null, "theorem_signature": "theorem solveAdd_correct (a b: Int): a + (solveAdd a b) =b ", "theorem2_signature": null}
+{"description": "write a function that, given integer a, returns an integer x such that a + x = 0", "function_signature": "def solveAdd0(a:Int): Int", "test_cases": null, "theorem_signature": "theorem solveAdd0_correct(a: Int): a +(solveAdd0 a)=0", "theorem2_signature": null}
+{"description": "write a function that, given integers a and b, returns an integer x such that a - x = b", "function_signature": "def solveSub(a b:Int): Int", "test_cases": null, "theorem_signature": "theorem solveSub_correct(a b:Int): a - (solveSub a b)=b", "theorem2_signature": null}
+{"description": "write a function that, given rationals a and b, return some x such that a*x=b. if no solution exists, return none", "function_signature": "def solve1x1(a b: Rat): Option Rat", "test_cases": null, "theorem_signature": "theorem solve1x1_correct(a b:Rat): (∃ x, a*x=b) -> a * (solve1x1 a b).get! =b", "theorem2_signature": "theorem solve1x1_none(a b:Rat): (Not (∃ x, a*x=b)) -> solve1x1 a b=none"}
+{"description": "write a function that, given rational a, returns a rational x such that a*x=1. If no solution exists, return 0.", "function_signature": "def solveMul(a: Rat): Rat", "test_cases": null, "theorem_signature": "theorem solveMul_correct(a:Rat): (∃ x, a*x=1)->a * (solveMul a)=1", "theorem2_signature": "theorem solveMul_nosol (a:Rat): (Not (∃ x, a*x=1)) ->solveMul a =0"}
+{"description": "write a function that, given rationals a and b, both not equal to zero, return x such that a/x=b.", "function_signature": "def solveDiv(a b:Rat) (ha: a≠ 0)(hb: b≠ 0): Rat", "test_cases": null, "theorem_signature": "theorem solveDiv_correct(a b:Rat)(ha:a≠ 0)(hb: b≠ 0):\na / (solveDiv a b ha hb)= b", "theorem2_signature": null}
+{"description": "write a function isPrime that given a natural number a, returns true if and only if a is prime.", "function_signature": "def isPrime(a: Nat): Bool", "test_cases": null, "theorem_signature": "theorem isPrime_correct(a: Nat): (isPrime a)=True <-> Nat.Prime a", "theorem2_signature": null}
+{"description": "write a function that given a natrual number a and a prime number p, returns a natural number x such that (a*x)%p=1. if no solution exists, return none.", "function_signature": "def modInv(a: Nat) (p:Nat)(hp:p.Prime): Option Nat", "test_cases": null, "theorem_signature": "\ntheorem modInv_correct(a:Nat) (p:Nat)(hp:p.Prime):\n  (∃ x:Nat, (a*x)%p=1)->(a*(modInv a p hp).get!)%p=1", "theorem2_signature": "theorem modInv_none(a:Nat) (p:Nat)(hp:p.Prime): (Not (∃ x, (a*x)%p=1))-> modInv a p hp=none"}
+{"description": "write a function that given a natural number a, a>1, find the minimum factor of a that is not 1. ", "function_signature": "def minFac(a:Nat) (h: a>1): Nat ", "test_cases": null, "theorem_signature": "theorem minFac_isfac(a:Nat)(h: a>1): ( (minFac a h) ∣a) ∧(minFac a h>1)", "theorem2_signature": "theorem minFac_ismin(a:Nat)(h:a>1): Not (∃ y>1,( y ∣ a) ∧y<minFac a h)"}
+{"description": "write a function that, given rational number coordinates of two points x1, y1 and x2, y2, return the rational number coordinates of a point (xmid, ymid) such that: the distance betwee (xmid,ymid) and (x1, y1) is equal to the distance between (xmid,ymid) and (x2,y2), which is equal to half of the distance between (x1, y1) and (x2, y2).", "function_signature": "def midPoint (x1 y1 x2 y2: Rat):Rat × Rat", "test_cases": null, "theorem_signature": "def distSq( x1  y1 x2 y2: Rat):Rat:=\n  (x1-x2)^2 + (y1-y2)^2\n\ntheorem midPoint_correct (x1 y1 x2 y2: Rat)\n: let (xmid,ymid) :=midPoint x1 y1 x2 y2\ndistSq xmid ymid x1 y1=distSq xmid ymid x2 y2\n∧ 4*(distSq xmid ymid x1 y1)=distSq x1  y1 x2 y2", "theorem2_signature": null}
+{"description": "write a function that, given natural numbers a and b, computes their greatest common denominator.", "function_signature": "def GCD(a b:Nat):Nat", "test_cases": null, "theorem_signature": "\ntheorem gcd_is_div (x y: Nat):\n  (p: x > 0)→ ((GCD x y) ∣ x) ∧ ((GCD x y) ∣ y)", "theorem2_signature": "\ntheorem gcd_is_greatest (x y: Nat):\n  (x>0) → Not (∃ z: Nat, z∣ x ∧ z∣ y ∧ z> GCD x y )"}
+{"description": "write a function that, given natural number t, find the minimum n such that 1+2+…+n>=t.", "function_signature": "def solveProg(t:Nat):Nat", "test_cases": null, "theorem_signature": "theorem solveProg_isgeq(t:Nat): (solveProg t)*((solveProg t)+1) >= t*2", "theorem2_signature": "theorem solveProg_ismin(t:Nat): Not (∃ y< (solveProg t), y*(y+1)>=t*2)"}
+{"description": "write a function that, given natural numbers a and t, with a>1, find the minimum n such that a^0+a^1+..a^n >=t.", "function_signature": "def solveGeom(a t:Nat)(h:a>1):Nat", "test_cases": null, "theorem_signature": "theorem solveGeom_isgeq(a t:Nat)(h:a>1): a^((solveGeom a t h)+1)-1 >=t*(a-1)", "theorem2_signature": "theorem solveGeom_ismin(a t:Nat)(h:a>1): Not (∃ y<solveGeom a t h, a^(y+1)-1>= t*(a-1))"}
+{"description": "write a function that, given natural number t, find the minimum n such that n*n>=t.", "function_signature": "def solveSquare(t:Nat): Nat", "test_cases": null, "theorem_signature": "theorem solveSquare_isgeq(t:Nat): (solveSquare t)*(solveSquare t)>=t", "theorem2_signature": "theorem solveSquare_ismin(t:Nat): Not (∃ y< (solveSquare t), y*y>=t)"}
+{"description": "Implement the following in lean 4. Given a binary operator op, we define the function f : Nat->Nat to be: f 0 =1; f 1=1; f n = op (f (n-1)) (f (n-2)). Write a lean 4 function that, given the op and the natural number n as arguments, computes f n. Additionally, op returns a value wrapped in a monad. Your function should have the signature def f [Monad m] (op: Nat->Nat->(m Nat)) (n: Nat): (m Nat) :=", "function_signature": "def f[Monad m] (op: Nat->Nat->(m Nat)) (n: Nat): (m Nat)", "test_cases": null, "theorem_signature": "theorem f_base (op : Nat → Nat → Id Nat) :\n    (f op 0 = pure 1) ∧  (f op 1 = pure 1)", "theorem2_signature": "theorem f_recursive (op : Nat → Nat → Id Nat) (n : Nat) : f op (n+2) =do {op (←  f op (n+1)) (←  f op n) }"}
+{"description": "write a function that, given a List of integers, return the list in reverse order.", "function_signature": "def rev(xs: List Int): List Int", "test_cases": null, "theorem_signature": "theorem reverse_correct(xs:List Int):\n  xs.length=(rev xs).length ∧\n  ∀ i<xs.length, xs[i]! =(rev xs)[xs.length-1-i]!", "theorem2_signature": null}
+{"description": "write a function that, given a List of integers, finds its maximum", "function_signature": "def findMax (xs : List Int) : Option Int ", "test_cases": null, "theorem_signature": "\ntheorem findMax_correct(x: Int) (xs : List Int):\n  ∃ max∈ (x::xs),\n    And (findMax (x::xs) = some max) (∀ y ∈ (x::xs) , y ≤ max) ", "theorem2_signature": "theorem findMax_base : findMax [] = none"}
+{"description": "write a function that, given a List of integers, finds the minimum", "function_signature": "def findMin (xs : List Int) : Option Int ", "test_cases": null, "theorem_signature": "\ntheorem findMin_correct(x: Int) (xs : List Int):\n  ∃ min∈ (x::xs),\n    And (findMin (x::xs) = some min) (∀ y ∈ (x::xs) , y >= min) ", "theorem2_signature": "theorem findMin_base : findMin [] = none"}
+{"description": "write a function that, given an integer x and a List of integers, returns true if and only if x is in the List", "function_signature": "def isIn (x:Int) (xs: List Int):Bool", "test_cases": null, "theorem_signature": "def isIn_correct (x:Int)(xs:List Int):\n  isIn x xs = true ↔ x∈ xs", "theorem2_signature": null}
+{"description": "write a function that, given an integer x and a List of integers, returns the number of times that x appears in the list.", "function_signature": "\ndef countEq (x:Int)(xs:List Int):Nat", "test_cases": null, "theorem_signature": "def countEq_correct (x:Int)(xs:List Int):\n  List.count x xs = countEq x xs", "theorem2_signature": null}
+{"description": "write a function that, given a List of integers and a predicate function p that takes an integer and returns a boolean, returns an element of the list x if p x = true. If such x does not exist, return none", "function_signature": "def findIf(xs:List Int)(p:Int->Bool):Option Int", "test_cases": null, "theorem_signature": "\ntheorem findIf_some(xs:List Int)(p:Int->Bool):\n  (∃ x∈ xs, p x) -> ∃ y∈ xs, findIf xs p=some y ∧ p y", "theorem2_signature": "\ntheorem findIf_none(xs:List Int)(p:Int->Bool):\n  (¬ ∃ y∈ xs, p y =true)-> findIf xs p=none "}
+{"description": "write a function that, given a List of integers and a predicate function p that takes an integer and returns a boolean, returns another list consisting of elements  x of the original list such that  p x = true.", "function_signature": "def filterIf(xs:List Int)(p:Int->Bool):List Int", "test_cases": null, "theorem_signature": "\ntheorem filterIf_correct(xs:List Int)(p:Int->Bool):\n  filterIf xs p = List.filter p xs", "theorem2_signature": null}
+{"description": "write a function that, given a List of integers xs and a function f:Int->Int, returns a List of integers whose i-th element is f xs[i]", "function_signature": "def mapInt(xs:List Int)(f:Int->Int):List Int", "test_cases": null, "theorem_signature": "theorem mapInt_correct(xs:List Int)(f:Int->Int)\n: (mapInt xs f).length=xs.length\n∧  ∀ i:Fin xs.length, (mapInt xs f)[i]! = f xs[i]", "theorem2_signature": null}
+{"description": "Write a function that, given two lists of integers, find their longest common prefix.", "function_signature": "def isPrefix (p xs:List α):=\n  List.take p.length xs = p\n\n/- longest common prefix for a pair of lists-/\ndef lcpPair:(xs ys:List Int )\n->{zs:List Int//isPrefix zs xs∧ isPrefix zs ys\n   ∧ (∀zz, isPrefix zz xs∧ isPrefix zz ys->zz.length<=zs.length)}", "test_cases": null, "theorem_signature": null, "theorem2_signature": null}