We must know. We will know.

Can we devise a process to determine in a finite number of operations, whether a first order logic statement is valid?
λ Calculus
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: |
0) INPUT INVENTORY FILE=A PRICE FILE=B, OUTPUT PRICED-INV FILE=C UNPRICED-INV FILE=D, HSP D. 1) COMPARE PRODUCT-NO(A) WITH PRODUCT-NO(B) IF GREATER GO TO OPERATION 10; IF EQUAL GO TO OPERATION 5; OTHERWISE GO TO OPERATION 2. 2) TRANSFER A TO D. 3) WRITE ITEM D. 4) JUMP TO OPERATION 8. 5) TRANSFER A TO C. |
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: |
6) MOVE UNIT-PRICE(B) TO UNIT-PRICE(C). 7) WRITE ITEM C. 8) READ ITEM A; IF END OF DATA GO TO OPERATION 14. 9) JUMP TO OPERATION 1. 10) READ ITEM B; IF END OF DATA GO TO OPERATION 12. 11) JUMP TO OPERATION 1. 12) SET OPERATION 9 TO GO TO OPERATION 2. 13) JUMP TO OPERATION 2. 14) TEST PRODUCT-NO(B) AGAINST ZZZZZZZZZZZZ; IF EQUAL GO TO OPERATION 16; OTHERWISE GO TO OPERATION 15. 15) REWIND B. 16) CLOSE-OUT FILES C, D. 17) STOP. (END) |
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: |
(defun sieve-of-eratosthenes (maximum) (loop with sieve = (make-array (1+ maximum) :element-type 'bit :initial-element 0) for candidate from 2 to maximum when (zerop (bit sieve candidate)) collect candidate and do (loop for composite from (expt candidate 2) to maximum by candidate do (setf (bit sieve composite) 1)))) |
\((~T \in T \circ.×T)/T←1 \downarrow ⍳R\)
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: |
mother_child(trude, sally). father_child(tom, sally). father_child(tom, erica). father_child(mike, tom). sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y). parent_child(X, Y) :- father_child(X, Y). parent_child(X, Y) :- mother_child(X, Y). |
1: 2: 3: 4: 5: 6: 7: 8: |
-module(mymath). -export([square/1,fib/1]). square(Value) -> Value*Value. fib(0) -> 0; fib(1) -> 1; fib(N) when N>1 -> fib(N-1) + fib(N-2). |
1: 2: 3: 4: 5: 6: |
function factorial(n) { if (n == 0) { return 1; } return n * factorial(n - 1); } |
1: 2: 3: 4: 5: 6: 7: |
ulong factorial(ulong n) { if (n<2) return 1; else return n * factorial(n-1); } |
1: 2: 3: 4: 5: 6: 7: 8: |
data Vect : Nat -> Type -> Type where Nil : Vect 0 a (::) : (x : a) -> (xs : Vect n a) -> Vect (n + 1) a total append : Vect n a -> Vect m a -> Vect (n + m) a append Nil ys = ys append (x :: xs) ys = x :: append xs ys |
We must know. We Will know

