Insert coin-04.png

BE:Gebietsversammlungen/Tempelhof-Schöneberg/Protokoll 2011.1

Aus Piratenwiki
Wechseln zu: Navigation, Suche

Das hieraus distillierte Wahlprotokoll: Datei:Wahlprotokoll-GVTS111.pdf


Protokoll der 1. Gebietsversammlung Tempelhof-Schöneberg 2011 am 12.02.2011

Begrüßung und Formalien

Pavel Mayer eröffnet als Mitglied des Landesvorstands die Versammlung um 16 Uhr.

Zum Versammlungsleiter wird einstimmig Gerhard Anger gewahlt.

Zum Protokollanten wird einstimmig Simon Weiß gewählt.

Pavel Mayer gibt zu Protokoll: 7 von 71 Mitgliedern im Gebiet (davon 49 stimmberechtigt) sind akkreditiert, damit ist die Versammlung beschlussfähig.

Der Versammlungsleiter stellt die Beschlussfähigkeit der Versammlung und die satzungs- und fristgemäße Einladung fest. Es erhebt sich kein Widerspruch.

Die Zulassung von Gästen wird abgestimmt und einstimmig angenommen.

Die Zulassung von Bild- und Tonaufnahmen wird abgestimmt und einstimmig angenommen.

Die Zulassung von Pressevertretern wird abgestimmt und einstimmig angenommen.

Abstimmung über die Tagesordnung

Die vorgeschlagene Tagesordnung wird vorgestellt:

  1. Begrüßung, Formalia
  2. Wahl der Kandidaten für die BVV Tempelhof-Schöneberg
  3. Wahl der Direktkandidaten für die 8 Wahlkreise des Bezirks Tempelhof-Schöneberg
  4. Wahl eines Gebietsbeauftragten
  5. Wahlkampf
  6. Verschiedenes

Eine Änderung der vorgestellten Tagesordnung wird vorgeschlagen, um eine kurze Vorstellungsrunde vor der anstehenden Wahl des Wahlleiters einzufügen. Es werden keine Einwände erhoben.

Der so geänderte Vorschlag für die Tagesordnung wird einstimmig angenommen.

Vorstellungsrunde

Die Anwesenden stellen sich der Reihe nach kurz vor.

Wahl des Wahlleiters

Martin Haase wird einstimmig zum Wahlleiter gewählt und bestimmt Martin Delius und Pavel Mayer zu Wahlhelfern.

Wahl der Kandidaten für die BVV Tempelhof-Schöneberg

Es wird vorgeschlagen, die Wahl der Kandidaten mit der Schulze-Methode durchzuführen. Dazu wird folgender Antrag gestellt:

Die Gebietsversammlung Tempelhof-Schöneberg möge beschließen:

Für die Wahl der Kandidaten für die BVV Tempelhof-Schöneberg kommt das Präferenzwahlverfahren nach der vereinfachten Schulze-Methode zur Anwendung, wie im Folgenden beschrieben:

Kandidaten, die bezüglich der Frage der Zustimmung nicht mehr Ja- als Nein-Stimmen auf sich vereinigen können, scheiden aus und finden im nachfolgend beschriebenen Prozess keine Berücksichtigung mehr. Für die übrigen Kandidaten wird auf Basis der abgegebenen Stimmzettel mittels der im Folgenden beschriebenen Schulze-Methode ein Wahlgewinner bzw. eine Reihenfolge von Gewinnern ermittelt:

Jeder Kandidat wird mit jedem anderen Kandidaten verglichen und es wird für jeden Kandidaten ausgezählt, wie viele Wähler den einen Kandidaten dem jeweils anderen Kandidaten vorziehen.

Definition: Ein Kandidat A kann einen anderen Kandidaten B mit einem Gewicht von n schlagen, wenn sich eine Abfolge von insgesamt mindestens zwei Kandidaten konstruieren lässt, die mit Kandidat A beginnt und mit Kandidat B endet, bei der für alle Paare direkt aufeinanderfolgender Kandidaten dieser Abfolge der jeweils eine Kandidat gegenüber seinem Nachfolger von einer einfachen Mehrheit, mindestens jedoch von n Wählern, bevorzugt wird. Eine einfache Mehrheit ist dann gegeben, wenn mehr Wähler den einen Kandidaten gegenüber seinem Nachfolger bevorzugen, als es umgekehrt der Fall ist.

1. Es wird für jedes Kandidatenpaar X und Y ermittelt, wie das größtmögliche Gewicht ist, mit dem ein Kandidat X nach oben stehender Definition den Kandidaten Y schlagen kann. Hierzu müssen alle der oben stehenden Definition genügenden Abfolgen von Kandidaten berücksichtigt werden. Gibt es keine solche Abfolge wird jeweils ein größtmögliches Gewicht von Null (0) angenommen.

2. Ein Kandidat X ist dann Gewinner der Wahl, wenn für jeden anderen Kandidaten Y das größtmögliche Gewicht, mit dem der Kandidat X den Kandidaten Y schlagen kann, größer als das größtmögliche oder gleich dem größtmöglichen Gewicht ist, mit dem der Kandididat Y den Kandidaten X schlagen kann.

3. Gibt es mehrere Gewinner, findet eine Stichwahl statt.

Im Falle der Ermittlung mehrerer Gewinner, die in eine Reihenfolge zu bringen sind, wird Schritt 2 unter Ausnahme der bisherigen Gewinner wiederholt, um die weiteren Plätze zu besetzen. Gleichplatzierte Kandidaten werden im Anschluss an die Auszählung mittels einer Stichwahl untereinander in eine Reihenfolge gebracht.

Stichwahlen werden als Wahl durch Zustimmung durchgeführt. Es werden hierbei nur Zustimmungen gezählt und der Kandidat mit den meisten Stimmen gewinnt bzw. wird erstplatziert. Sind mehrere Kandidaten in eine Reihenfolge zu bringen, entscheidet die Anzahl der Zustimmungen über die Reihenfolge der Kandidaten. Ergibt die Stichwahl einen Gleichstand, dann entscheidet das Los.

Technisch wird die Auszählung mit Ausnahme der Stichwahlen unter Verwendung des folgenden in der Programmiersprache Lua 5.1 geschriebenen Computerprogramms durchgeführt. Die Eingabedaten werden gemäß der Stimmzettel in einem öffentlichen Prozess erfasst. Eingaben und Ausgaben des Programms werden protokolliert und veröffentlicht.

#!/usr/bin/env lua


----------------------
-- Helper functions --
----------------------

function message(...)
  io.stderr:write(...)
end


------------------------------------------
-- Print notice related to tie-breaking --
------------------------------------------

message("NOTICE: This simplified version of the program does not perform tie-breaking.\n\n")


--------------------------------------
-- Command line argument processing --
--------------------------------------

settings = {}

do
  local next_arg
  do
    local argv = {...}
    local i = 0
    next_arg = function()
      i = i + 1
      return argv[i]
    end
  end
  local function command_line_error()
    message("Get help with -h or --help.\n")
    os.exit(1)
  end
  for option in next_arg do
    local argument, lower_argument
    local function require_argument()
      argument = next_arg()
      if argument == nil then
        message('Command line option "', option, '" requires an argument.\n')
        command_line_error()
      end
      lower_argument = string.lower(argument)
    end
    local function set_setting_once(key, value)
      if settings[key] ~= nil then
        message('Command line option "', option, '" occurred multiple times.\n')
        command_line_error()
      end
      settings[key] = value
    end
    if option == "-h" or option == "--help" then
      io.stdout:write("Usage:\n")
      io.stdout:write("schuool   -c|--candidates <candidates_file>\n")
      io.stdout:write("          -b|--ballots    <ballots_file>\n")
      io.stdout:write("        [ -d|--default    n|neutral|f|first|l|last            ]\n")
      io.stdout:write("        [ -o|--output     <output_file>                       ]\n")
      os.exit(0)
    elseif option == "-c" or option == "--candidates" then
      require_argument()
      set_setting_once("candidates_filename", argument)
    elseif option == "-b" or option == "--ballots" then
      require_argument()
      set_setting_once("ballots_filename", argument)
    elseif option == "-d" or option == "--default" then
      require_argument()
      if lower_argument == "n" or lower_argument == "neutral" then
        set_setting_once("default", "n")
      elseif lower_argument == "f" or lower_argument == "first" then
        set_setting_once("default", "f")
      elseif lower_argument == "l" or lower_argument == "last" then
        set_setting_once("default", "l")
      else
        message('Unknown default position "', argument, '" specified after ', option, ' switch.\n')
        command_line_error()
      end
    elseif option == "-o" or option == "--output" then
      require_argument()
      set_setting_once("output_filename", argument)
    else
      message('Illegal command line option "', option, '"\n')
      command_line_error()
    end
  end
  if settings.candidates_filename == nil then
    message("Use -c or --candidates to specify file containing candidate information.\n")
    command_line_error()
  end
  if settings.ballots_filename == nil then
    message("Use -b or --ballots to specify file containing all ballot data.\n")
    command_line_error()
  end
end


--------------------------
-- I/O helper functions --
--------------------------

function strip(str)
  return string.match(str, "^%s*(.-)%s*$")
end

function stripped_lines(filename)
  local file, errmsg = io.open(filename, "r")
  if not file then
    message(errmsg, "\n")
    os.exit(2)
  end
  local get_next_line = file:lines(filename)
  return function()
    if not file then return nil end
    local line
    repeat
      line = get_next_line()
      if line == nil then
        file:close()
        file = nil
        return nil
      end
      line = strip(string.match(line, "^[^#]*"))
    until line ~= ""
    return line
  end
end

function stripped_gmatch(str, pattern)
  local next_entry = string.gmatch(str, pattern)
  return function()
    local entry
    repeat
      entry = next_entry()
      if entry then entry = strip(entry) end
    until entry ~= ""
    return entry
  end
end

do
  local output_file
  if settings.output_filename == nil then
    output_file = io.stdout
  else
    local errmsg
    output_file, errmsg = io.open(settings.output_filename, "w")
    if not output_file then
      message(errmsg, "\n")
      os.exit(2)
    end
  end
  function output(...)
    output_file:write(...)
  end
end

function padded_number(number, maximum)
  local str = tostring(number)
  local max_digits = 1
  local tmp = maximum
  while tmp >= 10 do
    tmp = math.floor(tmp / 10)
    max_digits = max_digits + 1
  end
  for i = 1, max_digits - #str do
    str = " " .. str
  end
  return str
end


---------------------
-- Read candidates --
---------------------

candidates = {}  -- mapping string to candidate number and vice versa

do
  for line in stripped_lines(settings.candidates_filename) do
    for candidate in stripped_gmatch(line, "[^;,]+") do
      if candidates[candidate] then
        message('Duplicate candidate in "', settings.candidates_filename, '": "', candidate, '".\n')
        os.exit(2)
      end
      candidates[#candidates+1] = candidate
      candidates[candidate] = #candidates
    end
  end
end


------------------------------
-- Read and process ballots --
------------------------------

ballots = {}
approval_counts = {}
disapproval_counts = {}
for i = 1, #candidates do
  approval_counts[candidates[i]] = 0
  disapproval_counts[candidates[i]] = 0
end

for line in stripped_lines(settings.ballots_filename) do
  local ballot = {}
  local rank
  local processed = {}
  local approvals, neutrals, disapprovals = string.match(line, "^([^/]*)/([^/]*)/([^/]*)$")
  if not approvals then
    approvals, neutrals, disapprovals = string.match(line, "^([^/]*)$"), "", ""
  end
  if not approvals then
    message('Ill formatted ballot: "', line, '".\n')
    os.exit(2)
  end
  local function process_lists(candidate_lists, count_table)
    for candidate_list in string.gmatch(candidate_lists, "[^;]+") do
      if rank == -1 then
        -- only happens when there are different rankings in the neutral section
        message('Different rankings (semicolon) found in neutral section of ballot "', line, '".\n')
        os.exit(2)
      end
      local empty = true
      for candidate in stripped_gmatch(candidate_list, "[^,]+") do
        empty = false
        if not candidates[candidate] then
          message('Unknown candidate "', candidate, '" contained in ballot "', line, '".\n')
          os.exit(2)
        end
        if processed[candidate] then
          message('Duplicate candidate "', candidate, '" in ballot "', line, '".\n')
          os.exit(2)
        end
        ballot[candidate] = rank
        if count_table then
          count_table[candidate] = count_table[candidate] + 1
        end
        processed[candidate] = true
      end
      if not empty then
        -- It is important to only decrease rank, when candidates have been processed.
        rank = rank - 1
      end
    end
  end
  rank = #candidates
  process_lists(approvals, approval_counts)
  rank = 0
  process_lists(neutrals)
  rank = -2  -- rank -1 is reserved for default=first
  process_lists(disapprovals, disapproval_counts)
  for i = 1, #candidates do
    local candidate = candidates[i]
    if not processed[candidate] then
      if settings.default == "n" then
        ballot[candidate] = 0
      elseif settings.default == "f" then
        ballot[candidate] = -1
        disapproval_counts[candidate] = disapproval_counts[candidate] + 1
      elseif settings.default == "l" then
        ballot[candidate] = -#candidates - 2
        disapproval_counts[candidate] = disapproval_counts[candidate] + 1
      else
        message('Candidate "', candidate, '" missing in ballot "', line, '".\n')
        os.exit(2)
      end
    end
  end
  ballots[#ballots+1] = ballot
end


-------------------------------------------------------------------------
-- Select approved candidates, who passed the hard-coded quota of 1/2+ --
-------------------------------------------------------------------------

local approved_candidates = {}

do
  local max_approval    = 0
  local max_disapproval = 0
  local max_neutral     = 0
  for i = 1, #candidates do
    local candidate = candidates[i]
    local approval_count    = approval_counts[candidate]
    local disapproval_count = disapproval_counts[candidate]
    local neutral_count     = #ballots - approval_count - disapproval_count
    max_approval    = math.max(max_approval,    approval_count)
    max_disapproval = math.max(max_disapproval, disapproval_count)
    max_neutral     = math.max(max_neutral,     neutral_count)
  end
  output("Candidates:\n")
  for i = 1, #candidates do
    local candidate = candidates[i]
    local approval_count    = approval_counts[candidate]
    local disapproval_count = disapproval_counts[candidate]
    local neutral_count     = #ballots - approval_count - disapproval_count
    local approved = approval_count > disapproval_count
    output(padded_number(i, #candidates), ". ", padded_number(approval_count, max_approval), ':', padded_number(disapproval_count, max_disapproval), '(:', padded_number(neutral_count, max_neutral), ') 1/2+ ', approved and "APPROVED" or "FAILED  ", ' ', candidates[i], "\n")
    if approved then
      approved_candidates[#approved_candidates+1] = candidate
      approved_candidates[candidate] = #approved_candidates
    end
  end
  output("\n")
end


----------------------------------------------------------------
-- Calculate battles and rankings according to Schulze method --
----------------------------------------------------------------

battles = {}  -- two dimensional array
max_pro_contra = 0
for i = 1, #approved_candidates do
  battles[i] = {}
end
ranking = {}  -- mapping candidate name to ranking number and ranking number to list of candidates

function beating_weight(pro, contra)
  if pro > contra then
    return pro
  else
    return 0
  end
end

function approval_ratio(approval_count, disapproval_count)
  if approval_count > 0 and disapproval_count > 0 then
    return approval_count / (approval_count + disapproval_count)
  elseif approval_count > 0 then
    return approval_count
  elseif disapproval_count > 0 then
    return 1 - disapproval_count
  else
    return 1/2
  end
end

do
  local matrix = {}
  for i = 1, #approved_candidates do
    matrix[i] = {}
  end
  for i = 1, #approved_candidates do
    for j = i+1, #approved_candidates do
      local pro, contra = 0, 0
      for k = 1, #ballots do
        local ballot = ballots[k]
        local rank1 = ballot[approved_candidates[i]]
        local rank2 = ballot[approved_candidates[j]]
        if rank1 > rank2 then
          pro = pro + 1
        elseif rank2 > rank1 then
          contra = contra + 1
        end
      end
      battles[i][j] = pro
      battles[j][i] = contra
      max_pro_contra = math.max(max_pro_contra, pro)
      matrix[i][j] = beating_weight(pro, contra)
      matrix[j][i] = beating_weight(contra, pro)
    end
  end
  for i = 1, #approved_candidates do
    for j = 1, #approved_candidates do
      if i ~= j then
        for k = 1, #approved_candidates do
          if i ~= k and j ~= k then
            matrix[j][k] = math.max(matrix[j][k], math.min(matrix[j][i], matrix[i][k]))
          end
        end
      end
    end
  end
  local count = 0
  repeat
    local winners = {}
    for i = 1, #approved_candidates do
      local candidate = approved_candidates[i]
      if ranking[candidate] == nil then
        local best = true
        for j = 1, #approved_candidates do
          if i ~= j then
            local other_candidate = approved_candidates[j]
            if ranking[other_candidate] == nil and matrix[j][i] > matrix[i][j] then
              best = false
              break
            end
          end
        end
        if best then
          winners[#winners+1] = candidate
        end
      end
    end
    ranking[#ranking+1] = winners
    for i = 1, #winners do
      ranking[winners[i]] = #ranking
      count = count + 1
    end
  until count == #approved_candidates
end


--------------------
-- Output ranking --
--------------------

output("Ranking:\n")
for rank = 1, #ranking do
  local list = ranking[rank]
  for i = 1, #list do
    local candidate = list[i]
    output(padded_number(rank, #ranking), ". ", candidate, "\n")
  end
end
output("\n")


---------------------------
-- Output battle results --
---------------------------

for rank = 1, #ranking do
  local list = ranking[rank]
  for i = 1, #list do
    local candidate = list[i]
    output("Comparison of: ", padded_number(rank, #ranking), ". ", candidate, "\n")
    for other_rank = 1, #ranking do
      local other_list = ranking[other_rank]
      for j = 1, #other_list do
        local other_candidate = other_list[j]
        if candidate ~= other_candidate then
          local pro    = battles[approved_candidates[candidate]][approved_candidates[other_candidate]]
          local contra = battles[approved_candidates[other_candidate]][approved_candidates[candidate]]
          output(padded_number(pro, max_pro_contra), ":", padded_number(contra, max_pro_contra), "  ", padded_number(other_rank, #ranking), ". ", other_candidate, "\n")
        end
      end
    end
    output("\n")
  end
end

Das Verfahren wird vorgestellt und diskutiert.

Der Antrag wird einstimmig angenommen.

Eine Nachakkreditierung findet statt. 8 Mitglieder sind akkreditiert.

Es wird nach Kandidaten für den Bezirkswahlvorschlag gefragt.

Vorgeschlagen werden: Simon Kowalewski, Jakob Pfender, Sabine Preußker, Stefan Schulz-Günther, Michael Ickes.

Es wird diskutiert, ob die Aufstellung weiterer Kandidaten in Hinblick auf potentielle Nachrücker sinnvoll ist.

Jan-Ulrich Franz und Sven Malte Wehrend werden als weitere Kandidaten vorgeschlagen.

Die Kandidatenliste wird geschlossen.

Die Kandidaten stellen sich der Reihe nach vor und beantworten Fragen. Michael Ickes bittet dabei seine Biographie zu Protokoll zu nehmen, die sich über seinen Twitteraccount @mimaimix nachvollziehen lässt.

Der Wahlgang wird eröffnet.

Ein Muster des verwendeten Stimmzettels befindet sich unter Media:Stimmzettel GV Tempelhof-Schöneberg 2011.1.odt

Der Wahlgang wird geschlossen. Die Liste der Wahloptionen wird wie folgt in die Software zur Auszählung eingegeben:

Simon # Simon Kowalewski
Jakob # Jakob Pfender
Sabine # Sabine Preußker
Stefan # Stefan Schulz-Günther
Michael # Michael Ickes
Jan # Jan-Ulrich Franz
Sven # Sven Malte Wehrend

Die Angaben auf den Stimmzetteln werden wie folgt in die Software zur Auszählung eingegeben:

Simon,Jakob,Sabine,Stefan;Jan,Sven;Michael//
Simon;Jakob;Sabine;Stefan;Michael;Jan;Sven//
Simon;Stefan;Sabine;Jakob;Michael;Jan;Sven//
Jakob;Simon,Sabine;Michael;Stefan;Jan;Sven//
Jakob;Sabine;Simon;Stefan;Jan;Sven;Michael//
Simon,Jakob,Sabine,Stefan,Michael;Jan;Sven//
Jakob;Michael;Simon;Stefan;Sabine;Jan;Sven//
Stefan,Jan;Simon,Sabine;Jakob;Sven//Michael

Die Ausgabe des Auszählungsprogramms lautet wie folgt:

NOTICE: This simplified version of the program does not perform tie-breaking.

Candidates:
1. 8:0(:0) 1/2+ APPROVED Simon
2. 8:0(:0) 1/2+ APPROVED Jakob
3. 8:0(:0) 1/2+ APPROVED Sabine
4. 8:0(:0) 1/2+ APPROVED Stefan
5. 7:1(:0) 1/2+ APPROVED Michael
6. 8:0(:0) 1/2+ APPROVED Jan
7. 8:0(:0) 1/2+ APPROVED Sven

Ranking:
1. Simon
1. Jakob
2. Sabine
2. Stefan
3. Michael
4. Jan
5. Sven

Direct comparison of: 1. Simon
3:3  1. Jakob
3:1  2. Sabine
5:1  2. Stefan
6:1  3. Michael
7:1  4. Jan
8:0  5. Sven

Direct comparison of: 1. Jakob
3:3  1. Simon
4:2  2. Sabine
4:2  2. Stefan
7:0  3. Michael
7:1  4. Jan
8:0  5. Sven

Direct comparison of: 2. Sabine
1:3  1. Simon
2:4  1. Jakob
3:3  2. Stefan
6:1  3. Michael
7:1  4. Jan
8:0  5. Sven

Direct comparison of: 2. Stefan
1:5  1. Simon
2:4  1. Jakob
3:3  2. Sabine
5:2  3. Michael
7:0  4. Jan
8:0  5. Sven

Direct comparison of: 3. Michael
1:6  1. Simon
0:7  1. Jakob
1:6  2. Sabine
2:5  2. Stefan
5:3  4. Jan
5:3  5. Sven

Direct comparison of: 4. Jan
1:7  1. Simon
1:7  1. Jakob
1:7  2. Sabine
0:7  2. Stefan
3:5  3. Michael
7:0  5. Sven

Direct comparison of: 5. Sven
0:8  1. Simon
0:8  1. Jakob
0:8  2. Sabine
0:8  2. Stefan
3:5  3. Michael
0:7  4. Jan

Das Ergebnis für den Bezirkswahlvorschlag lautet also wie folgt:

  1. Simon Kowalewski, Jakob Pfender
  2. Sabine Preußker, Stefan Schulz-Günther
  3. Michael Ickes
  4. Jan-Ulrich Franz
  5. Sven Wehrend

Es werden zwei Stichwahlen nach Wahl durch Zustimmung zur Festlegung der Reihenfolge der Plätze 1 und 2 sowie 3 und 4 durchgeführt. Bei der ersten Stichwahl entfallen bei 8 abgegebenen gültigen Stimmzetteln 5 Stimmen auf Jakob Pfender und 4 Stimmen auf Simon Kowalewski. Bei der zweiten Stichwahl entfallen bei 8 abgegebenen gültigen Stimmzetteln 6 Stimmen auf Sabine Preußker und 5 Stimmen auf Stefan Schulz-Günther.

Das endgültige Ergebnis lautet demnach wie folgt:

  1. Jakob Pfender
  2. Simon Kowalewski
  3. Sabine Preußker
  4. Stefan Schulz-Günther
  5. Michael Ickes
  6. Jan-Ulrich Franz
  7. Sven Wehrend

Die Kandidaten nehmen die Wahl an.

Es wird ein Antrag zur Änderung der Wahlordnung gestellt, um die Wörter "entscheidet das Los" in "entscheidet ein Wurf mit gezinkten Würfeln" zu ändern. Der Antrag wird mehrheitlich abgelehnt.

Wahl der Direktkandidaten für die 8 Wahlkreise des Bezirks Tempelhof-Schöneberg

Es wird nach Kandidaten für Wahlkreis 1 gefragt.

Alexander Spies und Sabine Preußker werden vorgeschlagen.

Die Kandidatenliste wird geschlossen.

Es wird beantragt, zuerst alle Kandidaten zu sammeln und sich vorstellen zu lassen. Keine Gegenrede.

Es wird nach Kandidaten für Wahlkreis 2 gefragt.

Alexander Spies, Simon Kowalewski und Martin Haase werden vorgeschlagen.

Die Kandidatenliste wird geschlossen.

Es wird nach Kandidaten für Wahlkreis 3 gefragt.

Michael Ickes und Jan-Ulrich Franz werden vorgeschlagen.

Die Kandidatenliste wird geschlossen.

Es wird nach Kandidaten für Wahlkreis 4 gefragt.

Jakob Pfender wird vorgeschlagen.

Die Kandidatenliste wird geschlossen.

Es wird nach Kandidaten für Wahlkreis 5 gefragt.

Stefan Schulz-Günther wird vorgeschlagen.

Die Kandidatenliste wird geschlossen.

Es wird vorgeschlagen, das Sammeln von Kandidaten an dieser Stelle zu unterbrechen, die ersten 5 Wahlkreise zu besetzen und dann über die Besetzung der Wahlkreise 6-8 zu entscheiden. Der Antrag wird mehrheitlich angenommen.

Martin Haase und Alexander Spies erklären, dass sie als Kandidaten für Wahlkreis 2 nicht zur Verfügung stehen.

Jan-Ulrich Franz erklärt, dass er als Kandidat für Wahlkreis 3 nicht zur Verfügung steht.

Die Kandidaten für Wahlkreis 1 stellen sich vor und beantworten Fragen.

Martin Delius wird als Wahlhelfer von Jan-Ulrich Franz abgelöst.

Der Wahlgang zu Wahlkreis 1 wird eröffnet.

Es entfallen 4 Stimmen auf Alexander Spies und 3 Stimmen auf Sabine Preußker. Eine abgegebene Stimme ist ungültig. Damit ist Alexander Spies als Kandidat für Wahlkreis 1 gewählt.

Alexander Spies nimmt die Wahl an.

Der Wahlgang zu Wahlkreis 2 wird eröffnet.

Simon Kowalewski ist mit 7 Ja-Stimmen und einer ungültigen Stimme als Kandidat für Wahlkreis 2 gewählt.

Simon Kowalewski nimmt die Wahl an.

Es wird gefragt, aus welchem Grund die ungültige Stimme so gewertet wurde. Als Begründung wird vom Wahlleiter angegeben, dass der Stimmzettel zusätzliche schriftliche Kommentare enthielt. Der Versammlungsleiter weist auf die Möglichkeit hin, eine Wiederholung der Wahl zu beantragen; ein solcher Antrag wird nicht gestellt.

Der Wahlgang zu Wahlkreis 3 wird eröffnet.

Michael Ickes ist mit 5 Ja- und 3 Nein-Stimmen als Kandidat für Wahlkreis 3 gewählt.

Michael Ickes nimmt die Wahl an.

Der Wahlgang zu Wahlkreis 4 wird eröffnet.

Jakob Pfender ist mit 8 Ja-Stimmen als Kandidat für Wahlkreis 4 gewählt.

Jakob Pfender nimmt die Wahl an.

Der Wahlgang zu Wahlkreis 5 wird eröffnet.

Stefan Schulz-Günther ist mit 8 Ja-Stimmen als Kandidat für Wahlkreis 5 gewählt.

Stefan Schulz-Günther nimmt die Wahl an.

Es wird nach Kandidaten für die verbliebenen Wahlkreise 6, 7 und 8 gefragt. Es findet eine Diskussion über das Aufstellen von Direktkandidaten, Anforderungen an selbige und die Möglichkeit zur Nachnominierung auf einer weiteren Gebietsversammlung statt.

Keiner der Anwesenden erklärt sich zum jetzigen Zeitpunkt zu einer Kandidatur in diesen Wahlkreisen bereit.

Eine Unterbrechung für 10 Minuten wird beantragt und ohne Gegenrede angenommen.

Wahl eines Gebietsbeauftragten

Es wird über die Beauftragung eines Gebietsbeauftragten diskutiert. In diesem Kontext wird der entsprechende Antrag, der von der Gebietsversammlung Pankow beschlossen wurde, vorgestellt. Es wird vorgeschlagen, den Antrag leicht angepasst (Streichung Webpräsenz, Bezirksname, Singular) zu übernehmen. In der weiteren Diskussion wird vorgeschlagen, die BVV-Besuche aus den Aufgaben des Beauftragten zu streichen.

Der zur Abstimmung gestellte Antrag lautet demnach wie folgt:

Die Gebietsversammlung des Bezirks Tempelhof-Schöneberg möge beschliessen, einen mit der Vertretung der Interessen der Gebietsversammlung Tempelhof-Schöneberg zu beauftragen.

Für die Beauftragung sollen folgende Regelungen gelten:

  • Der Beauftragte vertritt die Interessen der Gebietsversammlung Tempelhof-Schöneberg nach Maßgabe ihrer Beschlüsse sowie der Satzung und den Beschlüssen der Organe der Piratenpartei Deutschland und der Piratenpartei Deutschland Berlin. Die Vertretung beschränkt sich auf ausschliesslich den Bezirk Tempelhof-Schöneberg betreffende politische Fragen und damit zusammenhängende organisatorische Tätigkeiten. Die grundsätzliche Vertretung der Piraten des Bezirks obliegt weiterhin dem Vorstand der Piratenpartei Deutschland Berlin. Insbesondere ist der Beauftragte nicht berechtigt, Rechtsgeschäfte im Namen der Piratenpartei Deutschland Berlin zu tätigen.
  • Der Beauftragte kann öffentliche Erklärungen über ausschließlich den Bezirk Tempelhof-Schöneberg betreffende politische Fragen abgeben. Er koordiniert sich dafür mit der Pressestelle der Piratenpartei Deutschland Berlin.
  • Der Beauftragte kann sich offiziell als “Gewählter Beauftragter der Gebietsversammlung für den Bezirk Tempelhof-Schöneberg in der Piratenpartei Deutschland Berlin” bezeichnen. Die Kurzbezeichnung ist “Bezirksbeauftragter der Piratenpartei in Tempelhof-Schöneberg”.
  • Der Beauftragte ist gehalten, seine Aussagen untereinander und mit den Piraten in Tempelhof-Schöneberg abzustimmen. Hierzu besucht er die Treffen der Crews im Bezirk.
  • Sobald es im Liquid Democracy System der Piratenpartei ein geeignetes Gebietsmerkmal gibt, wird er bei seinen Aktivitäten die dort von den Teilnehmern des Bezirks abgestimmten Anträge berücksichtigen. Die Gebietsversammlung gibt hiermit auch ihrem Wunsch nach baldiger Realisierung des Gebietsmerkmals Ausdruck und erklärt sich bereit, im Rahmen seiner Möglichkeiten die Realisierung zu unterstützen.
  • Der Beauftragte ist Anlaufpunkt für Fragen von Bürgern im Bezirk und erklärt sich bereit, entsprechende Kontaktdaten zu veröffentlichen und wenn möglich eine Anlaufstelle im Bezirk einzurichten.
  • Der Beauftragte informiert sich regelmässig über politische Vorgänge im Bezirk.
  • Der Beauftragte unterstützt den Landesvorstand bei der Einberufung und Durchführung von Gebietsversammlungen und unterrichtet den Landesvorstand über Ereignisse im Bezirk, die landespolitisch von Bedeutung sein können.
  • Es wird des weiteren beim Landesvorstand beantragt, dass zweckgebundene Spenden mit dem Zweck “LV Berlin, Bezirk Tempelhof-Schöneberg” vom Landesverband entgegengenommen werden. Der Bezirksbeauftragte koordiniert die Anträge von Piraten des Bezirks an den Landesvorstand zur Verwendung dieser Mittel. Das individuelle Antragsrecht jedes Mitglieds an den Landesvorstand bleibt hiervon selbstverständlich unberührt. Der Bezirksbeauftragte führt auch keine eigene Kasse, dies obliegt weiterhin dem Landesschatzmeister.
  • Der Bezirksbeauftragte soll in geheimer Wahl bestimmt werden.
  • Der Bezirksbeauftragte wird mindestens einmal im Jahr neu gewählt. Eine Wiederwahl ist möglich.

Der Antrag wird einstimmig angenommen.

Es werden Vorschläge für die Wahl des Bezirksbeauftragten gesammelt. Jan-Ulrich Franz wird vorgeschlagen, erklärt sich zur Kandidatur bereit und beantwortet Fragen.

Michael Ickes löst Jan-Ulrich Franz als Wahlhelfer ab.

Der Wahlgang wird eröffnet.

Jan-Ulrich Franz ist mit 8 Ja-Stimmen als Bezirksbeauftragter gewählt und nimmt die Wahl an.

Wahlkampf

Jan-Ulrich Franz und Alexander Spies stellen die Wahlkampfplanung der Crew Guybrush Threepwood vor. Es schließt sich eine Diskussion über die Planung an.

Verschiedenes

Es gibt Wortmeldungen zur Antwort des Datenschutzbeauftragten auf eine Anfrage und zum Berliner Wassertisch.

Der Termin für die nächste Gebietsversammlung wird diskutiert. Es wird vorgeschlagen, dies mit einer Fristsetzung der Verantwortung des Bezirksbeauftragten zu übergeben. Es wird über den Termin für die Frist diskutiert.

Hierzu werden werden zwei Anträge gestellt:

Die Gebietsversammlung Tempelhof-Schöneberg möge beschließen, den Bezirksbeauftragten mit der Vorbereitung der Einberufung einer weiteren Gebietsversammlung zu beauftragen, die bis spätestens 02.05.2011 stattfinden soll.

 

Die Gebietsversammlung Tempelhof-Schöneberg möge beschließen, beim Landesvorstand die Einberufung einer weiteren Gebietsversammlung am 12.03.2011 zu beantragen.

Es wird zunächst über den ersten Antrag abgestimmt. Der Antrag ist mehrheitlich angenommen. Der zweite Antrag wird ebenfalls mehrheitlich angenommen.

Es werden die nötigen weiteren Formalien zu den Kandidaturen (einzureichende Dokumente, Vertrauenspersonen) besprochen.

Dazu wird Folgendes beantragt:

Die Gebietsversammlung möge beschließen, dass sich die Crew Guybrush Threepwood am 17.02.2011 auf einen Beauftragten einigen soll, der die Abwicklung der Formalien mit dem Bezirkswahlleiter vornimmt.

Der Antrag ist einstimmig angenommen.

Die Versammlung wird um 20:34 geschlossen.