Quelle  Indep_System.thy

(*
  File:     Indep_System.thy
  Author:   Jonas Keinholz

Independence systems
*)
section ‹Independence systems›
theory Indep_System
  imports Main
begin

lemma finite_psubset_inc_induct:
  assumes "finite A" "X ⊆ A"
  assumes "∧X. (∧Y. X ⊂ Y ==> Y ⊆ A ==> P Y) ==> P X"
  shows "P X"
proof -
  have wf: "wf {(X,Y). Y ⊂ X ∧ X ⊆ A}"
    by (rule wf_bounded_set[where ub = "λ_. A" and f = id]) (auto simp add: ‹finite A›)
  show ?thesis
  proof (induction X rule: wf_induct[OF wf, case_names step])
    case (step X)
    then show ?case using assms(3)[of X] by blast
  qed
qed

text ‹
 An \emph{independence system} consists of a finite ground set together with an independence
 predicate over the sets of this ground set. At least one set of the carrier is independent and
 subsets of independent sets are also independent.
 ›

locale indep_system =
  fixes carrier :: "'a set"
  fixes indep :: "'a set → bool"
  assumes carrier_finite: "finite carrier"
  assumes indep_subset_carrier: "indep X ==> X ⊆ carrier"
  assumes indep_ex: "∃X. indep X"
  assumes indep_subset: "indep X ==> Y ⊆ X ==> indep Y"
begin

lemmas psubset_inc_induct [case_names carrier step] = finite_psubset_inc_induct[OF carrier_finite]
lemmas indep_finite [simp] = finite_subset[OF indep_subset_carrier carrier_finite]

text ‹
 The empty set is independent.
 ›

lemma indep_empty [simp]: "indep {}"
  using indep_ex indep_subset by auto

subsection ‹Sub-independence systems›

text ‹
 A subset of the ground set induces an independence system.
 ›

definition indep_in where "indep_in E X ⟷ X ⊆ E ∧ indep X"

lemma indep_inI:
  assumes "X ⊆ E"
  assumes "indep X"
  shows "indep_in E X"
  using assms unfolding indep_in_def by auto

lemma indep_in_subI: "indep_in E X ==> indep_in E' (X ∩ E')"
  using indep_subset unfolding indep_in_def by auto

lemma dep_in_subI:
  assumes "X ⊆ E'"
  shows "¬ indep_in E' X ==> ¬ indep_in E X"
  using assms unfolding indep_in_def by auto

lemma indep_in_subset_carrier: "indep_in E X ==> X ⊆ E"
  unfolding indep_in_def by auto

lemma indep_in_subI_subset:
  assumes "E' ⊆ E"
  assumes "indep_in E' X"
  shows "indep_in E X"
proof -
  have "indep_in E (X ∩ E)" using assms indep_in_subI by auto
  moreover have "X ∩ E = X" using assms indep_in_subset_carrier by auto
  ultimately show ?thesis by auto
qed

lemma indep_in_supI:
  assumes "X ⊆ E'" "E' ⊆ E"
  assumes "indep_in E X"
  shows "indep_in E' X"
proof -
  have "X ∩ E' = X" using assms by auto
  then show ?thesis using assms indep_in_subI[where E = E and E' = E' and X = X] by auto
qed

lemma indep_in_indep: "indep_in E X ==> indep X"
  unfolding indep_in_def by auto

lemmas indep_inD = indep_in_subset_carrier indep_in_indep

lemma indep_system_subset [simp, intro]:
  assumes "E ⊆ carrier"
  shows "indep_system E (indep_in E)"
  unfolding indep_system_def indep_in_def
  using finite_subset[OF assms carrier_finite] indep_subset by auto

text ‹
 We will work a lot with different sub structures. Therefore, every definition `foo' will have
 a counterpart `foo\_in' which has the ground set as an additional parameter. Furthermore, every
 result about `foo' will have another result about `foo\_in'. With this, we usually don't have to
 work with @{command interpretation} in proofs.
 ›

context
  fixes E
  assumes "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using ‹E ⊆ carrier› by auto

lemma indep_in_sub_cong:
  assumes "E' ⊆ E"
  shows "E.indep_in E' X ⟷ indep_in E' X"
  unfolding E.indep_in_def indep_in_def using assms by auto

lemmas indep_in_ex = E.indep_ex
lemmas indep_in_subset = E.indep_subset
lemmas indep_in_empty = E.indep_empty

end

subsection ‹Bases›

text ‹
 A \emph{basis} is a maximal independent set, i.\,e.\ an independent set which becomes dependent on
 inserting any element of the ground set.
 ›

definition basis where "basis X ⟷ indep X ∧ (∀x ∈ carrier - X. ¬ indep (insert x X))"

lemma basisI:
  assumes "indep X"
  assumes "∧x. x ∈ carrier - X ==> ¬ indep (insert x X)"
  shows "basis X"
  using assms unfolding basis_def by auto

lemma basis_indep: "basis X ==> indep X"
  unfolding basis_def by auto

lemma basis_max_indep: "basis X ==> x ∈ carrier - X ==> ¬ indep (insert x X)"
  unfolding basis_def by auto

lemmas basisD = basis_indep basis_max_indep
lemmas basis_subset_carrier = indep_subset_carrier[OF basis_indep]
lemmas basis_finite [simp] = indep_finite[OF basis_indep]

lemma indep_not_basis:
  assumes "indep X"
  assumes "¬ basis X"
  shows "∃x ∈ carrier - X. indep (insert x X)"
  using assms basisI by auto

lemma basis_subset_eq:
  assumes "basis B₁"
  assumes "basis B₂"
  assumes "B₁ ⊆ B₂"
  shows "B₁ = B₂"
proof (rule ccontr)
  assume "B₁ ≠ B₂"
  then obtain x where x: "x ∈ B₂ - B₁" using assms by auto
  then have "insert x B₁ ⊆ B₂" using assms by auto
  then have "indep (insert x B₁)" using assms basis_indep[of B₂] indep_subset by auto
  moreover have "x ∈ carrier - B₁" using assms x basis_subset_carrier by auto
  ultimately show False using assms basisD by auto
qed

definition basis_in where
  "basis_in E X ⟷ indep_system.basis E (indep_in E) X"

lemma basis_iff_basis_in: "basis B ⟷ basis_in carrier B"
proof -
  interpret E: indep_system carrier "indep_in carrier"
    by auto

  show "basis B ⟷ basis_in carrier B"
    unfolding basis_in_def
  proof (standard, goal_cases LTR RTL)
    case LTR
    show ?case
    proof (rule E.basisI)
      show "indep_in carrier B" using LTR basisD indep_subset_carrier indep_inI by auto
    next
      fix x
      assume "x ∈ carrier - B"
      then have "¬ indep (insert x B)" using LTR basisD by auto
      then show "¬ indep_in carrier (insert x B)" using indep_inD by auto
    qed
  next
    case RTL
    show ?case
    proof (rule basisI)
      show "indep B" using RTL E.basis_indep indep_inD by blast
    next
      fix x
      assume "x ∈ carrier - B"
      then have "¬ indep_in carrier (insert x B)" using RTL E.basisD by auto
      then show "¬ indep (insert x B)" using indep_subset_carrier indep_inI by blast
    qed
  qed
qed

context
  fixes E
  assumes "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using ‹E ⊆ carrier› by auto

lemma basis_inI_aux: "E.basis X ==> basis_in E X"
  unfolding basis_in_def by auto

lemma basis_inD_aux: "basis_in E X ==> E.basis X"
  unfolding basis_in_def by auto

lemma not_basis_inD_aux: "¬ basis_in E X ==> ¬ E.basis X"
  using basis_inI_aux by auto

lemmas basis_inI = basis_inI_aux[OF E.basisI]
lemmas basis_in_indep_in = E.basis_indep[OF basis_inD_aux]
lemmas basis_in_max_indep_in = E.basis_max_indep[OF basis_inD_aux]
lemmas basis_inD = E.basisD[OF basis_inD_aux]
lemmas basis_in_subset_carrier = E.basis_subset_carrier[OF basis_inD_aux]
lemmas basis_in_finite = E.basis_finite[OF basis_inD_aux]
lemmas indep_in_not_basis_in = E.indep_not_basis[OF _ not_basis_inD_aux]
lemmas basis_in_subset_eq = E.basis_subset_eq[OF basis_inD_aux basis_inD_aux]

end

context
  fixes E
  assumes *: "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using * by auto

lemma basis_in_sub_cong:
  assumes "E' ⊆ E"
  shows "E.basis_in E' B ⟷ basis_in E' B"
proof (safe, goal_cases LTR RTL)
  case LTR
  show ?case
  proof (rule basis_inI)
    show "E' ⊆ carrier" using assms * by auto
  next
    show "indep_in E' B"
      using * assms LTR E.basis_in_subset_carrier E.basis_in_indep_in indep_in_sub_cong by auto
  next
    fix x
    assume "x ∈ E' - B"
    then show "¬ indep_in E' (insert x B)"
      using * assms LTR E.basis_in_max_indep_in E.basis_in_subset_carrier indep_in_sub_cong by auto
  qed
next
  case RTL
  show ?case
  proof (rule E.basis_inI)
    show "E' ⊆ E" using assms by auto
  next
    show "E.indep_in E' B"
      using * assms RTL basis_in_subset_carrier basis_in_indep_in indep_in_sub_cong by auto
  next
    fix x
    assume "x ∈ E' - B"
    then show "¬ E.indep_in E' (insert x B)"
      using * assms RTL basis_in_max_indep_in basis_in_subset_carrier indep_in_sub_cong by auto
  qed
qed

end

subsection ‹Circuits›

text ‹
 A \emph{circuit} is a minimal dependent set, i.\,e.\ a set which becomes independent on removing
 any element of the ground set.
 ›

definition circuit where "circuit X ⟷ X ⊆ carrier ∧ ¬ indep X ∧ (∀x ∈ X. indep (X - {x}))"

lemma circuitI:
  assumes "X ⊆ carrier"
  assumes "¬ indep X"
  assumes "∧x. x ∈ X ==> indep (X - {x})"
  shows "circuit X"
  using assms unfolding circuit_def by auto

lemma circuit_subset_carrier: "circuit X ==> X ⊆ carrier"
  unfolding circuit_def by auto
lemmas circuit_finite [simp] = finite_subset[OF circuit_subset_carrier carrier_finite]

lemma circuit_dep: "circuit X ==> ¬ indep X"
  unfolding circuit_def by auto

lemma circuit_min_dep: "circuit X ==> x ∈ X ==> indep (X - {x})"
  unfolding circuit_def by auto

lemmas circuitD = circuit_subset_carrier circuit_dep circuit_min_dep

lemma circuit_nonempty: "circuit X ==> X ≠ {}"
  using circuit_dep indep_empty by blast

lemma dep_not_circuit:
  assumes "X ⊆ carrier"
  assumes "¬ indep X"
  assumes "¬ circuit X"
  shows "∃x ∈ X. ¬ indep (X - {x})"
  using assms circuitI by auto

lemma circuit_subset_eq:
  assumes "circuit C₁"
  assumes "circuit C₂"
  assumes "C₁ ⊆ C₂"
  shows "C₁ = C₂"
proof (rule ccontr)
  assume "C₁ ≠ C₂"
  then obtain x where "x ∉ C₁" "x ∈ C₂" using assms by auto
  then have "indep C₁" using indep_subset ‹C₁ ⊆ C₂› circuit_min_dep[OF ‹circuit C₂›, of x] by auto
  then show False using assms circuitD by auto
qed

definition circuit_in where
  "circuit_in E X ⟷ indep_system.circuit E (indep_in E) X"

context
  fixes E
  assumes "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using ‹E ⊆ carrier› by auto

lemma circuit_inI_aux: "E.circuit X ==> circuit_in E X"
  unfolding circuit_in_def by auto

lemma circuit_inD_aux: "circuit_in E X ==> E.circuit X"
  unfolding circuit_in_def by auto

lemma not_circuit_inD_aux: "¬ circuit_in E X ==> ¬ E.circuit X"
  using circuit_inI_aux by auto

lemmas circuit_inI = circuit_inI_aux[OF E.circuitI]

lemmas circuit_in_subset_carrier = E.circuit_subset_carrier[OF circuit_inD_aux]
lemmas circuit_in_finite = E.circuit_finite[OF circuit_inD_aux]
lemmas circuit_in_dep_in = E.circuit_dep[OF circuit_inD_aux]
lemmas circuit_in_min_dep_in = E.circuit_min_dep[OF circuit_inD_aux]
lemmas circuit_inD = E.circuitD[OF circuit_inD_aux]
lemmas circuit_in_nonempty = E.circuit_nonempty[OF circuit_inD_aux]
lemmas dep_in_not_circuit_in = E.dep_not_circuit[OF _ _ not_circuit_inD_aux]
lemmas circuit_in_subset_eq = E.circuit_subset_eq[OF circuit_inD_aux circuit_inD_aux]

end

lemma circuit_in_subI:
  assumes "E' ⊆ E" "E ⊆ carrier"
  assumes "circuit_in E' C"
  shows "circuit_in E C"
proof (rule circuit_inI)
  show "E ⊆ carrier" using assms by auto
next
  show "C ⊆ E" using assms circuit_in_subset_carrier[of E' C] by auto
next
  show "¬ indep_in E C"
    using assms
      circuit_in_dep_in[where E = E' and X = C]
      circuit_in_subset_carrier dep_in_subI[where E' = E' and E = E]
    by auto
next
  fix x
  assume "x ∈ C"
  then show "indep_in E (C - {x})"
    using assms circuit_in_min_dep_in indep_in_subI_subset by auto
qed

lemma circuit_in_supI:
  assumes "E' ⊆ E" "E ⊆ carrier" "C ⊆ E'"
  assumes "circuit_in E C"
  shows "circuit_in E' C"
proof (rule circuit_inI)
  show "E' ⊆ carrier" using assms by auto
next
  show "C ⊆ E'" using assms by auto
next
  have "¬ indep_in E C" using assms circuit_in_dep_in by auto
  then show "¬ indep_in E' C" using assms dep_in_subI[of C E] by auto
next
  fix x
  assume "x ∈ C"
  then have "indep_in E (C - {x})" using assms circuit_in_min_dep_in by auto
  then have "indep_in E' ((C - {x}) ∩ E')" using indep_in_subI by auto
  moreover have "(C - {x}) ∩ E' = C - {x}" using assms circuit_in_subset_carrier by auto
  ultimately show "indep_in E' (C - {x})" by auto
qed

context
  fixes E
  assumes *: "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using * by auto

lemma circuit_in_sub_cong:
  assumes "E' ⊆ E"
  shows "E.circuit_in E' C ⟷ circuit_in E' C"
proof (safe, goal_cases LTR RTL)
  case LTR
  show ?case
  proof (rule circuit_inI)
    show "E' ⊆ carrier" using assms * by auto
  next
    show "C ⊆ E'"
      using assms LTR E.circuit_in_subset_carrier by auto
  next
    show "¬ indep_in E' C"
      using assms LTR E.circuit_in_dep_in indep_in_sub_cong[OF *] by auto
  next
    fix x
    assume "x ∈ C"
    then show "indep_in E' (C - {x})"
      using assms LTR E.circuit_in_min_dep_in indep_in_sub_cong[OF *] by auto
  qed
next
  case RTL
  show ?case
  proof (rule E.circuit_inI)
    show "E' ⊆ E" using assms * by auto
  next
    show "C ⊆ E'"
      using assms * RTL circuit_in_subset_carrier by auto
  next
    show "¬ E.indep_in E' C"
      using assms * RTL circuit_in_dep_in indep_in_sub_cong[OF *] by auto
  next
    fix x
    assume "x ∈ C"
    then show "E.indep_in E' (C - {x})"
      using assms * RTL circuit_in_min_dep_in indep_in_sub_cong[OF *] by auto
  qed
qed

end

lemma circuit_imp_circuit_in:
  assumes "circuit C"
  shows "circuit_in carrier C"
proof (rule circuit_inI)
  show "C ⊆ carrier" using circuit_subset_carrier[OF assms] .
next
  show "¬ indep_in carrier C" using circuit_dep[OF assms] indep_in_indep by auto
next
  fix x
  assume "x ∈ C"
  then have "indep (C - {x})" using circuit_min_dep[OF assms] by auto
  then show "indep_in carrier (C - {x})" using circuit_subset_carrier[OF assms] by (auto intro: indep_inI)
qed auto

subsection ‹Relation between independence and bases›

text ‹
 A set is independent iff it is a subset of a basis.
 ›

lemma indep_imp_subset_basis:
  assumes "indep X"
  shows "∃B. basis B ∧ X ⊆ B"
  using assms
proof (induction X rule: psubset_inc_induct)
  case carrier
  show ?case using indep_subset_carrier[OF assms] .
next
  case (step X)
  {
    assume "¬ basis X"
    then obtain x where "x ∈ carrier" "x ∉ X" "indep (insert x X)"
      using step.prems indep_not_basis by auto
    then have ?case using step.IH[of "insert x X"] indep_subset_carrier by auto
  }
  then show ?case by auto
qed

lemmas subset_basis_imp_indep = indep_subset[OF basis_indep]

lemma indep_iff_subset_basis: "indep X ⟷ (∃B. basis B ∧ X ⊆ B)"
  using indep_imp_subset_basis subset_basis_imp_indep by auto

lemma basis_ex: "∃B. basis B"
  using indep_imp_subset_basis[OF indep_empty] by auto

context
  fixes E
  assumes *: "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using * by auto

lemma indep_in_imp_subset_basis_in:
  assumes "indep_in E X"
  shows "∃B. basis_in E B ∧ X ⊆ B"
  unfolding basis_in_def using E.indep_imp_subset_basis[OF assms] .

lemmas subset_basis_in_imp_indep_in = indep_in_subset[OF * basis_in_indep_in[OF *]]

lemma indep_in_iff_subset_basis_in: "indep_in E X ⟷ (∃B. basis_in E B ∧ X ⊆ B)"
  using indep_in_imp_subset_basis_in subset_basis_in_imp_indep_in by auto

lemma basis_in_ex: "∃B. basis_in E B"
  unfolding basis_in_def using E.basis_ex .

lemma basis_in_subI:
  assumes "E' ⊆ E" "E ⊆ carrier"
  assumes "basis_in E' B"
  shows "∃B' ⊆ E - E'. basis_in E (B ∪ B')"
proof -
  have "indep_in E B" using assms basis_in_indep_in indep_in_subI_subset by auto
  then obtain B' where B': "basis_in E B'" "B ⊆ B'"
    using assms indep_in_imp_subset_basis_in[of B] by auto
  show ?thesis
  proof (rule exI)
    have "B' - B ⊆ E - E'"
    proof
      fix x
      assume *: "x ∈ B' - B"
      then have "x ∈ E" "x ∉ B"
        using assms ‹basis_in E B'› basis_in_subset_carrier[of E] by auto
      moreover {
        assume "x ∈ E'"
        moreover have "indep_in E (insert x B)"
          using * assms indep_in_subset[OF _ basis_in_indep_in] B' by auto
        ultimately have "indep_in E' (insert x B)"
          using assms basis_in_subset_carrier unfolding indep_in_def by auto
        then have False using assms * ‹x ∈ E'› basis_in_max_indep_in by auto
      }
      ultimately show "x ∈ E - E'"  by auto
    qed
    moreover have "B ∪ (B' - B) = B'" using ‹B ⊆ B'› by auto
    ultimately show "B' - B ⊆ E - E' ∧ basis_in E (B ∪ (B' - B))"
      using ‹basis_in E B'› by auto
  qed
qed

lemma basis_in_supI:
  assumes "B ⊆ E'" "E' ⊆ E" "E ⊆ carrier"
  assumes "basis_in E B"
  shows "basis_in E' B"
proof (rule basis_inI)
  show "E' ⊆ carrier" using assms by auto
next
  show "indep_in E' B"
  proof -
    have "indep_in E' (B ∩ E')"
      using assms basis_in_indep_in[of E B] indep_in_subI by auto
    moreover have "B ∩ E' = B" using assms by auto
    ultimately show ?thesis by auto
  qed
next
  show "∧x. x ∈ E' - B ==> ¬ indep_in E' (insert x B)"
    using assms basis_in_subset_carrier basis_in_max_indep_in dep_in_subI[of _ E E'] by auto
qed

end

subsection ‹Relation between dependence and circuits›

text ‹
 A set is dependent iff it contains a circuit.
 ›

lemma dep_imp_supset_circuit:
  assumes "X ⊆ carrier"
  assumes "¬ indep X"
  shows "∃C. circuit C ∧ C ⊆ X"
  using assms
proof (induction X rule: remove_induct)
  case (remove X)
  {
    assume "¬ circuit X"
    then obtain x where "x ∈ X" "¬ indep (X - {x})"
      using remove.prems dep_not_circuit by auto
    then obtain C where "circuit C" "C ⊆ X - {x}"
      using remove.prems remove.IH[of x] by auto
    then have ?case by auto
  }
  then show ?case using remove.prems by auto
qed (auto simp add: carrier_finite finite_subset)

lemma supset_circuit_imp_dep:
  assumes "circuit C ∧ C ⊆ X"
  shows "¬ indep X"
  using assms indep_subset circuit_dep by auto

lemma dep_iff_supset_circuit:
  assumes "X ⊆ carrier"
  shows "¬ indep X ⟷ (∃C. circuit C ∧ C ⊆ X)"
  using assms dep_imp_supset_circuit supset_circuit_imp_dep by auto

context
  fixes E
  assumes "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using ‹E ⊆ carrier› by auto

lemma dep_in_imp_supset_circuit_in:
  assumes "X ⊆ E"
  assumes "¬ indep_in E X"
  shows "∃C. circuit_in E C ∧ C ⊆ X"
  unfolding circuit_in_def using E.dep_imp_supset_circuit[OF assms] .

lemma supset_circuit_in_imp_dep_in:
  assumes "circuit_in E C ∧ C ⊆ X"
  shows "¬ indep_in E X"
  using assms E.supset_circuit_imp_dep unfolding circuit_in_def by auto

lemma dep_in_iff_supset_circuit_in:
  assumes "X ⊆ E"
  shows "¬ indep_in E X ⟷ (∃C. circuit_in E C ∧ C ⊆ X)"
  using assms dep_in_imp_supset_circuit_in supset_circuit_in_imp_dep_in by auto

end

subsection ‹Ranks›

definition lower_rank_of :: "'a set → nat" where
  "lower_rank_of carrier' ≡ Min {card B | B. basis_in carrier' B}"

definition upper_rank_of :: "'a set → nat" where
  "upper_rank_of carrier' ≡ Max {card B | B. basis_in carrier' B}"

lemma collect_basis_finite: "finite (Collect basis)"
proof -
  have "Collect basis ⊆ {X. X ⊆ carrier}"
    using basis_subset_carrier by auto
  moreover have "finite …"
    using carrier_finite by auto
  ultimately show ?thesis using finite_subset by auto
qed

context
  fixes E
  assumes *: "E ⊆ carrier"
begin

interpretation E: indep_system E "indep_in E"
  using * by auto

lemma collect_basis_in_finite: "finite (Collect (basis_in E))"
  unfolding basis_in_def using E.collect_basis_finite .

lemma lower_rank_of_le: "lower_rank_of E ≤ card E"
proof -
  have "∃n ∈ {card B | B. basis_in E B}. n ≤ card E"
    using card_mono[OF E.carrier_finite basis_in_subset_carrier[OF *]] basis_in_ex[OF *] by auto
  moreover have "finite {card B | B. basis_in E B}"
    using collect_basis_in_finite by auto
  ultimately show ?thesis
    unfolding lower_rank_of_def using basis_ex Min_le_iff by auto
qed

lemma upper_rank_of_le: "upper_rank_of E ≤ card E"
proof -
  have "∀n ∈ {card B | B. basis_in E B}. n ≤ card E"
    using card_mono[OF E.carrier_finite basis_in_subset_carrier[OF *]] by auto
  then show ?thesis
    unfolding upper_rank_of_def using basis_in_ex[OF *] collect_basis_in_finite by auto
qed

context
  fixes E'
  assumes **: "E' ⊆ E"
begin

interpretation E'₁: indep_system E' "indep_in E'"
  using * ** by auto
interpretation E'₂: indep_system E' "E.indep_in E'"
  using * ** by auto

lemma lower_rank_of_sub_cong:
  shows "E.lower_rank_of E' = lower_rank_of E'"
proof -
  have "∧B. E'₁.basis B ⟷ E'₂.basis B"
    using ** basis_in_sub_cong[OF *, of E']
    unfolding basis_in_def E.basis_in_def by auto
  then show ?thesis
    unfolding lower_rank_of_def E.lower_rank_of_def
    using basis_in_sub_cong[OF * **]
    by auto
qed

lemma upper_rank_of_sub_cong:
  shows "E.upper_rank_of E' = upper_rank_of E'"
proof -
  have "∧B. E'₁.basis B ⟷ E'₂.basis B"
    using ** basis_in_sub_cong[OF *, of E']
    unfolding basis_in_def E.basis_in_def by auto
  then show ?thesis
    unfolding upper_rank_of_def E.upper_rank_of_def
    using basis_in_sub_cong[OF * **]
    by auto
qed

end

end

end

end