TITLE: Intuitionistic logic plus $A → B \lor C \vdash ( A → B ) \lor ( A → C )$
QUESTION [12 upvotes]: The following is a classically valid deduction for any propositions $A,B,C$.
$\def\imp{\rightarrow}$

$A \imp B \lor C \vdash ( A \imp B ) \lor ( A \imp C )$.

But I'm quite sure it isn't intuitionistically valid, although I don't know how to prove it, which is my first question.
If my conjecture is true, my next question is what happens if we add this rule to intuitionistic logic. I do not think we will get classical logic. Is my guess right?
[Edit: The user who came to close and downvote this 4 years after I asked this presumably did not see my comment: "The BHK interpretation suggests to me that it isn't intuitionistically valid, but that's just my intuition...". If you are not familiar with Kripke frames (and I was not at that time), good luck trying to figure out what to try!]

REPLY [2 votes]: It's interesting to me that different people's intuitions were so different on this. Different models are helpful with different examples, and nobody in the thread mentioned the connection between intuitionistic logic and programming language semantics, which for this example I found very helpful.
In the programming language model, $$(A\to(B\lor C))\to((A\to B)\lor(A\to C))$$ is the type of a function $f$ which is given a value $in$ of type $$A\to(B\lor C)$$ and which transforms it into a value $out$ of type $$(A\to B)\lor(A\to C).$$  How might we implement such a function $f$?
An experienced computer programmer will think something like this:

I would need to produce a function that turns $A$ into $B$.  I can't do that because all I have is a function that turns $A$ into $B\lor C$ and it might not give me the $B$ I need.

That's the intuition.  The intuition is a shortcut for the following thought process.
In code, our function $f$ will look like this:
def f in = out   where    -- `in` has type A → (B ∨ C)
   out = ???              -- `out` should have type (A → B) ∨ (A → C)

$\def\lt{\mathtt{Left}\ }\def\rt{\mathtt{Right}\ }$
A value of type $(A\to B)\lor(A\to C)$ must have the form $\lt out_L$ where $out_L$ has type $A\to B$, or $\rt out_R$ where $out_R$ has type $A\to C$.  Those are the only two choices. Let's try the first one:
def f in = out   where      -- `in` has type A → (B ∨ C)
   out        = Left outL   -- `outL` should have type A → B

Since outL has type $A\to B$, it is a function that takes a value of type $A$ and turns it into a value of type $B$:
def f in = out   where    -- `in` has type A → (B ∨ C)
   out        = Left outL 
   outL a     = ???       -- we want to produce a value of type B

Where is $out_L$ going to get a value of type $B$?  The only tools it has available are $in$ (of type $A\to(B\lor C)$) and $a$ (of type $A$) and there is only one thing it can do with these: it must give the argument $a$ to the function $in$, producing a result of type $B\lor C$:
def f in = out where      -- `in` has type A → (B ∨ C)
   out        = Left outL 
   outL a     = ?? in a ??  -- `in a` has type B ∨ C
                            --  we want to produce a value of type B

The in a expression produces a value of type $B\lor C$.  A value of type $B\lor C$ looks either like $\lt b$ or like $\rt c$, so we need a case expression to handle the two cases.
def f in = out where      -- `in` has type A → (B ∨ C)
   out        = Left outL 
   outL a     = case  in a  of    -- we want to produce a value of type B
                   Left b  -> ???
                   Right c -> ???

In the $\lt b$ case it's easy to see how to proceed: just return the $b$:
def f in = out where      -- `in` has type A → (B ∨ C)
   out        = Left outL 
   outL a     = case  in a  of      -- we want to produce a value of type B
                   Left b  -> b   -- … and we did!
                   Right c -> ???

In the $\rt c$ case there's no way to proceed, because $out_L$ has available a value $c$ of type $C$, but it still needs to produce a value of type $B$ and it has no way to get one.  There is no way to complete the implementation.
Perhaps we made a mistake back at the beginning when we chose to define out = Left outL?  Would out = Right outR work better?  No, the problem will be exactly the same:
def f in = out where      -- `in` has type A → (B ∨ C)
   out        = Right outR 
   outR a     = case  in a  of      -- we want to produce a value of type C
                   Left b  -> ??? -- … but we don't have one 
                   Right c -> c  

This exhausts the possibilities. There is no way to implement $f$.
The points I want to make here are not only that programmers can and do acquire this sort of intuition for what can't be implemented and why not, but also that they can convert the intuition into an argument that doesn't rely on the intuition alone.  Once the intuition is  turned a detailed argument, the Curry-Howard correspondence can be used to convert the failed implementation directly to an LJ sequent calculus proof or analytic tableau proof that the statement is invalid.
[ Addendum: Note by the way that the reverse implication, which is intuitionistically valid, is easy to prove and just as easy to construct a program:
def fINV out a =   -- fINV has type ((A→B)∨(A→C))→(A→(B∨C))
  case out of Left  outL -> Left  (outL a)  -- outL has type A→B
              Right outR -> Right (outR a)  -- outR has type A→C

and again the Curry-Howard correspondence converts the program into a proof or vice-versa. ]