Q:

How can I adjust "tail" to avoid incorrect indentation in Haskell

is there any way to solve this problem with incorrect indentation ? I want to check if every node on a given tree is bigger than it's grandfather (if it has one).
I've written a function that gives all nodes on every level and the idea in the main function is to compare the nodes if they are smaller than their grandchildren. 
data BTree = Empty | Node Int BTree Btree

grandchildrenIncreased :: BTree -> Bool
grandchildrenIncreased Empty = Empty
grandchildrenIncreased BTree = func BTree level
 where f BT n
  | head (level BT n) < head (level BT n+2) = tail (level BT 1)
     (level BT n+2) grandchildrenIncreased f BT (n+1)
  | length (level BT n) == 0 = True
  | otherwise = False

level :: BTree -> Int -> [a]
level Empty _ = []
level (Node n lt rt) 1 = [n]
level (Node _ lt rt) k
 = (level lt (k-1)) ++ (level rt (k-1))

It gives error on the whole line where "tail" is.

A:

It is usually better to use pattern matching. By using pattern matching, the compiler can warn you if you did not cover all possible patterns, and hence it is less likely that your program will error.
That being said, your current attempt has a lot of problems, and not only with indentation.
Your grandchildrenIncreased does not seem to make much sense if we look at the types. For example you write grandchildrenIncreased Empty = Empty, but the result type is a Bool, so it should be True or False.
You also mix type constructors (like BTree) with data constructors. For example your second line grandchildrenIncreased BTree = func BTree level makes not much sense either, since BTree is a type, it is not a specific pattern for tree values.
You also seem to use level in your grandchildrenIncreased to refer both to the level :: BTree -> Int -> [a] function, as well as to some non-existing Int value.
Finally by first converting the tree to lists of levels, you lose the structure of which node is connected to which grandparent, making it hard to check that.
grandchildrenIncreased :: BTree -> Bool
grandchildrenIncreased Empty = True
grandchildrenIncreased n@(Node v l r) =
    all (v <) (level n 3) && grandchildrenIncreased l && grandchildrenIncreased r
We thus check in the case of a Node v l r, if all the values of the level underneath the subtrees l and r are all larger than v, and that the condition also holds for the l and r subtree.
Note that since you constructed a tree of Ints, the most generic type signature for level is:
level :: BTree -> Int -> [Int]
level Empty _ = []
level (Node n lt rt) 1 = [n]
level (Node _ lt rt) k = (level lt (k-1)) ++ (level rt (k-1))
Here it might however be more useful to define a children function:
children :: BTree -> [BTree]
children Empty = []
children (Node _ lt rt) = [lt, rt]
and a way to extract the value of a Node:
treeVal :: BTree -> Maybe Int
treeVal Empty = Nothing
treeVal (Node v _ _) = Just v
then we can derive the values with:
import Data.Maybe(catMaybes)

grandchildrenIncreased :: BTree -> Bool
grandchildrenIncreased Empty = True
grandchildrenIncreased n@(Node v l r) =
    all (v <) (catMaybes (treeVal <$> (children n >>= children))) &&
    grandchildrenIncreased l && grandchildrenIncreased r

