Prelude Syntax-Checker Prelude is an esoteric programming language, which has very few, but unusual, restrictions on what constitutes a valid program. Any block of printable ASCII text ("block" meaning that lines of printable ASCII are separated by newlines - 0x0A) is valid provided that:


Every (vertical) column of text contains at most one of ( and ).
Ignoring their vertical position, the ( and ) are balanced, that is, each ( is paired with exactly one ) to the right of it, and vice versa.


Write a program or function which, given a string containing printable ASCII and newlines, determines if it constitutes a valid Prelude program. You may take input via STDIN (or closest alternative), command-line argument or function argument. The result may be returned or printed to STDOUT, using any two fixed truthy/falsy values of your choice.

You must not assume that the input is rectangular.

This is code golf, so the shortest submission (in bytes) wins.

Examples

The following are valid Prelude programs (in fact, they're even real Prelude programs):

?1-(v  #1)-             
1   0v ^(#    0)(1+0)#)!
    (#)  ^#1-(0 #       




1(#  1) v #  - 1+)
    vv (##^v^+
? v-(0 # ^   #)
?
  1+              1-!


And here are a number of inputs, all of which are invalid:

#(#(##)##)##(
)##(##(##)#)#




#(#)
)###




#(##
(##)




(##)
(#)#




(##)
(###




#(#)
(##)




#(#)
###)




#()#
()##




#(#)##
###
###(#)
Python 2, 128 119 105 bytes
def F(p):
 v=n=1
 for r in map(None,*p.split(&quot;\n&quot;)):A,B=map(r.count,&quot;()&quot;);n+=B-A;v*=n&lt;2&gt;A+B
 return n*v&gt;0

Did you know that you can map None in Python 2?
Explanation
We want to start by transposing the Prelude so that columns become rows. Usually we would do this with zip, but since zip truncates to the shortest row length and itertools.zip_longest is far too long for code-golf, it seems like there's no short way to do what we want...
Except for mapping None:
&gt;&gt;&gt; print map(None,*[[1,2,3],[4],[5,6]])
[(1, 4, 5), (2, None, 6), (3, None, None)]

Unfortunately (or rather, fortunately for all non-golf purposes), this only works in Python 2.
As for n and v:

n acts like a stack, counting 1 - &lt;number of unmatched '(' remaining&gt;. For every ( we see we subtract 1, and for every ) we see we add 1. Hence if n &gt;= 2 at any point, then we've seen too many )s and the program is invalid. If n doesn't finish on 1, then we have at least one unmatched ( remaining.
v checks validity, and starts at 1. If the program is ever invalid (n &gt;= 2 or A+B &gt;= 2), then v becomes 0 to mark invalidity.

Hence if the program is valid, then by the end we must have n = 1, v = 1. If the program is invalid, then by the end we must either have v = 0, or v = 1, n &lt;= 0. Therefore validity can be succinctly expressed as n*v&gt;0.
(Thanks to @feersum for a multitude of good suggestions which took off 14 bytes!)
Previous, more readable submission:
def F(p):
 p=map(None,*p.split(&quot;\n&quot;));v=n=0
 for r in p:R=r.count;A=R(&quot;(&quot;);B=R(&quot;)&quot;);n+=A-B;v|=A+B&gt;1or n&lt;0
 return n&lt;1&gt;v