Faithful flatness of left adjoint to almostification of algebras

I have been reading Bhatt’s notes on perfectoid spaces and I have stumbled upon a fact whose proof I am unable to understand. Specifically, in Remark 4.2.8 Bhatt describes the functor $Amapsto A_{!!}$ from $R^a$-algebras (almost $R$-algebras) to $R$-algebras which is left adjoint to the almostification functor (which is just the localization functor to the category of almost algebras). Bhatt gives as an exercise the statement that even though $(-)_{!!}$ doesn’t preserve flatness, it does preserve faithful flatness.

I have been unable to solve this myself, so I followed the reference to Gabber-Ramero’s Almost ring theory, Remark 3.1.3. Their argument is short so I replicate it here:

Let $phi:Ato B$ be a morphism of almost algebras. Then $phi$ is a monomorphism iff $phi_{!!}$ is injective; moreover, $B_{!!}/operatorname{Im}(A_{!!})cong B_!/A_!$ is flat over $A_{!!}$ if and only if $B/A$ is flat over $A$, by proposition 2.4.35.

I am able to follow the claims in this argument, but I don’t see how it implies faithful flatness. I suspect there is some faithful flatness criterion at play which I am not aware of, but I couldn’t find it in the literature I’ve checked. Could someone explain how exactly one recovers the result from this argument?

textures – How do I view a Source engine (Left 4 Dead 2) VTF?

I used to use Source a lot, but it’s been a long time. Now I want to look up some Left 4 Dead 2 textures for reference (Hard Rain’s water particles, mainly), but the tools I used to use don’t seem to have the same functionality as they used to, are broken or are new and seemingly broken.

I literally just want to look at VTFs I’ve exported from VPK’s with GCFScape in the manner of a normal image viewer, as if they were .pngs instead of VTFs.

This seems like the best candidate, but I couldn’t get it to open a viewer. Perhaps you can provide some documentation? Hammer might have been a useful texture inspector for me, except its thumbnails are restricted to 512×512 or lower viewing size.

Can anybody help me view these images in a vaguely straight-forward non-console GUI-ish manner? Like I used to be able to? Thank you in advance. =)

plotting – Combination of Left alignment and Rotate messes up Automatic PlotRange

In the following code, left-aligning the inset AND rotating it seems to completely mess up the Automatic PlotRange. Is this intended behavior? If it’s a bug, is there a workaround?

12.1.0.0 on MacOS

good1 = Graphics[{ Circle[{0, 0}, 1], Rotate[Inset[Style["Hi", FontSize -> 50], {0, 0}, Center], 0.5] }];
good2 = Graphics[{ Circle[{0, 0}, 1], Rotate[Inset[Style["Hi", FontSize -> 50], {0, 0}, Left],   0  ] }];
bad   = Graphics[{ Circle[{0, 0}, 1], Rotate[Inset[Style["Hi", FontSize -> 50], {0, 0}, Left],   0.5] }];
{good1, good2, bad}

enter image description here

Add a cloumn to the left side of a dataset

What I am trying to do is to add an id column at the left side of my data set.

This is the data set I am working with. I Have three columns and I want to add a new column on the left side with the column tag ID with the following values: Id={1,2,3,4,5,6}.

Dataset@
 {
  <|"Team name" -> "Chealse", "GF" -> 23, "GA" -> 12|>,
  <|"Team name" -> "Arsenal", "GF" -> 30, "GA" -> 13|>,
  <|"Team name" -> "Burnley", "GF" -> 33, "GA" -> 15|>,
  <|"Team name" -> "Everton", "GF" -> 53, "GA" -> 11|>,
  <|"Team name" -> "Watford", "GF" -> 45, "GA" -> 9|>,
  <|"Team name" -> "Brighton", "GF" -> 24, "GA" -> 7|>
  }

python – When Player Image Scrolling Left, Enemy Mob Scrolls To How Do I fix This?? Pygame

I have a problem with my enemy where when my player scrolls left the enemy scrolls with the player is there anyway to fix this even Video my full code is below its to long to fit here though

what I was trying to do is make my enemy not to change its position when my window is scrolling its doing the same for right and left keeps following the player


while runninggame:
    clock.tick(FPS)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            runninggame = False
  (...)
# I did the same for my players key movement  this part suppose to not make my player scroll
if playerman.y < 250:
        playerman.y += 1
        for platform in platforms:
            platform.y += playerman.speed
        for enemys in enemying:
            enemys.y += playerman.speed

my enemy class

class enemy:
    def __init__(self,x,y,height,width,end):
        self.x = x
        self.y =y
        self.esright = (pygame.image.load("esright1.png"),
        pygame.image.load("esright1.png"),
        pygame.image.load("esright2.png"),
        pygame.image.load("esright3.png"),
        pygame.image.load("esright4.png"),
        pygame.image.load("esright5.png"),
        pygame.image.load("esright6.png"),
        pygame.image.load("esright7.png"),
        pygame.image.load("esright8.png"),
        pygame.image.load("esright9.png"),
        pygame.image.load("esright10.png"),
        pygame.image.load("esright11.png"),
        pygame.image.load("esright12.png"),
        pygame.image.load("esright13.png"),
        pygame.image.load("esright14.png"),
        pygame.image.load("esright15.png"),
        pygame.image.load("esright16.png"),
        pygame.image.load("esright17.png"),
                          )
        self.esleft = (pygame.image.load("esleft1.png"),
        pygame.image.load("esleft1.png"),
        pygame.image.load("esleft2.png"),
        pygame.image.load("esleft3.png"),
        pygame.image.load("esleft4.png"),
        pygame.image.load("esleft5.png"),
        pygame.image.load("esleft6.png"),
        pygame.image.load("esleft7.png"),
        pygame.image.load("esleft8.png"),
        pygame.image.load("esleft9.png"),
        pygame.image.load("esleft10.png"),
        pygame.image.load("esleft11.png"),
        pygame.image.load("esleft12.png"),
        pygame.image.load("esleft13.png"),
        pygame.image.load("esleft14.png"),
        pygame.image.load("esleft15.png"),
        pygame.image.load("esleft16.png"),
        pygame.image.load("esleft17.png"),
                          )
        self.esright = (pygame.transform.scale(image,(image.get_width()//3,image.get_height()//3)) for image in self.esright)
        self.esleft = (pygame.transform.scale(image,(image.get_width()//3,image.get_height()//3)) for image in self.esleft)
        self.height = height
        self.width = width
        self.anim_index = 0
        self.distance = 80
        self.speed = 8
        self.vel = 3
        self.path = (x,end)
        self.walking_index = 0
        self.rect = pygame.Rect(x,y,height,width)
       def draw(self,window):
       self.move()
       if self.Walking_index + 1 >= 33:
           self.Walking_index = 0
       if self.vel > 0:
           window.blit(self.esright(self.Walking_index//3), (self.x,self.y))
           self.Walking_index += 1
       else:
           window.blit(self.esleft(self.Walking_index//3), (self.x,self.y))
           self.Walking_index += 1
       def move(self):
       if self.vel > 0:
           if self.x + self.vel < self.path(1):
               self.x += self.vel
           else:
               self.vel = self.vel * -1
               self.Walking_index = 0
       else:
           if self.x - self.vel >  self.path(0):
               self.x += self.vel
           else:
               self.vel = self.vel * -1
               self.Walking_index = 0


where I defined the enemy class

black = (0,0,0)
enemys1 = enemy(550,436,50,50,300)
enemys = (enemys1)

heres my full code script

How should we define the behavior of a Turing machine where the head tries to move left from the leftmost tape position?

If we have a Turing machine in a model with a tape that is infinite only to the right and assume at some point the head tries to move left from the leftmost position.

How should we define the behavior in such a case? Is a machine doing so for some input not a valid Turing machine? And if so, how can we make sure when we define a Turing machine that this situation can’t occur for any input?

I’ve read some sources about Turing machines though couldn’t find the answer to this specific case, and I see no reason why this case won’t happen for an arbitrary Turing machine and some input.