Simply put, my function compares two AABBs for collision detection, and when they are around the same size it works fine, but I noticed that if I greatly decreased the size of one of them (or augmented the size of the other), then the collision wouldn't be detected correctly; I would have to have them intersect for a collision to be registered rather than having it register when they are at least in direct contact, which is the intended behavior.

Below is my code.

local function DetectCollision(a, b) -- AABB to AABB
  local collisionX = (a.Position.X + a.Size.X) >= b.Position.X and (b.Position.X + b.Size.X) >= a.Position.X
  local collisionY = (a.Position.Y + a.Size.Y) >= b.Position.Y and (b.Position.Y + b.Size.Y) >= a.Position.Y
  local collisionZ = (a.Position.Z + a.Size.Z) >= b.Position.Z and (b.Position.Z + b.Size.Z) >= a.Position.Z
  return collisionX and collisionY and collisionZ
end

EDIT - To be more specific, the issues start to occur when I cut the size of one of the AABBs in half. For instance, if I had two cubes where one's size is 12 on all axes and the other is six on all axes, then the collision will not register. Upon debugging, I noticed that only one of the collision bools will become false. This seems to depend on what axis the smaller bounding box moves from in relation to the bigger one, so if I moved the smaller AABB away from the bigger one on the y-axis, then collisionY will be false.

@1024 Sorry about that, I should have included more information, the original post has been updated.

@Gnollrunner I am using the AABB function found here: https://learnopengl.com/In-Practice/2D-Game/Collisions/Collision-detection

Could you please explain how my logic is faulty?

Here is how I do AABB collision detection. My entities have a Scale factor (1.0 is normal size). This code is available on programming2dgames.com 

//=============================================================================
// Axis aligned bounding box collision detection method
// Called by collision()
// Pre:  &ent = The other Entity.
//       &collisionVector = Set by this function.
// Post: Returns true if collision, false otherwise.
//       Sets collisionVector if collision. The collisionVector points in the
//         direction of force that would be applied to this entity as a result
//         of the collision. The magnitude of the collision vector is the
//         distance the entities are overlapping.
//=============================================================================
bool Entity::collideBox(Entity &ent, VECTOR2 &collisionVector)
{
    // if either entity is not active then no collision may occcur
    if (!active || !ent.getActive())
        return false;

    // Check for collision using Axis Aligned Bounding Box
    if ((this->getCenterX() + edge.right*getScale() >= ent.getCenterX() + ent.getEdge().left*ent.getScale()) &&
        (this->getCenterX() + edge.left*getScale() <= ent.getCenterX() + ent.getEdge().right*ent.getScale()) &&
        (this->getCenterY() + edge.bottom*getScale() >= ent.getCenterY() + ent.getEdge().top*ent.getScale()) &&
        (this->getCenterY() + edge.top*getScale() <= ent.getCenterY() + ent.getEdge().bottom*ent.getScale()))
    {
        // If we get to here the entities are colliding. The edge with the smallest
        // overlapping section is the edge where the collision is occurring.
        // The collision vector is created perpendicular to the collision edge.

        // Calculate amount of overlap between entities on each edge of box
        float overlapX, overlapY;
        if (this->getCenterX() < ent.getCenterX())      // if this entity left of other entity
        {
            overlapX = (this->getCenterX() + edge.right*getScale()) - (ent.getCenterX() + ent.getEdge().left*ent.getScale());
            collisionVector = VECTOR2(-overlapX, 0);    // collison vector points left
        }
        else    // this entity right of other entity
        {
            overlapX = (ent.getCenterX() + ent.getEdge().right*ent.getScale()) - (this->getCenterX() + edge.left*getScale());
            collisionVector = VECTOR2(overlapX, 0);     // collison vector points right
        }
        if (this->getCenterY() < ent.getCenterY())      // if this entity above other entity
        {
            overlapY = (this->getCenterY() + edge.bottom*getScale()) - (ent.getCenterY() + ent.getEdge().top*ent.getScale());
            if (overlapY < overlapX)                    // if Y overlap is smaller
                collisionVector = VECTOR2(0, -overlapY); // collison vector points up
        }
        else    // this entity below other entity
        {
            overlapY = (ent.getCenterY() + ent.getEdge().bottom*ent.getScale()) - (this->getCenterY() + edge.top*getScale());
            if (overlapY < overlapX)                    // if Y overlap is smaller
                collisionVector = VECTOR2(0, overlapY); // collison vector points down
        }

        return true;    // entities are colliding
    }
    return false;       // entities are not colliding
}