GR A
1. ALGOL
silnia(0)=1
silnia(n)=PROD(n, silnia(n-1))
gdzie PROD czyli mnożenie:
PROD(0,m)=0
PROD(n+1,m)=SUM(m, PROD (n,m))
gdzie SUM (dodawanie) jest zbudowane na bazie funkcji SUCC, która jest funkcją bazową.
f(n)=3n^2 + 2n!
F(n) = SUM (PROD(3, PROD(n,n)), PROD(2, SILNIA(n)))
zamiast PROD(n,n) może być EXP czyli potęga.
wykorzystując funkcję bazową SUCC i uogólnione złożenie funkcji stworzyliśmy nową funkcję => funkcja jest prymitywnie rekursywna.
2. SNOBOL
a1 = prawda; a2 = fałsz; NULL = fałsz.
COTO(a1a1) = COND(a1, CONS(a2, COTO(a1)), NULL) =
= CONS(a2, COTO(a1)) = CONS(a2, CONS(a2, COTO(NULL)) = CONS(a2, CONS(a2, NULL) =
= a2a2
// tłumacząc to:
COND to instrukcja warunkowa :
za x podstawiam ogon (a1). jeśli jest prawdą to pierwsze polecenie (CONS(a2, COTO(X)), jak
nie to drugie - NULL.
CONS - łączenie
COTO(a1a2) = COND(a2, CONS(a2, COTO(a2)), NULL) = NULL
COTO(a2a1) = CONS(a1, a1) = a1a1
COTO(a2a2) = CONS(a1, a2) = a1a2
3. LISP
2 zmienne: A i L (pewnie lista)
COND - wyrażenie warunkowe
1 wyrażenie - jeśli argument L jest lista pustą - zwraca NIL
2 wyrażenie: EQUAL - sprawdza czy element A jest równy głowie listy L,
jeśli tak to wykonuje rekurencyjnie COTO (A (CDR L))
3 wyrażenie: w przeciwnym wypadku wykona się CONS ...
- i tu widzę że coś za mało zakichanych nawiasów więc technicznie rzecz biorąc wyniku nie będzie ;] -
(DEFINE COTO (LAMBDA (A L)
(COND
((NULL L) NIL)
((EQUAL A (CAR L)) COTO (A (CDR L))
(T (CONS (CAR L) COTO (A (CDR L))))
))))
COTO(A (A B C)) = (B C)
A = głowa => COTO(A (B C))
A /= głowa => CONS(B COTO(A (CDR C)))
COTO(A (CDR C)) => CONS(C COTO(A ()))
COTO(A ()) => NIL
CONS(B CONS(C NIL)) = (B C)
COTO(B (A B)) = (A B)
CONS (A COTO (A (B)))
CONS (A (CONS B COTO (A ())))
CONS (A (CONS B NIL))
4. PROLOG / ZASADA REZOLUCJI
kwantyfikatory:
V - każdy
E - istnieje
Przesłanka1:
Każdy obywatel RP musi płacić podatki:
Vx ObywatelRP(X) => Podatnik(X)
Alfa => Beta
Przesłanka2:
Jestem obywatelem RP:
ObywatelRP(JA)
Alfa
CEL:
ObywatelRP(JA) => Podatnik(JA)
Beta
Dowodzenie metodą rezolucji:
- zaprzeczenie celowi: NIE-Beta
- sprowadź zaprzeczony cel i przesłanki do postaci klauzalnej:
Alfa => Beta = NIE-Alfa v Beta
postać klauzalna (jakkolwiek się to pisze):
1. {NIE-Alfa, Beta}
2. {Alfa}
3. {NIE-Beta}
- uzyskaj klauzulę pustą:
4. (z 1 i 2) {Beta}
5. (z 3 i 4) {}
pusta => zdanie jest logiczną konsekwencją przesłanek.
5. PROLOG
1. prawdziwe.
dla każdego X istnieje Y, takie że X = Y i X=d.
Y = a.
3. ?
dla każdego X jest, tak że X jest pomiędzy d,c i X=b.
gdyby nie było kwantyfikatora było by OK.
bo ISTNIEJE takie X.
5. GrB
2. prawdziwe.
dla każdego sześcianu X i każdego sześcianu Y istnieje jakieś Z,
będące pomiędzy X i Y.
4. fałsz.
Dla każdego X istnieje Y, że pomiędzy X i Y jest c.
A c jest emo i siedzi w kącie.