Berechenbarkeitstheorie/Entscheidbarkeit und Aufzählbarkeit

Wiki-Quelltext dieser Seite.

<language>Scheme</language>
==Aufzählbarkeit==

<code id="4f71929a79c30" hidden>
;;; STREAMS - Implementation mit verzoegerter Evaluation (delay, force)

;; Selektoren

(define stream-car
  (lambda (s)
    (car (force s))))

(define stream-cdr
  (lambda (s)
    (cdr (force s))))

;; Konstruktoren

(define-syntax stream-cons
  (syntax-rules ()
    ((_ x str) (delay (cons x str)))))

(define make-stream 
  (lambda (seed proc)
    (letrec 
        ((stream-builder
          (lambda (n)
            (delay (cons n (stream-builder (proc n)))))))
      (stream-builder seed))))

;; Operationen mit streams

(define stream-item
  (lambda (str k)
    (if (= k 0)
        (stream-car str)
        (stream-item (stream-cdr str) (- k 1)))))

(define stream->list
  (lambda (str n)
    (if (= n 0)
        '()
        (cons 
         (stream-car str) 
         (stream->list (stream-cdr str) (- n 1))))))

(define stream-map
  (lambda (f str)
    (delay
      (cons
       (f (stream-car str))
       (stream-map f (stream-cdr str))))))

(define print-stream
  (lambda (str items)
    (if (<= items 0)
        (begin
          (display "...")(newline))
        (begin
          (write (stream-car str))
          (display ", ")
          (print-stream (stream-cdr str)(- items 1))))))

; nat_zahlen
; (display (stream->list nat_zahlen 20))
; nat_zahlen
; (display (stream->list (stream-map (lambda (i) (* 10 i)) nat_zahlen) 10))

;; ---  Ende streams ---

;;; Aufzaehlbare Mengen 

(define nat_zahlen (make-stream 0 (lambda (n) (+ n 1))))

(define menge-bis print-stream)  ; angepasster Prozedurnamen

(define generiere_aufzaehlbare_menge 
  (lambda (f)
    (stream-map f nat_zahlen)))

(define generiere_aufzaehlbare_wortmenge 
  (lambda (f)
    (stream-map number->string (stream-map f nat_zahlen))))
</code>

Beispiel: Wörter der Länge 3 über $\{a,b\}^*$

Die zu charakterisierende Menge ist eine endliche, denn es gibt nur $2^3=8$ solche Wörter.

<code id="4f6cafece05e6">
(define chi-laenge3
  (lambda (w)
    (if (member w '("aaa" "aab" "aba" "baa" "abb" "bab" "bba" "bbb"))
      #t
      #f))) 
</code>
<run id="4f6cafece065c">(chi-laenge3 "abb")</run>


Beispiel: Wörter über $\{a,b\}^*$, die mit $a$ beginnen. 

<code id="4f6ca9bc8928d">
(define chi-a
  (lambda (w)
    (char=? (string-ref w 0) #\a)))
</code> 
<run id="4f6ca9bc89383">
(chi-a "ababaab")
</run>

Die Menge der Primzahlen ist aufzählbar unendlich:
<code id="4f71666af239c" hidden>
(define prim?
  (lambda (n)
    (letrec
        ((helfer
          (lambda (t)
            (cond
              ((> t (sqrt n)) #t)
              ((= (remainder n t) 0) #f)
              (else
               (helfer (+ t 2)))))))
      (cond
        ((= n 1) #f)
        ((= n 2) #t)
        ((= (remainder n 2) 0) #f)
        (else
         (helfer 3))))))
</code>
<run id="4f71666af2ed9">(prim? 31)</run>
<code id="4f71666af2b1e">
(define f 
  (lambda (n)
    (if (prim? n)
      n
      2)))
</code>
<run id="4f71666af3428">(f 31)</run>