Dataset Viewer
description
stringlengths 66
400
| function_signature
stringlengths 20
247
| test_cases
null | theorem_signature
stringlengths 53
241
β | theorem2_signature
stringlengths 40
106
β |
---|---|---|---|---|
write a function that, given integers a and b, returns an integer x such that a + x = b
|
def solveAdd (a b:Int): Int
| null |
theorem solveAdd_correct (a b: Int): a + (solveAdd a b) =b
| null |
write a function that, given integer a, returns an integer x such that a + x = 0
|
def solveAdd0(a:Int): Int
| null |
theorem solveAdd0_correct(a: Int): a +(solveAdd0 a)=0
| null |
write a function that, given integers a and b, returns an integer x such that a - x = b
|
def solveSub(a b:Int): Int
| null |
theorem solveSub_correct(a b:Int): a - (solveSub a b)=b
| null |
write a function that, given rationals a and b, return some x such that a*x=b. if no solution exists, return none
|
def solve1x1(a b: Rat): Option Rat
| null |
theorem solve1x1_correct(a b:Rat): (β x, a*x=b) -> a * (solve1x1 a b).get! =b
|
theorem solve1x1_none(a b:Rat): (Not (β x, a*x=b)) -> solve1x1 a b=none
|
write a function that, given rational a, returns a rational x such that a*x=1. If no solution exists, return 0.
|
def solveMul(a: Rat): Rat
| null |
theorem solveMul_correct(a:Rat): (β x, a*x=1)->a * (solveMul a)=1
|
theorem solveMul_nosol (a:Rat): (Not (β x, a*x=1)) ->solveMul a =0
|
write a function that, given rationals a and b, both not equal to zero, return x such that a/x=b.
|
def solveDiv(a b:Rat) (ha: aβ 0)(hb: bβ 0): Rat
| null |
theorem solveDiv_correct(a b:Rat)(ha:aβ 0)(hb: bβ 0):
a / (solveDiv a b ha hb)= b
| null |
write a function isPrime that given a natural number a, returns true if and only if a is prime.
|
def isPrime(a: Nat): Bool
| null |
theorem isPrime_correct(a: Nat): (isPrime a)=True <-> Nat.Prime a
| null |
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.
|
def modInv(a: Nat) (p:Nat)(hp:p.Prime): Option Nat
| null |
theorem modInv_correct(a:Nat) (p:Nat)(hp:p.Prime):
(β x:Nat, (a*x)%p=1)->(a*(modInv a p hp).get!)%p=1
|
theorem modInv_none(a:Nat) (p:Nat)(hp:p.Prime): (Not (β x, (a*x)%p=1))-> modInv a p hp=none
|
write a function that given a natural number a, a>1, find the minimum factor of a that is not 1.
|
def minFac(a:Nat) (h: a>1): Nat
| null |
theorem minFac_isfac(a:Nat)(h: a>1): ( (minFac a h) β£a) β§(minFac a h>1)
|
theorem minFac_ismin(a:Nat)(h:a>1): Not (β y>1,( y β£ a) β§y<minFac a h)
|
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).
|
def midPoint (x1 y1 x2 y2: Rat):Rat Γ Rat
| null |
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
| null |
write a function that, given natural numbers a and b, computes their greatest common denominator.
|
def GCD(a b:Nat):Nat
| null |
theorem gcd_is_div (x y: Nat):
(p: x > 0)β ((GCD x y) β£ x) β§ ((GCD x y) β£ y)
|
theorem gcd_is_greatest (x y: Nat):
(x>0) β Not (β z: Nat, zβ£ x β§ zβ£ y β§ z> GCD x y )
|
write a function that, given natural number t, find the minimum n such that 1+2+β¦+n>=t.
|
def solveProg(t:Nat):Nat
| null |
theorem solveProg_isgeq(t:Nat): (solveProg t)*((solveProg t)+1) >= t*2
|
theorem solveProg_ismin(t:Nat): Not (β y< (solveProg t), y*(y+1)>=t*2)
|
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.
|
def solveGeom(a t:Nat)(h:a>1):Nat
| null |
theorem solveGeom_isgeq(a t:Nat)(h:a>1): a^((solveGeom a t h)+1)-1 >=t*(a-1)
|
theorem solveGeom_ismin(a t:Nat)(h:a>1): Not (β y<solveGeom a t h, a^(y+1)-1>= t*(a-1))
|
write a function that, given natural number t, find the minimum n such that n*n>=t.
|
def solveSquare(t:Nat): Nat
| null |
theorem solveSquare_isgeq(t:Nat): (solveSquare t)*(solveSquare t)>=t
|
theorem solveSquare_ismin(t:Nat): Not (β y< (solveSquare t), y*y>=t)
|
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) :=
|
def f[Monad m] (op: Nat->Nat->(m Nat)) (n: Nat): (m Nat)
| null |
theorem f_base (op : Nat β Nat β Id Nat) :
(f op 0 = pure 1) β§ (f op 1 = pure 1)
|
theorem f_recursive (op : Nat β Nat β Id Nat) (n : Nat) : f op (n+2) =do {op (β f op (n+1)) (β f op n) }
|
write a function that, given a List of integers, return the list in reverse order.
|
def rev(xs: List Int): List Int
| null |
theorem reverse_correct(xs:List Int):
xs.length=(rev xs).length β§
β i<xs.length, xs[i]! =(rev xs)[xs.length-1-i]!
| null |
write a function that, given a List of integers, finds its maximum
|
def findMax (xs : List Int) : Option Int
| null |
theorem findMax_correct(x: Int) (xs : List Int):
β maxβ (x::xs),
And (findMax (x::xs) = some max) (β y β (x::xs) , y β€ max)
|
theorem findMax_base : findMax [] = none
|
write a function that, given a List of integers, finds the minimum
|
def findMin (xs : List Int) : Option Int
| null |
theorem findMin_correct(x: Int) (xs : List Int):
β minβ (x::xs),
And (findMin (x::xs) = some min) (β y β (x::xs) , y >= min)
|
theorem findMin_base : findMin [] = none
|
write a function that, given an integer x and a List of integers, returns true if and only if x is in the List
|
def isIn (x:Int) (xs: List Int):Bool
| null |
def isIn_correct (x:Int)(xs:List Int):
isIn x xs = true β xβ xs
| null |
write a function that, given an integer x and a List of integers, returns the number of times that x appears in the list.
|
def countEq (x:Int)(xs:List Int):Nat
| null |
def countEq_correct (x:Int)(xs:List Int):
List.count x xs = countEq x xs
| null |
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
|
def findIf(xs:List Int)(p:Int->Bool):Option Int
| null |
theorem findIf_some(xs:List Int)(p:Int->Bool):
(β xβ xs, p x) -> β yβ xs, findIf xs p=some y β§ p y
|
theorem findIf_none(xs:List Int)(p:Int->Bool):
(Β¬ β yβ xs, p y =true)-> findIf xs p=none
|
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.
|
def filterIf(xs:List Int)(p:Int->Bool):List Int
| null |
theorem filterIf_correct(xs:List Int)(p:Int->Bool):
filterIf xs p = List.filter p xs
| null |
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]
|
def mapInt(xs:List Int)(f:Int->Int):List Int
| null |
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]
| null |
Write a function that, given two lists of integers, find their longest common prefix.
|
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)}
| null | null | null |
Code with Proofs Benchmark
Main essay: A Proposal for Safe and Hallucination-free Coding AI
This dataset contains an initial benchmark set of code-with-proof problems with solutions. There are 24 problems, mostly simple non-recursive functions and simple recursion on natural numbers and lists. Each problem statement consists of a natural language description, a function signature, and the formal specification consisting of up to two theorem statements. Currently in Lean only; translation to other languages is welcome.
Files
easy.jsonl
: the problem statements in JSONL format. Fields include "description", "function_signature", "theorem_signature", "theorem2_signature"EasyBenchmark.lean
: the solutions including function implementations and proofs. Requires Mathlib.
- Downloads last month
- 12