Reductions between LIS and LCS
Given an oracle that returns both the length and the subsequence for the Longest Increasing Subsequence of a given input $A$ of $n$ elements $\text{LIS}(A,n)$, can one use a polynomial number of calls to it to find the length of the Longest Common Subsequence of two sequences $A$ and $B$ ($\text{LCS}(A,B)$)? If so, how few calls can we query the LIS oracle in order to find the length of $\text{LCS(A,B)}$?


Well, we can find $\text{LCS}(A,B)$ without any call to the oracle since we can just run any algorithm that finds $\text{LCS}(A,B)$ such as brutal force or a solution by dynamic programming.

What you intended to ask was how much we can reduce the time-complexity of algorithms that find $\text{LCS}(A,B)$ if the oracle is available. The time-complexity will consist of two parts. One part comes from ordinary operations, and the other part comes from the calls to the oracle. There are two questions here.

Question one. Can we use less ordinary operations (asymptotically) with the availability of the oracle?

Question two.  If we can, how few calls to the oracle are needed to lower the complexity of the ordinary operations?

When one of $A$ and $B$ consists of distinct elements

Suppose the elements in $A$ are distinct. Here is an algorithm that employs the oracle. The idea of the algorithm is that if we regard the natural order of elements in $A$ according to the indices as defining a strictly increasing order, a common subsequence of $A$ and $B$ is exactly an increasing subsequence of $B$. 


Keeping $A$ intact, sort $A$ into a new sequence $\alpha$.
Initialize a new sequence $I$.
For $i$ from 0 to size($B$) exclusive, try finding the index $j$ such that $A[j]$ is $B[i]$. If found, append $\alpha[j]$ to $I$.
Return the length that is returned by the oracle given sequence $I$.


There are two ways to implement step 2.


If the elements in $A$ and $B$ can be totally ordered, we can sorted the elements in $A$, keeping track of each element's index in $A$. Then a binary search can find that index $j$.
Construct a hash set whose elements are $(A[i],i)$ for all $i$, where the hash depends only on $A[i]$. Then we can use the hash set to find that index $j$. 


So an answer to question one and two is that we can use a single call to the oracle to lower the complexity of the ordinary operations from $O(nm)$ to


$O(n\log n + m \log n)$ when $m\gg\log n$ or
$O(m)$ if the operation of finding an element in a hashset is considered $O(1)$.


Here $n$ is the number of distinct elements in one array and $m$ is the number of the elements in the other array.



When both $A$ and $B$ contain duplicate elements

It is not clear how we can take advantage of the oracle in order to reach a positive answer to question one. Instead, here is a conditional hardness result. 

It is not possible to find $LCS(A,B)$ in time $O(n^{2 - \epsilon})$ for any positive constant $\epsilon$ where $n$ is the length of $A$ and $B$, if we can assume the strong exponential time hypothesis. This is shown in Tight Hardness Results for LCS and Other Sequence Similarity Measures by Amir Abboud, Arturs Backurs and Virginia Vassilevska Williams, 2015.