An elegant and efficient solution can be achieved by leveraging the fact that the array is sorted. If an element `x` is a majority element (appears more than `n/2` times), then after sorting, it must occupy the middle position of the array. This is a necessary but not sufficient condition.

A stronger condition, which is both necessary and sufficient, can be derived. If `x` is a majority element, and its first occurrence is at `first_index`, then the block of `x`'s must be long enough to extend past the middle of the array. Specifically, the element at `first_index + n // 2` must also be `x`.

This leads to a simple and efficient algorithm:
1.  Use binary search to find the index of the first potential occurrence of `x`. This is equivalent to finding the "leftmost" insertion point for `x`.
2.  Calculate the index `majority_check_index = first_index + n // 2`.
3.  If `majority_check_index` is a valid index within the array and the element at that index is `x`, then `x` is a majority element. Otherwise, it is not.

This approach has a time complexity of O(log n) due to the binary search.

```python
def is_majority(arr, n, x):
    """
    Checks if x is a majority element in a sorted array.

    A majority element is an element that appears more than n / 2 times.

    Args:
        arr: A sorted list of numbers.
        n: The size of the list arr.
        x: The element to check for majority.

    Returns:
        True if x is a majority element, False otherwise.
    """
    if n == 0:
        return False

    # Find the first index 'i' where arr[i] >= x. This is equivalent to
    # finding the leftmost insertion point for x.
    low = 0
    high = n - 1
    first_index = -1

    while low <= high:
        mid = low + (high - low) // 2
        if arr[mid] >= x:
            # This could be the first occurrence, or an element greater than x.
            # In either case, this is a potential candidate for the first index.
            first_index = mid
            high = mid - 1
        else:
            # arr[mid] < x, so the first occurrence must be to the right.
            low = mid + 1
    
    # If x was not found (or all elements are smaller than x), first_index
    # will be -1 or point to an element larger than x.
    # The following logic correctly handles these cases.
    if first_index == -1:
        # This case happens if all elements are smaller than x.
        return False

    # To be a majority element, if x starts at first_index, it must also
    # be present at index first_index + n // 2.
    majority_check_index = first_index + n // 2

    # The index must be within the array bounds, and the element at that
    # index must be x.
    if majority_check_index < n and arr[majority_check_index] == x:
        return True
    
    return False

```