KLasse:
Navigatie:
 0-0     
Instantie:
Relatie:
Domein:
Linken:

Pattern Deduction AI in Connect Four 2023-09-21: An AI trying to do it the Human way - Pattern re0ppp

I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way. For patterns and deduction see among others:
https://en.wikipedia.org/wiki/Pattern
https://en.wikipedia.org/wiki/Deductive_reasoning

Currently I'm working on a connect four AI that scans the board for certain patterns to determine from these patterns which player is winning in how many moves in stead of using brute force for this purpose. Currently the actual pattern deduction, this is which patterns imply a win in how many moves for example a win in 1, 2, 3, ... 42 moves, is done by myself using the visual representation, current AI version and programming code at:
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PEPSSSPEEPSPPSEEEPSSEEEESPEEEEEESEEEEEEPEEE &relationship=All&drsid=0&pisid=0&page=1
The above link and corresponding first screenshot below (press ctrl+ for more image detail) show the last but one pattern re0ppp (four in a row with one empty rotating position with 0 empty positions below it) from which and only if this player is to move "Player Connects 4 in 1 Moves" is concluded by the AI. In future articles more of the patterns and work will be presented.

The ultimate goal and challenge is developing and programming a datamodel and algoritms that deduct by itself those patterns. Further on the plan is to apply and expand this pattern deduction AI framework on connect four with higher dimensions (unsolvable by brute force AI), chemistry, biochemistry, ecosystems, ... .

I'll make here my first attempt at the ultimate goal, at describing the game and deducting the patterns and from these the game's outcomes with logic statements using an object oriented datamodel of the game and then at automating the deduction.

xMax = 7 and
yMax = 6 and
conn = 4 and
opponent(1) = 2 and
opponent(2) = 1

matrix.pppp(player) <=>
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   matrix(x0, y0 + extent) = player
  ∀end extent and
  matrix.yEmpty(x0) = y0 + conn
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMove:
   previousMove >= 0 and previousMove < conn:
   matrix(x0 + previousMove, y0 + 1) = 0
  Ǝend previousMove
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMove:
   previousMove >= 0 and previousMove < conn:
   matrix(x0 + previousMove, y0 + previousMove + 1) = 0
  Ǝend previousMove
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMove:
   previousMove >= 0 and previousMove < conn:
   matrix(x0 + previousMove, y0 - previousMove + 1) = 0
  Ǝend previousMove
Ǝend x0, y0

matrix.yEmpty(x) = ye <=>
matrix(x, ye) = 0 and
(matrix(x, ye - 1) != 0 or ye = 0)

matrix.rexppp(player, rex) <=>
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  matrix.yEmpty(x0) = y0 + conn - 1 - rex and
  ∀ extent:
   extent >= 0 and extent < conn - 1: and
   matrix(x0, y0 + extent) = player
  ∀end extent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  Ǝ rexExtent:
   rexExtent >= 0 and rexExtent < conn:
   matrix.yEmpty(x0 + rexExtent) = y0 - rex and
  Ǝend rexExtent and
  ∀ extent:
   extent >= 0 and extent < conn and extent != rexExtent:
   matrix(x0 + extent, y0) = player
  ∀end extent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  Ǝ rexExtent:
   rexExtent >= 0 and rexExtent < conn:
   matrix.yEmpty(x0 + rexExtent) = y0 + rexExtent - rex
  Ǝend rexExtent and
  ∀ extent:
   extent >= 0 and extent < conn and extent != rexExtent:
   matrix(x0 + extent, y0 + extent) = player
  ∀end extent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  Ǝ rexExtent:
   rexExtent >= 0 and rexExtent < conn:
   matrix.yEmpty(x0 + rexExtent) = y0 - rexExtent - rex
  Ǝend rexExtent
  ∀ extent:
   extent >= 0 and extent < conn and extent != rexExtent:
   matrix(x0 + extent, y0 - extent) = player
  ∀end extent
Ǝend x0, y0

matrix.re0ppp(player) <=>
matrix.rexppp(player, 0) <=>
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  matrix.yEmpty(x0) = y0 + conn - 1 and
  ∀ extent:
   extent >= 0 and extent < conn - 1: and
   matrix(x0, y0 + extent) = player
  ∀end extent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  Ǝ rexExtent:
   rexExtent >= 0 and rexExtent < conn:
   matrix.yEmpty(x0 + rexExtent) = y0 and
  Ǝend rexExtent and
  ∀ extent:
   extent >= 0 and extent < conn and extent != rexExtent:
   matrix(x0 + extent, y0) = player
  ∀end extent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  Ǝ rexExtent:
   rexExtent >= 0 and rexExtent < conn:
   matrix.yEmpty(x0 + rexExtent) = y0 + rexExtent
  Ǝend rexExtent and
  ∀ extent:
   extent >= 0 and extent < conn and extent != rexExtent:
   matrix(x0 + extent, y0 + extent) = player
  ∀end extent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  Ǝ rexExtent:
   rexExtent >= 0 and rexExtent < conn:
   matrix.yEmpty(x0 + rexExtent) = y0 - rexExtent
  Ǝend rexExtent
  ∀ extent:
   extent >= 0 and extent < conn and extent != rexExtent:
   matrix(x0 + extent, y0 - extent) = player
  ∀end extent
Ǝend x0, y0

game.connects4InMoves(player, 0) <=>
game.matrix.pppp(player) and
game.toMove = opponent(player)

game.afterMove(xMove) <=>
game.matrix.yEmpty(xMove) < yMax - 1 and
game.afterMove(xMove).toMove = opponent(game.toMove) and
game.afterMove(xMove).matrix(xMove, game.matrix.yEmpty(xMove)) = game.toMove and
game.afterMove(xMove).matrix.yEmpty(xMove) = game.matrix.yEmpty(xMove) + 1 and
∀ x, y:
  x >= 0 and x < xMax and
  y >= 0 and y < yMax and
  (x != xMove or y != game.matrix.yEmpty(xMove)):
  game.afterMove(xMove).matrix(x, y) = game.matrix(x, y)
∀end x, y

game.connects4InMoves(player, 1) <=>
game.toMove = player and
Ǝ xMove:
  xMove >= 0 and xMove < xMax:
  game.afterMove(xMove).connects4InMoves(player, 0)
Ǝend xMove

Now, I want to deduct (proof), later automatically by algoritm, that:
game.connects4InMoves(player, 1)
is equivalent with:
game.toMove = player and
game.matrix.rexppp(player, 0)
The latter corresponds with the re0ppp pattern. So there I go. Given:

game.connects4InMoves(player, 1)

Step 1. The system substitutes the above function with its equivalence definition <=>

game.toMove = player and
Ǝ xMove:
  xMove >= 0 and xMove < xMax:
  game.afterMove(xMove).connects4InMoves(player, 0)
Ǝend xMove

Step 2. The system substitutes the connects4InMoves(player, 0) function with its equivalence definition <=>

game.toMove = player and
Ǝ xMove:
  xMove >= 0 and xMove < xMax:
  game.afterMove(xMove).matrix.pppp(player) and
  game.afterMove(xMove).toMove = opponent(player)
Ǝend xMove:

Step 3. The system substitutes the pppp(player) function with its equivalence definition <=>

game.toMove = player and
Ǝ xMove:
xMove >= 0 and xMove < xMax:
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0, y0 + extent) = player
  ∀end extent and
  game.afterMove(xMove).matrix.yEmpty(x0) = y0 + conn
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(xMove).matrix.yEmpty(x0 + previousMoveExtent) = y0 + 1
  Ǝend previousMoveExtent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(xMove).matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent + 1
  Ǝend previousMoveExtent
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(xMove).matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent + 1
  Ǝend previousMoveExtent
Ǝend x0, y0
game.afterMove(xMove).toMove = opponent(player)
Ǝend xMove:

Step 4. The system adds the game.afterMove(xMove) function its equivalence definition <=>

game.toMove = player and
Ǝ xMove:
xMove >= 0 and xMove < xMax:
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0, y0 + extent) = player
  ∀end extent and
  game.afterMove(xMove).matrix.yEmpty(x0) = y0 + conn and
  game.afterMove(xMove).matrix.yEmpty(xMove) = game.matrix.yEmpty(xMove) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != xMove or y != game.matrix.yEmpty(xMove)):
   game.afterMove(xMove).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(xMove).matrix.yEmpty(x0 + previousMoveExtent) = y0 + 1
  Ǝend previousMoveExtent
  game.afterMove(xMove).matrix.yEmpty(xMove) = game.matrix.yEmpty(xMove) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != xMove or y != game.matrix.yEmpty(xMove)):
   game.afterMove(xMove).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(xMove).matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent + 1
  Ǝend previousMoveExtent and
  game.afterMove(xMove).matrix.yEmpty(xMove) = game.matrix.yEmpty(xMove) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != xMove or y != game.matrix.yEmpty(xMove)):
   game.afterMove(xMove).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(xMove).matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(xMove).matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent + 1
  Ǝend previousMoveExtent
  game.afterMove(xMove).matrix.yEmpty(xMove) = game.matrix.yEmpty(xMove) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != xMove or y != game.matrix.yEmpty(xMove)):
   game.afterMove(xMove).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0
game.afterMove(xMove).toMove = opponent(player)
Ǝend xMove:

Step 5. The system substitutes xMove with x0 in the first (vertical) Ǝ x0, y0 pattern and with x0 + previousMoveExtent in the horizontal, diagonal up and down patterns. <=>

game.toMove = player and
Ǝ xMove:
xMove >= 0 and xMove < xMax:
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0).matrix(x0, y0 + extent) = player
  ∀end extent and
  game.afterMove(x0).matrix.yEmpty(x0) = y0 + conn and
  game.afterMove(x0).matrix.yEmpty(x0) = game.matrix.yEmpty(x0) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 or y != game.matrix.yEmpty(x0)):
   game.afterMove(x0).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.xEmpty(x0 + previousMoveExtent) = y0 + 1
  Ǝend previousMoveExtent
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != game.matrix.yEmpty(x0 + previousMoveExtent)):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent + 1 and
  Ǝend previousMoveExtent and
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != game.matrix.yEmpty(x0 + previousMoveExtent)):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent + 1
  Ǝend previousMoveExtent
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != game.matrix.yEmpty(x0 + previousMoveExtent)):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0
game.afterMove(x0 + previousMoveExtent).toMove = opponent(player)
Ǝend xMove:

Step 6. From the two yEmpty(x0) statements the system solves
game.matrix.yEmpty(x0) = y0 + conn - 1 for the vertical Ǝ x0, y0 pattern,
game.matrix.yEmpty(x0 + previousMoveExtent) = y0 for the horizontal Ǝ x0, y0 pattern,
game.matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent for the diagonal up pattern and
game.matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent for the diagonal down pattern,
adds these new statements and substitutes game.matrix.yEmpty(x0) with y0 + conn - 1 (vertical) and game.matrix.yEmpty(x0 + previousMoveExtent) with y0 (horizontal) or y0 + previousMoveExtent (diagonal up) or y0 - previousMoveExtent (diagonal down). <=>

game.toMove = player and
Ǝ xMove:
xMove >= 0 and xMove < xMax:
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0).matrix(x0, y0 + extent) = player
  ∀end extent and
  game.afterMove(x0).matrix.yEmpty(x0) = y0 + conn and
  game.afterMove(x0).matrix.yEmpty(x0) = game.matrix.yEmpty(x0) + 1 and
  game.matrix.yEmpty(x0) = y0 + conn - 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 or y != y0 + conn - 1):
   game.afterMove(x0).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.xEmpty(x0 + previousMoveExtent) = y0 + 1
  game.matrix.yEmpty(x0 + previousMoveExtent) = y0 and
  Ǝend previousMoveExtent
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent + 1
  game.matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent
  Ǝend previousMoveExtent and
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0 + previousMoveExtent):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent + 1
   game.matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent
  Ǝend previousMoveExtent
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0 - previousMoveExtent):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0
game.afterMove(x0 + previousMoveExtent).toMove = opponent(player)
Ǝend xMove:

Step 7. The system integrates ∀ x, y into ∀ extent. <=>

game.toMove = player and
Ǝ xMove:
xMove >= 0 and xMove < xMax:
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn and (x0 != x0 or y0 + extent != y0 + conn - 1):
   game.matrix(x0, y0 + extent) = player
  ∀end extent and
  game.afterMove(x0).matrix.yEmpty(x0) = y0 + conn and
  game.afterMove(x0).matrix.yEmpty(x0) = game.matrix.yEmpty(x0) + 1 and
  game.matrix.yEmpty(x0) = y0 + conn - 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 or y != y0 + conn - 1):
   game.afterMove(x0).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn and (x0 + extent != x0 + previousMoveExtent or y0 != y0):
   game.matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.xEmpty(x0 + previousMoveExtent) = y0 + 1
  game.matrix.yEmpty(x0 + previousMoveExtent) = y0 and
  Ǝend previousMoveExtent
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn and (x0 + extent != x0 + previousMoveExtent or y0 + extent != y0 + previousMoveExtent):
   game.matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent + 1
  game.matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent and
  Ǝend previousMoveExtent and
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0 + previousMoveExtent):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn and (x0 + extent != x0 + previousMoveExtent or y0 - extent != y0 - previousMoveExtent):
   game.matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent + 1
   game.matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent
  Ǝend previousMoveExtent
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0 - previousMoveExtent):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0
game.afterMove(x0 + previousMoveExtent).toMove = opponent(player)
Ǝend xMove:

Step 8. The system normalizes ∀ extent <=>

game.toMove = player and
Ǝ xMove:
xMove >= 0 and xMove < xMax:
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn - 1:
   game.matrix(x0, y0 + extent) = player
  ∀end extent and
  game.afterMove(x0).matrix.yEmpty(x0) = y0 + conn and
  game.afterMove(x0).matrix.yEmpty(x0) = game.matrix.yEmpty(x0) + 1 and
  game.matrix.yEmpty(x0) = y0 + conn - 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 or y != y0 + conn - 1):
   game.afterMove(x0).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn and extent != previousMoveExtent:
   game.matrix(x0 + extent, y0) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.matrix.yEmpty(x0 + previousMoveExtent) = y0 and
  Ǝend previousMoveExtent and
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= 0 and y0 < yMax - conn:
  ∀ extent:
   extent >= 0 and extent < conn and extent != x0 + previousMoveExtent:
   game.matrix(x0 + extent, y0 + extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.matrix.yEmpty(x0 + previousMoveExtent) = y0 + previousMoveExtent and
  Ǝend previousMoveExtent and
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1 and
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0 + previousMoveExtent):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0 or
Ǝ x0, y0:
  x0 >= 0 and x0 < xMax - conn and
  y0 >= conn and y0 < yMax:
  ∀ extent:
   extent >= 0 and extent < conn and extent != previousMoveExtent:
   game.matrix(x0 + extent, y0 - extent) = player
  ∀end extent and
  Ǝ previousMoveExtent:
   previousMoveExtent >= 0 and previousMoveExtent < conn:
   game.matrix.yEmpty(x0 + previousMoveExtent) = y0 - previousMoveExtent
  Ǝend previousMoveExtent and
  game.afterMove(x0 + previousMoveExtent).matrix.yEmpty(x0 + previousMoveExtent) = game.matrix.yEmpty(x0 + previousMoveExtent) + 1
  ∀ x, y:
   x >= 0 and x < xMax and
   y >= 0 and y < yMax and
   (x != x0 + previousMoveExtent or y != y0 - previousMoveExtent):
   game.afterMove(x0 + previousMoveExtent).matrix(x, y) = game.matrix(x, y)
  ∀end x, y
Ǝend x0, y0
game.afterMove(x0 + previousMoveExtent).toMove = opponent(player)
Ǝend xMove:

Step 9. The system matches the green statements above with the equivalence defintion of matrix.re0ppp(player) and deducts (proofs) as such the re0ppp pattern. Currently this is done for the vertical, horizontal and diagonal up and down Ǝ x0, y0 patterns. <=>

game.toMove = player and
game.matrix.re0ppp(player)

See the following list of links and screenshots further down for more examples of the re0ppp pattern:
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PSPSSSPEEPSPPSEEPPSESEEESPEEEEEESEEEEEEPEEE &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PSPSSSPEEPSPPSEEPPSSPEESSPSEEEEPSEEEEEEPEEE &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:SSPSSSPEPPSPPSEPPPSSPESSSPESEPSPSEPEESSPEPE &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PSPSSSPPPPSPPSSPPPSSPPSSSPPSSSSPSEPSPSSPEPE &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:SSPSSSPPPPSPPSSESPSSPPESSPPPSEPSSSEPESPPPES &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PSPSSSPPPPSPPSSPPPSSPPSSSPPSSSSPSSPSPSSPPPE &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PSSPPSPSPPSSPSPSSSPPESPPSSPEPSSPPSESPPSSPEP &relationship=All&drsid=0&pisid=0&page=1















Pattern Deduction AI in Connect Four 2023-09-21: An AI trying to do it the Human way - Pattern re0ppp” was written by Paka Small – 2023/09/21.



Informational Add: Flemish Tasty Forest 2023: 160 m2 wild food forest and food garden - harvest score 2023-11-06

Informational Add: The Parasitic System 2023-12-13: Lets Deflate the Parasitic System!

Informational Add: Pattern Deduction AI Connect 4 in 2 Moves: An AI trying to do it the Human way-re1ppp-re0ppp I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way.

Informational Add: Tumia.org is hosted and powered by One.com. Start your website with one.com - Start building your dream online with an easy-to-use and affordable website builder.

Informational Add: More Dangerous Sars-Cov-2 variants by creating biological niches for those variants and by Vaids?

Informational Add: Pattern Deduction AI in Connect Four in 3 Moves 2024-09-24: An AI trying to do it the Human way - Patterns re0re1pp, re0re0pp, re2ppp, re1ppp, re0ppp and pppp I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way.

Informational Add: Estimated Extra Deaths 31 Million and Estimated Adverse Effects 1.9 Billion for 3 Years of Covid Killing Protocols, Sars-Cov-2 Virus and Vaccine Bioweapons. By country. Audio-video version.

Informational Add: Timelapse of almost 8 hours of relentless persistent trailing, chemtrailing, wavering and hazing trails. I'm hoping somebody can send me the detailed science about trails, about how long types of trails can last under which conditions? #2024-02-01 8:30 AM - #Beautiful #Skies+#Clouds+#Trails of #Sint-#Lievens-#Houtem - #Belgium East-#Flanders #FHD #Speed x 256: 7:45:04->1:49 - #BeautifulSkies

Informational Add: Skateboarding Hardflip

Informational Add: Vlaams LekkerBos 2023: 160m2 wild voedselbos en voedseltuin - tussenstand 2023-11-06

Informational Add: Fake Opposition: Elitarian Puppets Pretending to Oppose the Elitarian Puppets on the other side but in fact both sides acting for the same agenda of Totalitarian Control and for their Controlling Elitarian Masters. As such they keep on fooling the people, hiding the most important truths and advance more and more the Totalitarian Control agenda of their Elitarian Masters.

Informational Add: Why deflate the parasitic system? Because the parasitic-destructiveness of oversized states and corporations always leads to decay, corruption, injustice, ..., to the destruction of its many hosts, the people, the working and creative people, the maimed and dying slaves of the elites. See examples below.

Informational Add: Pattern Deduction AI in Connect Four 2023-09-21: An AI trying to do it the Human way - Pattern re0ppp I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way.

Informational Add: The Parasitic System 2024-08-07: They simply evolve their-selves to extinction. Darwin at work.

Informational Add: Lokaal ruilen is een onontbeerlijke methode om het parasitaire systeem te deflateren!

Informational Add: Flemish Tasty Forest 2023: 160 m2 wild food forest and food garden - harvest score 2023-11-06

Informational Add: The Parasitic System 2023-12-13: Lets Deflate the Parasitic System!

Informational Add: Pattern Deduction AI Connect 4 in 2 Moves: An AI trying to do it the Human way-re1ppp-re0ppp I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way.

Informational Add: Tumia.org is hosted and powered by One.com. Start your website with one.com - Start building your dream online with an easy-to-use and affordable website builder.

Informational Add: More Dangerous Sars-Cov-2 variants by creating biological niches for those variants and by Vaids?

Informational Add: Pattern Deduction AI in Connect Four in 3 Moves 2024-09-24: An AI trying to do it the Human way - Patterns re0re1pp, re0re0pp, re2ppp, re1ppp, re0ppp and pppp I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way.

Informational Add: Estimated Extra Deaths 31 Million and Estimated Adverse Effects 1.9 Billion for 3 Years of Covid Killing Protocols, Sars-Cov-2 Virus and Vaccine Bioweapons. By country. Audio-video version.

Informational Add: Timelapse of almost 8 hours of relentless persistent trailing, chemtrailing, wavering and hazing trails. I'm hoping somebody can send me the detailed science about trails, about how long types of trails can last under which conditions? #2024-02-01 8:30 AM - #Beautiful #Skies+#Clouds+#Trails of #Sint-#Lievens-#Houtem - #Belgium East-#Flanders #FHD #Speed x 256: 7:45:04->1:49 - #BeautifulSkies

Informational Add: Skateboarding Hardflip

Informational Add: Vlaams LekkerBos 2023: 160m2 wild voedselbos en voedseltuin - tussenstand 2023-11-06

Informational Add: Fake Opposition: Elitarian Puppets Pretending to Oppose the Elitarian Puppets on the other side but in fact both sides acting for the same agenda of Totalitarian Control and for their Controlling Elitarian Masters. As such they keep on fooling the people, hiding the most important truths and advance more and more the Totalitarian Control agenda of their Elitarian Masters.

Informational Add: Why deflate the parasitic system? Because the parasitic-destructiveness of oversized states and corporations always leads to decay, corruption, injustice, ..., to the destruction of its many hosts, the people, the working and creative people, the maimed and dying slaves of the elites. See examples below.

Informational Add: Pattern Deduction AI in Connect Four 2023-09-21: An AI trying to do it the Human way - Pattern re0ppp I think the concept of pattern deduction will be a central and main paradigm in AI because it does not depend on huge computing power and memory size as brute force AI does. In fact pattern deduction is an attempt to simulate a more human and as such smarter form of modelling and reasoning than brute force: an AI trying to do it the human way.

Informational Add: The Parasitic System 2024-08-07: They simply evolve their-selves to extinction. Darwin at work.

Informational Add: Lokaal ruilen is een onontbeerlijke methode om het parasitaire systeem te deflateren!
Ontwerp & Kopiëerrecht 2010-2023: www.tumia.org - LAMP pagina gemaakt in 0.017743 sec.. - Tribute to Mama, Papa, ... - 
Share
Informational Add Above
>>

De meeste hyperlinken om op Tumia te navigeren zijn geïmplementeerd met Javascript. Niettemin om crawlers in staat te stellen deze hyperlinken gemakkelijk te herkennen werden zij ook toegevoegd in deze sectie als simpele html href hyperlinken. Deze laatst vernoemde hyperlinken zijn echter niet zeer geschikt en daarom niet aangewezen om te navigeren op Tumia.

|< <-- --> EN FR NL SW Ascot Residence Watamu of class Accommodatie De Belgische Apenkaste of class Artikel Bamburi natuurpark of class Attractie Kat of class Dier Hydro-electriciteit of class Energie een Belgische Belbus of class Foto Christendom of class Godsdienst Niveau 1 Internet Domeinen in Tumia of class Grafiek 00e89d5.netsolhost.com of class Internet Domein java Object.equals(java.lang.Object) controleert een operator enum of class Java Code Voorbeeld java.lang.Object of class Java Klasse java.lang.Object.clone() of class Java Methode Tandarts Joblijst in België of class Joblijst Vluchtkosten Vergelijking of class Kennis Globale Opwarming van de Aarde 2000 AD of class Klimaatsverandering Australië of class Land Benelux of class Landenunie Lidwoorden in het Nederlands of class Leerdoel Brussels Airlines of class Luchtvaartmaatschappij Bob Marley of class Persoon 's-Hertogenbosch of class Plaats Muffin of class Recept Reclame of class Sector De Nederlandse Taal of class Taal Bonenteelt of class Teelt Human-Caused Poisoning of Life and Earth: Poisoned Fields - Glyphosate, the underrated risk? of class Video Aardrijkskunde Leren: Kaarten van België in het Nederlands of class Video Afspeellijst @ArchiveOrg Frontline Workers Testimonies and VAERs Covid Vaccination Adverse Events – March 2021 @CNN A growing number of US colleges and univs are requiring students to get Covid-19 vaccinations @CNN FDA will evaluate Pfizers request to allow Covid-19 vaccine for children ages 12-15 as quickly @CNN To end this pandemic, weve got to get everyone in our country vaccinated, US surgeon general @DeStandaard Jan Jambon: ‘Voor de zomer krijgen alle inwoners van Vlaanderen minstens één prik’ @Forbes Travel Check: This Is The World On Covid @OregonHealth Frequently asked questions about the COVID-19 vaccine for 16- and 17-year-olds @ReturnToNow Biden Picks Mr. Monsanto Tom Vilsack to Head the USDA @REUTERS India s coronavirus deaths exceed 200,000 after record surge in cases @RTE Germany restricts AstraZeneca vaccine for under 60s @UNICEF Help spread the word that COVID-19 vaccines are safe and effective @VRT Premier De Croo in Karrewiet: Ook kinderen zullen na de zomer een vaccin kunnen krijgen Covid Australia 2021-11-15: Mass Vaccinated-Cases 290x Worse-Deaths 142 against 0 vs 2020-11 Not MV Covid Australië 2022-02-09: Massagevaccineerd-Gevallen 5075x-Doden 2651 329pc Meer vs 2020:7-21:2 NM Covid België 2021-08-26: Massagevaccineerd-Gevallen 3.5x Erger-Doden 2x Erger vs 2020-08 Niet MV Covid België 2021-09-20: Massagevaccineerd-Gevallen 2.9x Erger-Doden 2.7x Erger vs 2020-09 Niet MV Covid België 2022-01-05: 6,9 Miljoen Mensen (60 percent) hebben Vaccinatie Booster 1 niet genomen Covid Canada 2021-08-26: Mass Vaccinated-Cases 6x Worse-Deaths 2x Worse vs 2020-08 Not Mass V Covid Canada 2021-09-20: Mass Vaccinated-Cases 4.7x Worse-Deaths 5.5x Worse vs 2020-09 Not Mass V Covid Canada 2021-09-30: Mass Vaccinated-Cases 3.1x Worse-Deaths 5.0x Worse vs 2020-09 Not Mass V Covid Denemarken 2022-02-20: Massagevaccineerd-Gevallen 96x-O-Doden 2346 355pc Meer vs 20:7-21:2 NMV Covid Denmark 2021-09-11: Mass Vaccinated-Cases 4x Worse-Deaths 5x Worse vs 2020-09 Not Mass V Covid Duitsland 2021-08-30: Massagevaccineerd-Gevallen 7.5x Erger-Doden 3.3x Erger vs 2020-08 Nt MV Covid Duitsland 2021-10-15: Massagevaccineerd-Gevallen 2.7x Erger-Doden 3.6x Erger vs 2020-10 Nt MV Covid Duitsland 2021-11-28: Massagevaccineerd-Gevallen 2.7x Erger-O-Doden 2.0x Erger vs 2020:7-11 NM Covid Ireland 2021-08-29: Mass Vaccinated-Cases 19x Worse-Deaths 2.0x Worse vs 2020-08 Not Mass V Covid Ireland 2021-09-30: Mass Vaccinated-Cases 5.6x Worse-Deaths 4.3x Worse vs 2020-09 Not Mass V Covid Israel 2021-08-23: Mass Vaccinated-Cases 4.0x Worse-Deaths 2.0x Worse vs 2020-08 Not Mass V Covid Israel 2022-03-06: Massagevaccineerd-E-Doden 2580 Meer vs Bij Natuurlijke Imm. 2021:7-22:3 Covid Nederland 2021-08-26: Massagevaccineerd-Gevallen 5x Erger-Doden 2x Erger vs 2020-08 Niet MV Covid Nederland 2021-09-20: Massagevaccineerd-Gevallen 2.5x Erger-Doden 1.7x Erger vs 2020-09 Nt MV Covid Nederland 2021-11-28: Massagevaccineerd-Gevallen 2.6x Erger-O-Doden 2.8x Erger vs 2020-11 N MV Covid Nederland 2022-01-02: Massagevaccineerd-Gevallen 1.7x-O-Doden 4443 61pc Meer vs 2020:7-12 NMG Covid Nederland 2022-07-15: Massagevaccineerd-O-Doden 8303 Meer vs Natuurl. Immuniteit 2021:7-22:6 Covid Rusland 2022-01-31: Massagevaccineerd-E-Doden 314828 Meer vs Bij Natuurlijke Imm. 2021:7-22:1 Covid Rusland 2022-08-11: Massagevaccineerd-O-Doden 380516 Meer vs Natuurl. Immuniteit 2021:7-22:6 Covid Singapore 2021-08-31: Mass Vaccinated-Cases 1.2x Worse-Deaths 18-0 vs 2020-08 Not Mass V Covid Singapore 2021-09-30: Mass Vaccinated-Cases 73x Worse-Deaths 40-0 vs 2020-09 Not Mass V Covid Singapore 2021-10-31: Mass Vaccinated-Cases 424x Worse-Deaths 312 against 1 vs 2020-10 Not MV Covid Singapore 2022-03-11: Massagevaccineerd-Gevallen 555x-Doden 1090 36333pc Meer vs 20:7-3 NMV Covid Thailand 2022-07-22: Massagevaccineerd-O-Doden 83926 Meer vs Natuurl. Immuniteit 2021:7-22:6 Covid UK 2021-08-29: Mass Vaccinated-Cases 29x Worse-Deaths 9x Worse vs 2020-08 Not Mass V Covid UK 2021-09-30: Mass Vaccinated-Cases 8.9x Worse-Deaths 4.4x Worse vs 2020-09 Not Mass V Covid UK 2021-11-07: Mass Vaccinated-Cases 1.3x Worse-E-Deaths 5.2x Worse vs 2020:7-11 Not Mass V Covid UK 2022-01-02: Mass Vaccinated-Cases 2.1x Worse-E-Deaths 12562 57pc More vs 2020:7-12 Not MV Covid Uruguay 2022-03-14: Massagevaccineerd-Gevallen 0.9x-Doden 825 120pc Meer vs 2020:7-21:3 N MV Covid US 2021-08-23: Mass Vaccinated-Cases 3.5x Worse-Deaths the Same vs 2020-08 Not Mass V Covid US 2021-09-14: Mass Vaccinated-Cases 4x Worse-Deaths 1.5x Worse vs 2020-09 Not Mass V Covid US 2021-09-30: Mass Vaccinated-Cases 4.2x Worse-Deaths 2.5x Worse vs 2020-09 Not Mass V Covid US 2021-10-31: Mass Vaccinated-Cases 3.2x Worse-Deaths 1.8x Worse vs 2020-10 Not Mass V Covid VS 2022-01-12: 257,7 Miljoen Mensen (77 percent) hebben Vaccinatie Booster 1 niet genomen Covid VS 2022-01-29: 247,6 Miljoen Mensen (74 percent) hebben Vaccinatie Booster 1 niet genomen Covid VS 2022-02-25: 240,9 Miljoen Mensen (72 percent) hebben Vaccinatie Booster 1 niet genomen Covid VS 2022-03-06: Massagevaccineerd-E-Doden 216214 Meer vs Bij Natuurlijke Immuniteit 2021:7-22:3 Covid Wereld 2022-03-14: 1ste Massagevaccineerde Jaar: Geschatte Extra Doden 2,2M en Nad. Eff. 193M Covid Wereld 2022-03-22: Bij Natuurlijke Immuniteit, O-Doden 2021-22 57pc van Piek 2020-21 Plausibel Covid Wereld 2022-04-13: 1ste Massagevaccineerde Jaar: Geschatte Extra Doden 3,2M-Nd.Eff.276M vs VNI Covid Wereld 2022-05-10: 1ste Massagevaccineerde Jaar: Geschatte Extra Doden 3,4M-Nd.Eff.294M vs VNI Covid Wereld 2022-09-17: Massavaccinatie Doden, Schade, Data, Oorzakelijke Verbanden, ... Covid Wereld 2022-10-01: 3 Jaar Sars-Cov-2-Vaccin Biowapens: Geschatte Extra Doden 28M-Nd. Eff. 895M Covid Wereld 2022-10-09: 3 Jaar Sars-Cov-2-Vaccin Biowapens: Geschatte Extra Doden 31M-Nd.Eff. 1.9MJ De Belgische Apenkaste De Belgische Chocoladekaste De Belgische Griezel Bart De Wever en de N-VA - Uitbreiding van het Cordon Sanitaire De Elites 2022-03-08: Waarom creëren de Macht- en Geldelites Energie en andere Schaarste? De Fenomenen die Dominante Aandrijvers zijn voor de Perm Massa-Extinctie en de Hedendaagse AGW ME De Kolossale Vergissing van de Onderschatting van Klimaatverandering en van de zesde Massa-Extinctie De Vele Totalitaire Covid Concepten en Maatregelen De Verplichte Mondmaskerdracht – Beter Wandelen Boven de Verse Ademwolk van Muilkorfloze Voorgangers De Verplichte Mondmaskerdracht – Een Totalitaire Covid Maatregel – De Belg Laat zich Muilkorven De Verplichte Mondmaskerdracht – Marcheren in de Verse Ademwolk van jullie Gemuilkorfde Voorgangers De zeer Dubieuze Wereldwijde Covid en Vaccinatie Agenda Feitencontrole - Valse Bewering: “Covid Dodental” impliceert dat Covid de Dominante Doodsoorzaak is Oorlog Rusland vs Oekraïne 2022-02-10: Msm van Covid naar Totalitaire (Wereld)Oorlog(III) Propaganda Pattern Deduction AI Connect 4 in 2 2024-09-08: An AI trying to do it the Human way - re1ppp-re0ppp Pattern Deduction AI Connect 4 in 3 2024-09-24: An AI trying to do it the Human way - re0re1pp ... Pattern Deduction AI Connect 4 in 4 Moves 2024-11-09: An AI trying to do it the Human way-re3ppp ... Pattern Deduction AI in Connect Four 2023-02-19: An AI trying to do it the Human way - Pattern pppp Pattern Deduction AI in Connect Four 2023-09-21: An AI trying to do it the Human way-Pattern re0ppp Taken 2024-03-05: Extreme vervalsing van de Onderzoeks- en Rechtsgang in vos dossiers The Colossal Mistake of Underestimating the Death Spreading Agriculture and Meat Industry The Contemporary Societal Collapse caused by Climate Change, the 6th Mass Extinction and Inequality The Parasitic System 2023-12-13: Lets Deflate the Parasitic System! The Tumia Bot Tumia Privacy