gh-36354: added induced minor function to graph algorithms 
    
### Description

Fixes #36353

This pull request introduces the "induced_minor" function to the
SageMath library for graph theory. The function allows users to find an
induced minor isomorphic to a given target graph `H` in a graph `G`. It
utilizes Mixed Integer Linear Programming (MILP) to solve this problem
efficiently.

### Motivation

The "induced_minor" function is a valuable addition to SageMath as it
addresses the need to find induced minors, a fundamental concept in
graph theory. Users often encounter scenarios where they need to
identify an induced minor isomorphic to a specific target graph, and
this function streamlines the process.

Issue: #36353
Documentation Issue: ----

### Implementation

#### Logic
An existing minor function had several constraints for finding an
induced minor isomorphic to a given target graph `H` in a graph`G:
1. Representative Sets: Ensure that each vertex `v` in `G` represents a
vertex `h` in `H` using binary variables `rs[h, v]`.
2. Connected Representative Sets: Enforce that the representative sets
in `G` form a connected tree structure using binary variables `edges[h,
fuv]` for edges `(u, v)` in `G`.
3. Tree Structure: Ensure that the number of edges in the tree for each
`h` in `H` is exactly one less than the cardinality of its
representative set.
4. Acyclic Trees: Maintain acyclic tree structures for representative
sets using `r_edges[h, (u, v)]` variables and constraints.
5. Edges Correspondence: Ensure that edges between representative sets
in `G` correspond to edges in `H` using `h_edges` variables.

For induced minor, we just had to add an additional constraint:

6. Induced Subgraph Condition: Checks for the existence of edges `(h1,
h2)` in target graph `H`. If no such edge exists in `H`, it ensures that
there is no edge between the representative sets of vertices `h1` and
`h2` in graph `G`.

#### Algorithm and Complexity
The "induced_minor" function uses MILP to find the minor and follows the
algorithm described in [KKT2006]. The complexity of this operation is
discussed in the docstring.

#### Example Usage
The PR includes examples demonstrating how to use the "induced_minor"
function to find induced minors isomorphic to specific target graphs in
various scenarios.

#### Tests
The code includes tests to ensure the correctness of the "induced_minor"
function. These tests cover different use cases, including scenarios
where no induced minor exists.

#### Documentation
The documentation will be updated in a separate PR to include
information about the new "induced_minor" function.

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked the relevant issue #36353.
- [x] I have created tests covering the changes.
- [x] I will update the documentation in a separate PR, if required.

### ⌛ Dependencies

N/A (There are no open PRs that this PR depends on.)
    
URL: #36354
Reported by: saatvikraoIITGN
Reviewer(s): David Coudert, saatvikraoIITGN

Author: Release Manager

src/sage/graphs/graph.py

@@ -4891,7 +4891,7 @@ def independent_set_of_representatives(self, family, solver=None, verbose=0,
         return repr
 
     @doc_index("Algorithmically hard stuff")
-    def minor(self, H, solver=None, verbose=0, *, integrality_tolerance=1e-3):
+    def minor(self, H, solver=None, verbose=0, induced=False, *, integrality_tolerance=1e-3):
         r"""
         Return the vertices of a minor isomorphic to `H` in the current graph.
 
@@ -4901,6 +4901,14 @@ def minor(self, H, solver=None, verbose=0, *, integrality_tolerance=1e-3):
         been merged to create a new graph `G'`, this new graph contains `H` as a
         subgraph.
 
+        When parameter ``induced`` is ``True``, this method returns an induced minor
+        isomorphic to `H`, if it exists.
+
+        We say that a graph `G` has an induced `H`-minor (or that it has a
+        graph isomorphic to `H` as an induced minor), if `H` can be obtained
+        from an induced subgraph of `G` by contracting edges. Otherwise, `G` is
+        said to be `H`-induced minor-free.
+
         For more information, see the :wikipedia:`Minor_(graph_theory)`.
 
         INPUT:
@@ -4922,6 +4930,10 @@ def minor(self, H, solver=None, verbose=0, *, integrality_tolerance=1e-3):
           solvers over an inexact base ring; see
           :meth:`MixedIntegerLinearProgram.get_values`.
 
+        - ``induced`` -- boolean (default: ``False``); if ``True``, returns an
+          induced minor isomorphic to `H` if it exists, and raises a
+          :class:`ValueError` otherwise.
+
         OUTPUT:
 
         A dictionary associating to each vertex of `H` the set of vertices in
@@ -4979,6 +4991,43 @@ def minor(self, H, solver=None, verbose=0, *, integrality_tolerance=1e-3):
             Traceback (most recent call last):
             ...
             ValueError: This graph has no minor isomorphic to H !
+
+        Trying to find an induced minor isomorphic to `C_5` in a graph
+        containing an induced `C_6`::
+
+            sage: g = graphs.CycleGraph(6)
+            sage: for i in range(randint(10, 30)):
+            ....:     g.add_edge(randint(0, 5), g.add_vertex())
+            sage: h = graphs.CycleGraph(5)
+            sage: L = g.minor(h, induced=True)
+            sage: gg = g.subgraph(flatten(L.values(), max_level=1))
+            sage: _ = [gg.merge_vertices(l) for l in L.values() if len(l) > 1]
+            sage: gg.is_isomorphic(h)
+            True
+
+        TESTS::
+            
+        A graph `g` may have a minor isomorphic to a given graph `h` but no
+        induced minor isomorphic to `h`::
+
+            sage: g = Graph([(0, 1), (0, 2), (1, 2), (2, 3), (3, 4), (3, 5), (4, 5), (6, 5)])
+            sage: h = Graph([(9, 10), (9, 11), (9, 12), (9, 13)])
+            sage: l = g.minor(h, induced=False)
+            sage: l = g.minor(h, induced=True)
+            Traceback (most recent call last):
+            ...
+            ValueError: This graph has no induced minor isomorphic to H !
+
+        Checking that the returned induced minor is isomorphic to the given
+        graph::
+
+            sage: g = Graph([(0, 1), (0, 2), (1, 2), (2, 3), (3, 4), (3, 5), (4, 5), (6, 5)])
+            sage: h = Graph([(7, 8), (8, 9), (9, 10), (10, 11)])
+            sage: L = g.minor(h, induced=True)
+            sage: gg = g.subgraph(flatten(L.values(), max_level=1))
+            sage: _ = [gg.merge_vertices(l) for l in L.values() if len(l) > 1]
+            sage: gg.is_isomorphic(h)
+            True
         """
         self._scream_if_not_simple()
         H._scream_if_not_simple()
@@ -5044,12 +5093,25 @@ def minor(self, H, solver=None, verbose=0, *, integrality_tolerance=1e-3):
             p.add_constraint(p.sum(h_edges[(h1, h2), frozenset(e)] + h_edges[(h2, h1), frozenset(e)]
                                    for e in self.edge_iterator(labels=None)), min=1)
 
+        # if induced is True
+        # condition for induced subgraph ensures that if there
+        # doesnt exist an edge(h1, h2) in H then there should 
+        # not be an edge between representative sets of h1 and h2 in G
+        if induced:
+            for h1, h2 in H.complement().edge_iterator(labels=False):
+                for v1, v2 in self.edge_iterator(labels=False):
+                    p.add_constraint(rs[h1, v1] + rs[h2, v2], max=1)
+                    p.add_constraint(rs[h2, v1] + rs[h1, v2], max=1)
+
         p.set_objective(None)
 
         try:
             p.solve(log=verbose)
         except MIPSolverException:
-            raise ValueError("This graph has no minor isomorphic to H !")
+            if induced: 
+                raise ValueError("This graph has no induced minor isomorphic to H !")
+            else:
+                raise ValueError("This graph has no minor isomorphic to H !")
 
         rs = p.get_values(rs, convert=bool, tolerance=integrality_tolerance)