Class:
Navigation:
 0-0     
Instance:
Relationship:
Domain:
Links:

Pattern Deduction AI in Connect Four in 1 Move 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, ... .

A pattern set (pset) is a cohesive set of patterns realising a win in x moves. A standalone pset is a pset that does not depend on extra conditions for all the remaining columns of the board. An all columns pset does depend on extra conditions for all the remaining columns of the board.

There exist one main path for deducing standalone psets going from connects 4 in 0 to connects 4 in 1 move (0->1 winning moves). In other words one main path for deducing the standalone pset re0ppp for connects 4 in 1 from the one pset pppp of connects 4 in 0 moves. This is the omission path or in the opposite direction, from 1 to 0 winning moves, the completion path. Pppp is the one pset of 4 in 0 moves. Player completed pppp with its previous move. To backtrack this one move one p has to be omitted from pppp and replaced by an empty position. As such re0ppp is deduced by ommission of a p from pppp.

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)

Standalone Pset 1.1

This is thus the standalone pset 1.1 (re0ppp) of 4 in 1 deduced from the standalone pset 0.1 (pppp) from 4 in 0 moves. 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
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:SPSSPSPPSEPSSSPPEPPPSPPEPPSSSEESEEPEEESEESE &relationship=All&drsid=0&pisid=0&page=1
https://www.tumia.org/en/directory/en/instance.php?tiname= Connect%20Four:PPSSPSPPSSPSSSPPEPPPSPEEPPSSSEESEEPEEEEEESE &relationship=All&drsid=0&pisid=0&page=1
Twitter:
https://x.com/nesta_red/status/1881992425096536535















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: 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!

Informational Add: Flemish Tasty Forest 2023: 160 m2 wild food forest and food garden - harvest score 2023-11-06
Design & Copyright 2010-2023: www.tumia.org - LAMP page generated in 0.013169 seconds. - Tribute to Mama, Papa, ... - 
Share
Informational Add Above
>>

Most hyperlinks for navigating on Tumia are implemented using Javascript. Nevertheless to enable crawlers to easily recognize those hyperlinks they also have been added in this section as plain html href hyperlinks. The latter hyperlinks are however not very useful and hence not recommended for navigating on Tumia.

|< <-- --> EN FR NL SW Ascot Residence Watamu of class Accommodation Brussels Airlines of class Airline Cat of class Animal The Belgian Monkey Caste of class Article Bamburi nature park of class Attraction Level 1 Internet Domains in Tumia of class Chart Earth Global Warming 2000 AD of class Climate Change Connect Four:PEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE of class Connect Four Connect Four Test Webpage of class Connect Four Test Australia of class Country Growing Beans of class Cultivation Hydroelectricity of class Energy 00e89d5.netsolhost.com of class Internet Domain java.lang.Object of class Java Class java Object.equals(java.lang.Object) checks an operator enum of class Java Code Example java.lang.Object.clone() of class Java Method Dentist Joblist in Belgium of class Joblist Airfare Comparison of class Knowledge The Dutch Language of class Language Articles in Dutch of class Learning Goal Pattern Deduction: Connect 4 in 1 Move of class Pattern Deduction Connect 4 Pattern Set 0.s.1 of class Pattern Set Connect 4 Ecosystem Pset Feed on Figs of class Pattern Set Ecosystem Bob Marley of class Person a Belgian Callbus of class Picture 's-Hertogenbosch of class Place Muffin of class Recipe Christianity of class Religion Advertising of class Sector Benelux of class Union of Countries Human-Caused Poisoning of Life and Earth: Poisoned Fields - Glyphosate, the underrated risk? of class Video Learning Geography: Maps of Belgium in Dutch of class Video Playlist @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 Australia 2022-02-09: Mass Vaccinated-Cases 5075x-Deaths 2651 329pc More vs 2020:07-21:02 NMV Covid Belgium 2021-08-26: Mass Vaccinated-Cases 3.5x Worse-Deaths 2x Worse vs 2020-08 Not Mass V Covid Belgium 2021-09-20: Mass Vaccinated-Cases 2.9x Worse-Deaths 2.7x Worse vs 2020-09 Not Mass V Covid Belgium 2022-01-05: 6.9 Million People (60 percent) did Not take Vaccination Booster 1 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 Denmark 2021-09-11: Mass Vaccinated-Cases 4x Worse-Deaths 5x Worse vs 2020-09 Not Mass V Covid Denmark 2022-02-20: Mass Vaccinated-Cases 96x-E-Deaths 2346 355pc More vs 2020:7-21:2 Not MV Covid Germany 2021-08-30: Mass Vaccinated-Cases 7.5x Worse-Deaths 3.3x Worse vs 2020-08 Not Mass V Covid Germany 2021-10-15: Mass Vaccinated-Cases 2.7x Worse-Deaths 3.6x Worse vs 2020-10 Not Mass V Covid Germany 2021-11-28: Mass Vaccinated-Cases 2.7x Worse-E-Deaths 2.0x Worse vs 2020:7-11 Not MV 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: Mass Vaccinated-E-Deaths 2580 More vs With Natural Immunity 2021:7-22:3 Covid Netherlands 2021-08-29: Mass Vaccinated-Cases 5x Worse-Deaths 2x Worse vs 2020-08 Not Mass V Covid Netherlands 2021-09-20: Mass Vaccinated-Cases 2.5x Worse-Deaths 1.7x Worse vs 2020-09 Not MV Covid Netherlands 2021-11-28: Mass Vaccinated-Cases 2.6x Worse-E-Deaths 2.8x Worse vs 2020-11 Not MV Covid Netherlands 2022-01-02: Mass Vaccinated-Cases 1.7x-E-Deaths 4443 61pc More vs 2020:7-12 NMV Covid Netherlands 2022-07-15: Mass Vaccinated-E-Deaths 8303 More vs Natural Immunity 2021:7-22:6 Covid Russia 2022-01-31: Mass Vaccinated-E-Deaths 314828 More vs With Natural Immunity 2021:7-22:1 Covid Russia 2022-08-11: Mass Vaccinated-E-Deaths 380516 More vs Natural Immunity 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: Mass Vaccinated-Cases 555x-Deaths 1090 36333pc More vs 2020:7-21:3 NMV Covid Thailand 2022-07-22: Mass Vaccinated-E-Deaths 83926 More vs Natural Immunity 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: Mass Vaccinated-Cases 0.9x-Deaths 825 120pc More vs 2020:7-21:3 Not 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 US 2022-01-12: 257.7 Million People (77 percent) did Not take Vaccination Booster 1 Covid US 2022-01-29: 247.6 Million People (74 percent) did Not take Vaccination Booster 1 Covid US 2022-02-25: 240.9 Million People (72 percent) did Not take Vaccination Booster 1 Covid US 2022-03-06: Mass Vaccinated-E-Deaths 216214 More vs Assumed Natural Immunity 2021:7-22:3 Covid World 2022-03-14: 1st Mass Vaccinated Year: Estimated Extra Deaths 2.2M and Adv. Eff. 193M Covid World 2022-03-22: Assuming Natural Immunity, E-Deaths 2021-22 57pc of Peak 2020-21 Plausible Covid World 2022-04-13: 1st Mass Vaccinated Year: Estimated Extra Deaths 3.2M-Adv. Eff. 276M vs ANI Covid World 2022-05-10: 1st Mass Vaccinated Year: Estimated Extra Deaths 3.4M-Adv. Eff. 294M vs ANI Covid World 2022-09-17: Mass Vaccination Deaths, Damages, Data, Causal Links, Sacrificed ... Covid World 2022-10-01: 3 Years of Cov-Vaccine Bioweapons: Estimated Extra Deaths 28M-Adv. Eff. 895M Covid World 2022-10-09: 3 Years of Cov-Vaccine Bioweapons: Estimated Extra Deaths 31M-Adv. Eff. 1.9B De Verplichte Mondmaskerdracht – Een Totalitaire Covid Maatregel – De Belg Laat zich Muilkorven Fact Check - False Claim: “Covid Death Toll” implies that Covid is the Dominant Cause of Death 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 Belgian Chocolate Caste The Belgian Creep Bart De Wever and the N-VA - Expansion of the Cordon Sanitaire The Belgian Monkey Caste The Colossal Mistake of Underestimating Climate Change and the sixth Mass Extinction The Colossal Mistake of Underestimating the Death Spreading Agriculture and Meat Industry The Compulsory Mouth Mask Wear – Better Walk Above the Fresh Breath Cloud of Muzzlefree Predecessors The Compulsory Mouth Mask Wear – Marching in the Fresh Breath Cloud of your Muzzled Predecessors The Contemporary Societal Collapse caused by Climate Change, the 6th Mass Extinction and Inequality The Elites 2022-03-08: Why are the Power and Money Elites creating Energy and other Scarcities? The Many Totalitarian Covid Concepts and Measures The Parasitic System 2023-12-13: Lets Deflate the Parasitic System! The Phenomena Dominantly Driving the Permian Mass Extinction as well as the Contemporary AGW Mass Ex The Tumia Bot The very Dubious Worldwide Covid and Vaccination Agenda Tumia Privacy War Russia vs Ukraine 2022-02-10: The Msm from Covid to Totalitarian (World) War (III) Propaganda